436 files changed, 29196 insertions, 8521 deletions

diff --git a/src/Authenticator.cpp b/src/Authenticator.cpp
index 4cbe3beed..bd6db1c11 100644
--- a/src/Authenticator.cpp
+++ b/src/Authenticator.cpp
@@ -43,7 +43,6 @@ cAuthenticator::~cAuthenticator()
 
 
 
-/// Read custom values from INI
 void cAuthenticator::ReadINI(cIniFile & IniFile)
 {
 	m_Server  = IniFile.GetValueSet("Authentication", "Server", DEFAULT_AUTH_SERVER);
@@ -55,7 +54,6 @@ void cAuthenticator::ReadINI(cIniFile & IniFile)
 
 
 
-/// Queues a request for authenticating a user. If the auth fails, the user is kicked
 void cAuthenticator::Authenticate(int a_ClientID, const AString & a_UserName, const AString & a_ServerHash)
 {
 	if (!m_ShouldAuthenticate)
@@ -141,7 +139,9 @@ bool cAuthenticator::AuthFromAddress(const AString & a_Server, const AString & a
 	cBlockingTCPLink Link;
 	if (!Link.Connect(a_Server.c_str(), 80))
 	{
-		LOGERROR("cAuthenticator: cannot connect to auth server \"%s\", kicking user \"%s\"", a_Server.c_str(), a_Server.c_str());
+		LOGWARNING("%s: cannot connect to auth server \"%s\", kicking user \"%s\"",
+			__FUNCTION__, a_Server.c_str(), a_UserName.c_str()
+		);
 		return false;
 	}
 	
@@ -170,7 +170,7 @@ bool cAuthenticator::AuthFromAddress(const AString & a_Server, const AString & a
 		if (code == 302)
 		{
 			// redirect blabla
-			LOGINFO("Need to redirect!");
+			LOGD("%s: Need to redirect, current level %d!", __FUNCTION__, a_Level);
 			if (a_Level > MAX_REDIRECTS)
 			{
 				LOGERROR("cAuthenticator: received too many levels of redirection from auth server \"%s\" for user \"%s\", bailing out and kicking the user", a_Server.c_str(), a_UserName.c_str());
diff --git a/src/Bindings/AllToLua.bat b/src/Bindings/AllToLua.bat
index b2a192880..f085af9e9 100644
--- a/src/Bindings/AllToLua.bat
+++ b/src/Bindings/AllToLua.bat
@@ -4,17 +4,21 @@
 :: When called without any parameters, it will pause for a keypress at the end
 :: Call with any parameter to disable the wait (for buildserver use)
 
+@echo off
+
 
 
 
 
 :: Regenerate the files:
+echo Regenerating LUA bindings . . .
 "tolua++.exe" -L virtual_method_hooks.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
 
 
 
 
 : Wait for keypress, if no param given:
+echo.
 if %ALLTOLUA_WAIT%N == N pause
 
 
diff --git a/src/Bindings/AllToLua.pkg b/src/Bindings/AllToLua.pkg
index f65aed9bb..1cd7c74f8 100644
--- a/src/Bindings/AllToLua.pkg
+++ b/src/Bindings/AllToLua.pkg
@@ -11,6 +11,7 @@ typedef unsigned int       UInt32;
 typedef unsigned short     UInt16;
 
 
+$cfile "../Vector3.h"
 $cfile "../ChunkDef.h"
 $cfile "../BiomeDef.h"
 
@@ -26,6 +27,7 @@ $cfile "WebPlugin.h"
 $cfile "LuaWindow.h"
 
 $cfile "../BlockID.h"
+$cfile "../BlockInfo.h"
 $cfile "../StringUtils.h"
 $cfile "../Defines.h"
 $cfile "../ChatColor.h"
@@ -34,6 +36,7 @@ $cfile "../Entities/Entity.h"
 $cfile "../Entities/Floater.h"
 $cfile "../Entities/Pawn.h"
 $cfile "../Entities/Player.h"
+$cfile "../Entities/Painting.h"
 $cfile "../Entities/Pickup.h"
 $cfile "../Entities/ProjectileEntity.h"
 $cfile "../Entities/TNTEntity.h"
@@ -47,6 +50,7 @@ $cfile "../ItemGrid.h"
 $cfile "../BlockEntities/BlockEntity.h"
 $cfile "../BlockEntities/BlockEntityWithItems.h"
 $cfile "../BlockEntities/ChestEntity.h"
+$cfile "../BlockEntities/CommandBlockEntity.h"
 $cfile "../BlockEntities/DropSpenserEntity.h"
 $cfile "../BlockEntities/DispenserEntity.h"
 $cfile "../BlockEntities/DropperEntity.h"
@@ -55,12 +59,10 @@ $cfile "../BlockEntities/HopperEntity.h"
 $cfile "../BlockEntities/JukeboxEntity.h"
 $cfile "../BlockEntities/NoteEntity.h"
 $cfile "../BlockEntities/SignEntity.h"
+$cfile "../BlockEntities/MobHeadEntity.h"
+$cfile "../BlockEntities/FlowerPotEntity.h"
 $cfile "../WebAdmin.h"
 $cfile "../Root.h"
-$cfile "../Vector3f.h"
-$cfile "../Vector3d.h"
-$cfile "../Vector3i.h"
-$cfile "../Matrix4f.h"
 $cfile "../Cuboid.h"
 $cfile "../BoundingBox.h"
 $cfile "../Tracer.h"
@@ -70,6 +72,10 @@ $cfile "../Generating/ChunkDesc.h"
 $cfile "../CraftingRecipes.h"
 $cfile "../UI/Window.h"
 $cfile "../Mobs/Monster.h"
+$cfile "../CompositeChat.h"
+$cfile "../Map.h"
+$cfile "../MapManager.h"
+$cfile "../Scoreboard.h"
 
 
 
@@ -82,3 +88,16 @@ class cLineBlockTracer;
 
 
 
+
+// To avoid tolua treating Byte as a class, and avoid the need to $cfile entire Globals.h:
+typedef unsigned char Byte;
+
+
+
+// Aliases
+$renaming Vector3<double> @ Vector3d
+$renaming Vector3<float>  @ Vector3f
+$renaming Vector3<int>    @ Vector3i
+
+
+
diff --git a/src/Bindings/CMakeLists.txt b/src/Bindings/CMakeLists.txt
deleted file mode 100644
index 50b81e42a..000000000
--- a/src/Bindings/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-
-cmake_minimum_required (VERSION 2.6)
-project (MCServer)
-
-# NOTE: This CMake file is processed only for Unix builds; Windows(MSVC) builds handle all the subfolders in /src in a single file, /src/CMakeLists.txt
-
-include_directories ("${PROJECT_SOURCE_DIR}/../")
-
-ADD_CUSTOM_COMMAND(
-	# add any new generated bindings here
-	OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/Bindings.cpp ${CMAKE_CURRENT_SOURCE_DIR}/Bindings.h
-	
-	# command execuded to regerate bindings
-	COMMAND tolua -L virtual_method_hooks.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
-	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-	
-	# add any new generation dependencies here
-	DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/virtual_method_hooks.lua ${CMAKE_CURRENT_SOURCE_DIR}/AllToLua.pkg tolua
-)
-
-#add cpp files here
-add_library(Bindings PluginManager LuaState WebPlugin Bindings ManualBindings LuaWindow Plugin PluginLua WebPlugin)
-
-target_link_libraries(Bindings lua sqlite tolualib)
diff --git a/src/Bindings/DeprecatedBindings.cpp b/src/Bindings/DeprecatedBindings.cpp
new file mode 100644
index 000000000..d51ba2da3
--- /dev/null
+++ b/src/Bindings/DeprecatedBindings.cpp
@@ -0,0 +1,275 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "DeprecatedBindings.h"
+#undef TOLUA_TEMPLATE_BIND
+#include "tolua++/include/tolua++.h"
+
+#include "Plugin.h"
+#include "PluginLua.h"
+#include "PluginManager.h"
+#include "LuaWindow.h"
+#include "LuaChunkStay.h"
+
+#include "../BlockInfo.h"
+
+
+
+
+
+/* get function: g_BlockLightValue */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockLightValue
+static int tolua_get_AllToLua_g_BlockLightValue(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+		{
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+		}
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushnumber(tolua_S,(lua_Number)cBlockInfo::GetLightValue((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockSpreadLightFalloff */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockSpreadLightFalloff
+static int tolua_get_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushnumber(tolua_S, (lua_Number)cBlockInfo::GetSpreadLightFalloff((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockTransparent */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockTransparent
+static int tolua_get_AllToLua_g_BlockTransparent(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsTransparent((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockOneHitDig */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockOneHitDig
+static int tolua_get_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsOneHitDig((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockPistonBreakable */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockPistonBreakable
+static int tolua_get_AllToLua_g_BlockPistonBreakable(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsPistonBreakable((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockIsSnowable */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockIsSnowable
+static int tolua_get_AllToLua_g_BlockIsSnowable(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::IsSnowable((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockRequiresSpecialTool */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockRequiresSpecialTool
+static int tolua_get_AllToLua_g_BlockRequiresSpecialTool(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, cBlockInfo::RequiresSpecialTool((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockIsSolid */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockIsSolid
+static int tolua_get_AllToLua_g_BlockIsSolid(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, (bool)cBlockInfo::IsSolid((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* get function: g_BlockFullyOccupiesVoxel */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockFullyOccupiesVoxel
+static int tolua_get_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
+{
+	int BlockType;
+	#ifndef TOLUA_RELEASE
+	{
+		tolua_Error tolua_err;
+		if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+			tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+	}
+	#endif
+	BlockType = (int)tolua_tonumber(tolua_S, 2, 0);
+	if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
+	{
+		tolua_error(tolua_S, "array indexing out of range.", NULL);
+	}
+	tolua_pushboolean(tolua_S, (bool)cBlockInfo::FullyOccupiesVoxel((BLOCKTYPE)BlockType));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+void DeprecatedBindings::Bind(lua_State * tolua_S)
+{
+	tolua_beginmodule(tolua_S, NULL);
+
+	tolua_array(tolua_S, "g_BlockLightValue",          tolua_get_AllToLua_g_BlockLightValue,          NULL);
+	tolua_array(tolua_S, "g_BlockSpreadLightFalloff",  tolua_get_AllToLua_g_BlockSpreadLightFalloff,  NULL);
+	tolua_array(tolua_S, "g_BlockTransparent",         tolua_get_AllToLua_g_BlockTransparent,         NULL);
+	tolua_array(tolua_S, "g_BlockOneHitDig",           tolua_get_AllToLua_g_BlockOneHitDig,           NULL);
+	tolua_array(tolua_S, "g_BlockPistonBreakable",     tolua_get_AllToLua_g_BlockPistonBreakable,     NULL);
+	tolua_array(tolua_S, "g_BlockIsSnowable",          tolua_get_AllToLua_g_BlockIsSnowable,          NULL);
+	tolua_array(tolua_S, "g_BlockRequiresSpecialTool", tolua_get_AllToLua_g_BlockRequiresSpecialTool, NULL);
+	tolua_array(tolua_S, "g_BlockIsSolid",             tolua_get_AllToLua_g_BlockIsSolid,             NULL);
+	tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel",  tolua_get_AllToLua_g_BlockFullyOccupiesVoxel,  NULL);
+
+	tolua_endmodule(tolua_S);
+}
+
+
+
+
diff --git a/src/Bindings/DeprecatedBindings.h b/src/Bindings/DeprecatedBindings.h
new file mode 100644
index 000000000..5fc3cfa80
--- /dev/null
+++ b/src/Bindings/DeprecatedBindings.h
@@ -0,0 +1,8 @@
+#pragma once
+
+struct lua_State;
+class DeprecatedBindings
+{
+public:
+	static void Bind( lua_State* tolua_S );
+};
diff --git a/src/Bindings/LuaChunkStay.cpp b/src/Bindings/LuaChunkStay.cpp
new file mode 100644
index 000000000..db865cfa4
--- /dev/null
+++ b/src/Bindings/LuaChunkStay.cpp
@@ -0,0 +1,170 @@
+
+// LuaChunkStay.cpp
+
+// Implements the cLuaChunkStay class representing a cChunkStay binding for plugins, used by cWorld:ChunkStay() Lua API
+
+#include "Globals.h"
+#include "LuaChunkStay.h"
+#include "PluginLua.h"
+#include "../World.h"
+
+
+
+
+
+cLuaChunkStay::cLuaChunkStay(cPluginLua & a_Plugin) :
+	m_Plugin(a_Plugin),
+	m_LuaState(NULL)
+{
+}
+
+
+
+
+
+bool cLuaChunkStay::AddChunks(int a_ChunkCoordTableStackPos)
+{
+	// This function is expected to be called just once, with all the coords in a table
+	ASSERT(m_Chunks.empty());
+	
+	cPluginLua::cOperation Op(m_Plugin);
+	cLuaState & L = Op();
+	
+	// Check that we got a table:
+	if (!lua_istable(L, a_ChunkCoordTableStackPos))
+	{
+		LOGWARNING("%s: The parameter is not a table of coords (got %s). Ignoring the call.",
+			__FUNCTION__, lua_typename(L, lua_type(L, a_ChunkCoordTableStackPos))
+		);
+		L.LogStackTrace();
+		return false;
+	}
+	
+	// Add each set of coords:
+	int NumChunks = luaL_getn(L, a_ChunkCoordTableStackPos);
+	m_Chunks.reserve(NumChunks);
+	for (int idx = 1; idx <= NumChunks; idx++)
+	{
+		// Push the idx-th element of the array onto stack top, check that it's a table:
+		lua_rawgeti(L, a_ChunkCoordTableStackPos, idx);
+		if (!lua_istable(L, -1))
+		{
+			LOGWARNING("%s: Element #%d is not a table (got %s). Ignoring the element.",
+				__FUNCTION__, idx, lua_typename(L, -1)
+			);
+			L.LogStackTrace();
+			lua_pop(L, 1);
+			continue;
+		}
+		AddChunkCoord(L, idx);
+		lua_pop(L, 1);
+	}
+	
+	// If there are no chunks, log a warning and return failure:
+	if (m_Chunks.empty())
+	{
+		LOGWARNING("%s: Zero chunks to stay.", __FUNCTION__);
+		L.LogStackTrace();
+		return false;
+	}
+	
+	// All ok
+	return true;
+}
+
+
+
+
+
+void cLuaChunkStay::AddChunkCoord(cLuaState & L, int a_Index)		
+{
+	// Check that the element has 2 coords:
+	int NumCoords = luaL_getn(L, -1);
+	if (NumCoords != 2)
+	{
+		LOGWARNING("%s: Element #%d doesn't contain 2 coords (got %d). Ignoring the element.",
+			__FUNCTION__, a_Index, NumCoords
+		);
+		return;
+	}
+	
+	// Read the two coords from the element:
+	lua_rawgeti(L, -1, 1);
+	lua_rawgeti(L, -2, 2);
+	int ChunkX = luaL_checkint(L, -2);
+	int ChunkZ = luaL_checkint(L, -1);
+	lua_pop(L, 2);
+	
+	// Check that a coord is not yet present:
+	for (cChunkCoordsVector::iterator itr = m_Chunks.begin(), end = m_Chunks.end(); itr != end; ++itr)
+	{
+		if ((itr->m_ChunkX == ChunkX) && (itr->m_ChunkZ == ChunkZ))
+		{
+			LOGWARNING("%s: Element #%d is a duplicate, ignoring it.",
+				__FUNCTION__, a_Index
+			);
+			return;
+		}
+	}  // for itr - m_Chunks[]
+	
+	m_Chunks.push_back(cChunkCoords(ChunkX, ZERO_CHUNK_Y, ChunkZ));
+}
+
+
+
+
+
+void cLuaChunkStay::Enable(cChunkMap & a_ChunkMap, int a_OnChunkAvailableStackPos, int a_OnAllChunksAvailableStackPos)
+{
+	// Get the references to the callback functions:
+	m_LuaState = &m_Plugin.GetLuaState();
+	m_OnChunkAvailable.RefStack(*m_LuaState, a_OnChunkAvailableStackPos);
+	m_OnAllChunksAvailable.RefStack(*m_LuaState, a_OnAllChunksAvailableStackPos);
+	
+	// Enable the ChunkStay:
+	super::Enable(a_ChunkMap);
+}
+
+
+
+
+
+void cLuaChunkStay::OnChunkAvailable(int a_ChunkX, int a_ChunkZ)
+{
+	cPluginLua::cOperation Op(m_Plugin);
+	Op().Call((int)m_OnChunkAvailable, a_ChunkX, a_ChunkZ);
+}
+
+
+
+
+
+bool cLuaChunkStay::OnAllChunksAvailable(void)
+{
+	{
+		// Call the callback:
+		cPluginLua::cOperation Op(m_Plugin);
+		Op().Call((int)m_OnAllChunksAvailable);
+		
+		// Remove the callback references - they won't be needed anymore
+		m_OnChunkAvailable.UnRef();
+		m_OnAllChunksAvailable.UnRef();
+	}
+	
+	// Disable the ChunkStay by returning true
+	return true;
+}
+
+
+
+
+
+void cLuaChunkStay::OnDisabled(void)
+{
+	// This object is no longer needed, delete it
+	delete this;
+}
+
+
+
+
diff --git a/src/Bindings/LuaChunkStay.h b/src/Bindings/LuaChunkStay.h
new file mode 100644
index 000000000..49ab9a0ad
--- /dev/null
+++ b/src/Bindings/LuaChunkStay.h
@@ -0,0 +1,73 @@
+
+// LuaChunkStay.h
+
+// Declares the cLuaChunkStay class representing a cChunkStay binding for plugins, used by cWorld:ChunkStay() Lua API
+
+
+
+
+
+#pragma once
+
+#include "LuaState.h"
+#include "../ChunkStay.h"
+
+
+
+
+
+// fwd:
+class cPluginLua;
+
+
+
+
+
+class cLuaChunkStay
+	: public cChunkStay
+{
+	typedef cChunkStay super;
+	
+public:
+	cLuaChunkStay(cPluginLua & a_Plugin);
+	
+	~cLuaChunkStay() { }
+
+	/** Adds chunks in the specified on-stack Lua table.
+	Returns true if any chunk added, false (plus log warning) if none. */
+	bool AddChunks(int a_ChunkCoordTableStackPos);
+	
+	/** Enables the ChunkStay for the specified chunkmap, with the specified Lua callbacks. */
+	void Enable(cChunkMap & a_ChunkMap, int a_OnChunkAvailableStackPos, int a_OnAllChunksAvailableStackPos);
+	
+protected:
+	/** The plugin which has created the ChunkStay, via cWorld:ChunkStay() binding method.  */
+	cPluginLua & m_Plugin;
+	
+	/** The Lua state associated with the callbacks. Only valid when enabled. */
+	cLuaState * m_LuaState;
+	
+	/** The Lua function to call in OnChunkAvailable. Only valid when enabled. */
+	cLuaState::cRef m_OnChunkAvailable;
+	
+	/** The Lua function to call in OnAllChunksAvailable. Only valid when enabled. */
+	cLuaState::cRef m_OnAllChunksAvailable;
+	
+	
+	// cChunkStay overrides:
+	virtual void OnChunkAvailable(int a_ChunkX, int a_ChunkZ) override;
+	virtual bool OnAllChunksAvailable(void) override;
+	virtual void OnDisabled(void) override;
+	
+	/** Adds a single chunk coord from the table at the top of the Lua stack.
+	Expects the top element to be a table, checks that it contains two numbers.
+	Uses those two numbers as chunk coords appended to m_Chunks.
+	If the coords are already present, gives a warning and ignores the pair.
+	The a_Index parameter is only for the error messages. */
+	void AddChunkCoord(cLuaState & a_LuaState, int a_Index);
+} ;
+
+
+
+
+
diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index bfee1d037..a33459ad2 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -11,9 +11,11 @@ extern "C"
 	#include "lua/src/lualib.h"
 }
 
+#undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 #include "Bindings.h"
 #include "ManualBindings.h"
+#include "DeprecatedBindings.h"
 
 // fwd: SQLite/lsqlite3.c
 extern "C"
@@ -93,11 +95,20 @@ void cLuaState::Create(void)
 	}
 	m_LuaState = lua_open();
 	luaL_openlibs(m_LuaState);
+	m_IsOwned = true;
+}
+
+
+
+
+
+void cLuaState::RegisterAPILibs(void)
+{
 	tolua_AllToLua_open(m_LuaState);
 	ManualBindings::Bind(m_LuaState);
+	DeprecatedBindings::Bind(m_LuaState);
 	luaopen_lsqlite3(m_LuaState);
 	luaopen_lxp(m_LuaState);
-	m_IsOwned = true;
 }
 
 
@@ -173,6 +184,31 @@ void cLuaState::Detach(void)
 
 
 
+void cLuaState::AddPackagePath(const AString & a_PathVariable, const AString & a_Path)
+{
+	// Get the current path:
+	lua_getfield(m_LuaState, LUA_GLOBALSINDEX, "package");                           // Stk: <package>
+	lua_getfield(m_LuaState, -1, a_PathVariable.c_str());                            // Stk: <package> <package.path>
+	size_t len = 0;
+	const char * PackagePath = lua_tolstring(m_LuaState, -1, &len);
+	
+	// Append the new path:
+	AString NewPackagePath(PackagePath, len);
+	NewPackagePath.append(LUA_PATHSEP);
+	NewPackagePath.append(a_Path);
+	
+	// Set the new path to the environment:
+	lua_pop(m_LuaState, 1);                                                          // Stk: <package>
+	lua_pushlstring(m_LuaState, NewPackagePath.c_str(), NewPackagePath.length());    // Stk: <package> <NewPackagePath>
+	lua_setfield(m_LuaState, -2, a_PathVariable.c_str());                            // Stk: <package>
+	lua_pop(m_LuaState, 1);
+	lua_pop(m_LuaState, 1);                                                          // Stk: -
+}
+
+
+
+
+
 bool cLuaState::LoadFile(const AString & a_FileName)
 {
 	ASSERT(IsValid());
@@ -235,7 +271,7 @@ bool cLuaState::PushFunction(const char * a_FunctionName)
 	if (!lua_isfunction(m_LuaState, -1))
 	{
 		LOGWARNING("Error in %s: Could not find function %s()", m_SubsystemName.c_str(), a_FunctionName);
-		lua_pop(m_LuaState, 1);
+		lua_pop(m_LuaState, 2);
 		return false;
 	}
 	m_CurrentFunctionName.assign(a_FunctionName);
@@ -258,7 +294,7 @@ bool cLuaState::PushFunction(int a_FnRef)
 	lua_rawgeti(m_LuaState, LUA_REGISTRYINDEX, a_FnRef);  // same as lua_getref()
 	if (!lua_isfunction(m_LuaState, -1))
 	{
-		lua_pop(m_LuaState, 1);
+		lua_pop(m_LuaState, 2);
 		return false;
 	}
 	m_CurrentFunctionName = "<callback>";
@@ -282,16 +318,20 @@ bool cLuaState::PushFunction(const cTableRef & a_TableRef)
 	if (!lua_istable(m_LuaState, -1))
 	{
 		// Not a table, bail out
-		lua_pop(m_LuaState, 1);
+		lua_pop(m_LuaState, 2);
 		return false;
 	}
 	lua_getfield(m_LuaState, -1, a_TableRef.GetFnName());
 	if (lua_isnil(m_LuaState, -1) || !lua_isfunction(m_LuaState, -1))
 	{
 		// Not a valid function, bail out
-		lua_pop(m_LuaState, 2);
+		lua_pop(m_LuaState, 3);
 		return false;
 	}
+	
+	// Pop the table off the stack:
+	lua_remove(m_LuaState, -2);
+	
 	Printf(m_CurrentFunctionName, "<table-callback %s>", a_TableRef.GetFnName());
 	m_NumCurrentFunctionArgs = 0;
 	return true;
@@ -440,6 +480,18 @@ void cLuaState::Push(cEntity * a_Entity)
 
 
 
+void cLuaState::Push(cProjectileEntity * a_ProjectileEntity)
+{
+	ASSERT(IsValid());
+
+	tolua_pushusertype(m_LuaState, a_ProjectileEntity, "cProjectileEntity");
+	m_NumCurrentFunctionArgs += 1;
+}
+
+
+
+
+
 void cLuaState::Push(cMonster * a_Monster)
 {
 	ASSERT(IsValid());
@@ -646,8 +698,15 @@ void cLuaState::Push(Vector3i * a_Vector)
 
 void cLuaState::Push(void * a_Ptr)
 {
+	UNUSED(a_Ptr);
 	ASSERT(IsValid());
 
+	// Investigate the cause of this - what is the callstack?
+	// One code path leading here is the OnHookExploding / OnHookExploded with exotic parameters. Need to decide what to do with them
+	LOGWARNING("Lua engine: attempting to push a plain pointer, pushing nil instead.");
+	LOGWARNING("This indicates an unimplemented part of MCS bindings");
+	LogStackTrace();
+	
 	lua_pushnil(m_LuaState);
 	m_NumCurrentFunctionArgs += 1;
 }
@@ -680,7 +739,7 @@ void cLuaState::Push(cBlockEntity * a_BlockEntity)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, bool & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, bool & a_ReturnedVal)
 {
 	a_ReturnedVal = (tolua_toboolean(m_LuaState, a_StackPos, a_ReturnedVal ? 1 : 0) > 0);
 }
@@ -689,11 +748,13 @@ void cLuaState::GetReturn(int a_StackPos, bool & a_ReturnedVal)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, AString & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, AString & a_Value)
 {
-	if (lua_isstring(m_LuaState, a_StackPos))
+	size_t len = 0;
+	const char * data = lua_tolstring(m_LuaState, a_StackPos, &len);
+	if (data != NULL)
 	{
-		a_ReturnedVal = tolua_tocppstring(m_LuaState, a_StackPos, a_ReturnedVal.c_str());
+		a_Value.assign(data, len);
 	}
 }
 
@@ -701,7 +762,7 @@ void cLuaState::GetReturn(int a_StackPos, AString & a_ReturnedVal)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, int & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, int & a_ReturnedVal)
 {
 	if (lua_isnumber(m_LuaState, a_StackPos))
 	{
@@ -713,7 +774,7 @@ void cLuaState::GetReturn(int a_StackPos, int & a_ReturnedVal)
 
 
 
-void cLuaState::GetReturn(int a_StackPos, double & a_ReturnedVal)
+void cLuaState::GetStackValue(int a_StackPos, double & a_ReturnedVal)
 {
 	if (lua_isnumber(m_LuaState, a_StackPos))
 	{
@@ -731,17 +792,24 @@ bool cLuaState::CallFunction(int a_NumResults)
 	ASSERT(lua_isfunction(m_LuaState, -m_NumCurrentFunctionArgs - 1));  // The function to call
 	ASSERT(lua_isfunction(m_LuaState, -m_NumCurrentFunctionArgs - 2));  // The error handler
 	
-	int s = lua_pcall(m_LuaState, m_NumCurrentFunctionArgs, a_NumResults, -m_NumCurrentFunctionArgs - 2);
+	// Save the current "stack" state and reset, in case the callback calls another function:
+	AString CurrentFunctionName;
+	std::swap(m_CurrentFunctionName, CurrentFunctionName);
+	int NumArgs = m_NumCurrentFunctionArgs;
+	m_NumCurrentFunctionArgs = -1;
+	
+	// Call the function:
+	int s = lua_pcall(m_LuaState, NumArgs, a_NumResults, -NumArgs - 2);
 	if (s != 0)
 	{
 		// The error has already been printed together with the stacktrace
-		LOGWARNING("Error in %s calling function %s()", m_SubsystemName.c_str(), m_CurrentFunctionName.c_str());
-		m_NumCurrentFunctionArgs = -1;
-		m_CurrentFunctionName.clear();
+		LOGWARNING("Error in %s calling function %s()", m_SubsystemName.c_str(), CurrentFunctionName.c_str());
 		return false;
 	}
-	m_NumCurrentFunctionArgs = -1;
-	m_CurrentFunctionName.clear();
+	
+	// Remove the error handler from the stack:
+	lua_remove(m_LuaState, -a_NumResults - 1);
+	
 	return true;
 }
 
@@ -933,10 +1001,42 @@ bool cLuaState::CheckParamFunction(int a_StartParam, int a_EndParam)
 		lua_Debug entry;
 		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
 		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
-		AString ErrMsg = Printf("Error in function '%s' parameter #%d. Function expected, got %s",
+		luaL_error(m_LuaState, "Error in function '%s' parameter #%d. Function expected, got %s",
+			(entry.name != NULL) ? entry.name : "?", i, GetTypeText(i).c_str()
+		);
+		return false;
+	}  // for i - Param
+	
+	// All params checked ok
+	return true;
+}
+
+
+
+
+
+bool cLuaState::CheckParamFunctionOrNil(int a_StartParam, int a_EndParam)
+{
+	ASSERT(IsValid());
+	
+	if (a_EndParam < 0)
+	{
+		a_EndParam = a_StartParam;
+	}
+	
+	for (int i = a_StartParam; i <= a_EndParam; i++)
+	{
+		if (lua_isfunction(m_LuaState, i) || lua_isnil(m_LuaState, i))
+		{
+			continue;
+		}
+		// Not the correct parameter
+		lua_Debug entry;
+		VERIFY(lua_getstack(m_LuaState, 0,   &entry));
+		VERIFY(lua_getinfo (m_LuaState, "n", &entry));
+		luaL_error(m_LuaState, "Error in function '%s' parameter #%d. Function expected, got %s",
 			(entry.name != NULL) ? entry.name : "?", i, GetTypeText(i).c_str()
 		);
-		LogStackTrace();
 		return false;
 	}  // for i - Param
 	
@@ -994,25 +1094,23 @@ bool cLuaState::ReportErrors(lua_State * a_LuaState, int a_Status)
 
 
 
-void cLuaState::LogStackTrace(void)
+void cLuaState::LogStackTrace(int a_StartingDepth)
 {
-	LogStackTrace(m_LuaState);
+	LogStackTrace(m_LuaState, a_StartingDepth);
 }
 
 
 
 
 
-void cLuaState::LogStackTrace(lua_State * a_LuaState)
+void cLuaState::LogStackTrace(lua_State * a_LuaState, int a_StartingDepth)
 {
 	LOGWARNING("Stack trace:");
 	lua_Debug entry;
-	int depth = 0;
+	int depth = a_StartingDepth;
 	while (lua_getstack(a_LuaState, depth, &entry))
 	{
-		int status = lua_getinfo(a_LuaState, "Sln", &entry);
-		assert(status);
-
+		lua_getinfo(a_LuaState, "Sln", &entry);
 		LOGWARNING("  %s(%d): %s", entry.short_src, entry.currentline, entry.name ? entry.name : "(no name)");
 		depth++;
 	}
@@ -1025,21 +1123,200 @@ void cLuaState::LogStackTrace(lua_State * a_LuaState)
 
 AString cLuaState::GetTypeText(int a_StackPos)
 {
-	int Type = lua_type(m_LuaState, a_StackPos);
-	switch (Type)
+	return lua_typename(m_LuaState, lua_type(m_LuaState, a_StackPos));
+}
+
+
+
+
+
+int cLuaState::CallFunctionWithForeignParams(
+	const AString & a_FunctionName,
+	cLuaState & a_SrcLuaState,
+	int a_SrcParamStart,
+	int a_SrcParamEnd
+)
+{
+	ASSERT(IsValid());
+	ASSERT(a_SrcLuaState.IsValid());
+	
+	// Store the stack position before any changes
+	int OldTop = lua_gettop(m_LuaState);
+	
+	// Push the function to call, including the error handler:
+	if (!PushFunction(a_FunctionName.c_str()))
 	{
-		case LUA_TNONE:          return "TNONE";
-		case LUA_TNIL:           return "TNIL";
-		case LUA_TBOOLEAN:       return "TBOOLEAN";
-		case LUA_TLIGHTUSERDATA: return "TLIGHTUSERDATA";
-		case LUA_TNUMBER:        return "TNUMBER";
-		case LUA_TSTRING:        return "TSTRING";
-		case LUA_TTABLE:         return "TTABLE";
-		case LUA_TFUNCTION:      return "TFUNCTION";
-		case LUA_TUSERDATA:      return "TUSERDATA";
-		case LUA_TTHREAD:        return "TTHREAD";
+		LOGWARNING("Function '%s' not found", a_FunctionName.c_str());
+		lua_pop(m_LuaState, 2);
+		return -1;
 	}
-	return Printf("Unknown (%d)", Type);
+
+	// Copy the function parameters to the target state
+	if (CopyStackFrom(a_SrcLuaState, a_SrcParamStart, a_SrcParamEnd) < 0)
+	{
+		// Something went wrong, fix the stack and exit
+		lua_pop(m_LuaState, 2);
+		m_NumCurrentFunctionArgs = -1;
+		m_CurrentFunctionName.clear();
+		return -1;
+	}
+	
+	// Call the function, with an error handler:
+	int s = lua_pcall(m_LuaState, a_SrcParamEnd - a_SrcParamStart + 1, LUA_MULTRET, OldTop + 1);
+	if (ReportErrors(s))
+	{
+		LOGWARN("Error while calling function '%s' in '%s'", a_FunctionName.c_str(), m_SubsystemName.c_str());
+		// Fix the stack.
+		// We don't know how many values have been pushed, so just get rid of any that weren't there initially
+		int CurTop = lua_gettop(m_LuaState);
+		if (CurTop > OldTop)
+		{
+			lua_pop(m_LuaState, CurTop - OldTop);
+		}
+		
+		// Reset the internal checking mechanisms:
+		m_NumCurrentFunctionArgs = -1;
+		m_CurrentFunctionName.clear();
+		
+		// Make Lua think everything is okay and return 0 values, so that plugins continue executing.
+		// The failure is indicated by the zero return values.
+		return 0;
+	}
+	
+	// Reset the internal checking mechanisms:
+	m_NumCurrentFunctionArgs = -1;
+	m_CurrentFunctionName.clear();
+	
+	// Remove the error handler from the stack:
+	lua_remove(m_LuaState, OldTop + 1);
+	
+	// Return the number of return values:
+	return lua_gettop(m_LuaState) - OldTop;
+}
+
+
+
+
+
+int cLuaState::CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_SrcEnd)
+{
+	/*
+	// DEBUG:
+	LOGD("Copying stack values from %d to %d", a_SrcStart, a_SrcEnd);
+	a_SrcLuaState.LogStack("Src stack before copying:");
+	LogStack("Dst stack before copying:");
+	*/
+	for (int i = a_SrcStart; i <= a_SrcEnd; ++i)
+	{
+		int t = lua_type(a_SrcLuaState, i);
+		switch (t)
+		{
+			case LUA_TNIL:
+			{
+				lua_pushnil(m_LuaState);
+				break;
+			}
+			case LUA_TSTRING:
+			{
+				AString s;
+				a_SrcLuaState.ToString(i, s);
+				Push(s);
+				break;
+			}
+			case LUA_TBOOLEAN:
+			{
+				bool b = (tolua_toboolean(a_SrcLuaState, i, false) != 0);
+				Push(b);
+				break;
+			}
+			case LUA_TNUMBER:
+			{
+				lua_Number d = tolua_tonumber(a_SrcLuaState, i, 0);
+				Push(d);
+				break;
+			}
+			case LUA_TUSERDATA:
+			{
+				// Get the class name:
+				const char * type = NULL;
+				if (lua_getmetatable(a_SrcLuaState, i) == 0)
+				{
+					LOGWARNING("%s: Unknown class in pos %d, cannot copy.", __FUNCTION__, i);
+					lua_pop(m_LuaState, i - a_SrcStart);
+					return -1;
+				}
+				lua_rawget(a_SrcLuaState, LUA_REGISTRYINDEX);  // Stack +1
+				type = lua_tostring(a_SrcLuaState, -1);
+				lua_pop(a_SrcLuaState, 1);                     // Stack -1
+				
+				// Copy the value:
+				void * ud = tolua_touserdata(a_SrcLuaState, i, NULL);
+				tolua_pushusertype(m_LuaState, ud, type);
+				break;
+			}
+			default:
+			{
+				LOGWARNING("%s: Unsupported value: '%s' at stack position %d. Can only copy numbers, strings, bools and classes!",
+					__FUNCTION__, lua_typename(a_SrcLuaState, t), i
+				);
+				a_SrcLuaState.LogStack("Stack where copying failed:");
+				lua_pop(m_LuaState, i - a_SrcStart);
+				return -1;
+			}
+		}
+	}
+	return a_SrcEnd - a_SrcStart + 1;
+}
+
+
+
+
+
+void cLuaState::ToString(int a_StackPos, AString & a_String)
+{
+	size_t len;
+	const char * s = lua_tolstring(m_LuaState, a_StackPos, &len);
+	if (s != NULL)
+	{
+		a_String.assign(s, len);
+	}
+}
+
+
+
+
+
+void cLuaState::LogStack(const char * a_Header)
+{
+	LogStack(m_LuaState, a_Header);
+}
+
+
+
+
+
+void cLuaState::LogStack(lua_State * a_LuaState, const char * a_Header)
+{
+	UNUSED(a_Header);  // The param seems unused when compiling for release, so the compiler warns
+	
+	
+	// Format string consisting only of %s is used to appease the compiler
+	LOGD("%s",(a_Header != NULL) ? a_Header : "Lua C API Stack contents:");
+	for (int i = lua_gettop(a_LuaState); i > 0; i--)
+	{
+		AString Value;
+		int Type = lua_type(a_LuaState, i);
+		switch (Type)
+		{
+			case LUA_TBOOLEAN: Value.assign((lua_toboolean(a_LuaState, i) != 0) ? "true" : "false"); break;
+			case LUA_TLIGHTUSERDATA: Printf(Value, "%p", lua_touserdata(a_LuaState, i)); break;
+			case LUA_TNUMBER:        Printf(Value, "%f", (double)lua_tonumber(a_LuaState, i)); break;
+			case LUA_TSTRING:        Printf(Value, "%s", lua_tostring(a_LuaState, i)); break;
+			case LUA_TTABLE:         Printf(Value, "%p", lua_topointer(a_LuaState, i)); break;
+			default: break;
+		}
+		LOGD("  Idx %d: type %d (%s) %s", i, Type, lua_typename(a_LuaState, Type), Value.c_str());
+	}  // for i - stack idx
 }
 
 
@@ -1049,7 +1326,7 @@ AString cLuaState::GetTypeText(int a_StackPos)
 int cLuaState::ReportFnCallErrors(lua_State * a_LuaState)
 {
 	LOGWARNING("LUA: %s", lua_tostring(a_LuaState, -1));
-	LogStackTrace(a_LuaState);
+	LogStackTrace(a_LuaState, 1);
 	return 1;  // We left the error message on the stack as the return value
 }
 
@@ -1060,13 +1337,21 @@ int cLuaState::ReportFnCallErrors(lua_State * a_LuaState)
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cLuaState::cRef:
 
+cLuaState::cRef::cRef(void) :
+	m_LuaState(NULL),
+	m_Ref(LUA_REFNIL)
+{
+}
+
+
+
+
+
 cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
-	m_LuaState(a_LuaState)
+	m_LuaState(NULL),
+	m_Ref(LUA_REFNIL)
 {
-	ASSERT(m_LuaState.IsValid());
-	
-	lua_pushvalue(m_LuaState, a_StackPos);  // Push a copy of the value at a_StackPos onto the stack
-	m_Ref = luaL_ref(m_LuaState, LUA_REGISTRYINDEX);
+	RefStack(a_LuaState, a_StackPos);
 }
 
 
@@ -1075,12 +1360,42 @@ cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
 
 cLuaState::cRef::~cRef()
 {
-	ASSERT(m_LuaState.IsValid());
+	if (m_LuaState != NULL)
+	{
+		UnRef();
+	}
+}
+
+
+
+
+
+void cLuaState::cRef::RefStack(cLuaState & a_LuaState, int a_StackPos)
+{
+	ASSERT(a_LuaState.IsValid());
+	if (m_LuaState != NULL)
+	{
+		UnRef();
+	}
+	m_LuaState = &a_LuaState;
+	lua_pushvalue(a_LuaState, a_StackPos);  // Push a copy of the value at a_StackPos onto the stack
+	m_Ref = luaL_ref(a_LuaState, LUA_REGISTRYINDEX);
+}
+
+
+
+
+
+void cLuaState::cRef::UnRef(void)
+{
+	ASSERT(m_LuaState->IsValid());  // The reference should be destroyed before destroying the LuaState
 	
 	if (IsValid())
 	{
-		luaL_unref(m_LuaState, LUA_REGISTRYINDEX, m_Ref);
+		luaL_unref(*m_LuaState, LUA_REGISTRYINDEX, m_Ref);
 	}
+	m_LuaState = NULL;
+	m_Ref = LUA_REFNIL;
 }
 
 
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index f8b67f5cd..b9ca2f29b 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -29,6 +29,8 @@ extern "C"
 	#include "lua/src/lauxlib.h"
 }
 
+#include "../Vector3.h"
+
 
 
 
@@ -36,6 +38,7 @@ extern "C"
 class cWorld;
 class cPlayer;
 class cEntity;
+class cProjectileEntity;
 class cMonster;
 class cItem;
 class cItems;
@@ -52,7 +55,6 @@ class cWebAdmin;
 struct HTTPTemplateRequest;
 class cTNTEntity;
 class cCreeper;
-class Vector3i;
 class cHopperEntity;
 class cBlockEntity;
 
@@ -60,27 +62,40 @@ class cBlockEntity;
 
 
 
-/// Encapsulates a Lua state and provides some syntactic sugar for common operations
+/** Encapsulates a Lua state and provides some syntactic sugar for common operations */
 class cLuaState
 {
 public:
 
-	/// Used for storing references to object in the global registry
+	/** Used for storing references to object in the global registry.
+	Can be bound (contains a reference) or unbound (doesn't contain reference).
+	The reference can also be reset by calling RefStack(). */
 	class cRef
 	{
 	public:
-		/// Creates a reference in the specified LuaState for object at the specified StackPos
+		/** Creates an unbound reference object. */
+		cRef(void);
+		
+		/** Creates a reference in the specified LuaState for object at the specified StackPos */
 		cRef(cLuaState & a_LuaState, int a_StackPos);
+		
 		~cRef();
 		
-		/// Returns true if the reference is valid
+		/** Creates a reference to Lua object at the specified stack pos, binds this object to it.
+		Calls UnRef() first if previously bound to another reference. */
+		void RefStack(cLuaState & a_LuaState, int a_StackPos);
+		
+		/** Removes the bound reference, resets the object to Unbound state. */
+		void UnRef(void);
+		
+		/** Returns true if the reference is valid */
 		bool IsValid(void) const {return (m_Ref != LUA_REFNIL); }
 		
-		/// Allows to use this class wherever an int (i. e. ref) is to be used
+		/** Allows to use this class wherever an int (i. e. ref) is to be used */
 		operator int(void) const { return m_Ref; }
 		
 	protected:
-		cLuaState & m_LuaState;
+		cLuaState * m_LuaState;
 		int m_Ref;
 	} ;
 	
@@ -102,7 +117,7 @@ public:
 	} ;
 	
 	
-	/// A dummy class that's used only to delimit function args from return values for cLuaState::Call()
+	/** A dummy class that's used only to delimit function args from return values for cLuaState::Call() */
 	class cRet
 	{
 	} ;
@@ -123,31 +138,39 @@ public:
 	
 	~cLuaState();
 	
-	/// Allows this object to be used in the same way as a lua_State *, for example in the LuaLib functions
+	/** Allows this object to be used in the same way as a lua_State *, for example in the LuaLib functions */
 	operator lua_State * (void) { return m_LuaState; }
 	
-	/// Creates the m_LuaState, if not closed already. This state will be automatically closed in the destructor
+	/** Creates the m_LuaState, if not closed already. This state will be automatically closed in the destructor.
+	The regular Lua libs are registered, but the MCS API is not registered (so that Lua can be used as
+	lite-config as well), use RegisterAPILibs() to do that. */
 	void Create(void);
 	
-	/// Closes the m_LuaState, if not closed already
+	/** Registers all the API libraries that MCS provides into m_LuaState. */
+	void RegisterAPILibs(void);
+	
+	/** Closes the m_LuaState, if not closed already */
 	void Close(void);
 	
-	/// Attaches the specified state. Operations will be carried out on this state, but it will not be closed in the destructor
+	/** Attaches the specified state. Operations will be carried out on this state, but it will not be closed in the destructor */
 	void Attach(lua_State * a_State);
 	
-	/// Detaches a previously attached state.
+	/** Detaches a previously attached state. */
 	void Detach(void);
 	
-	/// Returns true if the m_LuaState is valid
+	/** Returns true if the m_LuaState is valid */
 	bool IsValid(void) const { return (m_LuaState != NULL); }
 	
+	/** Adds the specified path to package.<a_PathVariable> */
+	void AddPackagePath(const AString & a_PathVariable, const AString & a_Path);
+	
 	/** Loads the specified file
 	Returns false and logs a warning to the console if not successful (but the LuaState is kept open).
 	m_SubsystemName is displayed in the warning log message.
 	*/
 	bool LoadFile(const AString & a_FileName);
 	
-	/// Returns true if a_FunctionName is a valid Lua function that can be called
+	/** Returns true if a_FunctionName is a valid Lua function that can be called */
 	bool HasFunction(const char * a_FunctionName);
 	
 	// Push a value onto the stack
@@ -161,6 +184,7 @@ public:
 	void Push(cPlayer * a_Player);
 	void Push(const cPlayer * a_Player);
 	void Push(cEntity * a_Entity);
+	void Push(cProjectileEntity * a_ProjectileEntity);
 	void Push(cMonster * a_Monster);
 	void Push(cItem * a_Item);
 	void Push(cItems * a_Items);
@@ -181,8 +205,21 @@ public:
 	void Push(void * a_Ptr);
 	void Push(cHopperEntity * a_Hopper);
 	void Push(cBlockEntity * a_BlockEntity);
+	
+	/** Retrieve value at a_StackPos, if it is a valid bool. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, bool & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid string. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, AString & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid number. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, int & a_Value);
+	
+	/** Retrieve value at a_StackPos, if it is a valid number. If not, a_Value is unchanged */
+	void GetStackValue(int a_StackPos, double & a_Value);
+	
 
-	/// Call any 0-param 0-return Lua function in a single line:
+	/** Call any 0-param 0-return Lua function in a single line: */
 	template <typename FnT>
 	bool Call(FnT a_FnName)
 	{
@@ -193,7 +230,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 1-param 0-return Lua function in a single line:
+	/** Call any 1-param 0-return Lua function in a single line: */
 	template<
 		typename FnT,
 		typename ArgT1
@@ -208,7 +245,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 2-param 0-return Lua function in a single line:
+	/** Call any 2-param 0-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2
 	>
@@ -223,7 +260,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 3-param 0-return Lua function in a single line:
+	/** Call any 3-param 0-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3
 	>
@@ -239,7 +276,7 @@ public:
 		return CallFunction(0);
 	}
 
-	/// Call any 0-param 1-return Lua function in a single line:
+	/** Call any 0-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename RetT1
 	>
@@ -254,17 +291,18 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 
-	/// Call any 1-param 1-return Lua function in a single line:
+	/** Call any 1-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename RetT1
 	>
 	bool Call(FnT a_FnName, ArgT1 a_Arg1, const cRet & a_Mark, RetT1 & a_Ret1)
 	{
+		int InitialTop = lua_gettop(m_LuaState);
 		UNUSED(a_Mark);
 		if (!PushFunction(a_FnName))
 		{
@@ -275,12 +313,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
+		ASSERT(InitialTop == lua_gettop(m_LuaState));
 		return true;
 	}
 
-	/// Call any 2-param 1-return Lua function in a single line:
+	/** Call any 2-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename RetT1
 	>
@@ -297,12 +336,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 
-	/// Call any 3-param 1-return Lua function in a single line:
+	/** Call any 3-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename RetT1
 	>
@@ -320,12 +359,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 4-param 1-return Lua function in a single line:
+	/** Call any 4-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename RetT1
 	>
@@ -344,12 +383,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 5-param 1-return Lua function in a single line:
+	/** Call any 5-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename RetT1
 	>
@@ -369,12 +408,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 6-param 1-return Lua function in a single line:
+	/** Call any 6-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename RetT1
@@ -396,12 +435,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 7-param 1-return Lua function in a single line:
+	/** Call any 7-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename RetT1
@@ -424,12 +463,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 8-param 1-return Lua function in a single line:
+	/** Call any 8-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename ArgT8, typename RetT1
@@ -453,12 +492,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 9-param 1-return Lua function in a single line:
+	/** Call any 9-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename ArgT8, typename ArgT9, typename RetT1
@@ -483,12 +522,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 10-param 1-return Lua function in a single line:
+	/** Call any 10-param 1-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5, typename ArgT6,
 		typename ArgT7, typename ArgT8, typename ArgT9, typename ArgT10, typename RetT1
@@ -514,12 +553,12 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
 	
-	/// Call any 1-param 2-return Lua function in a single line:
+	/** Call any 1-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename RetT1, typename RetT2
 	>
@@ -535,13 +574,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 2-param 2-return Lua function in a single line:
+	/** Call any 2-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename RetT1, typename RetT2
 	>
@@ -558,13 +597,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 3-param 2-return Lua function in a single line:
+	/** Call any 3-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3,
 		typename RetT1, typename RetT2
@@ -583,13 +622,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 4-param 2-return Lua function in a single line:
+	/** Call any 4-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4,
 		typename RetT1, typename RetT2
@@ -609,13 +648,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 5-param 2-return Lua function in a single line:
+	/** Call any 5-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename RetT1, typename RetT2
@@ -636,13 +675,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 6-param 2-return Lua function in a single line:
+	/** Call any 6-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6,
@@ -665,13 +704,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 7-param 2-return Lua function in a single line:
+	/** Call any 7-param 2-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7,
@@ -695,13 +734,13 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-2, a_Ret1);
-		GetReturn(-1, a_Ret2);
+		GetStackValue(-2, a_Ret1);
+		GetStackValue(-1, a_Ret2);
 		lua_pop(m_LuaState, 2);
 		return true;
 	}
 
-	/// Call any 7-param 3-return Lua function in a single line:
+	/** Call any 7-param 3-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7,
@@ -725,14 +764,14 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-3, a_Ret1);
-		GetReturn(-2, a_Ret2);
-		GetReturn(-1, a_Ret3);
+		GetStackValue(-3, a_Ret1);
+		GetStackValue(-2, a_Ret2);
+		GetStackValue(-1, a_Ret3);
 		lua_pop(m_LuaState, 3);
 		return true;
 	}
 
-	/// Call any 8-param 3-return Lua function in a single line:
+	/** Call any 8-param 3-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7, typename ArgT8,
@@ -757,14 +796,14 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-3, a_Ret1);
-		GetReturn(-2, a_Ret2);
-		GetReturn(-1, a_Ret3);
+		GetStackValue(-3, a_Ret1);
+		GetStackValue(-2, a_Ret2);
+		GetStackValue(-1, a_Ret3);
 		lua_pop(m_LuaState, 3);
 		return true;
 	}
 
-	/// Call any 9-param 5-return Lua function in a single line:
+	/** Call any 9-param 5-return Lua function in a single line: */
 	template<
 		typename FnT, typename ArgT1, typename ArgT2, typename ArgT3, typename ArgT4, typename ArgT5,
 		typename ArgT6, typename ArgT7, typename ArgT8, typename ArgT9, 
@@ -790,56 +829,84 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-5, a_Ret1);
-		GetReturn(-4, a_Ret2);
-		GetReturn(-3, a_Ret3);
-		GetReturn(-2, a_Ret4);
-		GetReturn(-1, a_Ret5);
+		GetStackValue(-5, a_Ret1);
+		GetStackValue(-4, a_Ret2);
+		GetStackValue(-3, a_Ret3);
+		GetStackValue(-2, a_Ret4);
+		GetStackValue(-1, a_Ret5);
 		lua_pop(m_LuaState, 5);
 		return true;
 	}
 
 
-	/// Returns true if the specified parameters on the stack are of the specified usertable type; also logs warning if not. Used for static functions
+	/** Returns true if the specified parameters on the stack are of the specified usertable type; also logs warning if not. Used for static functions */
 	bool CheckParamUserTable(int a_StartParam, const char * a_UserTable, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are of the specified usertype; also logs warning if not. Used for regular functions
+	/** Returns true if the specified parameters on the stack are of the specified usertype; also logs warning if not. Used for regular functions */
 	bool CheckParamUserType(int a_StartParam, const char * a_UserType, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are tables; also logs warning if not
+	/** Returns true if the specified parameters on the stack are tables; also logs warning if not */
 	bool CheckParamTable(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are numbers; also logs warning if not
+	/** Returns true if the specified parameters on the stack are numbers; also logs warning if not */
 	bool CheckParamNumber(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are strings; also logs warning if not
+	/** Returns true if the specified parameters on the stack are strings; also logs warning if not */
 	bool CheckParamString(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameters on the stack are functions; also logs warning if not
+	/** Returns true if the specified parameters on the stack are functions; also logs warning if not */
 	bool CheckParamFunction(int a_StartParam, int a_EndParam = -1);
 	
-	/// Returns true if the specified parameter on the stack is nil (indicating an end-of-parameters)
+	/** Returns true if the specified parameters on the stack are functions or nils; also logs warning if not */
+	bool CheckParamFunctionOrNil(int a_StartParam, int a_EndParam = -1);
+	
+	/** Returns true if the specified parameter on the stack is nil (indicating an end-of-parameters) */
 	bool CheckParamEnd(int a_Param);
 	
-	/// If the status is nonzero, prints the text on the top of Lua stack and returns true
+	/** If the status is nonzero, prints the text on the top of Lua stack and returns true */
 	bool ReportErrors(int status);
 	
-	/// If the status is nonzero, prints the text on the top of Lua stack and returns true
+	/** If the status is nonzero, prints the text on the top of Lua stack and returns true */
 	static bool ReportErrors(lua_State * a_LuaState, int status);
 	
-	/// Logs all items in the current stack trace to the server console
-	void LogStackTrace(void);
+	/** Logs all items in the current stack trace to the server console */
+	void LogStackTrace(int a_StartingDepth = 0);
 	
-	/// Logs all items in the current stack trace to the server console
-	static void LogStackTrace(lua_State * a_LuaState);
+	/** Logs all items in the current stack trace to the server console */
+	static void LogStackTrace(lua_State * a_LuaState, int a_StartingDepth = 0);
 	
-	/// Returns the type of the item on the specified position in the stack
+	/** Returns the type of the item on the specified position in the stack */
 	AString GetTypeText(int a_StackPos);
 	
+	/** Calls the function specified by its name, with arguments copied off the foreign state.
+	If successful, keeps the return values on the stack and returns their number.
+	If unsuccessful, returns a negative number and keeps the stack position unchanged. */
+	int CallFunctionWithForeignParams(
+		const AString & a_FunctionName,
+		cLuaState & a_SrcLuaState,
+		int a_SrcParamStart,
+		int a_SrcParamEnd
+	);
+	
+	/** Copies objects on the stack from the specified state.
+	Only numbers, bools, strings and userdatas are copied.
+	If successful, returns the number of objects copied.
+	If failed, returns a negative number and rewinds the stack position. */
+	int CopyStackFrom(cLuaState & a_SrcLuaState, int a_SrcStart, int a_SrcEnd);
+	
+	/** Reads the value at the specified stack position as a string and sets it to a_String. */
+	void ToString(int a_StackPos, AString & a_String);
+
+	/** Logs all the elements' types on the API stack, with an optional header for the listing. */
+	void LogStack(const char * a_Header);
+	
+	/** Logs all the elements' types on the API stack, with an optional header for the listing. */
+	static void LogStack(lua_State * a_LuaState, const char * a_Header = NULL);
+	
 protected:
 	lua_State * m_LuaState;
 	
-	/// If true, the state is owned by this object and will be auto-Closed. False => attached state
+	/** If true, the state is owned by this object and will be auto-Closed. False => attached state */
 	bool m_IsOwned;
 	
 	/** The subsystem name is used for reporting errors to the console, it is either "plugin %s" or "LuaScript"
@@ -847,10 +914,10 @@ protected:
 	*/
 	AString m_SubsystemName;
 	
-	/// Name of the currently pushed function (for the Push / Call chain)
+	/** Name of the currently pushed function (for the Push / Call chain) */
 	AString m_CurrentFunctionName;
 	
-	/// Number of arguments currently pushed (for the Push / Call chain)
+	/** Number of arguments currently pushed (for the Push / Call chain) */
 	int m_NumCurrentFunctionArgs;
 
 
@@ -869,21 +936,9 @@ protected:
 	*/
 	bool PushFunction(const cTableRef & a_TableRef);
 	
-	/// Pushes a usertype of the specified class type onto the stack
+	/** Pushes a usertype of the specified class type onto the stack */
 	void PushUserType(void * a_Object, const char * a_Type);
 
-	/// Retrieve value returned at a_StackPos, if it is a valid bool. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, bool & a_ReturnedVal);
-	
-	/// Retrieve value returned at a_StackPos, if it is a valid string. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, AString & a_ReturnedVal);
-	
-	/// Retrieve value returned at a_StackPos, if it is a valid number. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, int & a_ReturnedVal);
-	
-	/// Retrieve value returned at a_StackPos, if it is a valid number. If not, a_ReturnedVal is unchanged
-	void GetReturn(int a_StackPos, double & a_ReturnedVal);
-	
 	/**
 	Calls the function that has been pushed onto the stack by PushFunction(),
 	with arguments pushed by PushXXX().
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index 2206dd371..92b410481 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -2,17 +2,20 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "ManualBindings.h"
+#undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 
 #include "Plugin.h"
 #include "PluginLua.h"
 #include "PluginManager.h"
 #include "LuaWindow.h"
+#include "LuaChunkStay.h"
 #include "../Root.h"
 #include "../World.h"
 #include "../Entities/Player.h"
 #include "../WebAdmin.h"
 #include "../ClientHandle.h"
+#include "../BlockArea.h"
 #include "../BlockEntities/ChestEntity.h"
 #include "../BlockEntities/CommandBlockEntity.h"
 #include "../BlockEntities/DispenserEntity.h"
@@ -20,8 +23,12 @@
 #include "../BlockEntities/FurnaceEntity.h"
 #include "../BlockEntities/HopperEntity.h"
 #include "../BlockEntities/NoteEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 #include "md5/md5.h"
 #include "../LineBlockTracer.h"
+#include "../WorldStorage/SchematicFileSerializer.h"
+#include "../CompositeChat.h"
 
 
 
@@ -109,10 +116,44 @@ static int tolua_StringSplitAndTrim(lua_State * tolua_S)
 
 
 
-static int tolua_LOG(lua_State* tolua_S)
+/** Retrieves the log message from the first param on the Lua stack.
+Can take either a string or a cCompositeChat.
+*/
+static AString GetLogMessage(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 0 );
+	tolua_Error err;
+	if (tolua_isusertype(tolua_S, 1, "cCompositeChat", false, &err))
+	{
+		return ((cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL))->ExtractText();
+	}
+	else
+	{
+		size_t len = 0;
+		const char * str = lua_tolstring(tolua_S, 1, &len);
+		if (str != NULL)
+		{
+			return AString(str, len);
+		}
+	}
+	return "";
+}
+
+
+
+
+
+static int tolua_LOG(lua_State * tolua_S)
+{
+	// If the param is a cCompositeChat, read the log level from it:
+	cMCLogger::eLogLevel LogLevel = cMCLogger::llRegular;
+	tolua_Error err;
+	if (tolua_isusertype(tolua_S, 1, "cCompositeChat", false, &err))
+	{
+		LogLevel = cCompositeChat::MessageTypeToLogLevel(((cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL))->GetMessageType());
+	}
+	
+	// Log the message:
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), LogLevel);
 	return 0;
 }
 
@@ -120,10 +161,9 @@ static int tolua_LOG(lua_State* tolua_S)
 
 
 
-static int tolua_LOGINFO(lua_State* tolua_S)
+static int tolua_LOGINFO(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 1 );
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), cMCLogger::llInfo);
 	return 0;
 }
 
@@ -131,10 +171,9 @@ static int tolua_LOGINFO(lua_State* tolua_S)
 
 
 
-static int tolua_LOGWARN(lua_State* tolua_S)
+static int tolua_LOGWARN(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 2 );
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), cMCLogger::llWarning);
 	return 0;
 }
 
@@ -142,10 +181,9 @@ static int tolua_LOGWARN(lua_State* tolua_S)
 
 
 
-static int tolua_LOGERROR(lua_State* tolua_S)
+static int tolua_LOGERROR(lua_State * tolua_S)
 {
-	const char* str = tolua_tocppstring(tolua_S,1,0);
-	cMCLogger::GetInstance()->LogSimple( str, 3 );
+	cMCLogger::GetInstance()->LogSimple(GetLogMessage(tolua_S).c_str(), cMCLogger::llError);
 	return 0;
 }
 
@@ -153,6 +191,50 @@ static int tolua_LOGERROR(lua_State* tolua_S)
 
 
 
+static int tolua_Base64Encode(lua_State * tolua_S)
+{
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamString(1) ||
+		!L.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	AString Src;
+	L.GetStackValue(1, Src);
+	AString res = Base64Encode(Src);
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_Base64Decode(lua_State * tolua_S)
+{
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamString(1) ||
+		!L.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	AString Src;
+	L.GetStackValue(1, Src);
+	AString res = Base64Decode(Src);
+	L.Push(res);
+	return 1;
+}
+
+
+
+
+
 cPluginLua * GetLuaPlugin(lua_State * L)
 {
 	// Get the plugin identification out of LuaState:
@@ -209,7 +291,7 @@ static int tolua_DoWith(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const char * ItemName = tolua_tocppstring(tolua_S, 2, "");
 	if ((ItemName == NULL) || (ItemName[0] == 0))
@@ -303,7 +385,7 @@ static int tolua_DoWithID(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, NULL);
 
 	int ItemID = (int)tolua_tonumber(tolua_S, 2, 0);
 	if (!lua_isfunction(tolua_S, 3))
@@ -393,7 +475,7 @@ static int tolua_DoWithXYZ(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 4 or 5 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3) || !lua_isnumber(tolua_S, 4))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1, #2 and #3");
@@ -487,7 +569,7 @@ static int tolua_ForEachInChunk(lua_State* tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 3 or 4 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 	if (!lua_isnumber(tolua_S, 2) || !lua_isnumber(tolua_S, 3))
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a number for parameters #1 and #2");
@@ -581,7 +663,7 @@ static int tolua_ForEach(lua_State * tolua_S)
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 1 or 2 arguments, got %i", NumArgs);
 	}
 
-	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, 0);
+	Ty1 * self = (Ty1 *)  tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
@@ -678,7 +760,7 @@ static int tolua_cWorld_GetBlockInfo(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -733,7 +815,7 @@ static int tolua_cWorld_GetBlockTypeMeta(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -785,7 +867,7 @@ static int tolua_cWorld_GetSignLines(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -843,7 +925,7 @@ static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockY          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 4, 0);
@@ -892,7 +974,7 @@ static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
 	else
 	#endif
 	{
-		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
+		cWorld * self       = (cWorld *) tolua_tousertype (tolua_S, 1, NULL);
 		int BlockX          = (int)      tolua_tonumber   (tolua_S, 2, 0);
 		int BlockZ          = (int)      tolua_tonumber   (tolua_S, 3, 0);
 		#ifndef TOLUA_RELEASE
@@ -904,8 +986,12 @@ static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
 		{
 			int Height = 0;
 			bool res = self->TryGetHeight(BlockX, BlockZ, Height);
-			tolua_pushnumber(tolua_S, Height);
 			tolua_pushboolean(tolua_S, res ? 1 : 0);
+			if (res)
+			{
+				tolua_pushnumber(tolua_S, Height);
+				return 2;
+			}
 		}
 	}
 	return 1;
@@ -960,7 +1046,7 @@ static int tolua_cWorld_QueueTask(lua_State * tolua_S)
 	}
 
 	// Retrieve the args:
-	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, 0);
+	cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		return lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
@@ -1058,7 +1144,7 @@ static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
 
 static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
 {
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, 0);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
 
 	const cPluginManager::PluginMap & AllPlugins = self->GetAllPlugins();
 
@@ -1104,6 +1190,16 @@ static int tolua_cPluginManager_GetCurrentPlugin(lua_State * S)
 
 
 
+static int tolua_cPluginManager_LogStackTrace(lua_State * S)
+{
+	cLuaState::LogStackTrace(S);
+	return 0;
+}
+
+
+
+
+
 static int tolua_cPluginManager_AddHook_FnRef(cPluginManager * a_PluginManager, cLuaState & S, int a_ParamIdx)
 {
 	// Helper function for cPluginmanager:AddHook() binding
@@ -1272,7 +1368,7 @@ static int tolua_cPluginManager_ForEachCommand(lua_State * tolua_S)
 		return 0;
 	}
 
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, 0);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		LOGWARN("Error in function call 'ForEachCommand': Not called on an object instance");
@@ -1303,7 +1399,9 @@ static int tolua_cPluginManager_ForEachCommand(lua_State * tolua_S)
 	private:
 		virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) override
 		{
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
+			UNUSED(a_Plugin);
+			
+			lua_rawgeti(LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
 			tolua_pushcppstring(LuaState, a_Command);
 			tolua_pushcppstring(LuaState, a_Permission);
 			tolua_pushcppstring(LuaState, a_HelpString);
@@ -1347,7 +1445,7 @@ static int tolua_cPluginManager_ForEachConsoleCommand(lua_State * tolua_S)
 		return 0;
 	}
 
-	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, 0);
+	cPluginManager * self = (cPluginManager *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		LOGWARN("Error in function call 'ForEachConsoleCommand': Not called on an object instance");
@@ -1378,7 +1476,10 @@ static int tolua_cPluginManager_ForEachConsoleCommand(lua_State * tolua_S)
 	private:
 		virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) override
 		{
-			lua_rawgeti( LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
+			UNUSED(a_Plugin);
+			UNUSED(a_Permission);
+			
+			lua_rawgeti(LuaState, LUA_REGISTRYINDEX, FuncRef);  /* Push function reference */
 			tolua_pushcppstring(LuaState, a_Command);
 			tolua_pushcppstring(LuaState, a_HelpString);
 
@@ -1427,7 +1528,10 @@ static int tolua_cPluginManager_BindCommand(lua_State * L)
 	// Read the arguments to this API call:
 	tolua_Error tolua_err;
 	int idx = 1;
-	if (tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err))
+	if (
+		tolua_isusertype (L, 1, "cPluginManager", 0, &tolua_err) ||
+		tolua_isusertable(L, 1, "cPluginManager", 0, &tolua_err)
+	)
 	{
 		idx++;
 	}
@@ -1469,7 +1573,8 @@ static int tolua_cPluginManager_BindCommand(lua_State * L)
 	}
 	
 	Plugin->BindCommand(Command, FnRef);
-	return 0;
+	lua_pushboolean(L, true);
+	return 1;
 }
 
 
@@ -1493,7 +1598,10 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	// Read the arguments to this API call:
 	tolua_Error tolua_err;
 	int idx = 1;
-	if (tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err))
+	if (
+		tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err) ||
+		tolua_isusertable(L, 1, "cPluginManager", 0, &tolua_err)
+	)
 	{
 		idx++;
 	}
@@ -1533,6 +1641,131 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	}
 	
 	Plugin->BindConsoleCommand(Command, FnRef);
+	lua_pushboolean(L, true);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cPluginManager_CallPlugin(lua_State * tolua_S)
+{
+	/*
+	Function signature:
+	cPluginManager:CallPlugin("PluginName", "FunctionName", args...)
+	*/
+	
+	// Check the parameters:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserTable(1, "cPluginManager") ||
+		!L.CheckParamString(2, 3))
+	{
+		return 0;
+	}
+	
+	// Retrieve the plugin name and function name
+	AString PluginName, FunctionName;
+	L.ToString(2, PluginName);
+	L.ToString(3, FunctionName);
+	if (PluginName.empty() || FunctionName.empty())
+	{
+		LOGWARNING("cPluginManager:CallPlugin(): Invalid plugin name or function name");
+		L.LogStackTrace();
+		return 0;
+	}
+	
+	// If requesting calling the current plugin, refuse:
+	cPluginLua * ThisPlugin = GetLuaPlugin(L);
+	if (ThisPlugin == NULL)
+	{
+		return 0;
+	}
+	if (ThisPlugin->GetName() == PluginName)
+	{
+		LOGWARNING("cPluginManager::CallPlugin(): Calling self is not implemented (why would it?)");
+		L.LogStackTrace();
+		return 0;
+	}
+	
+	// Call the destination plugin using a plugin callback:
+	class cCallback :
+		public cPluginManager::cPluginCallback
+	{
+	public:
+		int m_NumReturns;
+
+		cCallback(const AString & a_FunctionName, cLuaState & a_SrcLuaState) :
+			m_NumReturns(0),
+			m_FunctionName(a_FunctionName),
+			m_SrcLuaState(a_SrcLuaState)
+		{
+		}
+	protected:
+		const AString & m_FunctionName;
+		cLuaState & m_SrcLuaState;
+		
+		virtual bool Item(cPlugin * a_Plugin) override
+		{
+			m_NumReturns = ((cPluginLua *)a_Plugin)->CallFunctionFromForeignState(
+				m_FunctionName, m_SrcLuaState, 4, lua_gettop(m_SrcLuaState)
+			);
+			return true;
+		}
+	} Callback(FunctionName, L);
+	if (!cPluginManager::Get()->DoWithPlugin(PluginName, Callback))
+	{
+		// TODO 2014_01_20 _X: This might be too much logging, plugins cannot know if other plugins are loaded (async)
+		LOGWARNING("cPluginManager::CallPlugin: No such plugin name (\"%s\")", PluginName.c_str());
+		L.LogStackTrace();
+		return 0;
+	}
+	return Callback.m_NumReturns;
+}
+
+
+
+
+
+static int tolua_cWorld_ChunkStay(lua_State * tolua_S)
+{
+	/* Function signature:
+	World:ChunkStay(ChunkCoordTable, OnChunkAvailable, OnAllChunksAvailable)
+	ChunkCoordTable == { {Chunk1x, Chunk1z}, {Chunk2x, Chunk2z}, ... }
+	*/
+	
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType     (1, "cWorld") ||
+		!L.CheckParamTable        (2) ||
+		!L.CheckParamFunctionOrNil(3, 4)
+	)
+	{
+		return 0;
+	}
+	
+	cPluginLua * Plugin = GetLuaPlugin(tolua_S);
+	if (Plugin == NULL)
+	{
+		return 0;
+	}
+	cLuaChunkStay * ChunkStay = new cLuaChunkStay(*Plugin);
+	
+	// Read the params:
+	cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, NULL);
+	if (World == NULL)
+	{
+		LOGWARNING("World:ChunkStay(): invalid world parameter");
+		L.LogStackTrace();
+		return 0;
+	}
+	if (!ChunkStay->AddChunks(2))
+	{
+		return 0;
+	}
+
+	ChunkStay->Enable(*World->GetChunkMap(), 3, 4);
 	return 0;
 }
 
@@ -1542,7 +1775,7 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 
 static int tolua_cPlayer_GetGroups(lua_State* tolua_S)
 {
-	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,0);
+	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const cPlayer::GroupList & AllGroups = self->GetGroups();
 
@@ -1567,7 +1800,7 @@ static int tolua_cPlayer_GetGroups(lua_State* tolua_S)
 
 static int tolua_cPlayer_GetResolvedPermissions(lua_State* tolua_S)
 {
-	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,0);
+	cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	cPlayer::StringList AllPermissions = self->GetResolvedPermissions();
 
@@ -1680,7 +1913,7 @@ static int tolua_SetObjectCallback(lua_State * tolua_S)
 
 static int tolua_cPluginLua_AddWebTab(lua_State * tolua_S)
 {
-	cPluginLua * self = (cPluginLua *)tolua_tousertype(tolua_S,1,0);
+	cPluginLua * self = (cPluginLua *)tolua_tousertype(tolua_S, 1, NULL);
 
 	tolua_Error tolua_err;
 	tolua_err.array = 0;
@@ -1724,7 +1957,7 @@ static int tolua_cPluginLua_AddWebTab(lua_State * tolua_S)
 
 static int tolua_cPluginLua_AddTab(lua_State* tolua_S)
 {
-	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, 0);
+	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, NULL);
 	LOGWARN("WARNING: Using deprecated function AddTab()! Use AddWebTab() instead. (plugin \"%s\" in folder \"%s\")",
 		self->GetName().c_str(), self->GetDirectory().c_str()
 	);
@@ -1734,112 +1967,28 @@ static int tolua_cPluginLua_AddTab(lua_State* tolua_S)
 
 
 
-// Perhaps use this as well for copying tables https://github.com/keplerproject/rings/pull/1
-static int copy_lua_values(lua_State * a_Source, lua_State * a_Destination, int i, int top)
-{
-	for(; i <= top; ++i )
-	{
-		int t = lua_type(a_Source, i);
-		switch (t) {
-			case LUA_TSTRING:  /* strings */
-				{
-					const char * s = lua_tostring(a_Source, i);
-					LOGD("%i push string: %s", i, s);
-					tolua_pushstring(a_Destination, s);
-				}
-				break;
-			case LUA_TBOOLEAN:  /* booleans */
-				{
-					int b = tolua_toboolean(a_Source, i, false);
-					LOGD("%i push bool: %i", i, b);
-					tolua_pushboolean(a_Destination, b );
-				}
-				break;
-			case LUA_TNUMBER:  /* numbers */
-				{
-					lua_Number d = tolua_tonumber(a_Source, i, 0);
-					LOGD("%i push number: %0.2f", i, d);
-					tolua_pushnumber(a_Destination, d );
-				}
-				break;
-			case LUA_TUSERDATA:
-				{
-					const char * type = 0;
-					if (lua_getmetatable(a_Source,i))
-					{
-						lua_rawget(a_Source, LUA_REGISTRYINDEX);
-						type = lua_tostring(a_Source, -1);
-						lua_pop(a_Source, 1); // Pop.. something?! I don't knooow~~ T_T
-					}
-					
-					// don't need tolua_tousertype we already have the type
-					void * ud = tolua_touserdata(a_Source, i, 0);
-					LOGD("%i push usertype: %p of type '%s'", i, ud, type);
-					if( type == 0 )
-					{
-						LOGERROR("Call(): Something went wrong when trying to get usertype name!");
-						return 0;
-					}
-					tolua_pushusertype(a_Destination, ud, type);
-				}
-				break;
-			default:  /* other values */
-				LOGERROR("Call(): Unsupported value: '%s'. Can only use numbers and strings!", lua_typename(a_Source, t));
-				return 0;
-		}
-	}
-	return 1;
-}
-
-
-
 
-
-static int tolua_cPlugin_Call(lua_State* tolua_S)
+static int tolua_cPlugin_Call(lua_State * tolua_S)
 {
-	cPluginLua * self = (cPluginLua *) tolua_tousertype(tolua_S, 1, 0);
-	lua_State* targetState = self->GetLuaState();
-	int targetTop = lua_gettop(targetState);
-
-	int top = lua_gettop(tolua_S);
-	LOGD("total in stack: %i", top );
-
-	std::string funcName = tolua_tostring(tolua_S, 2, "");
-	LOGD("Func name: %s", funcName.c_str() );
-
-	lua_getglobal(targetState, funcName.c_str());
-	if(!lua_isfunction(targetState,-1))
-	{
-		LOGWARN("Error could not find function '%s' in plugin '%s'", funcName.c_str(), self->GetName().c_str() );
-		lua_pop(targetState,1);
-		return 0;
-	}
-
-	if( copy_lua_values(tolua_S, targetState, 3, top) == 0 ) // Start at 3 because 1 and 2 are the plugin and function name respectively
-	{
-		// something went wrong, exit
-		return 0;
-	}
+	cLuaState L(tolua_S);
 	
-	int s = lua_pcall(targetState, top - 2, LUA_MULTRET, 0);
-	if (cLuaState::ReportErrors(targetState, s))
-	{
-		LOGWARN("Error while calling function '%s' in plugin '%s'", funcName.c_str(), self->GetName().c_str() );
-		return 0;
-	}
-
-	int nresults = lua_gettop(targetState) - targetTop;
-	LOGD("num results: %i", nresults);
-	int ttop = lua_gettop(targetState);
-	if( copy_lua_values(targetState, tolua_S, targetTop+1, ttop) == 0 ) // Start at targetTop+1 and I have no idea why xD
+	// Log the obsoletion warning:
+	LOGWARNING("cPlugin:Call() is obsolete and unsafe, use cPluginManager:CallPlugin() instead.");
+	L.LogStackTrace();
+	
+	// Retrieve the params: plugin and the function name to call
+	cPluginLua * TargetPlugin = (cPluginLua *) tolua_tousertype(tolua_S, 1, NULL);
+	AString FunctionName = tolua_tostring(tolua_S, 2, "");
+	
+	// Call the function:
+	int NumReturns = TargetPlugin->CallFunctionFromForeignState(FunctionName, L, 3, lua_gettop(L));
+	if (NumReturns < 0)
 	{
-		// something went wrong, exit
+		LOGWARNING("cPlugin::Call() failed to call destination function");
+		L.LogStackTrace();
 		return 0;
 	}
-
-	lua_pop(targetState, nresults); // I have no idea what I'm doing, but it works
-
-	return nresults;
+	return NumReturns;
 }
 
 
@@ -1881,7 +2030,7 @@ static int tolua_push_StringStringMap(lua_State* tolua_S, std::map< std::string,
 
 static int tolua_get_HTTPRequest_Params(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,0);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
 	return tolua_push_StringStringMap(tolua_S, self->Params);
 }
 
@@ -1891,7 +2040,7 @@ static int tolua_get_HTTPRequest_Params(lua_State* tolua_S)
 
 static int tolua_get_HTTPRequest_PostParams(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,0);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
 	return tolua_push_StringStringMap(tolua_S, self->PostParams);
 }
 
@@ -1901,7 +2050,7 @@ static int tolua_get_HTTPRequest_PostParams(lua_State* tolua_S)
 
 static int tolua_get_HTTPRequest_FormData(lua_State* tolua_S)
 {
-	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,0);
+	HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S, 1, NULL);
 	std::map< std::string, HTTPFormData >& FormData = self->FormData;
 
 	lua_newtable(tolua_S);
@@ -1924,7 +2073,7 @@ static int tolua_get_HTTPRequest_FormData(lua_State* tolua_S)
 
 static int tolua_cWebAdmin_GetPlugins(lua_State * tolua_S)
 {
-	cWebAdmin* self = (cWebAdmin*)  tolua_tousertype(tolua_S,1,0);
+	cWebAdmin* self = (cWebAdmin*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const cWebAdmin::PluginList & AllPlugins = self->GetPlugins();
 
@@ -1949,7 +2098,7 @@ static int tolua_cWebAdmin_GetPlugins(lua_State * tolua_S)
 
 static int tolua_cWebPlugin_GetTabNames(lua_State * tolua_S)
 {
-	cWebPlugin* self = (cWebPlugin*)  tolua_tousertype(tolua_S,1,0);
+	cWebPlugin* self = (cWebPlugin*)  tolua_tousertype(tolua_S, 1, NULL);
 
 	const cWebPlugin::TabNameList & TabNames = self->GetTabNames();
 
@@ -2016,7 +2165,7 @@ static int Lua_ItemGrid_GetSlotCoords(lua_State * L)
 	}
 
 	{
-		const cItemGrid * self = (const cItemGrid *)tolua_tousertype(L, 1, 0);
+		const cItemGrid * self = (const cItemGrid *)tolua_tousertype(L, 1, NULL);
 		int SlotNum = (int)tolua_tonumber(L, 2, 0);
 		if (self == NULL)
 		{
@@ -2131,26 +2280,40 @@ protected:
 
 static int tolua_cLineBlockTracer_Trace(lua_State * tolua_S)
 {
-	// cLineBlockTracer.Trace(World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ)
+	/* Supported function signatures:
+	cLineBlockTracer:Trace(World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ)  // Canonical
+	cLineBlockTracer.Trace(World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ)
+	*/
+	
+	// If the first param is the cLineBlockTracer class, shift param index by one:
+	int idx = 1;
+	tolua_Error err;
+	if (tolua_isusertable(tolua_S, 1, "cLineBlockTracer", 0, &err))
+	{
+		idx = 2;
+	}
+	
+	// Check params:
 	cLuaState L(tolua_S);
 	if (
-		!L.CheckParamUserType(1, "cWorld") ||
-		!L.CheckParamTable   (2) ||
-		!L.CheckParamNumber  (3, 8) ||
-		!L.CheckParamEnd     (9)
+		!L.CheckParamUserType(idx, "cWorld") ||
+		!L.CheckParamTable   (idx + 1) ||
+		!L.CheckParamNumber  (idx + 2, idx + 7) ||
+		!L.CheckParamEnd     (idx + 8)
 	)
 	{
 		return 0;
 	}
 
-	cWorld * World = (cWorld *)tolua_tousertype(L, 1, NULL);
-	cLuaBlockTracerCallbacks Callbacks(L, 2);
-	double StartX = tolua_tonumber(L, 3, 0);
-	double StartY = tolua_tonumber(L, 4, 0);
-	double StartZ = tolua_tonumber(L, 5, 0);
-	double EndX   = tolua_tonumber(L, 6, 0);
-	double EndY   = tolua_tonumber(L, 7, 0);
-	double EndZ   = tolua_tonumber(L, 8, 0);
+	// Trace:
+	cWorld * World = (cWorld *)tolua_tousertype(L, idx, NULL);
+	cLuaBlockTracerCallbacks Callbacks(L, idx + 1);
+	double StartX = tolua_tonumber(L, idx + 2, 0);
+	double StartY = tolua_tonumber(L, idx + 3, 0);
+	double StartZ = tolua_tonumber(L, idx + 4, 0);
+	double EndX   = tolua_tonumber(L, idx + 5, 0);
+	double EndY   = tolua_tonumber(L, idx + 6, 0);
+	double EndZ   = tolua_tonumber(L, idx + 7, 0);
 	bool res = cLineBlockTracer::Trace(*World, Callbacks, StartX, StartY, StartZ, EndX, EndY, EndZ);
 	tolua_pushboolean(L, res ? 1 : 0);
 	return 1;
@@ -2214,7 +2377,7 @@ static int tolua_cHopperEntity_GetOutputBlockPos(lua_State * tolua_S)
 	{
 		return 0;
 	}
-	cHopperEntity * self = (cHopperEntity *)tolua_tousertype(tolua_S, 1, 0);
+	cHopperEntity * self = (cHopperEntity *)tolua_tousertype(tolua_S, 1, NULL);
 	if (self == NULL)
 	{
 		tolua_error(tolua_S, "invalid 'self' in function 'cHopperEntity::GetOutputBlockPos()'", NULL);
@@ -2239,6 +2402,508 @@ static int tolua_cHopperEntity_GetOutputBlockPos(lua_State * tolua_S)
 
 
 
+
+static int tolua_cBlockArea_GetBlockTypeMeta(lua_State * tolua_S)
+{
+	// function cBlockArea::GetBlockTypeMeta()
+	// Exported manually because tolua generates extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamNumber  (2, 4)
+	)
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", NULL);
+		return 0;
+	}
+	int BlockX = (int)tolua_tonumber(tolua_S, 2, 0);
+	int BlockY = (int)tolua_tonumber(tolua_S, 3, 0);
+	int BlockZ = (int)tolua_tonumber(tolua_S, 4, 0);
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+	self->GetBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
+	tolua_pushnumber(tolua_S, BlockType);
+	tolua_pushnumber(tolua_S, BlockMeta);
+	return 2;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetOrigin(lua_State * tolua_S)
+{
+	// function cBlockArea::GetOrigin()
+	// Returns all three coords of the origin point
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (!L.CheckParamUserType(1, "cBlockArea"))
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetOrigin'", NULL);
+		return 0;
+	}
+	
+	// Push the three origin coords:
+	lua_pushnumber(tolua_S, self->GetOriginX());
+	lua_pushnumber(tolua_S, self->GetOriginY());
+	lua_pushnumber(tolua_S, self->GetOriginZ());
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetRelBlockTypeMeta(lua_State * tolua_S)
+{
+	// function cBlockArea::GetRelBlockTypeMeta()
+	// Exported manually because tolua generates extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamNumber  (2, 4)
+	)
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetRelBlockTypeMeta'", NULL);
+		return 0;
+	}
+	int BlockX = (int)tolua_tonumber(tolua_S, 2, 0);
+	int BlockY = (int)tolua_tonumber(tolua_S, 3, 0);
+	int BlockZ = (int)tolua_tonumber(tolua_S, 4, 0);
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+	self->GetRelBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
+	tolua_pushnumber(tolua_S, BlockType);
+	tolua_pushnumber(tolua_S, BlockMeta);
+	return 2;
+}
+
+
+
+
+
+static int tolua_cBlockArea_GetSize(lua_State * tolua_S)
+{
+	// function cBlockArea::GetSize()
+	// Returns all three sizes of the area
+	// Exported manually because there's no direct C++ equivalent,
+	// plus tolua would generate extra input params for the outputs
+	
+	cLuaState L(tolua_S);
+	if (!L.CheckParamUserType(1, "cBlockArea"))
+	{
+		return 0;
+	}
+	
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea:GetSize'", NULL);
+		return 0;
+	}
+	
+	// Push the three origin coords:
+	lua_pushnumber(tolua_S, self->GetSizeX());
+	lua_pushnumber(tolua_S, self->GetSizeY());
+	lua_pushnumber(tolua_S, self->GetSizeZ());
+	return 3;
+}
+
+
+
+
+
+static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * tolua_S)
+{
+	// function cBlockArea::LoadFromSchematicFile
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamEnd     (3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", NULL);
+		return 0;
+	}
+
+	AString Filename = tolua_tostring(tolua_S, 2, 0);
+	bool res = cSchematicFileSerializer::LoadFromSchematicFile(*self,Filename);
+	tolua_pushboolean(tolua_S, res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_LoadFromSchematicString(lua_State * tolua_S)
+{
+	// function cBlockArea::LoadFromSchematicString
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamEnd     (3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::LoadFromSchematicFile'", NULL);
+		return 0;
+	}
+
+	AString Data;
+	L.GetStackValue(2, Data);
+	bool res = cSchematicFileSerializer::LoadFromSchematicString(*self, Data);
+	tolua_pushboolean(tolua_S, res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_SaveToSchematicFile(lua_State * tolua_S)
+{
+	// function cBlockArea::SaveToSchematicFile
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamString  (2) ||
+		!L.CheckParamEnd     (3)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", NULL);
+		return 0;
+	}
+	AString Filename = tolua_tostring(tolua_S, 2, 0);
+	bool res = cSchematicFileSerializer::SaveToSchematicFile(*self,Filename);
+	tolua_pushboolean(tolua_S, res);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cBlockArea_SaveToSchematicString(lua_State * tolua_S)
+{
+	// function cBlockArea::SaveToSchematicString
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cBlockArea") ||
+		!L.CheckParamEnd     (2)
+	)
+	{
+		return 0;
+	}
+	cBlockArea * self = (cBlockArea *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cBlockArea::SaveToSchematicFile'", NULL);
+		return 0;
+	}
+	
+	AString Data;
+	if (cSchematicFileSerializer::SaveToSchematicString(*self, Data))
+	{
+		L.Push(Data);
+		return 1;
+	}
+	return 0;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddRunCommandPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddRunCommandPart(Message, Command, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2, 3)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddRunCommandPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Command, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Command);
+	L.GetStackValue(4, Style);
+	self->AddRunCommandPart(Text, Command, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddSuggestCommandPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddSuggestCommandPart(Message, Command, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2, 3)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddSuggestCommandPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Command, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Command);
+	L.GetStackValue(4, Style);
+	self->AddSuggestCommandPart(Text, Command, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddTextPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddTextPart(Message, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddTextPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Style);
+	self->AddTextPart(Text, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_AddUrlPart(lua_State * tolua_S)
+{
+	// function cCompositeChat:AddTextPart(Message, Url, [Style])
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2, 3)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:AddUrlPart'", NULL);
+		return 0;
+	}
+	
+	// Add the part:
+	AString Text, Url, Style;
+	L.GetStackValue(2, Text);
+	L.GetStackValue(3, Url);
+	L.GetStackValue(4, Style);
+	self->AddUrlPart(Text, Url, Style);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_ParseText(lua_State * tolua_S)
+{
+	// function cCompositeChat:ParseText(TextMessage)
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamString(2)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:ParseText'", NULL);
+		return 0;
+	}
+	
+	// Parse the text:
+	AString Text;
+	L.GetStackValue(2, Text);
+	self->ParseText(Text);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_SetMessageType(lua_State * tolua_S)
+{
+	// function cCompositeChat:SetMessageType(MessageType)
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (
+		!L.CheckParamUserType(1, "cCompositeChat") ||
+		!L.CheckParamNumber(2)
+	)
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:SetMessageType'", NULL);
+		return 0;
+	}
+	
+	// Set the type:
+	int MessageType;
+	L.GetStackValue(1, MessageType);
+	self->SetMessageType((eMessageType)MessageType);
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
+static int tolua_cCompositeChat_UnderlineUrls(lua_State * tolua_S)
+{
+	// function cCompositeChat:UnderlineUrls()
+	// Exported manually to support call-chaining (return *this)
+	
+	// Check params:
+	cLuaState L(tolua_S);
+	if (!L.CheckParamUserType(1, "cCompositeChat"))
+	{
+		return 0;
+	}
+	cCompositeChat * self = (cCompositeChat *)tolua_tousertype(tolua_S, 1, NULL);
+	if (self == NULL)
+	{
+		tolua_error(tolua_S, "invalid 'self' in function 'cCompositeChat:UnderlineUrls'", NULL);
+		return 0;
+	}
+	
+	// Call the processing
+	self->UnderlineUrls();
+	
+	// Cut away everything from the stack except for the cCompositeChat instance; return that:
+	lua_settop(L, 1);
+	return 1;
+}
+
+
+
+
+
 void ManualBindings::Bind(lua_State * tolua_S)
 {
 	tolua_beginmodule(tolua_S, NULL);
@@ -2249,11 +2914,34 @@ void ManualBindings::Bind(lua_State * tolua_S)
 		tolua_function(tolua_S, "LOGWARN",            tolua_LOGWARN);
 		tolua_function(tolua_S, "LOGWARNING",         tolua_LOGWARN);
 		tolua_function(tolua_S, "LOGERROR",           tolua_LOGERROR);
+		tolua_function(tolua_S, "Base64Encode",       tolua_Base64Encode);
+		tolua_function(tolua_S, "Base64Decode",       tolua_Base64Decode);
 		
 		tolua_beginmodule(tolua_S, "cFile");
 			tolua_function(tolua_S, "GetFolderContents", tolua_cFile_GetFolderContents);
 		tolua_endmodule(tolua_S);
 		
+		tolua_beginmodule(tolua_S, "cBlockArea");
+			tolua_function(tolua_S, "GetBlockTypeMeta",        tolua_cBlockArea_GetBlockTypeMeta);
+			tolua_function(tolua_S, "GetOrigin",               tolua_cBlockArea_GetOrigin);
+			tolua_function(tolua_S, "GetRelBlockTypeMeta",     tolua_cBlockArea_GetRelBlockTypeMeta);
+			tolua_function(tolua_S, "GetSize",                 tolua_cBlockArea_GetSize);
+			tolua_function(tolua_S, "LoadFromSchematicFile",   tolua_cBlockArea_LoadFromSchematicFile);
+			tolua_function(tolua_S, "LoadFromSchematicString", tolua_cBlockArea_LoadFromSchematicString);
+			tolua_function(tolua_S, "SaveToSchematicFile",     tolua_cBlockArea_SaveToSchematicFile);
+			tolua_function(tolua_S, "SaveToSchematicString",   tolua_cBlockArea_SaveToSchematicString);
+		tolua_endmodule(tolua_S);
+		
+		tolua_beginmodule(tolua_S, "cCompositeChat");
+			tolua_function(tolua_S, "AddRunCommandPart",     tolua_cCompositeChat_AddRunCommandPart);
+			tolua_function(tolua_S, "AddSuggestCommandPart", tolua_cCompositeChat_AddSuggestCommandPart);
+			tolua_function(tolua_S, "AddTextPart",           tolua_cCompositeChat_AddTextPart);
+			tolua_function(tolua_S, "AddUrlPart",            tolua_cCompositeChat_AddUrlPart);
+			tolua_function(tolua_S, "ParseText",             tolua_cCompositeChat_ParseText);
+			tolua_function(tolua_S, "SetMessageType",        tolua_cCompositeChat_SetMessageType);
+			tolua_function(tolua_S, "UnderlineUrls",         tolua_cCompositeChat_UnderlineUrls);
+		tolua_endmodule(tolua_S);
+		
 		tolua_beginmodule(tolua_S, "cHopperEntity");
 			tolua_function(tolua_S, "GetOutputBlockPos", tolua_cHopperEntity_GetOutputBlockPos);
 		tolua_endmodule(tolua_S);
@@ -2270,6 +2958,7 @@ void ManualBindings::Bind(lua_State * tolua_S)
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cWorld");
+			tolua_function(tolua_S, "ChunkStay",                 tolua_cWorld_ChunkStay);
 			tolua_function(tolua_S, "DoWithBlockEntityAt",       tolua_DoWithXYZ<cWorld, cBlockEntity,        &cWorld::DoWithBlockEntityAt>);
 			tolua_function(tolua_S, "DoWithChestAt",             tolua_DoWithXYZ<cWorld, cChestEntity,        &cWorld::DoWithChestAt>);
 			tolua_function(tolua_S, "DoWithDispenserAt",         tolua_DoWithXYZ<cWorld, cDispenserEntity,    &cWorld::DoWithDispenserAt>);
@@ -2279,6 +2968,8 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "DoWithFurnaceAt",           tolua_DoWithXYZ<cWorld, cFurnaceEntity,      &cWorld::DoWithFurnaceAt>);
 			tolua_function(tolua_S, "DoWithNoteBlockAt",         tolua_DoWithXYZ<cWorld, cNoteEntity,         &cWorld::DoWithNoteBlockAt>);
 			tolua_function(tolua_S, "DoWithCommandBlockAt",      tolua_DoWithXYZ<cWorld, cCommandBlockEntity, &cWorld::DoWithCommandBlockAt>);
+			tolua_function(tolua_S, "DoWithMobHeadAt",           tolua_DoWithXYZ<cWorld, cMobHeadEntity,      &cWorld::DoWithMobHeadAt>);
+			tolua_function(tolua_S, "DoWithFlowerPotAt",         tolua_DoWithXYZ<cWorld, cFlowerPotEntity,    &cWorld::DoWithFlowerPotAt>);
 			tolua_function(tolua_S, "DoWithPlayer",              tolua_DoWith<   cWorld, cPlayer,             &cWorld::DoWithPlayer>);
 			tolua_function(tolua_S, "FindAndDoWithPlayer",       tolua_DoWith<   cWorld, cPlayer,             &cWorld::FindAndDoWithPlayer>);
 			tolua_function(tolua_S, "ForEachBlockEntityInChunk", tolua_ForEachInChunk<cWorld, cBlockEntity,   &cWorld::ForEachBlockEntityInChunk>);
@@ -2297,6 +2988,15 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "UpdateSign",                tolua_cWorld_SetSignLines);
 		tolua_endmodule(tolua_S);
 		
+		tolua_beginmodule(tolua_S, "cMapManager");
+			tolua_function(tolua_S, "DoWithMap", tolua_DoWithID<cMapManager, cMap, &cMapManager::DoWithMap>);
+		tolua_endmodule(tolua_S);
+
+		tolua_beginmodule(tolua_S, "cScoreboard");
+			tolua_function(tolua_S, "ForEachObjective", tolua_ForEach<cScoreboard, cObjective, &cScoreboard::ForEachObjective>);
+			tolua_function(tolua_S, "ForEachTeam",      tolua_ForEach<cScoreboard, cTeam,      &cScoreboard::ForEachTeam>);
+		tolua_endmodule(tolua_S);
+		
 		tolua_beginmodule(tolua_S, "cPlugin");
 			tolua_function(tolua_S, "Call", tolua_cPlugin_Call);
 		tolua_endmodule(tolua_S);
@@ -2305,10 +3005,12 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "AddHook",               tolua_cPluginManager_AddHook);
 			tolua_function(tolua_S, "BindCommand",           tolua_cPluginManager_BindCommand);
 			tolua_function(tolua_S, "BindConsoleCommand",    tolua_cPluginManager_BindConsoleCommand);
+			tolua_function(tolua_S, "CallPlugin",            tolua_cPluginManager_CallPlugin);
 			tolua_function(tolua_S, "ForEachCommand",        tolua_cPluginManager_ForEachCommand);
 			tolua_function(tolua_S, "ForEachConsoleCommand", tolua_cPluginManager_ForEachConsoleCommand);
 			tolua_function(tolua_S, "GetAllPlugins",         tolua_cPluginManager_GetAllPlugins);
 			tolua_function(tolua_S, "GetCurrentPlugin",      tolua_cPluginManager_GetCurrentPlugin);
+			tolua_function(tolua_S, "LogStackTrace",         tolua_cPluginManager_LogStackTrace);
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cPlayer");
diff --git a/src/Bindings/ManualBindings.h b/src/Bindings/ManualBindings.h
index e6594947e..f38e26267 100644
--- a/src/Bindings/ManualBindings.h
+++ b/src/Bindings/ManualBindings.h
@@ -5,4 +5,4 @@ class ManualBindings
 {
 public:
 	static void Bind( lua_State* tolua_S );
-};
\ No newline at end of file
+};
diff --git a/src/Bindings/Plugin.h b/src/Bindings/Plugin.h
index f4a117721..df0bd4dcc 100644
--- a/src/Bindings/Plugin.h
+++ b/src/Bindings/Plugin.h
@@ -46,6 +46,7 @@ public:
 	 * On all these functions, return true if you want to override default behavior and not call other plugins on that callback.
 	 * You can also return false, so default behavior is used.
 	 **/
+	virtual bool OnBlockSpread              (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source) = 0;
 	virtual bool OnBlockToPickups           (cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) = 0;
 	virtual bool OnChat                     (cPlayer * a_Player, AString & a_Message) = 0;
 	virtual bool OnChunkAvailable           (cWorld * a_World, int a_ChunkX, int a_ChunkZ) = 0;
@@ -67,6 +68,7 @@ public:
 	virtual bool OnPlayerAnimation          (cPlayer & a_Player, int a_Animation) = 0;
 	virtual bool OnPlayerBreakingBlock      (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
 	virtual bool OnPlayerBrokenBlock        (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
+	virtual bool OnPlayerDestroyed          (cPlayer & a_Player) = 0;
 	virtual bool OnPlayerEating             (cPlayer & a_Player) = 0;
 	virtual bool OnPlayerFished             (cPlayer & a_Player, const cItems & a_Reward) = 0;
 	virtual bool OnPlayerFishing            (cPlayer & a_Player, cItems & a_Reward) = 0;
@@ -88,6 +90,8 @@ public:
 	virtual bool OnPluginsLoaded            (void) = 0;
 	virtual bool OnPostCrafting             (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) = 0;
 	virtual bool OnPreCrafting              (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) = 0;
+	virtual bool OnProjectileHitBlock       (cProjectileEntity & a_Projectile) = 0;
+	virtual bool OnProjectileHitEntity      (cProjectileEntity & a_Projectile, cEntity & a_HitEntity) = 0;
 	virtual bool OnSpawnedEntity            (cWorld & a_World, cEntity & a_Entity) = 0;
 	virtual bool OnSpawnedMonster           (cWorld & a_World, cMonster & a_Monster) = 0;
 	virtual bool OnSpawningEntity           (cWorld & a_World, cEntity & a_Entity) = 0;
diff --git a/src/Bindings/PluginLua.cpp b/src/Bindings/PluginLua.cpp
index 4c4664815..dcc816839 100644
--- a/src/Bindings/PluginLua.cpp
+++ b/src/Bindings/PluginLua.cpp
@@ -5,7 +5,11 @@
 
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
+#ifdef __APPLE__
+#define LUA_USE_MACOSX
+#else
 #define LUA_USE_POSIX
+#endif
 #include "PluginLua.h"
 #include "../CommandOutput.h"
 
@@ -14,6 +18,7 @@ extern "C"
 	#include "lua/src/lualib.h"
 }
 
+#undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 
 
@@ -75,6 +80,7 @@ bool cPluginLua::Initialize(void)
 	if (!m_LuaState.IsValid())
 	{	
 		m_LuaState.Create();
+		m_LuaState.RegisterAPILibs();
 		
 		// Inject the identification global variables into the state:
 		lua_pushlightuserdata(m_LuaState, this);
@@ -82,42 +88,69 @@ bool cPluginLua::Initialize(void)
 		lua_pushstring(m_LuaState, GetName().c_str());
 		lua_setglobal(m_LuaState, LUA_PLUGIN_NAME_VAR_NAME);
 		
+		// Add the plugin's folder to the package.path and package.cpath variables (#693):
+		m_LuaState.AddPackagePath("path", FILE_IO_PREFIX + GetLocalFolder() + "/?.lua");
+		#ifdef _WIN32
+			m_LuaState.AddPackagePath("cpath", GetLocalFolder() + "\\?.dll");
+		#else
+			m_LuaState.AddPackagePath("cpath", FILE_IO_PREFIX + GetLocalFolder() + "/?.so");
+		#endif
+		
 		tolua_pushusertype(m_LuaState, this, "cPluginLua");
 		lua_setglobal(m_LuaState, "g_Plugin");
 	}
 
 	std::string PluginPath = FILE_IO_PREFIX + GetLocalFolder() + "/";
 
-	// Load all files for this plugin, and execute them
+	// List all Lua files for this plugin. Info.lua has a special handling - make it the last to load:
 	AStringVector Files = cFile::GetFolderContents(PluginPath.c_str());
-
-	int numFiles = 0;
-	for (AStringVector::const_iterator itr = Files.begin(); itr != Files.end(); ++itr)
+	AStringVector LuaFiles;
+	bool HasInfoLua = false;
+	for (AStringVector::const_iterator itr = Files.begin(), end = Files.end(); itr != end; ++itr)
 	{
-		if (itr->rfind(".lua") == AString::npos)
+		if (itr->rfind(".lua") != AString::npos)
 		{
-			continue;
+			if (*itr == "Info.lua")
+			{
+				HasInfoLua = true;
+			}
+			else
+			{
+				LuaFiles.push_back(*itr);
+			}
 		}
+	}
+	std::sort(LuaFiles.begin(), LuaFiles.end());
+	
+	// Warn if there are no Lua files in the plugin folder:
+	if (LuaFiles.empty())
+	{
+		LOGWARNING("No lua files found: plugin %s is missing.", GetName().c_str());
+		Close();
+		return false;
+	}
+
+	// Load all files in the list, including the Info.lua as last, if it exists:
+	for (AStringVector::const_iterator itr = LuaFiles.begin(), end = LuaFiles.end(); itr != end; ++itr)
+	{
 		AString Path = PluginPath + *itr;
 		if (!m_LuaState.LoadFile(Path))
 		{
 			Close();
 			return false;
-		} 
-		else 
-		{
-			numFiles++;
 		}
 	}  // for itr - Files[]
-
-	if (numFiles == 0)
+	if (HasInfoLua)
 	{
-		LOGWARNING("No lua files found: plugin %s is missing.", GetName().c_str());
-		Close();
-		return false;
+		AString Path = PluginPath + "Info.lua";
+		if (!m_LuaState.LoadFile(Path))
+		{
+			Close();
+			return false;
+		}
 	}
 
-	// Call intialize function
+	// Call the Initialize function:
 	bool res = false;
 	if (!m_LuaState.Call("Initialize", this, cLuaState::Return, res))
 	{
@@ -125,7 +158,6 @@ bool cPluginLua::Initialize(void)
 		Close();
 		return false;
 	}
-
 	if (!res)
 	{
 		LOGINFO("Plugin %s: Initialize() call failed, plugin is temporarily disabled.", GetName().c_str());
@@ -168,6 +200,26 @@ void cPluginLua::Tick(float a_Dt)
 
 
 
+bool cPluginLua::OnBlockSpread(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_BLOCK_SPREAD];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), a_World, a_BlockX, a_BlockY, a_BlockZ, a_Source, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginLua::OnBlockToPickups(cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -623,6 +675,26 @@ bool cPluginLua::OnPlayerBrokenBlock(cPlayer & a_Player, int a_BlockX, int a_Blo
 
 
 
+bool cPluginLua::OnPlayerDestroyed(cPlayer & a_Player)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PLAYER_DESTROYED];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Player, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginLua::OnPlayerEating(cPlayer & a_Player)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -1041,6 +1113,46 @@ bool cPluginLua::OnPreCrafting(const cPlayer * a_Player, const cCraftingGrid * a
 
 
 
+bool cPluginLua::OnProjectileHitBlock(cProjectileEntity & a_Projectile)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PROJECTILE_HIT_BLOCK];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Projectile, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+bool cPluginLua::OnProjectileHitEntity(cProjectileEntity & a_Projectile, cEntity & a_HitEntity)
+{
+	cCSLock Lock(m_CriticalSection);
+	bool res = false;
+	cLuaRefs & Refs = m_HookMap[cPluginManager::HOOK_PROJECTILE_HIT_ENTITY];
+	for (cLuaRefs::iterator itr = Refs.begin(), end = Refs.end(); itr != end; ++itr)
+	{
+		m_LuaState.Call((int)(**itr), &a_Projectile, &a_HitEntity, cLuaState::Return, res);
+		if (res)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginLua::OnSpawnedEntity(cWorld & a_World, cEntity & a_Entity)
 {
 	cCSLock Lock(m_CriticalSection);
@@ -1383,6 +1495,7 @@ const char * cPluginLua::GetHookFnName(int a_HookType)
 {
 	switch (a_HookType)
 	{
+		case cPluginManager::HOOK_BLOCK_SPREAD:                 return "OnBlockSpread";
 		case cPluginManager::HOOK_BLOCK_TO_PICKUPS:             return "OnBlockToPickups";
 		case cPluginManager::HOOK_CHAT:                         return "OnChat";
 		case cPluginManager::HOOK_CHUNK_AVAILABLE:              return "OnChunkAvailable";
@@ -1469,6 +1582,40 @@ bool cPluginLua::AddHookRef(int a_HookType, int a_FnRefIdx)
 
 
 
+int cPluginLua::CallFunctionFromForeignState(
+	const AString & a_FunctionName,
+	cLuaState & a_ForeignState,
+	int a_ParamStart,
+	int a_ParamEnd
+)
+{
+	cCSLock Lock(m_CriticalSection);
+	
+	// Call the function:
+	int NumReturns = m_LuaState.CallFunctionWithForeignParams(a_FunctionName, a_ForeignState, a_ParamStart, a_ParamEnd);
+	if (NumReturns < 0)
+	{
+		// The call has failed, an error has already been output to the log, so just silently bail out with the same error
+		return NumReturns;
+	}
+	
+	// Copy all the return values:
+	int Top = lua_gettop(m_LuaState);
+	int res = a_ForeignState.CopyStackFrom(m_LuaState, Top - NumReturns + 1, Top);
+	
+	// Remove the return values off this stack:
+	if (NumReturns > 0)
+	{
+		lua_pop(m_LuaState, NumReturns);
+	}
+	
+	return res;
+}
+
+
+
+
+
 AString cPluginLua::HandleWebRequest(const HTTPRequest * a_Request )
 {
 	cCSLock Lock(m_CriticalSection);
diff --git a/src/Bindings/PluginLua.h b/src/Bindings/PluginLua.h
index c01f5ca89..59542d23a 100644
--- a/src/Bindings/PluginLua.h
+++ b/src/Bindings/PluginLua.h
@@ -35,7 +35,33 @@ class cPluginLua :
 public:
 	// tolua_end
 	
-	cPluginLua( const AString & a_PluginDirectory );
+	/** A RAII-style mutex lock for accessing the internal LuaState.
+	This will be the only way to retrieve the plugin's LuaState;
+	therefore it directly supports accessing the LuaState of the locked plugin.
+	Usage:
+		cPluginLua::cOperation Op(SomePlugin);
+		Op().Call(...)  // Call a function in the plugin's LuaState
+	*/
+	class cOperation
+	{
+	public:
+		cOperation(cPluginLua & a_Plugin) :
+			m_Plugin(a_Plugin),
+			m_Lock(a_Plugin.m_CriticalSection)
+		{
+		}
+
+		cLuaState & operator ()(void) { return m_Plugin.m_LuaState; }
+		
+	protected:
+		cPluginLua & m_Plugin;
+		
+		/** RAII lock for m_Plugin.m_CriticalSection */
+		cCSLock m_Lock;
+	} ;
+	
+	
+	cPluginLua(const AString & a_PluginDirectory);
 	~cPluginLua();
 
 	virtual void OnDisable(void) override;
@@ -43,6 +69,7 @@ public:
 
 	virtual void Tick(float a_Dt) override;
 
+	virtual bool OnBlockSpread              (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source) override;
 	virtual bool OnBlockToPickups           (cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) override;
 	virtual bool OnChat                     (cPlayer * a_Player, AString & a_Message) override;
 	virtual bool OnChunkAvailable           (cWorld * a_World, int a_ChunkX, int a_ChunkZ) override;
@@ -64,6 +91,7 @@ public:
 	virtual bool OnPlayerAnimation          (cPlayer & a_Player, int a_Animation) override;
 	virtual bool OnPlayerBreakingBlock      (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
 	virtual bool OnPlayerBrokenBlock        (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual bool OnPlayerDestroyed          (cPlayer & a_Player) override;
 	virtual bool OnPlayerEating             (cPlayer & a_Player) override;
 	virtual bool OnPlayerFished             (cPlayer & a_Player, const cItems & a_Reward) override;
 	virtual bool OnPlayerFishing            (cPlayer & a_Player, cItems & a_Reward) override;
@@ -85,6 +113,8 @@ public:
 	virtual bool OnPluginsLoaded            (void) override;
 	virtual bool OnPostCrafting             (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) override;
 	virtual bool OnPreCrafting              (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) override;
+	virtual bool OnProjectileHitBlock       (cProjectileEntity & a_Projectile) override;
+	virtual bool OnProjectileHitEntity      (cProjectileEntity & a_Projectile, cEntity & a_HitEntity) override;
 	virtual bool OnSpawnedEntity            (cWorld & a_World, cEntity & a_Entity) override;
 	virtual bool OnSpawnedMonster           (cWorld & a_World, cMonster & a_Monster) override;
 	virtual bool OnSpawningEntity           (cWorld & a_World, cEntity & a_Entity) override;
@@ -105,7 +135,7 @@ public:
 	
 	virtual void ClearConsoleCommands(void) override;
 
-	/// Returns true if the plugin contains the function for the specified hook type, using the old-style registration (#121)
+	/** Returns true if the plugin contains the function for the specified hook type, using the old-style registration (#121) */
 	bool CanAddOldStyleHook(int a_HookType);
 	
 	// cWebPlugin override
@@ -115,26 +145,26 @@ public:
 	virtual AString HandleWebRequest(const HTTPRequest * a_Request ) override;
 	bool AddWebTab(const AString & a_Title, lua_State * a_LuaState, int a_FunctionReference);	// >> EXPORTED IN MANUALBINDINGS <<
 	
-	/// Binds the command to call the function specified by a Lua function reference. Simply adds to CommandMap.
+	/** Binds the command to call the function specified by a Lua function reference. Simply adds to CommandMap. */
 	void BindCommand(const AString & a_Command, int a_FnRef);
 
-	/// Binds the console command to call the function specified by a Lua function reference. Simply adds to CommandMap.
+	/** Binds the console command to call the function specified by a Lua function reference. Simply adds to CommandMap. */
 	void BindConsoleCommand(const AString & a_Command, int a_FnRef);
 
 	cLuaState & GetLuaState(void) { return m_LuaState; }
 
 	cCriticalSection & GetCriticalSection(void) { return m_CriticalSection; }
 	
-	/// Removes a previously referenced object (luaL_unref())
+	/** Removes a previously referenced object (luaL_unref()) */
 	void Unreference(int a_LuaRef);
 	
-	/// Calls the plugin-specified "cLuaWindow closing" callback. Returns true only if the callback returned true
+	/** Calls the plugin-specified "cLuaWindow closing" callback. Returns true only if the callback returned true */
 	bool CallbackWindowClosing(int a_FnRef, cWindow & a_Window, cPlayer & a_Player, bool a_CanRefuse);
 	
-	/// Calls the plugin-specified "cLuaWindow slot changed" callback.
+	/** Calls the plugin-specified "cLuaWindow slot changed" callback. */
 	void CallbackWindowSlotChanged(int a_FnRef, cWindow & a_Window, int a_SlotNum);
 	
-	/// Returns the name of Lua function that should handle the specified hook type in the older (#121) API
+	/** Returns the name of Lua function that should handle the specified hook type in the older (#121) API */
 	static const char * GetHookFnName(int a_HookType);
 	
 	/** Adds a Lua function to be called for the specified hook.
@@ -143,37 +173,47 @@ public:
 	*/
 	bool AddHookRef(int a_HookType, int a_FnRefIdx);
 	
+	/** Calls a function in this plugin's LuaState with parameters copied over from a_ForeignState.
+	The values that the function returns are placed onto a_ForeignState.
+	Returns the number of values returned, if successful, or negative number on failure. */
+	int CallFunctionFromForeignState(
+		const AString & a_FunctionName,
+		cLuaState & a_ForeignState,
+		int a_ParamStart,
+		int a_ParamEnd
+	);
+	
 	// The following templates allow calls to arbitrary Lua functions residing in the plugin:
 	
-	/// Call a Lua function with 0 args
+	/** Call a Lua function with 0 args */
 	template <typename FnT> bool Call(FnT a_Fn)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn);
 	}
 
-	/// Call a Lua function with 1 arg
+	/** Call a Lua function with 1 arg */
 	template <typename FnT, typename ArgT0> bool Call(FnT a_Fn, ArgT0 a_Arg0)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn, a_Arg0);
 	}
 
-	/// Call a Lua function with 2 args
+	/** Call a Lua function with 2 args */
 	template <typename FnT, typename ArgT0, typename ArgT1> bool Call(FnT a_Fn, ArgT0 a_Arg0, ArgT1 a_Arg1)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn, a_Arg0, a_Arg1);
 	}
 
-	/// Call a Lua function with 3 args
+	/** Call a Lua function with 3 args */
 	template <typename FnT, typename ArgT0, typename ArgT1, typename ArgT2> bool Call(FnT a_Fn, ArgT0 a_Arg0, ArgT1 a_Arg1, ArgT2 a_Arg2)
 	{
 		cCSLock Lock(m_CriticalSection);
 		return m_LuaState.Call(a_Fn, a_Arg0, a_Arg1, a_Arg2);
 	}
 
-	/// Call a Lua function with 4 args
+	/** Call a Lua function with 4 args */
 	template <typename FnT, typename ArgT0, typename ArgT1, typename ArgT2, typename ArgT3> bool Call(FnT a_Fn, ArgT0 a_Arg0, ArgT1 a_Arg1, ArgT2 a_Arg2, ArgT3 a_Arg3)
 	{
 		cCSLock Lock(m_CriticalSection);
@@ -181,13 +221,13 @@ public:
 	}
 
 protected:
-	/// Maps command name into Lua function reference
+	/** Maps command name into Lua function reference */
 	typedef std::map<AString, int> CommandMap;
 	
-	/// Provides an array of Lua function references
+	/** Provides an array of Lua function references */
 	typedef std::vector<cLuaState::cRef *> cLuaRefs;
 	
-	/// Maps hook types into arrays of Lua function references to call for each hook type
+	/** Maps hook types into arrays of Lua function references to call for each hook type */
 	typedef std::map<int, cLuaRefs> cHookMap;
 	
 	cCriticalSection m_CriticalSection;
@@ -198,7 +238,7 @@ protected:
 	
 	cHookMap m_HookMap;
 	
-	/// Releases all Lua references and closes the LuaState
+	/** Releases all Lua references and closes the LuaState */
 	void Close(void);
 } ;  // tolua_export
 
diff --git a/src/Bindings/PluginManager.cpp b/src/Bindings/PluginManager.cpp
index 24bb914d1..6a5356c0b 100644
--- a/src/Bindings/PluginManager.cpp
+++ b/src/Bindings/PluginManager.cpp
@@ -56,7 +56,7 @@ void cPluginManager::ReloadPlugins(void)
 
 void cPluginManager::FindPlugins(void)
 {
-	AString PluginsPath = FILE_IO_PREFIX + AString( "Plugins/" );
+	AString PluginsPath = GetPluginsPath() + "/";
 
 	// First get a clean list of only the currently running plugins, we don't want to mess those up
 	for (PluginMap::iterator itr = m_Plugins.begin(); itr != m_Plugins.end();)
@@ -205,6 +205,27 @@ void cPluginManager::Tick(float a_Dt)
 
 
 
+bool cPluginManager::CallHookBlockSpread(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_BLOCK_SPREAD);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnBlockSpread(a_World, a_BlockX, a_BlockY, a_BlockZ, a_Source))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginManager::CallHookBlockToPickups(
 	cWorld * a_World, cEntity * a_Digger,
 	int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
@@ -248,7 +269,7 @@ bool cPluginManager::CallHookChat(cPlayer * a_Player, AString & a_Message)
 	{
 		AStringVector Split(StringSplit(a_Message, " "));
 		ASSERT(!Split.empty());  // This should not happen - we know there's at least one char in the message so the split needs to be at least one item long
-		a_Player->SendMessage(Printf("%s[INFO] %sUnknown command: \"%s\"", cChatColor::Yellow.c_str(), cChatColor::White.c_str(), Split[0].c_str()));
+		a_Player->SendMessageInfo(Printf("Unknown command: \"%s\"", a_Message.c_str()));
 		LOGINFO("Player %s issued an unknown command: \"%s\"", a_Player->GetName().c_str(), a_Message.c_str());
 		return true;  // Cancel sending
 	}
@@ -673,6 +694,27 @@ bool cPluginManager::CallHookPlayerBrokenBlock(cPlayer & a_Player, int a_BlockX,
 
 
 
+bool cPluginManager::CallHookPlayerDestroyed(cPlayer & a_Player)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_PLAYER_DESTROYED);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnPlayerDestroyed(a_Player))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginManager::CallHookPlayerEating(cPlayer & a_Player)
 {
 	HookMap::iterator Plugins = m_Hooks.find(HOOK_PLAYER_EATING);
@@ -1112,6 +1154,48 @@ bool cPluginManager::CallHookPreCrafting(const cPlayer * a_Player, const cCrafti
 
 
 
+bool cPluginManager::CallHookProjectileHitBlock(cProjectileEntity & a_Projectile)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_PROJECTILE_HIT_BLOCK);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnProjectileHitBlock(a_Projectile))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+bool cPluginManager::CallHookProjectileHitEntity(cProjectileEntity & a_Projectile, cEntity & a_HitEntity)
+{
+	HookMap::iterator Plugins = m_Hooks.find(HOOK_PROJECTILE_HIT_ENTITY);
+	if (Plugins == m_Hooks.end())
+	{
+		return false;
+	}
+	for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
+	{
+		if ((*itr)->OnProjectileHitEntity(a_Projectile, a_HitEntity))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
 bool cPluginManager::CallHookSpawnedEntity(cWorld & a_World, cEntity & a_Entity)
 {
 	HookMap::iterator Plugins = m_Hooks.find(HOOK_SPAWNED_ENTITY);
@@ -1371,7 +1455,7 @@ bool cPluginManager::HandleCommand(cPlayer * a_Player, const AString & a_Command
 		!a_Player->HasPermission(cmd->second.m_Permission)
 	)
 	{
-		a_Player->SendMessage(Printf("%s[INFO] %sForbidden command; insufficient privileges: \"%s\"", cChatColor::Rose.c_str(), cChatColor::White.c_str(), Split[0].c_str()));
+		a_Player->SendMessageFailure(Printf("Forbidden command; insufficient privileges: \"%s\"", Split[0].c_str()));
 		LOGINFO("Player %s tried to execute forbidden command: \"%s\"", a_Player->GetName().c_str(), Split[0].c_str());
 		a_WasCommandForbidden = true;
 		return false;
@@ -1736,6 +1820,21 @@ bool cPluginManager::IsValidHookType(int a_HookType)
 
 
 
+bool cPluginManager::DoWithPlugin(const AString & a_PluginName, cPluginCallback & a_Callback)
+{
+	// TODO: Implement locking for plugins
+	PluginMap::iterator itr = m_Plugins.find(a_PluginName);
+	if ((itr == m_Plugins.end()) || (itr->second == NULL))
+	{
+		return false;
+	}
+	return a_Callback.Item(itr->second);
+}
+
+
+
+
+
 bool cPluginManager::AddPlugin(cPlugin * a_Plugin)
 {
 	m_Plugins[a_Plugin->GetDirectory()] = a_Plugin;
diff --git a/src/Bindings/PluginManager.h b/src/Bindings/PluginManager.h
index 9936f5a35..512bc1351 100644
--- a/src/Bindings/PluginManager.h
+++ b/src/Bindings/PluginManager.h
@@ -18,6 +18,9 @@ class cChunkDesc;
 // fwd: Entities/Entity.h
 class cEntity;
 
+// fwd: Entities/ProjectileEntity.h
+class cProjectileEntity;
+
 // fwd: Mobs/Monster.h
 class cMonster;
 
@@ -58,6 +61,7 @@ public:																	// tolua_export
 	// tolua_begin
 	enum PluginHook
 	{
+		HOOK_BLOCK_SPREAD,
 		HOOK_BLOCK_TO_PICKUPS,
 		HOOK_CHAT,
 		HOOK_CHUNK_AVAILABLE,
@@ -79,6 +83,7 @@ public:																	// tolua_export
 		HOOK_LOGIN,
 		HOOK_PLAYER_BREAKING_BLOCK,
 		HOOK_PLAYER_BROKEN_BLOCK,
+		HOOK_PLAYER_DESTROYED,
 		HOOK_PLAYER_EATING,
 		HOOK_PLAYER_FISHED,
 		HOOK_PLAYER_FISHING,
@@ -100,6 +105,8 @@ public:																	// tolua_export
 		HOOK_PLUGINS_LOADED,
 		HOOK_POST_CRAFTING,
 		HOOK_PRE_CRAFTING,
+		HOOK_PROJECTILE_HIT_BLOCK,
+		HOOK_PROJECTILE_HIT_ENTITY,
 		HOOK_SPAWNED_ENTITY,
 		HOOK_SPAWNED_MONSTER,
 		HOOK_SPAWNING_ENTITY,
@@ -122,17 +129,23 @@ public:																	// tolua_export
 	} ;
 	// tolua_end
 
-	/// Used as a callback for enumerating bound commands
+	/** Used as a callback for enumerating bound commands */
 	class cCommandEnumCallback
 	{
 	public:
+		virtual ~cCommandEnumCallback() {}
+		
 		/** Called for each command; return true to abort enumeration
 		For console commands, a_Permission is not used (set to empty string)
 		*/
 		virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) = 0;
 	} ;
 	
-	/// Returns the instance of the Plugin Manager (there is only ever one)
+	/** The interface used for enumerating and extern-calling plugins */
+	typedef cItemCallback<cPlugin> cPluginCallback;
+	
+	
+	/** Returns the instance of the Plugin Manager (there is only ever one) */
 	static cPluginManager * Get(void);							// tolua_export
 
 	typedef std::map< AString, cPlugin * > PluginMap;
@@ -143,12 +156,13 @@ public:																	// tolua_export
 	void FindPlugins();													// tolua_export
 	void ReloadPlugins();												// tolua_export
 	
-	/// Adds the plugin to the list of plugins called for the specified hook type. Handles multiple adds as a single add
+	/** Adds the plugin to the list of plugins called for the specified hook type. Handles multiple adds as a single add */
 	void AddHook(cPlugin * a_Plugin, int a_HookType);
 
 	unsigned int GetNumPlugins() const;  // tolua_export
 	
 	// Calls for individual hooks. Each returns false if the action is to continue or true if the plugin wants to abort
+	bool CallHookBlockSpread              (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, eSpreadSource a_Source);
 	bool CallHookBlockToPickups           (cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups);
 	bool CallHookChat                     (cPlayer * a_Player, AString & a_Message);
 	bool CallHookChunkAvailable           (cWorld * a_World, int a_ChunkX, int a_ChunkZ);
@@ -170,6 +184,7 @@ public:																	// tolua_export
 	bool CallHookPlayerAnimation          (cPlayer & a_Player, int a_Animation);
 	bool CallHookPlayerBreakingBlock      (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	bool CallHookPlayerBrokenBlock        (cPlayer & a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	bool CallHookPlayerDestroyed          (cPlayer & a_Player);
 	bool CallHookPlayerEating             (cPlayer & a_Player);
 	bool CallHookPlayerFished             (cPlayer & a_Player, const cItems a_Reward);
 	bool CallHookPlayerFishing            (cPlayer & a_Player, cItems a_Reward);
@@ -191,6 +206,8 @@ public:																	// tolua_export
 	bool CallHookPluginsLoaded            (void);
 	bool CallHookPostCrafting             (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
 	bool CallHookPreCrafting              (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
+	bool CallHookProjectileHitBlock       (cProjectileEntity & a_Projectile);
+	bool CallHookProjectileHitEntity      (cProjectileEntity & a_Projectile, cEntity & a_HitEntity);
 	bool CallHookSpawnedEntity            (cWorld & a_World, cEntity & a_Entity);
 	bool CallHookSpawnedMonster           (cWorld & a_World, cMonster & a_Monster);
 	bool CallHookSpawningEntity           (cWorld & a_World, cEntity & a_Entity);
@@ -206,46 +223,46 @@ public:																	// tolua_export
 	bool DisablePlugin(const AString & a_PluginName);  // tolua_export
 	bool LoadPlugin   (const AString & a_PluginName);  // tolua_export
 
-	/// Removes all hooks the specified plugin has registered
+	/** Removes all hooks the specified plugin has registered */
 	void RemoveHooks(cPlugin * a_Plugin);
 	
-	/// Removes the plugin from the internal structures and deletes its object.
+	/** Removes the plugin from the internal structures and deletes its object. */
 	void RemovePlugin(cPlugin * a_Plugin);
 	
-	/// Removes all command bindings that the specified plugin has made
+	/** Removes all command bindings that the specified plugin has made */
 	void RemovePluginCommands(cPlugin * a_Plugin);
 	
-	/// Binds a command to the specified plugin. Returns true if successful, false if command already bound.
+	/** Binds a command to the specified plugin. Returns true if successful, false if command already bound. */
 	bool BindCommand(const AString & a_Command, cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString);  // Exported in ManualBindings.cpp, without the a_Plugin param
 	
-	/// Calls a_Callback for each bound command, returns true if all commands were enumerated
+	/** Calls a_Callback for each bound command, returns true if all commands were enumerated */
 	bool ForEachCommand(cCommandEnumCallback & a_Callback);  // Exported in ManualBindings.cpp
 	
-	/// Returns true if the command is in the command map
+	/** Returns true if the command is in the command map */
 	bool IsCommandBound(const AString & a_Command);  // tolua_export
 	
-	/// Returns the permission needed for the specified command; empty string if command not found
+	/** Returns the permission needed for the specified command; empty string if command not found */
 	AString GetCommandPermission(const AString & a_Command);  // tolua_export
 	
-	/// Executes the command, as if it was requested by a_Player. Checks permissions first. Returns true if executed.
+	/** Executes the command, as if it was requested by a_Player. Checks permissions first. Returns true if executed. */
 	bool ExecuteCommand(cPlayer * a_Player, const AString & a_Command);  // tolua_export
 	
-	/// Executes the command, as if it was requested by a_Player. Permisssions are not checked. Returns true if executed (false if not found)
+	/** Executes the command, as if it was requested by a_Player. Permisssions are not checked. Returns true if executed (false if not found) */
 	bool ForceExecuteCommand(cPlayer * a_Player, const AString & a_Command);  // tolua_export
 	
-	/// Removes all console command bindings that the specified plugin has made
+	/** Removes all console command bindings that the specified plugin has made */
 	void RemovePluginConsoleCommands(cPlugin * a_Plugin);
 	
-	/// Binds a console command to the specified plugin. Returns true if successful, false if command already bound.
+	/** Binds a console command to the specified plugin. Returns true if successful, false if command already bound. */
 	bool BindConsoleCommand(const AString & a_Command, cPlugin * a_Plugin, const AString & a_HelpString);  // Exported in ManualBindings.cpp, without the a_Plugin param
 	
-	/// Calls a_Callback for each bound console command, returns true if all commands were enumerated
+	/** Calls a_Callback for each bound console command, returns true if all commands were enumerated */
 	bool ForEachConsoleCommand(cCommandEnumCallback & a_Callback);  // Exported in ManualBindings.cpp
 	
-	/// Returns true if the console command is in the command map
+	/** Returns true if the console command is in the command map */
 	bool IsConsoleCommandBound(const AString & a_Command);  // tolua_export
 	
-	/// Executes the command split into a_Split, as if it was given on the console. Returns true if executed. Output is sent to the a_Output callback
+	/** Executes the command split into a_Split, as if it was given on the console. Returns true if executed. Output is sent to the a_Output callback */
 	bool ExecuteConsoleCommand(const AStringVector & a_Split, cCommandOutputCallback & a_Output);
 	
 	/** Appends all commands beginning with a_Text (case-insensitive) into a_Results.
@@ -253,9 +270,17 @@ public:																	// tolua_export
 	*/
 	void TabCompleteCommand(const AString & a_Text, AStringVector & a_Results, cPlayer * a_Player);
 	
-	/// Returns true if the specified hook type is within the allowed range
+	/** Returns true if the specified hook type is within the allowed range */
 	static bool IsValidHookType(int a_HookType);
 	
+	/** Calls the specified callback with the plugin object of the specified plugin.
+	Returns false if plugin not found, and the value that the callback has returned otherwise. */
+	bool DoWithPlugin(const AString & a_PluginName, cPluginCallback & a_Callback);
+	
+	/** Returns the path where individual plugins' folders are expected.
+	The path doesn't end in a slash. */
+	static AString GetPluginsPath(void) { return FILE_IO_PREFIX + AString("Plugins"); }  // tolua_export
+	
 private:
 	friend class cRoot;
 	
@@ -281,22 +306,22 @@ private:
 	cPluginManager();
 	virtual ~cPluginManager();
 
-	/// Reloads all plugins, defaulting to settings.ini for settings location
+	/** Reloads all plugins, defaulting to settings.ini for settings location */
 	void ReloadPluginsNow(void);
 
-	/// Reloads all plugins with a cIniFile object expected to be initialised to settings.ini
+	/** Reloads all plugins with a cIniFile object expected to be initialised to settings.ini */
 	void ReloadPluginsNow(cIniFile & a_SettingsIni);
 
-	/// Unloads all plugins
+	/** Unloads all plugins */
 	void UnloadPluginsNow(void);
 
-	/// Handles writing default plugins if 'Plugins' key not found using a cIniFile object expected to be intialised to settings.ini
+	/** Handles writing default plugins if 'Plugins' key not found using a cIniFile object expected to be intialised to settings.ini */
 	void InsertDefaultPlugins(cIniFile & a_SettingsIni);
 
-	/// Adds the plugin into the internal list of plugins and initializes it. If initialization fails, the plugin is removed again.
+	/** Adds the plugin into the internal list of plugins and initializes it. If initialization fails, the plugin is removed again. */
 	bool AddPlugin(cPlugin * a_Plugin);
 
-	/// Tries to match a_Command to the internal table of commands, if a match is found, the corresponding plugin is called. Returns true if the command is handled.
+	/** Tries to match a_Command to the internal table of commands, if a match is found, the corresponding plugin is called. Returns true if the command is handled. */
 	bool HandleCommand(cPlayer * a_Player, const AString & a_Command, bool a_ShouldCheckPermissions, bool & a_WasCommandForbidden);	
 	bool HandleCommand(cPlayer * a_Player, const AString & a_Command, bool a_ShouldCheckPermissions)
 	{
diff --git a/src/Bindings/WebPlugin.cpp b/src/Bindings/WebPlugin.cpp
index 3b71d553c..bf45405ba 100644
--- a/src/Bindings/WebPlugin.cpp
+++ b/src/Bindings/WebPlugin.cpp
@@ -110,4 +110,4 @@ AString cWebPlugin::SafeString( const AString & a_String )
 		RetVal.push_back( c );
 	}
 	return RetVal;
-}
\ No newline at end of file
+}
diff --git a/src/Bindings/lua5.1.dll b/src/Bindings/lua51.dll
index 515cf8b30..515cf8b30 100644
--- a/src/Bindings/lua5.1.dll
+++ b/src/Bindings/lua51.dll
diff --git a/src/Bindings/tolua++.exe b/src/Bindings/tolua++.exe
index e5cec6d78..ba3a6b0c7 100644
--- a/src/Bindings/tolua++.exe
+++ b/src/Bindings/tolua++.exe
diff --git a/src/BiomeDef.cpp b/src/BiomeDef.cpp
index 89a1cdefb..3fba93e8a 100644
--- a/src/BiomeDef.cpp
+++ b/src/BiomeDef.cpp
@@ -13,8 +13,16 @@ EMCSBiome StringToBiome(const AString & a_BiomeString)
 	int res = atoi(a_BiomeString.c_str());
 	if ((res != 0) || (a_BiomeString.compare("0") == 0))
 	{
-		// It was a valid number
-		return (EMCSBiome)res;
+		if ((res >= biFirstBiome) && (res < biNumBiomes))
+		{
+			return (EMCSBiome)res;
+		}
+		else if ((res >= biFirstVariantBiome) && (res < biNumVariantBiomes))
+		{
+			return (EMCSBiome)res;
+		}
+		// It was an invalid number
+		return biInvalidBiome;
 	}
 	
 	// Convert using the built-in map:
@@ -100,7 +108,7 @@ EMCSBiome StringToBiome(const AString & a_BiomeString)
 			return BiomeMap[i].m_Biome;
 		}
 	}  // for i - BiomeMap[]
-	return (EMCSBiome)-1;
+	return biInvalidBiome;
 }
 
 
diff --git a/src/BiomeDef.h b/src/BiomeDef.h
index df1e387f0..474d4df76 100644
--- a/src/BiomeDef.h
+++ b/src/BiomeDef.h
@@ -20,6 +20,9 @@ BiomeIDs over 255 are used by MCServer internally and are translated to MC biome
 */
 enum EMCSBiome
 {
+	biInvalidBiome     = -1,
+
+	biFirstBiome       = 0,
 	biOcean            = 0,
 	biPlains           = 1,
 	biDesert           = 2,
@@ -74,6 +77,7 @@ enum EMCSBiome
 	biVariant = 128,
 	
 	// Release 1.7 biome variants:
+	biFirstVariantBiome    = 129,
 	biSunflowerPlains      = 129,
 	biDesertM              = 130,
 	biExtremeHillsM        = 131,
@@ -95,9 +99,12 @@ enum EMCSBiome
 	biMesaBryce            = 165,
 	biMesaPlateauFM        = 166,
 	biMesaPlateauM         = 167,
+	// Automatically capture the maximum consecutive biome value into biVarientMaxBiome:
+	biNumVariantBiomes,  // True number of biomes, since they are zero-based
+	biMaxVariantBiome = biNumVariantBiomes - 1,  // The maximum biome value
 } ;
 
-/// Translates a biome string to biome enum. Takes either a number or a biome alias (built-in). Returns -1 on failure.
+/// Translates a biome string to biome enum. Takes either a number or a biome alias (built-in). Returns biInvalidBiome on failure.
 extern EMCSBiome StringToBiome(const AString & a_BiomeString);
 
 /// Returns true if the biome has no downfall - deserts and savannas
diff --git a/src/BlockArea.cpp b/src/BlockArea.cpp
index 910661f60..40cca8882 100644
--- a/src/BlockArea.cpp
+++ b/src/BlockArea.cpp
@@ -6,10 +6,9 @@
 
 #include "Globals.h"
 #include "BlockArea.h"
-#include "World.h"
 #include "OSSupport/GZipFile.h"
-#include "WorldStorage/FastNBT.h"
 #include "Blocks/BlockHandler.h"
+#include "Cuboid.h"
 
 
 
@@ -55,7 +54,7 @@ template<typename Combinator> void InternalMergeBlocks(
 
 
 /// Combinator used for cBlockArea::msOverwrite merging
-static void MergeCombinatorOverwrite(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+static inline void MergeCombinatorOverwrite(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
 {
 	a_DstType = a_SrcType;
 	a_DstMeta = a_SrcMeta;
@@ -66,7 +65,7 @@ static void MergeCombinatorOverwrite(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType,
 
 
 /// Combinator used for cBlockArea::msFillAir merging
-static void MergeCombinatorFillAir(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+static inline void MergeCombinatorFillAir(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
 {
 	if (a_DstType == E_BLOCK_AIR)
 	{
@@ -81,7 +80,7 @@ static void MergeCombinatorFillAir(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, N
 
 
 /// Combinator used for cBlockArea::msImprint merging
-static void MergeCombinatorImprint(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+static inline void MergeCombinatorImprint(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
 {
 	if (a_SrcType != E_BLOCK_AIR)
 	{
@@ -96,7 +95,7 @@ static void MergeCombinatorImprint(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, N
 
 
 /// Combinator used for cBlockArea::msLake merging
-static void MergeCombinatorLake(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+static inline void MergeCombinatorLake(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
 {
 	// Sponge is the NOP block
 	if (a_SrcType == E_BLOCK_SPONGE)
@@ -159,16 +158,59 @@ static void MergeCombinatorLake(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBB
 
 
 
+/** Combinator used for cBlockArea::msSpongePrint merging */
+static inline void MergeCombinatorSpongePrint(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+{
+	// Sponge overwrites nothing, everything else overwrites anything
+	if (a_SrcType != E_BLOCK_SPONGE)
+	{
+		a_DstType = a_SrcType;
+		a_DstMeta = a_SrcMeta;
+	}
+}
+
+
+
+
+
+/** Combinator used for cBlockArea::msDifference merging */
+static inline void MergeCombinatorDifference(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+{
+	if ((a_DstType == a_SrcType) && (a_DstMeta == a_SrcMeta))
+	{
+		a_DstType = E_BLOCK_AIR;
+		a_DstMeta = 0;
+	}
+	else
+	{
+		a_DstType = a_SrcType;
+		a_DstMeta = a_SrcMeta;
+	}
+}
+
+
+
+
+
+/** Combinator used for cBlockArea::msMask merging */
+static inline void MergeCombinatorMask(BLOCKTYPE & a_DstType, BLOCKTYPE a_SrcType, NIBBLETYPE & a_DstMeta, NIBBLETYPE a_SrcMeta)
+{
+	// If the blocks are the same, keep the dest; otherwise replace with air
+	if ((a_SrcType != a_DstType) || (a_SrcMeta != a_DstMeta))
+	{
+		a_DstType = E_BLOCK_AIR;
+		a_DstMeta = 0;
+	}
+}
+
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cBlockArea:
 
 cBlockArea::cBlockArea(void) :
-	m_OriginX(0),
-	m_OriginY(0),
-	m_OriginZ(0),
-	m_SizeX(0),
-	m_SizeY(0),
-	m_SizeZ(0),
 	m_BlockTypes(NULL),
 	m_BlockMetas(NULL),
 	m_BlockLight(NULL),
@@ -195,12 +237,8 @@ void cBlockArea::Clear(void)
 	delete[] m_BlockMetas;    m_BlockMetas = NULL;
 	delete[] m_BlockLight;    m_BlockLight = NULL;
 	delete[] m_BlockSkyLight; m_BlockSkyLight = NULL;
-	m_OriginX = 0;
-	m_OriginY = 0;
-	m_OriginZ = 0;
-	m_SizeX = 0;
-	m_SizeY = 0;
-	m_SizeZ = 0;
+	m_Origin.Set(0, 0, 0);
+	m_Size.Set(0, 0, 0);
 }
 
 
@@ -243,12 +281,35 @@ void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			m_BlockSkyLight[i] = 0x0f;
 		}
 	}
-	m_SizeX = a_SizeX;
-	m_SizeY = a_SizeY;
-	m_SizeZ = a_SizeZ;
-	m_OriginX = 0;
-	m_OriginY = 0;
-	m_OriginZ = 0;
+	m_Size.Set(a_SizeX, a_SizeY, a_SizeZ);
+	m_Origin.Set(0, 0, 0);
+}
+
+
+
+
+
+void cBlockArea::Create(const Vector3i & a_Size, int a_DataTypes)
+{
+	Create(a_Size.x, a_Size.y, a_Size.z, a_DataTypes);
+}
+
+
+
+
+
+void cBlockArea::SetWEOffset(int a_OffsetX, int a_OffsetY, int a_OffsetZ)
+{
+	m_WEOffset.Set(a_OffsetX, a_OffsetY, a_OffsetZ);
+}
+
+
+
+
+
+void cBlockArea::SetWEOffset(const Vector3i & a_Offset)
+{
+	m_WEOffset.Set(a_Offset.x, a_Offset.y, a_Offset.z);
 }
 
 
@@ -257,16 +318,23 @@ void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 
 void cBlockArea::SetOrigin(int a_OriginX, int a_OriginY, int a_OriginZ)
 {
-	m_OriginX = a_OriginX;
-	m_OriginY = a_OriginY;
-	m_OriginZ = a_OriginZ;
+	m_Origin.Set(a_OriginX, a_OriginY, a_OriginZ);
+}
+
+
+
+
+
+void cBlockArea::SetOrigin(const Vector3i & a_Origin)
+{
+	m_Origin.Set(a_Origin.x, a_Origin.y, a_Origin.z);
 }
 
 
 
 
 
-bool cBlockArea::Read(cWorld * a_World, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes)
+bool cBlockArea::Read(cForEachChunkProvider * a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes)
 {
 	// Normalize the coords:
 	if (a_MinBlockX > a_MaxBlockX)
@@ -315,9 +383,7 @@ bool cBlockArea::Read(cWorld * a_World, int a_MinBlockX, int a_MaxBlockX, int a_
 	{
 		return false;
 	}
-	m_OriginX = a_MinBlockX;
-	m_OriginY = a_MinBlockY;
-	m_OriginZ = a_MinBlockZ;
+	m_Origin.Set(a_MinBlockX, a_MinBlockY, a_MinBlockZ);
 	cChunkReader Reader(*this);
 	
 	// Convert block coords to chunks coords:
@@ -327,7 +393,7 @@ bool cBlockArea::Read(cWorld * a_World, int a_MinBlockX, int a_MaxBlockX, int a_
 	cChunkDef::AbsoluteToRelative(a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ, MaxChunkX, MaxChunkZ);
 	
 	// Query block data:
-	if (!a_World->ForEachChunkInRect(MinChunkX, MaxChunkX, MinChunkZ, MaxChunkZ, Reader))
+	if (!a_ForEachChunkProvider->ForEachChunkInRect(MinChunkX, MaxChunkX, MinChunkZ, MaxChunkZ, Reader))
 	{
 		Clear();
 		return false;
@@ -340,7 +406,37 @@ bool cBlockArea::Read(cWorld * a_World, int a_MinBlockX, int a_MaxBlockX, int a_
 
 
 
-bool cBlockArea::Write(cWorld * a_World, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
+bool cBlockArea::Read(cForEachChunkProvider * a_ForEachChunkProvider, const cCuboid & a_Bounds, int a_DataTypes)
+{
+	return Read(
+		a_ForEachChunkProvider,
+		a_Bounds.p1.x, a_Bounds.p2.x,
+		a_Bounds.p1.y, a_Bounds.p2.y,
+		a_Bounds.p1.z, a_Bounds.p2.z,
+		a_DataTypes
+	);
+}
+
+
+
+
+
+bool cBlockArea::Read(cForEachChunkProvider * a_ForEachChunkProvider, const Vector3i & a_Point1, const Vector3i & a_Point2, int a_DataTypes)
+{
+	return Read(
+		a_ForEachChunkProvider,
+		a_Point1.x, a_Point2.x,
+		a_Point1.y, a_Point2.y,
+		a_Point1.z, a_Point2.z,
+		a_DataTypes
+	);
+}
+
+
+
+
+
+bool cBlockArea::Write(cForEachChunkProvider * a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
 {
 	ASSERT((a_DataTypes & GetDataTypes()) == a_DataTypes);  // Are you requesting only the data that I have?
 	a_DataTypes = a_DataTypes & GetDataTypes();  // For release builds, silently cut off the datatypes that I don't have
@@ -351,13 +447,26 @@ bool cBlockArea::Write(cWorld * a_World, int a_MinBlockX, int a_MinBlockY, int a
 		LOGWARNING("%s: MinBlockY less than zero, adjusting to zero", __FUNCTION__);
 		a_MinBlockY = 0;
 	}
-	else if (a_MinBlockY > cChunkDef::Height - m_SizeY)
+	else if (a_MinBlockY > cChunkDef::Height - m_Size.y)
 	{
 		LOGWARNING("%s: MinBlockY + m_SizeY more than chunk height, adjusting to chunk height", __FUNCTION__);
-		a_MinBlockY = cChunkDef::Height - m_SizeY;
+		a_MinBlockY = cChunkDef::Height - m_Size.y;
 	}
 
-	return a_World->WriteBlockArea(*this, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
+	return a_ForEachChunkProvider->WriteBlockArea(*this, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
+}
+
+
+
+
+
+bool cBlockArea::Write(cForEachChunkProvider * a_ForEachChunkProvider, const Vector3i & a_MinCoords, int a_DataTypes)
+{
+	return Write(
+		a_ForEachChunkProvider,
+		a_MinCoords.x, a_MinCoords.y, a_MinCoords.z,
+		a_DataTypes
+	);
 }
 
 
@@ -373,10 +482,8 @@ void cBlockArea::CopyTo(cBlockArea & a_Into) const
 	}
 	
 	a_Into.Clear();
-	a_Into.SetSize(m_SizeX, m_SizeY, m_SizeZ, GetDataTypes());
-	a_Into.m_OriginX = m_OriginX;
-	a_Into.m_OriginY = m_OriginY;
-	a_Into.m_OriginZ = m_OriginZ;
+	a_Into.SetSize(m_Size.x, m_Size.y, m_Size.z, GetDataTypes());
+	a_Into.m_Origin = m_Origin;
 	int BlockCount = GetBlockCount();
 	if (HasBlockTypes())
 	{
@@ -417,13 +524,13 @@ void cBlockArea::DumpToRawFile(const AString & a_FileName)
 		LOGWARNING("cBlockArea: Cannot open file \"%s\" for raw dump", a_FileName.c_str());
 		return;
 	}
-	UInt32 SizeX = ntohl(m_SizeX);
-	UInt32 SizeY = ntohl(m_SizeY);
-	UInt32 SizeZ = ntohl(m_SizeZ);
+	UInt32 SizeX = ntohl(m_Size.x);
+	UInt32 SizeY = ntohl(m_Size.y);
+	UInt32 SizeZ = ntohl(m_Size.z);
 	f.Write(&SizeX, 4);
 	f.Write(&SizeY, 4);
 	f.Write(&SizeZ, 4);
-	unsigned char DataTypes = GetDataTypes();
+	unsigned char DataTypes = (unsigned char)GetDataTypes();
 	f.Write(&DataTypes, 1);
 	int NumBlocks = GetBlockCount();
 	if (HasBlockTypes())
@@ -448,85 +555,12 @@ void cBlockArea::DumpToRawFile(const AString & a_FileName)
 
 
 
-bool cBlockArea::LoadFromSchematicFile(const AString & a_FileName)
-{
-	// Un-GZip the contents:
-	AString Contents;
-	cGZipFile File;
-	if (!File.Open(a_FileName, cGZipFile::fmRead))
-	{
-		LOG("Cannot open the schematic file \"%s\".", a_FileName.c_str());
-		return false;
-	}
-	int NumBytesRead = File.ReadRestOfFile(Contents);
-	if (NumBytesRead < 0)
-	{
-		LOG("Cannot read GZipped data in the schematic file \"%s\", error %d", a_FileName.c_str(), NumBytesRead);
-		return false;
-	}
-	File.Close();
-	
-	// Parse the NBT:
-	cParsedNBT NBT(Contents.data(), Contents.size());
-	if (!NBT.IsValid())
-	{
-		LOG("Cannot parse the NBT in the schematic file \"%s\".", a_FileName.c_str());
-		return false;
-	}
-	
-	return LoadFromSchematicNBT(NBT);
-}
 
 
 
 
 
-bool cBlockArea::SaveToSchematicFile(const AString & a_FileName)
-{
-	cFastNBTWriter Writer("Schematic");
-	Writer.AddShort("Width", m_SizeX);
-	Writer.AddShort("Height", m_SizeY);
-	Writer.AddShort("Length", m_SizeZ);
-	Writer.AddString("Materials", "Alpha");
-	if (HasBlockTypes())
-	{
-		Writer.AddByteArray("Blocks", (const char *)m_BlockTypes, GetBlockCount());
-	}
-	else
-	{
-		AString Dummy(GetBlockCount(), 0);
-		Writer.AddByteArray("Blocks", Dummy.data(), Dummy.size());
-	}
-	if (HasBlockMetas())
-	{
-		Writer.AddByteArray("Data", (const char *)m_BlockMetas, GetBlockCount());
-	}
-	else
-	{
-		AString Dummy(GetBlockCount(), 0);
-		Writer.AddByteArray("Data", Dummy.data(), Dummy.size());
-	}
-	// TODO: Save entities and block entities
-	Writer.BeginList("Entities", TAG_Compound);
-	Writer.EndList();
-	Writer.BeginList("TileEntities", TAG_Compound);
-	Writer.EndList();
-	Writer.Finish();
-	
-	// Save to file
-	cGZipFile File;
-	if (!File.Open(a_FileName, cGZipFile::fmWrite))
-	{
-		LOG("Cannot open file \"%s\" for writing.", a_FileName.c_str());
-		return false;
-	}
-	if (!File.Write(Writer.GetResult()))
-	{
-		LOG("Cannot write data to file \"%s\".", a_FileName.c_str());
-		return false;
-	}
-	return true;
-}
+
 
 
 
@@ -535,13 +569,13 @@ bool cBlockArea::SaveToSchematicFile(const AString & a_FileName)
 void cBlockArea::Crop(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ)
 {
 	if (
-		(a_AddMinX + a_SubMaxX >= m_SizeX) ||
-		(a_AddMinY + a_SubMaxY >= m_SizeY) ||
-		(a_AddMinZ + a_SubMaxZ >= m_SizeZ)
+		(a_AddMinX + a_SubMaxX >= m_Size.x) ||
+		(a_AddMinY + a_SubMaxY >= m_Size.y) ||
+		(a_AddMinZ + a_SubMaxZ >= m_Size.z)
 	)
 	{
 		LOGWARNING("cBlockArea:Crop called with more croping than the dimensions: %d x %d x %d with cropping %d, %d and %d",
-			m_SizeX, m_SizeY, m_SizeZ,
+			m_Size.x, m_Size.y, m_Size.z,
 			a_AddMinX + a_SubMaxX, a_AddMinY + a_SubMaxY, a_AddMinZ + a_SubMaxZ
 		);
 		return;
@@ -563,12 +597,10 @@ void cBlockArea::Crop(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY
 	{
 		CropNibbles(m_BlockSkyLight, a_AddMinX, a_SubMaxX, a_AddMinY, a_SubMaxY, a_AddMinZ, a_SubMaxZ);
 	}
-	m_OriginX += a_AddMinX;
-	m_OriginY += a_AddMinY;
-	m_OriginZ += a_AddMinZ;
-	m_SizeX -= a_AddMinX + a_SubMaxX;
-	m_SizeY -= a_AddMinY + a_SubMaxY;
-	m_SizeZ -= a_AddMinZ + a_SubMaxZ;
+	m_Origin.Move(a_AddMinX, a_AddMinY, a_AddMinZ);
+	m_Size.x -= a_AddMinX + a_SubMaxX;
+	m_Size.y -= a_AddMinY + a_SubMaxY;
+	m_Size.z -= a_AddMinZ + a_SubMaxZ;
 }
 
 
@@ -593,12 +625,10 @@ void cBlockArea::Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMa
 	{
 		ExpandNibbles(m_BlockSkyLight, a_SubMinX, a_AddMaxX, a_SubMinY, a_AddMaxY, a_SubMinZ, a_AddMaxZ);
 	}
-	m_OriginX -= a_SubMinX;
-	m_OriginY -= a_SubMinY;
-	m_OriginZ -= a_SubMinZ;
-	m_SizeX += a_SubMinX + a_AddMaxX;
-	m_SizeY += a_SubMinY + a_AddMaxY;
-	m_SizeZ += a_SubMinZ + a_AddMaxZ;
+	m_Origin.Move(-a_SubMinX, -a_SubMinY, -a_SubMinZ);
+	m_Size.x += a_SubMinX + a_AddMaxX;
+	m_Size.y += a_SubMinY + a_AddMaxY;
+	m_Size.z += a_SubMinZ + a_AddMaxZ;
 }
 
 
@@ -648,7 +678,7 @@ void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_R
 				SrcOffX, SrcOffY, SrcOffZ,
 				DstOffX, DstOffY, DstOffZ,
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
-				m_SizeX, m_SizeY, m_SizeZ,
+				m_Size.x, m_Size.y, m_Size.z,
 				MergeCombinatorOverwrite
 			);
 			break;
@@ -663,7 +693,7 @@ void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_R
 				SrcOffX, SrcOffY, SrcOffZ,
 				DstOffX, DstOffY, DstOffZ,
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
-				m_SizeX, m_SizeY, m_SizeZ,
+				m_Size.x, m_Size.y, m_Size.z,
 				MergeCombinatorFillAir
 			);
 			break;
@@ -678,7 +708,7 @@ void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_R
 				SrcOffX, SrcOffY, SrcOffZ,
 				DstOffX, DstOffY, DstOffZ,
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
-				m_SizeX, m_SizeY, m_SizeZ,
+				m_Size.x, m_Size.y, m_Size.z,
 				MergeCombinatorImprint
 			);
 			break;
@@ -693,12 +723,57 @@ void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_R
 				SrcOffX, SrcOffY, SrcOffZ,
 				DstOffX, DstOffY, DstOffZ,
 				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
-				m_SizeX, m_SizeY, m_SizeZ,
+				m_Size.x, m_Size.y, m_Size.z,
 				MergeCombinatorLake
 			);
 			break;
 		}  // case msLake
 		
+		case msSpongePrint:
+		{
+			InternalMergeBlocks(
+				m_BlockTypes, a_Src.GetBlockTypes(),
+				DstMetas, SrcMetas,
+				SizeX, SizeY, SizeZ,
+				SrcOffX, SrcOffY, SrcOffZ,
+				DstOffX, DstOffY, DstOffZ,
+				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
+				m_Size.x, m_Size.y, m_Size.z,
+				MergeCombinatorSpongePrint
+			);
+			break;
+		}  // case msSpongePrint
+
+		case msDifference:
+		{
+			InternalMergeBlocks(
+				m_BlockTypes, a_Src.GetBlockTypes(),
+				DstMetas, SrcMetas,
+				SizeX, SizeY, SizeZ,
+				SrcOffX, SrcOffY, SrcOffZ,
+				DstOffX, DstOffY, DstOffZ,
+				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
+				m_Size.x, m_Size.y, m_Size.z,
+				MergeCombinatorDifference
+			);
+			break;
+		}	// case msDifference
+		
+		case msMask:
+		{
+			InternalMergeBlocks(
+				m_BlockTypes, a_Src.GetBlockTypes(),
+				DstMetas, SrcMetas,
+				SizeX, SizeY, SizeZ,
+				SrcOffX, SrcOffY, SrcOffZ,
+				DstOffX, DstOffY, DstOffZ,
+				a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(),
+				m_Size.x, m_Size.y, m_Size.z,
+				MergeCombinatorMask
+			);
+			break;
+		}  // case msMask
+		
 		default:
 		{
 			LOGWARNING("Unknown block area merge strategy: %d", a_Strategy);
@@ -718,6 +793,15 @@ void cBlockArea::Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_R
 
 
 
+void cBlockArea::Merge(const cBlockArea & a_Src, const Vector3i & a_RelMinCoords, eMergeStrategy a_Strategy)
+{
+	Merge(a_Src, a_RelMinCoords.x, a_RelMinCoords.y, a_RelMinCoords.z, a_Strategy);
+}
+
+
+
+
+
 void cBlockArea::Fill(int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight)
 {
 	if ((a_DataTypes & GetDataTypes()) != a_DataTypes)
@@ -810,6 +894,23 @@ void cBlockArea::FillRelCuboid(int a_MinRelX, int a_MaxRelX, int a_MinRelY, int
 
 
 
+void cBlockArea::FillRelCuboid(const cCuboid & a_RelCuboid,
+	int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
+	NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight
+)
+{
+	FillRelCuboid(
+		a_RelCuboid.p1.x, a_RelCuboid.p2.x,
+		a_RelCuboid.p1.y, a_RelCuboid.p2.y,
+		a_RelCuboid.p1.z, a_RelCuboid.p2.z,
+		a_DataTypes, a_BlockType, a_BlockMeta, a_BlockLight, a_BlockSkyLight
+	);
+}
+
+
+
+
+
 void cBlockArea::RelLine(int a_RelX1, int a_RelY1, int a_RelZ1, int a_RelX2, int a_RelY2, int a_RelZ2,
 	int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
 	NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight
@@ -927,6 +1028,22 @@ void cBlockArea::RelLine(int a_RelX1, int a_RelY1, int a_RelZ1, int a_RelX2, int
 
 
 
+void cBlockArea::RelLine(const Vector3i & a_Point1, const Vector3i & a_Point2,
+	int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
+	NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight
+)
+{
+	RelLine(
+		a_Point1.x, a_Point1.y, a_Point1.z,
+		a_Point2.x, a_Point2.y, a_Point2.z,
+		a_DataTypes, a_BlockType, a_BlockMeta, a_BlockLight, a_BlockSkyLight
+	);
+}
+
+
+
+
+
 void cBlockArea::RotateCCW(void)
 {
 	if (!HasBlockTypes())
@@ -943,17 +1060,17 @@ void cBlockArea::RotateCCW(void)
 	}
 	
 	// We are guaranteed that both blocktypes and blockmetas exist; rotate both at the same time:
-	BLOCKTYPE * NewTypes = new BLOCKTYPE[m_SizeX * m_SizeY * m_SizeZ];
-	NIBBLETYPE * NewMetas = new NIBBLETYPE[m_SizeX * m_SizeY * m_SizeZ];
-	for (int x = 0; x < m_SizeX; x++)
+	BLOCKTYPE * NewTypes = new BLOCKTYPE[GetBlockCount()];
+	NIBBLETYPE * NewMetas = new NIBBLETYPE[GetBlockCount()];
+	for (int x = 0; x < m_Size.x; x++)
 	{
-		int NewZ = m_SizeX - x - 1;
-		for (int z = 0; z < m_SizeZ; z++)
+		int NewZ = m_Size.x - x - 1;
+		for (int z = 0; z < m_Size.z; z++)
 		{
 			int NewX = z;
-			for (int y = 0; y < m_SizeY; y++)
+			for (int y = 0; y < m_Size.y; y++)
 			{
-				int NewIdx = NewX + NewZ * m_SizeX + y * m_SizeX * m_SizeZ;
+				int NewIdx = NewX + NewZ * m_Size.z + y * m_Size.x * m_Size.z;
 				int OldIdx = MakeIndex(x, y, z);
 				NewTypes[NewIdx] = m_BlockTypes[OldIdx];
 				NewMetas[NewIdx] = BlockHandler(m_BlockTypes[OldIdx])->MetaRotateCCW(m_BlockMetas[OldIdx]);
@@ -965,7 +1082,7 @@ void cBlockArea::RotateCCW(void)
 	delete[] NewTypes;
 	delete[] NewMetas;
 
-	std::swap(m_SizeX, m_SizeZ);
+	std::swap(m_Size.x, m_Size.z);
 }
 
 
@@ -988,17 +1105,17 @@ void cBlockArea::RotateCW(void)
 	}
 	
 	// We are guaranteed that both blocktypes and blockmetas exist; rotate both at the same time:
-	BLOCKTYPE * NewTypes = new BLOCKTYPE[m_SizeX * m_SizeY * m_SizeZ];
-	NIBBLETYPE * NewMetas = new NIBBLETYPE[m_SizeX * m_SizeY * m_SizeZ];
-	for (int x = 0; x < m_SizeX; x++)
+	BLOCKTYPE * NewTypes = new BLOCKTYPE[GetBlockCount()];
+	NIBBLETYPE * NewMetas = new NIBBLETYPE[GetBlockCount()];
+	for (int x = 0; x < m_Size.x; x++)
 	{
 		int NewZ = x;
-		for (int z = 0; z < m_SizeZ; z++)
+		for (int z = 0; z < m_Size.z; z++)
 		{
-			int NewX = m_SizeZ - z - 1;
-			for (int y = 0; y < m_SizeY; y++)
+			int NewX = m_Size.z - z - 1;
+			for (int y = 0; y < m_Size.y; y++)
 			{
-				int NewIdx = NewX + NewZ * m_SizeX + y * m_SizeX * m_SizeZ;
+				int NewIdx = NewX + NewZ * m_Size.z + y * m_Size.x * m_Size.z;
 				int OldIdx = MakeIndex(x, y, z);
 				NewTypes[NewIdx] = m_BlockTypes[OldIdx];
 				NewMetas[NewIdx] = BlockHandler(m_BlockTypes[OldIdx])->MetaRotateCW(m_BlockMetas[OldIdx]);
@@ -1010,7 +1127,7 @@ void cBlockArea::RotateCW(void)
 	delete[] NewTypes;
 	delete[] NewMetas;
 
-	std::swap(m_SizeX, m_SizeZ);
+	std::swap(m_Size.x, m_Size.z);
 }
 
 
@@ -1033,13 +1150,13 @@ void cBlockArea::MirrorXY(void)
 	}
 
 	// We are guaranteed that both blocktypes and blockmetas exist; mirror both at the same time:
-	int HalfZ = m_SizeZ / 2;
-	int MaxZ = m_SizeZ - 1;
-	for (int y = 0; y < m_SizeY; y++)
+	int HalfZ = m_Size.z / 2;
+	int MaxZ = m_Size.z - 1;
+	for (int y = 0; y < m_Size.y; y++)
 	{
 		for (int z = 0; z < HalfZ; z++)
 		{
-			for (int x = 0; x < m_SizeX; x++)
+			for (int x = 0; x < m_Size.x; x++)
 			{
 				int Idx1 = MakeIndex(x, y, z);
 				int Idx2 = MakeIndex(x, y, MaxZ - z);
@@ -1073,13 +1190,13 @@ void cBlockArea::MirrorXZ(void)
 	}
 
 	// We are guaranteed that both blocktypes and blockmetas exist; mirror both at the same time:
-	int HalfY = m_SizeY / 2;
-	int MaxY = m_SizeY - 1;
+	int HalfY = m_Size.y / 2;
+	int MaxY = m_Size.y - 1;
 	for (int y = 0; y < HalfY; y++)
 	{
-		for (int z = 0; z < m_SizeZ; z++)
+		for (int z = 0; z < m_Size.z; z++)
 		{
-			for (int x = 0; x < m_SizeX; x++)
+			for (int x = 0; x < m_Size.x; x++)
 			{
 				int Idx1 = MakeIndex(x, y, z);
 				int Idx2 = MakeIndex(x, MaxY - y, z);
@@ -1113,11 +1230,11 @@ void cBlockArea::MirrorYZ(void)
 	}
 
 	// We are guaranteed that both blocktypes and blockmetas exist; mirror both at the same time:
-	int HalfX = m_SizeX / 2;
-	int MaxX = m_SizeX - 1;
-	for (int y = 0; y < m_SizeY; y++)
+	int HalfX = m_Size.x / 2;
+	int MaxX = m_Size.x - 1;
+	for (int y = 0; y < m_Size.y; y++)
 	{
-		for (int z = 0; z < m_SizeZ; z++)
+		for (int z = 0; z < m_Size.z; z++)
 		{
 			for (int x = 0; x < HalfX; x++)
 			{
@@ -1141,16 +1258,16 @@ void cBlockArea::RotateCCWNoMeta(void)
 {
 	if (HasBlockTypes())
 	{
-		BLOCKTYPE * NewTypes = new BLOCKTYPE[m_SizeX * m_SizeY * m_SizeZ];
-		for (int x = 0; x < m_SizeX; x++)
+		BLOCKTYPE * NewTypes = new BLOCKTYPE[GetBlockCount()];
+		for (int x = 0; x < m_Size.x; x++)
 		{
-			int NewZ = m_SizeX - x - 1;
-			for (int z = 0; z < m_SizeZ; z++)
+			int NewZ = m_Size.x - x - 1;
+			for (int z = 0; z < m_Size.z; z++)
 			{
 				int NewX = z;
-				for (int y = 0; y < m_SizeY; y++)
+				for (int y = 0; y < m_Size.y; y++)
 				{
-					NewTypes[NewX + NewZ * m_SizeX + y * m_SizeX * m_SizeZ] = m_BlockTypes[MakeIndex(x, y, z)];
+					NewTypes[NewX + NewZ * m_Size.z + y * m_Size.x * m_Size.z] = m_BlockTypes[MakeIndex(x, y, z)];
 				}  // for y
 			}  // for z
 		}  // for x
@@ -1159,23 +1276,23 @@ void cBlockArea::RotateCCWNoMeta(void)
 	}
 	if (HasBlockMetas())
 	{
-		NIBBLETYPE * NewMetas = new NIBBLETYPE[m_SizeX * m_SizeY * m_SizeZ];
-		for (int x = 0; x < m_SizeX; x++)
+		NIBBLETYPE * NewMetas = new NIBBLETYPE[GetBlockCount()];
+		for (int x = 0; x < m_Size.x; x++)
 		{
-			int NewZ = m_SizeX - x - 1;
-			for (int z = 0; z < m_SizeZ; z++)
+			int NewZ = m_Size.x - x - 1;
+			for (int z = 0; z < m_Size.z; z++)
 			{
 				int NewX = z;
-				for (int y = 0; y < m_SizeY; y++)
+				for (int y = 0; y < m_Size.y; y++)
 				{
-					NewMetas[NewX + NewZ * m_SizeX + y * m_SizeX * m_SizeZ] = m_BlockMetas[MakeIndex(x, y, z)];
+					NewMetas[NewX + NewZ * m_Size.z + y * m_Size.x * m_Size.z] = m_BlockMetas[MakeIndex(x, y, z)];
 				}  // for y
 			}  // for z
 		}  // for x
 		std::swap(m_BlockMetas, NewMetas);
 		delete[] NewMetas;
 	}
-	std::swap(m_SizeX, m_SizeZ);
+	std::swap(m_Size.x, m_Size.z);
 }
 
 
@@ -1186,16 +1303,16 @@ void cBlockArea::RotateCWNoMeta(void)
 {
 	if (HasBlockTypes())
 	{
-		BLOCKTYPE * NewTypes = new BLOCKTYPE[m_SizeX * m_SizeY * m_SizeZ];
-		for (int z = 0; z < m_SizeZ; z++)
+		BLOCKTYPE * NewTypes = new BLOCKTYPE[GetBlockCount()];
+		for (int z = 0; z < m_Size.z; z++)
 		{
-			int NewX = m_SizeZ - z - 1;
-			for (int x = 0; x < m_SizeX; x++)
+			int NewX = m_Size.z - z - 1;
+			for (int x = 0; x < m_Size.x; x++)
 			{
 				int NewZ = x;
-				for (int y = 0; y < m_SizeY; y++)
+				for (int y = 0; y < m_Size.y; y++)
 				{
-					NewTypes[NewX + NewZ * m_SizeX + y * m_SizeX * m_SizeZ] = m_BlockTypes[MakeIndex(x, y, z)];
+					NewTypes[NewX + NewZ * m_Size.z + y * m_Size.x * m_Size.z] = m_BlockTypes[MakeIndex(x, y, z)];
 				}  // for y
 			}  // for x
 		}  // for z
@@ -1204,23 +1321,23 @@ void cBlockArea::RotateCWNoMeta(void)
 	}
 	if (HasBlockMetas())
 	{
-		NIBBLETYPE * NewMetas = new NIBBLETYPE[m_SizeX * m_SizeY * m_SizeZ];
-		for (int z = 0; z < m_SizeZ; z++)
+		NIBBLETYPE * NewMetas = new NIBBLETYPE[GetBlockCount()];
+		for (int z = 0; z < m_Size.z; z++)
 		{
-			int NewX = m_SizeZ - z - 1;
-			for (int x = 0; x < m_SizeX; x++)
+			int NewX = m_Size.z - z - 1;
+			for (int x = 0; x < m_Size.x; x++)
 			{
 				int NewZ = x;
-				for (int y = 0; y < m_SizeY; y++)
+				for (int y = 0; y < m_Size.y; y++)
 				{
-					NewMetas[NewX + NewZ * m_SizeX + y * m_SizeX * m_SizeZ] = m_BlockMetas[MakeIndex(x, y, z)];
+					NewMetas[NewX + NewZ * m_Size.z + y * m_Size.x * m_Size.z] = m_BlockMetas[MakeIndex(x, y, z)];
 				}  // for y
 			}  // for x
 		}  // for z
 		std::swap(m_BlockMetas, NewMetas);
 		delete[] NewMetas;
 	}
-	std::swap(m_SizeX, m_SizeZ);
+	std::swap(m_Size.x, m_Size.z);
 }
 
 
@@ -1229,15 +1346,15 @@ void cBlockArea::RotateCWNoMeta(void)
 
 void cBlockArea::MirrorXYNoMeta(void)
 {
-	int HalfZ = m_SizeZ / 2;
-	int MaxZ = m_SizeZ - 1;
+	int HalfZ = m_Size.z / 2;
+	int MaxZ = m_Size.z - 1;
 	if (HasBlockTypes())
 	{
-		for (int y = 0; y < m_SizeY; y++)
+		for (int y = 0; y < m_Size.y; y++)
 		{
 			for (int z = 0; z < HalfZ; z++)
 			{
-				for (int x = 0; x < m_SizeX; x++)
+				for (int x = 0; x < m_Size.x; x++)
 				{
 					std::swap(m_BlockTypes[MakeIndex(x, y, z)], m_BlockTypes[MakeIndex(x, y, MaxZ - z)]);
 				}  // for x
@@ -1247,11 +1364,11 @@ void cBlockArea::MirrorXYNoMeta(void)
 	
 	if (HasBlockMetas())
 	{
-		for (int y = 0; y < m_SizeY; y++)
+		for (int y = 0; y < m_Size.y; y++)
 		{
 			for (int z = 0; z < HalfZ; z++)
 			{
-				for (int x = 0; x < m_SizeX; x++)
+				for (int x = 0; x < m_Size.x; x++)
 				{
 					std::swap(m_BlockMetas[MakeIndex(x, y, z)], m_BlockMetas[MakeIndex(x, y, MaxZ - z)]);
 				}  // for x
@@ -1266,15 +1383,15 @@ void cBlockArea::MirrorXYNoMeta(void)
 
 void cBlockArea::MirrorXZNoMeta(void)
 {
-	int HalfY = m_SizeY / 2;
-	int MaxY = m_SizeY - 1;
+	int HalfY = m_Size.y / 2;
+	int MaxY = m_Size.y - 1;
 	if (HasBlockTypes())
 	{
 		for (int y = 0; y < HalfY; y++)
 		{
-			for (int z = 0; z < m_SizeZ; z++)
+			for (int z = 0; z < m_Size.z; z++)
 			{
-				for (int x = 0; x < m_SizeX; x++)
+				for (int x = 0; x < m_Size.x; x++)
 				{
 					std::swap(m_BlockTypes[MakeIndex(x, y, z)], m_BlockTypes[MakeIndex(x, MaxY - y, z)]);
 				}  // for x
@@ -1286,9 +1403,9 @@ void cBlockArea::MirrorXZNoMeta(void)
 	{
 		for (int y = 0; y < HalfY; y++)
 		{
-			for (int z = 0; z < m_SizeZ; z++)
+			for (int z = 0; z < m_Size.z; z++)
 			{
-				for (int x = 0; x < m_SizeX; x++)
+				for (int x = 0; x < m_Size.x; x++)
 				{
 					std::swap(m_BlockMetas[MakeIndex(x, y, z)], m_BlockMetas[MakeIndex(x, MaxY - y, z)]);
 				}  // for x
@@ -1303,13 +1420,13 @@ void cBlockArea::MirrorXZNoMeta(void)
 
 void cBlockArea::MirrorYZNoMeta(void)
 {
-	int HalfX = m_SizeX / 2;
-	int MaxX = m_SizeX - 1;
+	int HalfX = m_Size.x / 2;
+	int MaxX = m_Size.x - 1;
 	if (HasBlockTypes())
 	{
-		for (int y = 0; y < m_SizeY; y++)
+		for (int y = 0; y < m_Size.y; y++)
 		{
-			for (int z = 0; z < m_SizeZ; z++)
+			for (int z = 0; z < m_Size.z; z++)
 			{
 				for (int x = 0; x < HalfX; x++)
 				{
@@ -1321,9 +1438,9 @@ void cBlockArea::MirrorYZNoMeta(void)
 	
 	if (HasBlockMetas())
 	{
-		for (int y = 0; y < m_SizeY; y++)
+		for (int y = 0; y < m_Size.y; y++)
 		{
-			for (int z = 0; z < m_SizeZ; z++)
+			for (int z = 0; z < m_Size.z; z++)
 			{
 				for (int x = 0; x < HalfX; x++)
 				{
@@ -1354,7 +1471,7 @@ void cBlockArea::SetRelBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a
 
 void cBlockArea::SetBlockType(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType)
 {
-	SetRelBlockType(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_BlockType);
+	SetRelBlockType(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_BlockType);
 }
 
 
@@ -1431,7 +1548,7 @@ BLOCKTYPE cBlockArea::GetRelBlockType(int a_RelX, int a_RelY, int a_RelZ) const
 
 BLOCKTYPE cBlockArea::GetBlockType(int a_BlockX, int a_BlockY, int a_BlockZ) const
 {
-	return GetRelBlockType(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ);
+	return GetRelBlockType(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z);
 }
 
 
@@ -1494,7 +1611,7 @@ NIBBLETYPE cBlockArea::GetBlockSkyLight(int a_BlockX, int a_BlockY, int a_BlockZ
 
 void cBlockArea::SetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
-	SetRelBlockTypeMeta(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_BlockType, a_BlockMeta);
+	SetRelBlockTypeMeta(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_BlockType, a_BlockMeta);
 }
 
 
@@ -1528,7 +1645,7 @@ void cBlockArea::SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   B
 
 void cBlockArea::GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
 {
-	return GetRelBlockTypeMeta(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_BlockType, a_BlockMeta);
+	return GetRelBlockTypeMeta(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_BlockType, a_BlockMeta);
 }
 
 
@@ -1631,9 +1748,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 			return false;
 		}
 	}
-	m_SizeX = a_SizeX;
-	m_SizeY = a_SizeY;
-	m_SizeZ = a_SizeZ;
+	m_Size.Set(a_SizeX, a_SizeY, a_SizeZ);
 	return true;
 }
 
@@ -1644,13 +1759,13 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 int cBlockArea::MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const
 {
 	ASSERT(a_RelX >= 0);
-	ASSERT(a_RelX < m_SizeX);
+	ASSERT(a_RelX < m_Size.x);
 	ASSERT(a_RelY >= 0);
-	ASSERT(a_RelY < m_SizeY);
+	ASSERT(a_RelY < m_Size.y);
 	ASSERT(a_RelZ >= 0);
-	ASSERT(a_RelZ < m_SizeZ);
+	ASSERT(a_RelZ < m_Size.z);
 	
-	return a_RelX + a_RelZ * m_SizeX + a_RelY * m_SizeX * m_SizeZ;
+	return a_RelX + a_RelZ * m_Size.x + a_RelY * m_Size.x * m_Size.z;
 }
 
 
@@ -1673,7 +1788,7 @@ void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_V
 
 void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array)
 {
-	SetRelNibble(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_Value, a_Array);
+	SetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Value, a_Array);
 }
 
 
@@ -1696,7 +1811,7 @@ NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETY
 
 NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array) const
 {
-	return GetRelNibble(a_BlockX - m_OriginX, a_BlockY - m_OriginY, a_BlockZ - m_OriginZ, a_Array);
+	return GetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Array);
 }
 
 
@@ -1709,9 +1824,7 @@ NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBL
 
 cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) :
 	m_Area(a_Area),
-	m_OriginX(a_Area.m_OriginX),
-	m_OriginY(a_Area.m_OriginY),
-	m_OriginZ(a_Area.m_OriginZ)
+	m_Origin(a_Area.m_Origin.x, a_Area.m_Origin.y, a_Area.m_Origin.z)
 {
 }
 
@@ -1721,8 +1834,8 @@ cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) :
 
 void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc)
 {
-	int SizeY = m_Area.m_SizeY;
-	int MinY = m_OriginY;
+	int SizeY = m_Area.m_Size.y;
+	int MinY = m_Origin.y;
 	
 	// SizeX, SizeZ are the dmensions of the block data to copy from the current chunk (size of the geometric union)
 	// OffX, OffZ are the offsets of the current chunk data from the area origin
@@ -1731,7 +1844,7 @@ void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLET
 	int SizeZ = cChunkDef::Width;
 	int OffX, OffZ;
 	int BaseX, BaseZ;
-	OffX = m_CurrentChunkX * cChunkDef::Width - m_OriginX;
+	OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x;
 	if (OffX < 0)
 	{
 		BaseX = -OffX;
@@ -1742,7 +1855,7 @@ void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLET
 	{
 		BaseX = 0;
 	}
-	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_OriginZ;
+	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z;
 	if (OffZ < 0)
 	{
 		BaseZ = -OffZ;
@@ -1754,13 +1867,13 @@ void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLET
 		BaseZ = 0;
 	}
 	// If the chunk extends beyond the area in the X or Z axis, cut off the Size:
-	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_OriginX + m_Area.m_SizeX)
+	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x)
 	{
-		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_OriginX + m_Area.m_SizeX);
+		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x);
 	}
-	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_OriginZ + m_Area.m_SizeZ)
+	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z)
 	{
-		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_OriginZ + m_Area.m_SizeZ);
+		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z);
 	}
 
 	for (int y = 0; y < SizeY; y++)
@@ -1804,8 +1917,8 @@ void cBlockArea::cChunkReader::BlockTypes(const BLOCKTYPE * a_BlockTypes)
 		return;
 	}
 	
-	int SizeY = m_Area.m_SizeY;
-	int MinY = m_OriginY;
+	int SizeY = m_Area.m_Size.y;
+	int MinY = m_Origin.y;
 	
 	// SizeX, SizeZ are the dmensions of the block data to copy from the current chunk (size of the geometric union)
 	// OffX, OffZ are the offsets of the current chunk data from the area origin
@@ -1814,7 +1927,7 @@ void cBlockArea::cChunkReader::BlockTypes(const BLOCKTYPE * a_BlockTypes)
 	int SizeZ = cChunkDef::Width;
 	int OffX, OffZ;
 	int BaseX, BaseZ;
-	OffX = m_CurrentChunkX * cChunkDef::Width - m_OriginX;
+	OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x;
 	if (OffX < 0)
 	{
 		BaseX = -OffX;
@@ -1825,7 +1938,7 @@ void cBlockArea::cChunkReader::BlockTypes(const BLOCKTYPE * a_BlockTypes)
 	{
 		BaseX = 0;
 	}
-	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_OriginZ;
+	OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z;
 	if (OffZ < 0)
 	{
 		BaseZ = -OffZ;
@@ -1837,13 +1950,13 @@ void cBlockArea::cChunkReader::BlockTypes(const BLOCKTYPE * a_BlockTypes)
 		BaseZ = 0;
 	}
 	// If the chunk extends beyond the area in the X or Z axis, cut off the Size:
-	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_OriginX + m_Area.m_SizeX)
+	if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x)
 	{
-		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_OriginX + m_Area.m_SizeX);
+		SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x);
 	}
-	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_OriginZ + m_Area.m_SizeZ)
+	if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z)
 	{
-		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_OriginZ + m_Area.m_SizeZ);
+		SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z);
 	}
 
 	for (int y = 0; y < SizeY; y++)
@@ -1963,21 +2076,21 @@ void cBlockArea::CropNibbles(NIBBLEARRAY & a_Array, int a_AddMinX, int a_SubMaxX
 
 void cBlockArea::ExpandBlockTypes(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ)
 {
-	int NewSizeX = m_SizeX + a_SubMinX + a_AddMaxX;
-	int NewSizeY = m_SizeY + a_SubMinY + a_AddMaxY;
-	int NewSizeZ = m_SizeZ + a_SubMinZ + a_AddMaxZ;
+	int NewSizeX = m_Size.x + a_SubMinX + a_AddMaxX;
+	int NewSizeY = m_Size.y + a_SubMinY + a_AddMaxY;
+	int NewSizeZ = m_Size.z + a_SubMinZ + a_AddMaxZ;
 	int BlockCount = NewSizeX * NewSizeY * NewSizeZ;
 	BLOCKTYPE * NewBlockTypes = new BLOCKTYPE[BlockCount];
 	memset(NewBlockTypes, 0, BlockCount * sizeof(BLOCKTYPE));
 	int OldIndex = 0;
-	for (int y = 0; y < m_SizeY; y++)
+	for (int y = 0; y < m_Size.y; y++)
 	{
-		int IndexBaseY = (y + a_SubMinY) * m_SizeX * m_SizeZ;
-		for (int z = 0; z < m_SizeZ; z++)
+		int IndexBaseY = (y + a_SubMinY) * m_Size.x * m_Size.z;
+		for (int z = 0; z < m_Size.z; z++)
 		{
-			int IndexBaseZ = IndexBaseY + (z + a_SubMinZ) * m_SizeX;
+			int IndexBaseZ = IndexBaseY + (z + a_SubMinZ) * m_Size.x;
 			int idx = IndexBaseZ + a_SubMinX;
-			for (int x = 0; x < m_SizeX; x++)
+			for (int x = 0; x < m_Size.x; x++)
 			{
 				NewBlockTypes[idx++] = m_BlockTypes[OldIndex++];
 			}  // for x
@@ -1993,21 +2106,21 @@ void cBlockArea::ExpandBlockTypes(int a_SubMinX, int a_AddMaxX, int a_SubMinY, i
 
 void cBlockArea::ExpandNibbles(NIBBLEARRAY & a_Array, int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ)
 {
-	int NewSizeX = m_SizeX + a_SubMinX + a_AddMaxX;
-	int NewSizeY = m_SizeY + a_SubMinY + a_AddMaxY;
-	int NewSizeZ = m_SizeZ + a_SubMinZ + a_AddMaxZ;
+	int NewSizeX = m_Size.x + a_SubMinX + a_AddMaxX;
+	int NewSizeY = m_Size.y + a_SubMinY + a_AddMaxY;
+	int NewSizeZ = m_Size.z + a_SubMinZ + a_AddMaxZ;
 	int BlockCount = NewSizeX * NewSizeY * NewSizeZ;
 	NIBBLETYPE * NewNibbles = new NIBBLETYPE[BlockCount];
 	memset(NewNibbles, 0, BlockCount * sizeof(NIBBLETYPE));
 	int OldIndex = 0;
-	for (int y = 0; y < m_SizeY; y++)
+	for (int y = 0; y < m_Size.y; y++)
 	{
-		int IndexBaseY = (y + a_SubMinY) * m_SizeX * m_SizeZ;
-		for (int z = 0; z < m_SizeZ; z++)
+		int IndexBaseY = (y + a_SubMinY) * m_Size.x * m_Size.z;
+		for (int z = 0; z < m_Size.z; z++)
 		{
-			int IndexBaseZ = IndexBaseY + (z + a_SubMinZ) * m_SizeX;
+			int IndexBaseZ = IndexBaseY + (z + a_SubMinZ) * m_Size.x;
 			int idx = IndexBaseZ + a_SubMinX;
-			for (int x = 0; x < m_SizeX; x++)
+			for (int x = 0; x < m_Size.x; x++)
 			{
 				NewNibbles[idx++] = a_Array[OldIndex++];
 			}  // for x
@@ -2021,86 +2134,6 @@ void cBlockArea::ExpandNibbles(NIBBLEARRAY & a_Array, int a_SubMinX, int a_AddMa
 
 
 
-bool cBlockArea::LoadFromSchematicNBT(cParsedNBT & a_NBT)
-{
-	int TMaterials = a_NBT.FindChildByName(a_NBT.GetRoot(), "Materials");
-	if ((TMaterials > 0) && (a_NBT.GetType(TMaterials) == TAG_String))
-	{
-		AString Materials = a_NBT.GetString(TMaterials);
-		if (Materials.compare("Alpha") != 0)
-		{
-			LOG("Materials tag is present and \"%s\" instead of \"Alpha\". Possibly a wrong-format schematic file.", Materials.c_str());
-			return false;
-		}
-	}
-	int TSizeX = a_NBT.FindChildByName(a_NBT.GetRoot(), "Width");
-	int TSizeY = a_NBT.FindChildByName(a_NBT.GetRoot(), "Height");
-	int TSizeZ = a_NBT.FindChildByName(a_NBT.GetRoot(), "Length");
-	if (
-		(TSizeX < 0) || (TSizeY < 0) || (TSizeZ < 0) ||
-		(a_NBT.GetType(TSizeX) != TAG_Short) ||
-		(a_NBT.GetType(TSizeY) != TAG_Short) ||
-		(a_NBT.GetType(TSizeZ) != TAG_Short)
-	)
-	{
-		LOG("Dimensions are missing from the schematic file (%d, %d, %d), (%d, %d, %d)",
-			TSizeX, TSizeY, TSizeZ,
-			a_NBT.GetType(TSizeX), a_NBT.GetType(TSizeY), a_NBT.GetType(TSizeZ)
-		);
-		return false;
-	}
-	
-	int SizeX = a_NBT.GetShort(TSizeX);
-	int SizeY = a_NBT.GetShort(TSizeY);
-	int SizeZ = a_NBT.GetShort(TSizeZ);
-	if ((SizeX < 1) || (SizeY < 1) || (SizeZ < 1))
-	{
-		LOG("Dimensions are invalid in the schematic file: %d, %d, %d", SizeX, SizeY, SizeZ);
-		return false;
-	}
-	
-	int TBlockTypes = a_NBT.FindChildByName(a_NBT.GetRoot(), "Blocks");
-	int TBlockMetas = a_NBT.FindChildByName(a_NBT.GetRoot(), "Data");
-	if ((TBlockTypes < 0) || (a_NBT.GetType(TBlockTypes) != TAG_ByteArray))
-	{
-		LOG("BlockTypes are invalid in the schematic file: %d", TBlockTypes);
-		return false;
-	}
-	bool AreMetasPresent = (TBlockMetas > 0) && (a_NBT.GetType(TBlockMetas) == TAG_ByteArray);
-	
-	Clear();
-	SetSize(SizeX, SizeY, SizeZ, AreMetasPresent ? (baTypes | baMetas) : baTypes);
-	
-	// Copy the block types and metas:
-	int NumBytes = m_SizeX * m_SizeY * m_SizeZ;
-	if (a_NBT.GetDataLength(TBlockTypes) < NumBytes)
-	{
-		LOG("BlockTypes truncated in the schematic file (exp %d, got %d bytes). Loading partial.",
-			NumBytes, a_NBT.GetDataLength(TBlockTypes)
-		);
-		NumBytes = a_NBT.GetDataLength(TBlockTypes);
-	}
-	memcpy(m_BlockTypes, a_NBT.GetData(TBlockTypes), NumBytes);
-	
-	if (AreMetasPresent)
-	{
-		int NumBytes = m_SizeX * m_SizeY * m_SizeZ;
-		if (a_NBT.GetDataLength(TBlockMetas) < NumBytes)
-		{
-			LOG("BlockMetas truncated in the schematic file (exp %d, got %d bytes). Loading partial.",
-				NumBytes, a_NBT.GetDataLength(TBlockMetas)
-			);
-			NumBytes = a_NBT.GetDataLength(TBlockMetas);
-		}
-		memcpy(m_BlockMetas, a_NBT.GetData(TBlockMetas), NumBytes);
-	}
-	
-	return true;
-}
-
-
-
-
 void cBlockArea::RelSetData(
 	int a_RelX, int a_RelY, int a_RelZ,
 	int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
diff --git a/src/BlockArea.h b/src/BlockArea.h
index 075cc99ec..c48175b8c 100644
--- a/src/BlockArea.h
+++ b/src/BlockArea.h
@@ -12,15 +12,14 @@
 
 #pragma once
 
+#include "ForEachChunkProvider.h"
+#include "Vector3.h"
 
 
 
 
-// fwd: World.h
-class cWorld;
-
-// fwd: FastNBT.h
-class cParsedNBT;
+// fwd:
+class cCuboid;
 
 
 
@@ -35,7 +34,7 @@ class cBlockArea
 	
 public:
 
-	/// What data is to be queried (bit-mask)
+	/** What data is to be queried (bit-mask) */
 	enum
 	{
 		baTypes    = 1,
@@ -44,57 +43,74 @@ public:
 		baSkyLight = 8,
 	} ;
 	
+	/** The per-block strategy to use when merging another block area into this object.
+	See the Merge function for the description of these */
 	enum eMergeStrategy
 	{
 		msOverwrite,
 		msFillAir,
 		msImprint,
 		msLake,
+		msSpongePrint,
+		msDifference,
+		msMask,
 	} ;
 	
 	cBlockArea(void);
 	~cBlockArea();
 	
-	/// Clears the data stored to reclaim memory
+	/** Clears the data stored to reclaim memory */
 	void Clear(void);
 	
-	/** Creates a new area of the specified size and contents. 
-	Origin is set to all zeroes. 
+	/** Creates a new area of the specified size and contents.
+	Origin is set to all zeroes.
 	BlockTypes are set to air, block metas to zero, blocklights to zero and skylights to full light.
 	*/
 	void Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes = baTypes | baMetas);
 	
-	/// Resets the origin. No other changes are made, contents are untouched.
+	/** Creates a new area of the specified size and contents.
+	Origin is set to all zeroes.
+	BlockTypes are set to air, block metas to zero, blocklights to zero and skylights to full light.
+	*/
+	void Create(const Vector3i & a_Size, int a_DataTypes = baTypes | baMetas);
+	
+	/** Resets the origin. No other changes are made, contents are untouched. */
 	void SetOrigin(int a_OriginX, int a_OriginY, int a_OriginZ);
 	
-	/// Reads an area of blocks specified. Returns true if successful. All coords are inclusive.
-	bool Read(cWorld * a_World, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes = baTypes | baMetas);
+	/** Resets the origin. No other changes are made, contents are untouched. */
+	void SetOrigin(const Vector3i & a_Origin);
+	
+	/** Reads an area of blocks specified. Returns true if successful. All coords are inclusive. */
+	bool Read(cForEachChunkProvider * a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes = baTypes | baMetas);
+	
+	/** Reads an area of blocks specified. Returns true if successful. The bounds are included in the read area. */
+	bool Read(cForEachChunkProvider * a_ForEachChunkProvider, const cCuboid & a_Bounds, int a_DataTypes = baTypes | baMetas);
+	
+	/** Reads an area of blocks specified. Returns true if successful. The bounds are included in the read area. */
+	bool Read(cForEachChunkProvider * a_ForEachChunkProvider, const Vector3i & a_Point1, const Vector3i & a_Point2, int a_DataTypes = baTypes | baMetas);
 	
 	// TODO: Write() is not too good an interface: if it fails, there's no way to repeat only for the parts that didn't write
 	// A better way may be to return a list of cBlockAreas for each part that didn't succeed writing, so that the caller may try again
 	
-	/// Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all
-	bool Write(cWorld * a_World, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes = baTypes | baMetas);
+	/** Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all */
+	bool Write(cForEachChunkProvider * a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes = baTypes | baMetas);
 	
-	/// Copies this object's contents into the specified BlockArea.
+	/** Writes the area back into cWorld at the coords specified. Returns true if successful in all chunks, false if only partially / not at all */
+	bool Write(cForEachChunkProvider * a_ForEachChunkProvider, const Vector3i & a_MinCoords, int a_DataTypes = baTypes | baMetas);
+	
+	/** Copies this object's contents into the specified BlockArea. */
 	void CopyTo(cBlockArea & a_Into) const;
 	
-	/// Copies the contents from the specified BlockArea into this object.
+	/** Copies the contents from the specified BlockArea into this object. */
 	void CopyFrom(const cBlockArea & a_From);
 	
-	/// For testing purposes only, dumps the area into a file.
+	/** For testing purposes only, dumps the area into a file. */
 	void DumpToRawFile(const AString & a_FileName);
 	
-	/// Loads an area from a .schematic file. Returns true if successful
-	bool LoadFromSchematicFile(const AString & a_FileName);
-	
-	/// Saves the area into a .schematic file. Returns true if successful
-	bool SaveToSchematicFile(const AString & a_FileName);
-	
-	/// Crops the internal contents by the specified amount of blocks from each border.
+	/** Crops the internal contents by the specified amount of blocks from each border. */
 	void Crop(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ);
 	
-	/// Expands the internal contents by the specified amount of blocks from each border
+	/** Expands the internal contents by the specified amount of blocks from each border */
 	void Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 	
 	/** Merges another block area into this one, using the specified block combinating strategy
@@ -114,8 +130,8 @@ public:
 	- msFillAir overwrites only those blocks that were air
 	- msImprint overwrites with only those blocks that are non-air
 
-	Special strategies:
-	msLake (evaluate top-down, first match wins):
+	Special strategies (evaluate top-down, first match wins):
+	msLake:
 	|    area block     |        |
 	|   this   | Src    | result |
 	+----------+--------+--------+
@@ -130,53 +146,85 @@ public:
 	| mycelium | stone  | stone  |    ... and mycelium
 	| A        | stone  | A      |    ... but nothing else
 	| A        | *      | A      |  Everything else is left as it is
+	
+	msSpongePrint:
+	Used for most generators, it allows carving out air pockets, too, and uses the Sponge as the NOP block
+	|    area block     |        |
+	|   this   | Src    | result |
+	+----------+--------+--------+
+	| A        | sponge | A      |  Sponge is the NOP block
+	| *        | B      | B      |  Everything else overwrites anything
+	
+	msMask:
+	Combines two areas, the blocks that are the same are kept, differing ones are reset to air
+	|  area block  |        |
+	| this | Src   | result |
+	+------+-------+--------+
+	| A    | A     | A      |  Same blocks are kept
+	| A    | non-A | air    |  Everything else is replaced with air
 
 	*/
 	void Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_RelZ, eMergeStrategy a_Strategy);
 	
-	/// Fills the entire block area with the specified data
+	/** Merges another block area into this one, using the specified block combinating strategy.
+	See Merge() above for details. */
+	void Merge(const cBlockArea & a_Src, const Vector3i & a_RelMinCoords, eMergeStrategy a_Strategy);
+	
+	/** Fills the entire block area with the specified data */
 	void Fill(int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0, NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f);
 	
-	/// Fills a cuboid inside the block area with the specified data
+	/** Fills a cuboid inside the block area with the specified data */
 	void FillRelCuboid(int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ, 
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
 		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
 	);
 	
-	/// Draws a line from between two points with the specified data
+	/** Fills a cuboid inside the block area with the specified data. a_Cuboid must be sorted. */
+	void FillRelCuboid(const cCuboid & a_RelCuboid,
+		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
+		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
+	);
+	
+	/** Draws a line from between two points with the specified data */
 	void RelLine(int a_RelX1, int a_RelY1, int a_RelZ1, int a_RelX2, int a_RelY2, int a_RelZ2,
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
 		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
 	);
 	
-	/// Rotates the entire area counter-clockwise around the Y axis
+	/** Draws a line from between two points with the specified data */
+	void RelLine(const Vector3i & a_Point1, const Vector3i & a_Point2,
+		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
+		NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
+	);
+	
+	/** Rotates the entire area counter-clockwise around the Y axis */
 	void RotateCCW(void);
 	
-	/// Rotates the entire area clockwise around the Y axis
+	/** Rotates the entire area clockwise around the Y axis */
 	void RotateCW(void);
 	
-	/// Mirrors the entire area around the XY plane
+	/** Mirrors the entire area around the XY plane */
 	void MirrorXY(void);
 	
-	/// Mirrors the entire area around the XZ plane
+	/** Mirrors the entire area around the XZ plane */
 	void MirrorXZ(void);
 	
-	/// Mirrors the entire area around the YZ plane
+	/** Mirrors the entire area around the YZ plane */
 	void MirrorYZ(void);
 	
-	/// Rotates the entire area counter-clockwise around the Y axis, doesn't use blockhandlers for block meta
+	/** Rotates the entire area counter-clockwise around the Y axis, doesn't use blockhandlers for block meta */
 	void RotateCCWNoMeta(void);
 	
-	/// Rotates the entire area clockwise around the Y axis, doesn't use blockhandlers for block meta
+	/** Rotates the entire area clockwise around the Y axis, doesn't use blockhandlers for block meta */
 	void RotateCWNoMeta(void);
 	
-	/// Mirrors the entire area around the XY plane, doesn't use blockhandlers for block meta
+	/** Mirrors the entire area around the XY plane, doesn't use blockhandlers for block meta */
 	void MirrorXYNoMeta(void);
 	
-	/// Mirrors the entire area around the XZ plane, doesn't use blockhandlers for block meta
+	/** Mirrors the entire area around the XZ plane, doesn't use blockhandlers for block meta */
 	void MirrorXZNoMeta(void);
 	
-	/// Mirrors the entire area around the YZ plane, doesn't use blockhandlers for block meta
+	/** Mirrors the entire area around the YZ plane, doesn't use blockhandlers for block meta */
 	void MirrorYZNoMeta(void);
 	
 	// Setters:
@@ -188,6 +236,8 @@ public:
 	void SetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockLight);
 	void SetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockSkyLight);
 	void SetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockSkyLight);
+	void SetWEOffset        (int a_OffsetX, int a_OffsetY, int a_OffsetZ);
+	void SetWEOffset        (const Vector3i & a_Offset);
 
 	// Getters:
 	BLOCKTYPE  GetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ)   const;
@@ -198,21 +248,37 @@ public:
 	NIBBLETYPE GetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ) const;
 	NIBBLETYPE GetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ)   const;
 	NIBBLETYPE GetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ) const;
+	const Vector3i & GetWEOffset  (void)                                     const {return m_WEOffset;}
 
 	void SetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
 	void SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
+	
+	// tolua_end
+	
+	// These need manual exporting, tolua generates the binding as requiring 2 extra input params
 	void GetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 	void GetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 	
-	int GetSizeX(void) const { return m_SizeX; }
-	int GetSizeY(void) const { return m_SizeY; }
-	int GetSizeZ(void) const { return m_SizeZ; }
+	// GetSize() is already exported manually to return 3 numbers, can't auto-export
+	const Vector3i & GetSize(void) const { return m_Size; }
+	
+	// GetOrigin() is already exported manually to return 3 numbers, can't auto-export
+	const Vector3i & GetOrigin(void) const { return m_Origin; }
+	
+	// tolua_begin
+	
+	int GetSizeX(void) const { return m_Size.x; }
+	int GetSizeY(void) const { return m_Size.y; }
+	int GetSizeZ(void) const { return m_Size.z; }
+	
+	/** Returns the volume of the area, as number of blocks */
+	int GetVolume(void) const { return m_Size.x * m_Size.y * m_Size.z; }
 	
-	int GetOriginX(void) const { return m_OriginX; }
-	int GetOriginY(void) const { return m_OriginY; }
-	int GetOriginZ(void) const { return m_OriginZ; }
+	int GetOriginX(void) const { return m_Origin.x; }
+	int GetOriginY(void) const { return m_Origin.y; }
+	int GetOriginZ(void) const { return m_Origin.z; }
 	
-	/// Returns the datatypes that are stored in the object (bitmask of baXXX values)
+	/** Returns the datatypes that are stored in the object (bitmask of baXXX values) */
 	int GetDataTypes(void) const;
 	
 	bool HasBlockTypes    (void) const { return (m_BlockTypes    != NULL); }
@@ -223,16 +289,17 @@ public:
 	// tolua_end
 	
 	// Clients can use these for faster access to all blocktypes. Be careful though!
-	/// Returns the internal pointer to the block types
+	/** Returns the internal pointer to the block types */
 	BLOCKTYPE *  GetBlockTypes   (void) const { return m_BlockTypes; }
 	NIBBLETYPE * GetBlockMetas   (void) const { return m_BlockMetas; }     // NOTE: one byte per block!
 	NIBBLETYPE * GetBlockLight   (void) const { return m_BlockLight; }     // NOTE: one byte per block!
 	NIBBLETYPE * GetBlockSkyLight(void) const { return m_BlockSkyLight; }  // NOTE: one byte per block!
-	int          GetBlockCount(void) const { return m_SizeX * m_SizeY * m_SizeZ; }
+	int          GetBlockCount(void) const { return m_Size.x * m_Size.y * m_Size.z; }
 	int MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const;
 
 protected:
 	friend class cChunkDesc;
+	friend class cSchematicFileSerializer;
 	
 	class cChunkReader :
 		public cChunkDataCallback
@@ -242,9 +309,7 @@ protected:
 		
 	protected:
 		cBlockArea & m_Area;
-		int m_OriginX;
-		int m_OriginY;
-		int m_OriginZ;
+		Vector3i m_Origin;
 		int m_CurrentChunkX;
 		int m_CurrentChunkZ;
 		
@@ -261,19 +326,19 @@ protected:
 	typedef NIBBLETYPE * NIBBLEARRAY;
 	
 	
-	int m_OriginX;
-	int m_OriginY;
-	int m_OriginZ;
-	int m_SizeX;
-	int m_SizeY;
-	int m_SizeZ;
+	Vector3i m_Origin;
+	Vector3i m_Size;
 	
+	/** An extra data value sometimes stored in the .schematic file. Used mainly by the WorldEdit plugin.
+	cBlockArea doesn't use this value in any way. */
+	Vector3i m_WEOffset;
+
 	BLOCKTYPE *  m_BlockTypes;
 	NIBBLETYPE * m_BlockMetas;     // Each meta is stored as a separate byte for faster access
 	NIBBLETYPE * m_BlockLight;     // Each light value is stored as a separate byte for faster access
 	NIBBLETYPE * m_BlockSkyLight;  // Each light value is stored as a separate byte for faster access
 	
-	/// Clears the data stored and prepares a fresh new block area with the specified dimensions
+	/** Clears the data stored and prepares a fresh new block area with the specified dimensions */
 	bool SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes);
 	
 	// Basic Setters:
@@ -291,11 +356,8 @@ protected:
 	// Expand helpers:
 	void ExpandBlockTypes(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 	void ExpandNibbles   (NIBBLEARRAY & a_Array, int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
-	
-	/// Loads the area from a schematic file uncompressed and parsed into a NBT tree. Returns true if successful.
-	bool LoadFromSchematicNBT(cParsedNBT & a_NBT);
 
-	/// Sets the specified datatypes at the specified location.
+	/** Sets the specified datatypes at the specified location. */
 	void RelSetData(
 		int a_RelX, int a_RelY, int a_RelZ, 
 		int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
diff --git a/src/BlockEntities/BlockEntity.cpp b/src/BlockEntities/BlockEntity.cpp
index 97b5c1a66..b42318c2f 100644
--- a/src/BlockEntities/BlockEntity.cpp
+++ b/src/BlockEntities/BlockEntity.cpp
@@ -10,11 +10,13 @@
 #include "DispenserEntity.h"
 #include "DropperEntity.h"
 #include "EnderChestEntity.h"
+#include "FlowerPotEntity.h"
 #include "FurnaceEntity.h"
 #include "HopperEntity.h"
 #include "JukeboxEntity.h"
 #include "NoteEntity.h"
 #include "SignEntity.h"
+#include "MobHeadEntity.h"
 
 
 
@@ -29,6 +31,8 @@ cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE
 		case E_BLOCK_DISPENSER:     return new cDispenserEntity   (a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_DROPPER:       return new cDropperEntity     (a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_ENDER_CHEST:   return new cEnderChestEntity  (a_BlockX, a_BlockY, a_BlockZ, a_World);
+		case E_BLOCK_FLOWER_POT:    return new cFlowerPotEntity   (a_BlockX, a_BlockY, a_BlockZ, a_World);
+		case E_BLOCK_HEAD:          return new cMobHeadEntity     (a_BlockX, a_BlockY, a_BlockZ, a_World);
 		case E_BLOCK_LIT_FURNACE:   return new cFurnaceEntity     (a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_World);
 		case E_BLOCK_FURNACE:       return new cFurnaceEntity     (a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_World);
 		case E_BLOCK_HOPPER:        return new cHopperEntity      (a_BlockX, a_BlockY, a_BlockZ, a_World);
diff --git a/src/BlockEntities/BlockEntityWithItems.h b/src/BlockEntities/BlockEntityWithItems.h
index bf6289a2f..918781a00 100644
--- a/src/BlockEntities/BlockEntityWithItems.h
+++ b/src/BlockEntities/BlockEntityWithItems.h
@@ -11,6 +11,7 @@
 
 #include "BlockEntity.h"
 #include "../ItemGrid.h"
+#include "../UI/WindowOwner.h"
 
 
 
@@ -22,6 +23,7 @@ class cBlockEntityWithItems :
 	// tolua_end
 	// tolua doesn't seem to support multiple inheritance?
 	, public cItemGrid::cListener
+	, public cBlockEntityWindowOwner
 	// tolua_begin
 {
 	typedef cBlockEntity super;
@@ -77,6 +79,11 @@ protected:
 		ASSERT(a_Grid == &m_Contents);
 		if (m_World != NULL)
 		{
+			if (GetWindow() != NULL)
+			{
+				GetWindow()->BroadcastWholeWindow();
+			}
+
 			m_World->MarkChunkDirty(GetChunkX(), GetChunkZ());
 		}
 	}
diff --git a/src/BlockEntities/ChestEntity.h b/src/BlockEntities/ChestEntity.h
index 4110de1f3..ce16f84d7 100644
--- a/src/BlockEntities/ChestEntity.h
+++ b/src/BlockEntities/ChestEntity.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockEntityWithItems.h"
-#include "../UI/WindowOwner.h"
 
 
 
@@ -23,8 +22,7 @@ class cNBTData;
 
 // tolua_begin
 class cChestEntity :
-	public cBlockEntityWithItems,
-	public cBlockEntityWindowOwner
+	public cBlockEntityWithItems
 {
 	typedef cBlockEntityWithItems super;
 	
diff --git a/src/BlockEntities/CommandBlockEntity.cpp b/src/BlockEntities/CommandBlockEntity.cpp
index 7e9015d33..96ca0ac37 100644
--- a/src/BlockEntities/CommandBlockEntity.cpp
+++ b/src/BlockEntities/CommandBlockEntity.cpp
@@ -12,6 +12,7 @@
 #include "../CommandOutput.h"
 #include "../Root.h"
 #include "../Server.h" // ExecuteConsoleCommand()
+#include "../Chunk.h"
 
 
 
@@ -126,6 +127,8 @@ void cCommandBlockEntity::SetRedstonePower(bool a_IsPowered)
 
 bool cCommandBlockEntity::Tick(float a_Dt, cChunk & a_Chunk)
 {
+	UNUSED(a_Dt);
+	UNUSED(a_Chunk);
 	if (!m_ShouldExecute)
 	{
 		return false;
@@ -151,9 +154,13 @@ void cCommandBlockEntity::SendTo(cClientHandle & a_Client)
 
 bool cCommandBlockEntity::LoadFromJson(const Json::Value & a_Value)
 {
-	m_Command = a_Value.get("Command", "").asString();
+	m_PosX = a_Value.get("x", 0).asInt();
+	m_PosY = a_Value.get("y", 0).asInt();
+	m_PosZ = a_Value.get("z", 0).asInt();
 
-	m_LastOutput = a_Value.get("LastOutput", "").asString();
+	m_Command    = a_Value.get("Command",     "").asString();
+	m_LastOutput = a_Value.get("LastOutput",  "").asString();
+	m_Result     = (NIBBLETYPE)a_Value.get("SuccessCount", 0).asInt();
 
 	return true;
 }
@@ -164,9 +171,13 @@ bool cCommandBlockEntity::LoadFromJson(const Json::Value & a_Value)
 
 void cCommandBlockEntity::SaveToJson(Json::Value & a_Value)
 {
-	a_Value["Command"] = m_Command;
+	a_Value["x"] = m_PosX;
+	a_Value["y"] = m_PosY;
+	a_Value["z"] = m_PosZ;
 
-	a_Value["LastOutput"] = m_LastOutput;
+	a_Value["Command"]      = m_Command;
+	a_Value["LastOutput"]   = m_LastOutput;
+	a_Value["SuccessCount"] = m_Result;
 }
 
 
@@ -175,18 +186,24 @@ void cCommandBlockEntity::SaveToJson(Json::Value & a_Value)
 
 void cCommandBlockEntity::Execute()
 {
+	if (m_World != NULL)
+	{
+		if (!m_World->AreCommandBlocksEnabled())
+		{
+			return;
+		}
+	}
+
 	class CommandBlockOutCb :
 		public cCommandOutputCallback
 	{
-		cCommandBlockEntity* m_CmdBlock;
+		cCommandBlockEntity * m_CmdBlock;
 
 	public:
-		CommandBlockOutCb(cCommandBlockEntity* a_CmdBlock) : m_CmdBlock(a_CmdBlock) {}
+		CommandBlockOutCb(cCommandBlockEntity * a_CmdBlock) : m_CmdBlock(a_CmdBlock) {}
 
 		virtual void Out(const AString & a_Text)
 		{
-			ASSERT(m_CmdBlock != NULL);
-
 			// Overwrite field
 			m_CmdBlock->SetLastOutput(a_Text);
 		}
@@ -194,7 +211,7 @@ void cCommandBlockEntity::Execute()
 
 	LOGD("cCommandBlockEntity: Executing command %s", m_Command.c_str());
 
-	cServer* Server = cRoot::Get()->GetServer();
+	cServer * Server = cRoot::Get()->GetServer();
 
 	Server->ExecuteConsoleCommand(m_Command, CmdBlockOutCb);
 
diff --git a/src/BlockEntities/DispenserEntity.cpp b/src/BlockEntities/DispenserEntity.cpp
index 374f3d6e3..e03bf776d 100644
--- a/src/BlockEntities/DispenserEntity.cpp
+++ b/src/BlockEntities/DispenserEntity.cpp
@@ -116,7 +116,7 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
 			{
 				double TNTX = 0.5 + (DispX + DispChunk->GetPosX() * cChunkDef::Width);
 				double TNTZ = 0.5 + (DispZ + DispChunk->GetPosZ() * cChunkDef::Width);
-				m_World->SpawnPrimedTNT(TNTX, DispY + 0.5, TNTZ, 4, 0);  // 4 seconds fuse, no initial velocity
+				m_World->SpawnPrimedTNT(TNTX, DispY + 0.5, TNTZ, 80, 0);  // 80 ticks fuse, no initial velocity
 				m_Contents.ChangeSlotCount(a_SlotNum, -1);
 			}
 			break;
@@ -138,6 +138,12 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
 			break;
 		}
 		
+		case E_ITEM_FIRE_CHARGE:
+		{
+			// TODO: Spawn fireball entity
+			break;
+		}
+		
 		default:
 		{
 			DropFromSlot(a_Chunk, a_SlotNum);
diff --git a/src/BlockEntities/DropSpenserEntity.cpp b/src/BlockEntities/DropSpenserEntity.cpp
index 7c9a40ce6..0012742fb 100644
--- a/src/BlockEntities/DropSpenserEntity.cpp
+++ b/src/BlockEntities/DropSpenserEntity.cpp
@@ -99,13 +99,6 @@ void cDropSpenserEntity::DropSpense(cChunk & a_Chunk)
 	}
 	m_World->BroadcastSoundParticleEffect(2000, m_PosX, m_PosY, m_PosZ, SmokeDir);
 	m_World->BroadcastSoundEffect("random.click", m_PosX * 8, m_PosY * 8, m_PosZ * 8, 1.0f, 1.0f);
-	
-	// Update the UI window, if open:
-	cWindow * Window = GetWindow();
-	if (Window != NULL)
-	{
-		Window->BroadcastWholeWindow();
-	}
 }	
 
 
@@ -136,6 +129,7 @@ void cDropSpenserEntity::SetRedstonePower(bool a_IsPowered)
 
 bool cDropSpenserEntity::Tick(float a_Dt, cChunk & a_Chunk)
 {
+	UNUSED(a_Dt);
 	if (!m_ShouldDropSpense)
 	{
 		return false;
diff --git a/src/BlockEntities/DropSpenserEntity.h b/src/BlockEntities/DropSpenserEntity.h
index f2f1eba36..47d3bd492 100644
--- a/src/BlockEntities/DropSpenserEntity.h
+++ b/src/BlockEntities/DropSpenserEntity.h
@@ -11,7 +11,6 @@
 #pragma once
 
 #include "BlockEntityWithItems.h"
-#include "../UI/WindowOwner.h"
 
 
 
@@ -31,8 +30,7 @@ class cServer;
 
 // tolua_begin
 class cDropSpenserEntity :
-	public cBlockEntityWithItems,
-	public cBlockEntityWindowOwner
+	public cBlockEntityWithItems
 {
 	typedef cBlockEntityWithItems super;
 
diff --git a/src/BlockEntities/EnderChestEntity.h b/src/BlockEntities/EnderChestEntity.h
index 0ee3cab3b..45beee45f 100644
--- a/src/BlockEntities/EnderChestEntity.h
+++ b/src/BlockEntities/EnderChestEntity.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockEntityWithItems.h"
-#include "../UI/WindowOwner.h"
 
 
 
@@ -23,8 +22,7 @@ class cNBTData;
 
 // tolua_begin
 class cEnderChestEntity :
-	public cBlockEntityWithItems,
-	public cBlockEntityWindowOwner
+	public cBlockEntityWithItems
 {
 	typedef cBlockEntityWithItems super;
 	
diff --git a/src/BlockEntities/FlowerPotEntity.cpp b/src/BlockEntities/FlowerPotEntity.cpp
new file mode 100644
index 000000000..87bf8b921
--- /dev/null
+++ b/src/BlockEntities/FlowerPotEntity.cpp
@@ -0,0 +1,134 @@
+
+// FlowerPotEntity.cpp
+
+// Implements the cFlowerPotEntity class representing a single sign in the world
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+#include "json/json.h"
+#include "FlowerPotEntity.h"
+#include "../Entities/Player.h"
+#include "../Item.h"
+
+
+
+
+
+cFlowerPotEntity::cFlowerPotEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) :
+	super(E_BLOCK_FLOWER_POT, a_BlockX, a_BlockY, a_BlockZ, a_World)
+{
+}
+
+
+
+
+
+// It don't do anything when 'used'
+void cFlowerPotEntity::UsedBy(cPlayer * a_Player)
+{
+	if (IsItemInPot())
+	{
+		return;
+	}
+	
+	cItem SelectedItem = a_Player->GetInventory().GetEquippedItem();
+	if (IsFlower(SelectedItem.m_ItemType, SelectedItem.m_ItemDamage))
+	{
+		m_Item = SelectedItem.CopyOne();
+		if (!a_Player->IsGameModeCreative())
+		{
+			a_Player->GetInventory().RemoveOneEquippedItem();
+		}
+		m_World->BroadcastBlockEntity(m_PosX, m_PosY, m_PosZ, a_Player->GetClientHandle());
+	}
+}
+
+
+
+
+
+void cFlowerPotEntity::SendTo(cClientHandle & a_Client)
+{
+	a_Client.SendUpdateBlockEntity(*this);
+}
+
+
+
+
+
+void cFlowerPotEntity::Destroy(void)
+{
+	// Drop the contents as pickups:
+	if (!m_Item.IsEmpty())
+	{
+		ASSERT(m_World != NULL);
+		cItems Pickups;
+		Pickups.Add(m_Item);
+		m_World->SpawnItemPickups(Pickups, m_PosX + 0.5, m_PosY + 0.5, m_PosZ + 0.5);
+		
+		m_Item.Empty();
+	}
+}
+
+
+
+
+
+bool cFlowerPotEntity::LoadFromJson(const Json::Value & a_Value)
+{
+	m_PosX = a_Value.get("x", 0).asInt();
+	m_PosY = a_Value.get("y", 0).asInt();
+	m_PosZ = a_Value.get("z", 0).asInt();
+
+	m_Item = cItem();
+	m_Item.FromJson(a_Value.get("Item", 0));
+
+	return true;
+}
+
+
+
+
+
+void cFlowerPotEntity::SaveToJson(Json::Value & a_Value)
+{
+	a_Value["x"] = m_PosX;
+	a_Value["y"] = m_PosY;
+	a_Value["z"] = m_PosZ;
+	
+	Json::Value Item;
+	m_Item.GetJson(Item);
+	a_Value["Item"] = Item;
+}
+
+
+
+
+
+bool cFlowerPotEntity::IsFlower(short m_ItemType, short m_ItemData)
+{
+	switch (m_ItemType)
+	{
+		case E_BLOCK_DANDELION:
+		case E_BLOCK_FLOWER:
+		case E_BLOCK_CACTUS:
+		case E_BLOCK_BROWN_MUSHROOM:
+		case E_BLOCK_RED_MUSHROOM:
+		case E_BLOCK_SAPLING:
+		case E_BLOCK_DEAD_BUSH:
+		{
+			return true;
+		}
+		case E_BLOCK_TALL_GRASS:
+		{
+			return (m_ItemData == (short) 2);
+		}
+		default:
+		{
+			return false;
+		}
+	}
+}
+
+
+
+
diff --git a/src/BlockEntities/FlowerPotEntity.h b/src/BlockEntities/FlowerPotEntity.h
new file mode 100644
index 000000000..da3fe9b7e
--- /dev/null
+++ b/src/BlockEntities/FlowerPotEntity.h
@@ -0,0 +1,74 @@
+// FlowerPotEntity.h
+
+// Declares the cFlowerPotEntity class representing a single sign in the world
+
+
+
+
+
+#pragma once
+
+#include "BlockEntity.h"
+
+class cItem;
+
+
+
+
+
+namespace Json
+{
+	class Value;
+}
+
+
+
+
+
+// tolua_begin
+
+class cFlowerPotEntity : 
+	public cBlockEntity
+{
+	typedef cBlockEntity super;
+	
+public:
+
+	// tolua_end
+	
+	/** Creates a new flowerpot entity at the specified block coords. a_World may be NULL */
+	cFlowerPotEntity(int a_BlocX, int a_BlockY, int a_BlockZ, cWorld * a_World);
+
+	bool LoadFromJson( const Json::Value& a_Value );
+	virtual void SaveToJson(Json::Value& a_Value ) override;
+	
+	virtual void Destroy(void) override;
+
+	// tolua_begin
+	
+	/** Is a flower in the pot? */
+	bool IsItemInPot(void) { return !m_Item.IsEmpty(); }
+	
+	/** Get the item in the flower pot */
+	cItem GetItem(void) const { return m_Item; }
+	
+	/** Set the item in the flower pot */
+	void SetItem(const cItem a_Item) { m_Item = a_Item; }
+	
+	// tolua_end
+	
+	virtual void UsedBy(cPlayer * a_Player) override;
+	virtual void SendTo(cClientHandle & a_Client) override;
+
+	static bool IsFlower(short m_ItemType, short m_ItemData);
+
+	static const char * GetClassStatic(void) { return "cFlowerPotEntity"; }
+	
+private:
+
+	cItem m_Item;
+} ;  // tolua_export
+
+
+
+
diff --git a/src/BlockEntities/FurnaceEntity.cpp b/src/BlockEntities/FurnaceEntity.cpp
index c6643bcff..7d6d1f89e 100644
--- a/src/BlockEntities/FurnaceEntity.cpp
+++ b/src/BlockEntities/FurnaceEntity.cpp
@@ -94,6 +94,8 @@ bool cFurnaceEntity::ContinueCooking(void)
 
 bool cFurnaceEntity::Tick(float a_Dt, cChunk & a_Chunk)
 {
+	UNUSED(a_Dt);
+	UNUSED(a_Chunk);
 	if (m_FuelBurnTime <= 0)
 	{
 		// No fuel is burning, reset progressbars and bail out
@@ -110,7 +112,7 @@ bool cFurnaceEntity::Tick(float a_Dt, cChunk & a_Chunk)
 		if (m_TimeCooked >= m_NeedCookTime)
 		{
 			// Finished smelting one item
-			FinishOne(a_Chunk);
+			FinishOne();
 		}
 	}
 	
@@ -208,7 +210,7 @@ void cFurnaceEntity::BroadcastProgress(int a_ProgressbarID, short a_Value)
 
 
 /// One item finished cooking
-void cFurnaceEntity::FinishOne(cChunk & a_Chunk)
+void cFurnaceEntity::FinishOne()
 {
 	m_TimeCooked = 0;
 
diff --git a/src/BlockEntities/FurnaceEntity.h b/src/BlockEntities/FurnaceEntity.h
index b08187300..4f935a74b 100644
--- a/src/BlockEntities/FurnaceEntity.h
+++ b/src/BlockEntities/FurnaceEntity.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockEntityWithItems.h"
-#include "../UI/WindowOwner.h"
 #include "../FurnaceRecipe.h"
 
 
@@ -23,8 +22,7 @@ class cServer;
 
 // tolua_begin
 class cFurnaceEntity :
-	public cBlockEntityWithItems,
-	public cBlockEntityWindowOwner
+	public cBlockEntityWithItems
 {
 	typedef cBlockEntityWithItems super;
 	
@@ -128,7 +126,7 @@ protected:
 	void BroadcastProgress(int a_ProgressbarID, short a_Value);
 	
 	/// One item finished cooking
-	void FinishOne(cChunk & a_Chunk);
+	void FinishOne();
 	
 	/// Starts burning a new fuel, if possible
 	void BurnNewFuel(void);
diff --git a/src/BlockEntities/HopperEntity.cpp b/src/BlockEntities/HopperEntity.cpp
index 2255cad64..41fb9f811 100644
--- a/src/BlockEntities/HopperEntity.cpp
+++ b/src/BlockEntities/HopperEntity.cpp
@@ -7,10 +7,13 @@
 #include "HopperEntity.h"
 #include "../Chunk.h"
 #include "../Entities/Player.h"
+#include "../Entities/Pickup.h"
 #include "../Bindings/PluginManager.h"
 #include "ChestEntity.h"
 #include "DropSpenserEntity.h"
 #include "FurnaceEntity.h"
+#include "../BoundingBox.h"
+#include "json/json.h"
 
 
 
@@ -56,6 +59,7 @@ bool cHopperEntity::GetOutputBlockPos(NIBBLETYPE a_BlockMeta, int & a_OutputX, i
 
 bool cHopperEntity::Tick(float a_Dt, cChunk & a_Chunk)
 {
+	UNUSED(a_Dt);
 	Int64 CurrentTick = a_Chunk.GetWorld()->GetWorldAge();
 	
 	bool res = false;
@@ -71,6 +75,7 @@ bool cHopperEntity::Tick(float a_Dt, cChunk & a_Chunk)
 
 void cHopperEntity::SaveToJson(Json::Value & a_Value)
 {
+	UNUSED(a_Value);
 	// TODO
 	LOGWARNING("%s: Not implemented yet", __FUNCTION__);
 }
@@ -190,8 +195,87 @@ bool cHopperEntity::MoveItemsIn(cChunk & a_Chunk, Int64 a_CurrentTick)
 /// Moves pickups from above this hopper into it. Returns true if the contents have changed.
 bool cHopperEntity::MovePickupsIn(cChunk & a_Chunk, Int64 a_CurrentTick)
 {
-	// TODO
-	return false;
+	UNUSED(a_CurrentTick);
+
+	class cHopperPickupSearchCallback :
+		public cEntityCallback
+	{
+	public:
+		cHopperPickupSearchCallback(const Vector3i & a_Pos, cItemGrid & a_Contents) :
+			m_Pos(a_Pos),
+			m_bFoundPickupsAbove(false),
+			m_Contents(a_Contents)
+		{
+		}
+
+		virtual bool Item(cEntity * a_Entity) override
+		{
+			ASSERT(a_Entity != NULL);
+
+			if (!a_Entity->IsPickup() || a_Entity->IsDestroyed())
+			{
+				return false;
+			}
+
+			Vector3f EntityPos = a_Entity->GetPosition();
+			Vector3f BlockPos(m_Pos.x + 0.5f, (float)m_Pos.y + 1, m_Pos.z + 0.5f); // One block above hopper, and search from center outwards
+			double Distance = (EntityPos - BlockPos).Length();
+
+			if (Distance < 0.5)
+			{
+				if (TrySuckPickupIn((cPickup *)a_Entity))
+				{
+					return false;
+				}
+			}
+
+			return false;
+		}
+
+		bool TrySuckPickupIn(cPickup * a_Pickup)
+		{
+			for (int i = 0; i < ContentsWidth * ContentsHeight; i++)
+			{
+				if (m_Contents.IsSlotEmpty(i))
+				{
+					m_bFoundPickupsAbove = true;
+					m_Contents.SetSlot(i, a_Pickup->GetItem());
+					a_Pickup->Destroy(); // Kill pickup
+
+					return true;
+				}
+				else if (m_Contents.GetSlot(i).IsEqual(a_Pickup->GetItem()) && !m_Contents.GetSlot(i).IsFullStack())
+				{
+					m_bFoundPickupsAbove = true;
+
+					int PreviousCount = m_Contents.GetSlot(i).m_ItemCount;
+					a_Pickup->GetItem().m_ItemCount -= m_Contents.ChangeSlotCount(i, a_Pickup->GetItem().m_ItemCount) - PreviousCount; // Set count to however many items were added
+					
+					if (a_Pickup->GetItem().IsEmpty())
+					{
+						a_Pickup->Destroy(); // Kill pickup if all items were added
+					}
+					return true;
+				}
+			}
+			return false;
+		}
+
+		bool FoundPickupsAbove(void) const
+		{
+			return m_bFoundPickupsAbove;
+		}
+
+	protected:
+		Vector3i m_Pos;
+		bool m_bFoundPickupsAbove;
+		cItemGrid & m_Contents;
+	};
+
+	cHopperPickupSearchCallback HopperPickupSearchCallback(Vector3i(GetPosX(), GetPosY(), GetPosZ()), m_Contents);
+	a_Chunk.ForEachEntity(HopperPickupSearchCallback);
+
+	return HopperPickupSearchCallback.FoundPickupsAbove();
 }
 
 
diff --git a/src/BlockEntities/HopperEntity.h b/src/BlockEntities/HopperEntity.h
index 2c8b301fe..6ef98f43a 100644
--- a/src/BlockEntities/HopperEntity.h
+++ b/src/BlockEntities/HopperEntity.h
@@ -10,7 +10,6 @@
 #pragma once
 
 #include "BlockEntityWithItems.h"
-#include "../UI/WindowOwner.h"
 
 
 
@@ -18,8 +17,7 @@
 
 // tolua_begin
 class cHopperEntity :
-	public cBlockEntityWithItems,
-	public cBlockEntityWindowOwner
+	public cBlockEntityWithItems
 {
 	typedef cBlockEntityWithItems super;
 
diff --git a/src/BlockEntities/JukeboxEntity.cpp b/src/BlockEntities/JukeboxEntity.cpp
index 33042179d..c96253b11 100644
--- a/src/BlockEntities/JukeboxEntity.cpp
+++ b/src/BlockEntities/JukeboxEntity.cpp
@@ -30,48 +30,70 @@ cJukeboxEntity::~cJukeboxEntity()
 
 void cJukeboxEntity::UsedBy(cPlayer * a_Player)
 {
-	if (m_Record == 0)
+	if (IsPlayingRecord())
+	{
+		EjectRecord();
+	}
+	else
 	{
 		const cItem & HeldItem = a_Player->GetEquippedItem();
-		if (HeldItem.m_ItemType >= 2256 && HeldItem.m_ItemType <= 2267)
+		if (PlayRecord(HeldItem.m_ItemType))
 		{
-			m_Record = HeldItem.m_ItemType;
 			a_Player->GetInventory().RemoveOneEquippedItem();
-			PlayRecord();
 		}
 	}
-	else
-	{
-		EjectRecord();
-	}
 }
 
 
 
 
 
-void cJukeboxEntity::PlayRecord(void)
+bool cJukeboxEntity::PlayRecord(int a_Record)
 {
+	if (!IsRecordItem(a_Record))
+	{
+		// This isn't a Record Item
+		return false;
+	}
+	if (IsPlayingRecord())
+	{
+		// A Record is already in the Jukebox.
+		EjectRecord();
+	}
+	m_Record = a_Record;
 	m_World->BroadcastSoundParticleEffect(1005, m_PosX, m_PosY, m_PosZ, m_Record);
+	m_World->SetBlockMeta(m_PosX, m_PosY, m_PosZ, E_META_JUKEBOX_ON);
+	return true;
 }
 
 
 
 
 
-void cJukeboxEntity::EjectRecord(void)
+bool cJukeboxEntity::EjectRecord(void)
 {
-	if ((m_Record < E_ITEM_FIRST_DISC) || (m_Record > E_ITEM_LAST_DISC))
+	if (!IsPlayingRecord())
 	{
 		// There's no record here
-		return;
+		return false;
 	}
 
 	cItems Drops;
 	Drops.push_back(cItem(m_Record, 1, 0));
+	m_Record = 0;
 	m_World->SpawnItemPickups(Drops, m_PosX + 0.5, m_PosY + 1, m_PosZ + 0.5, 8);
 	m_World->BroadcastSoundParticleEffect(1005, m_PosX, m_PosY, m_PosZ, 0);
-	m_Record = 0;
+	m_World->SetBlockMeta(m_PosX, m_PosY, m_PosZ, E_META_JUKEBOX_OFF);
+	return true;
+}
+
+
+
+
+
+bool cJukeboxEntity::IsPlayingRecord(void)
+{
+	return (m_Record != 0);
 }
 
 
diff --git a/src/BlockEntities/JukeboxEntity.h b/src/BlockEntities/JukeboxEntity.h
index 996de965b..3d1d604f7 100644
--- a/src/BlockEntities/JukeboxEntity.h
+++ b/src/BlockEntities/JukeboxEntity.h
@@ -37,12 +37,25 @@ public:
 	
 	int  GetRecord(void);
 	void SetRecord(int a_Record);
-	void PlayRecord(void);
 	
-	/// Ejects the currently held record as a pickup. Does nothing when no record inserted.
-	void EjectRecord(void);
+	/** Plays the specified Record. Return false if a_Record isn't a playable Record (E_ITEM_XXX_DISC).
+	If there is a record already playing, ejects it first. */
+	bool PlayRecord(int a_Record);
+	
+	/** Ejects the currently held record as a pickup. Return false when no record had been inserted. */
+	bool EjectRecord(void);
+	
+	/** Is in the Jukebox a Record? */
+	bool IsPlayingRecord(void);
+	
+	static bool IsRecordItem(int a_Item)
+	{
+		return ((a_Item >= E_ITEM_FIRST_DISC) && (a_Item <= E_ITEM_LAST_DISC));
+	}
 	
 	// tolua_end
+
+	static const char * GetClassStatic(void) { return "cJukeboxEntity"; }
 	
 	virtual void UsedBy(cPlayer * a_Player) override;
 	virtual void SendTo(cClientHandle &) override { };
diff --git a/src/BlockEntities/MobHeadEntity.cpp b/src/BlockEntities/MobHeadEntity.cpp
new file mode 100644
index 000000000..c0a1781f6
--- /dev/null
+++ b/src/BlockEntities/MobHeadEntity.cpp
@@ -0,0 +1,108 @@
+
+// MobHeadEntity.cpp
+
+// Implements the cMobHeadEntity class representing a single skull/head in the world
+
+#include "Globals.h"
+#include "json/json.h"
+#include "MobHeadEntity.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+cMobHeadEntity::cMobHeadEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) :
+	super(E_BLOCK_HEAD, a_BlockX, a_BlockY, a_BlockZ, a_World),
+	m_Owner("")
+{
+}
+
+
+
+
+
+void cMobHeadEntity::UsedBy(cPlayer * a_Player)
+{
+	UNUSED(a_Player);
+}
+
+
+
+
+
+void cMobHeadEntity::SetType(const eMobHeadType & a_Type)
+{
+	if ((!m_Owner.empty()) && (a_Type != SKULL_TYPE_PLAYER))
+	{
+		m_Owner = "";
+	}
+	m_Type = a_Type;
+}
+
+
+
+
+
+void cMobHeadEntity::SetRotation(eMobHeadRotation a_Rotation)
+{
+	m_Rotation = a_Rotation;
+}
+
+
+
+
+
+void cMobHeadEntity::SetOwner(const AString & a_Owner)
+{
+	if ((a_Owner.length() > 16) || (m_Type != SKULL_TYPE_PLAYER))
+	{
+		return;
+	}
+	m_Owner = a_Owner;
+}
+
+
+
+
+
+void cMobHeadEntity::SendTo(cClientHandle & a_Client)
+{
+	a_Client.SendUpdateBlockEntity(*this);
+}
+
+
+
+
+
+bool cMobHeadEntity::LoadFromJson(const Json::Value & a_Value)
+{
+	m_PosX = a_Value.get("x", 0).asInt();
+	m_PosY = a_Value.get("y", 0).asInt();
+	m_PosZ = a_Value.get("z", 0).asInt();
+
+	m_Type      = static_cast<eMobHeadType>(a_Value.get("Type", 0).asInt());
+	m_Rotation  = static_cast<eMobHeadRotation>(a_Value.get("Rotation", 0).asInt());
+	m_Owner     = a_Value.get("Owner", "").asString();
+
+	return true;
+}
+
+
+
+
+
+void cMobHeadEntity::SaveToJson(Json::Value & a_Value)
+{
+	a_Value["x"] = m_PosX;
+	a_Value["y"] = m_PosY;
+	a_Value["z"] = m_PosZ;
+
+	a_Value["Type"] = m_Type;
+	a_Value["Rotation"]  = m_Rotation;
+	a_Value["Owner"]     = m_Owner;
+}
+
+
+
+
diff --git a/src/BlockEntities/MobHeadEntity.h b/src/BlockEntities/MobHeadEntity.h
new file mode 100644
index 000000000..367eb15e7
--- /dev/null
+++ b/src/BlockEntities/MobHeadEntity.h
@@ -0,0 +1,79 @@
+// MobHeadEntity.h
+
+// Declares the cMobHeadEntity class representing a single skull/head in the world
+
+
+
+
+
+#pragma once
+
+#include "BlockEntity.h"
+
+
+
+
+
+namespace Json
+{
+	class Value;
+}
+
+
+
+
+
+// tolua_begin
+
+class cMobHeadEntity : 
+	public cBlockEntity
+{
+	typedef cBlockEntity super;
+	
+public:
+
+	// tolua_end
+	
+	/** Creates a new mob head entity at the specified block coords. a_World may be NULL */
+	cMobHeadEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
+
+	bool LoadFromJson( const Json::Value& a_Value );
+	virtual void SaveToJson(Json::Value& a_Value ) override;
+
+	// tolua_begin
+	
+	/** Set the Type */
+	void SetType(const eMobHeadType & a_SkullType);
+	
+	/** Set the Rotation */
+	void SetRotation(eMobHeadRotation a_Rotation);
+	
+	/** Set the Player Name for Mobheads with Player type */
+	void SetOwner(const AString & a_Owner);
+	
+	/** Get the Type */
+	eMobHeadType GetType(void) const { return m_Type; }
+	
+	/** Get the Rotation */
+	eMobHeadRotation GetRotation(void) const { return m_Rotation; }
+	
+	/** Get the setted Player Name */
+	AString GetOwner(void) const { return m_Owner; }
+	
+	// tolua_end
+	
+	virtual void UsedBy(cPlayer * a_Player) override;
+	virtual void SendTo(cClientHandle & a_Client) override;
+
+	static const char * GetClassStatic(void) { return "cMobHeadEntity"; }
+	
+private:
+
+	eMobHeadType m_Type;
+	eMobHeadRotation m_Rotation;
+	AString m_Owner;
+} ;  // tolua_export
+
+
+
+
diff --git a/src/BlockEntities/NoteEntity.cpp b/src/BlockEntities/NoteEntity.cpp
index 9a33ead62..58b05a324 100644
--- a/src/BlockEntities/NoteEntity.cpp
+++ b/src/BlockEntities/NoteEntity.cpp
@@ -21,6 +21,7 @@ cNoteEntity::cNoteEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_Wo
 
 void cNoteEntity::UsedBy(cPlayer * a_Player)
 {
+	UNUSED(a_Player);
 	IncrementPitch();
 	MakeSound();
 }
diff --git a/src/BlockEntities/NoteEntity.h b/src/BlockEntities/NoteEntity.h
index cf78aeac6..b698899c0 100644
--- a/src/BlockEntities/NoteEntity.h
+++ b/src/BlockEntities/NoteEntity.h
@@ -54,6 +54,8 @@ public:
 	virtual void UsedBy(cPlayer * a_Player) override;
 	virtual void SendTo(cClientHandle &) override { };
 
+	static const char * GetClassStatic(void) { return "cNoteEntity"; }
+
 private:
 	char m_Pitch;
 } ;  // tolua_export
diff --git a/src/BlockEntities/SignEntity.h b/src/BlockEntities/SignEntity.h
index d998ff1e8..80c7bbfdf 100644
--- a/src/BlockEntities/SignEntity.h
+++ b/src/BlockEntities/SignEntity.h
@@ -1,4 +1,3 @@
-
 // SignEntity.h
 
 // Declares the cSignEntity class representing a single sign in the world
@@ -56,6 +55,8 @@ public:
 	
 	virtual void UsedBy(cPlayer * a_Player) override;
 	virtual void SendTo(cClientHandle & a_Client) override;
+
+	static const char * GetClassStatic(void) { return "cSignEntity"; }
 	
 private:
 
diff --git a/src/BlockID.cpp b/src/BlockID.cpp
index 095865d07..79e122032 100644
--- a/src/BlockID.cpp
+++ b/src/BlockID.cpp
@@ -12,20 +12,6 @@
 
 
 
-NIBBLETYPE g_BlockLightValue[256];
-NIBBLETYPE g_BlockSpreadLightFalloff[256];
-bool       g_BlockTransparent[256];
-bool       g_BlockOneHitDig[256];
-bool       g_BlockPistonBreakable[256];
-bool       g_BlockIsSnowable[256];
-bool       g_BlockRequiresSpecialTool[256];
-bool       g_BlockIsSolid[256];
-bool       g_BlockFullyOccupiesVoxel[256];
-
-
-
-
-
 class cBlockIDMap
 {
 	// Making the map case-insensitive:
@@ -380,7 +366,7 @@ AString DamageTypeToString(eDamageType a_DamageType)
 		case dtRangedAttack:    return "dtRangedAttack";
 		case dtStarving:        return "dtStarving";
 		case dtSuffocating:     return "dtSuffocation";
-
+		case dtExplosion:       return "dtExplosion";
 	}
 	
 	// Unknown damage type:
@@ -426,6 +412,7 @@ eDamageType StringToDamageType(const AString & a_DamageTypeString)
 		{ dtInVoid,          "dtInVoid"},
 		{ dtPotionOfHarming, "dtPotionOfHarming"},
 		{ dtAdmin,           "dtAdmin"},
+		{ dtExplosion,       "dtExplosion"},
 
 		// Common synonyms:
 		{ dtAttack,        "dtPawnAttack"},
@@ -480,383 +467,4 @@ cItem GetIniItemSet(cIniFile & a_IniFile, const char * a_Section, const char * a
 
 
 
-// This is actually just some code that needs to run at program startup, so it is wrapped into a global var's constructor:
-class cBlockPropertiesInitializer
-{
-public:
-	cBlockPropertiesInitializer(void)
-	{
-		memset(g_BlockLightValue,          0x00, sizeof(g_BlockLightValue));
-		memset(g_BlockSpreadLightFalloff,  0x0f, sizeof(g_BlockSpreadLightFalloff)); // 0x0f means total falloff
-		memset(g_BlockTransparent,         0x00, sizeof(g_BlockTransparent));
-		memset(g_BlockOneHitDig,           0x00, sizeof(g_BlockOneHitDig));
-		memset(g_BlockPistonBreakable,     0x00, sizeof(g_BlockPistonBreakable));
-		memset(g_BlockFullyOccupiesVoxel,  0x00, sizeof(g_BlockFullyOccupiesVoxel));
-		
-		// Setting bools to true must be done manually, see http://forum.mc-server.org/showthread.php?tid=629&pid=5415#pid5415
-		for (size_t i = 0; i < ARRAYCOUNT(g_BlockIsSnowable); i++)
-		{
-			g_BlockIsSnowable[i] = true;
-		}
-		memset(g_BlockRequiresSpecialTool, 0x00, sizeof(g_BlockRequiresSpecialTool));  // Set all blocks to false
-		
-		// Setting bools to true must be done manually, see http://forum.mc-server.org/showthread.php?tid=629&pid=5415#pid5415
-		for (size_t i = 0; i < ARRAYCOUNT(g_BlockIsSolid); i++)
-		{
-			g_BlockIsSolid[i] = true;
-		}
-
-		// Emissive blocks
-		g_BlockLightValue[E_BLOCK_FIRE]                 = 15;
-		g_BlockLightValue[E_BLOCK_GLOWSTONE]            = 15;
-		g_BlockLightValue[E_BLOCK_JACK_O_LANTERN]       = 15;
-		g_BlockLightValue[E_BLOCK_LAVA]                 = 15;
-		g_BlockLightValue[E_BLOCK_STATIONARY_LAVA]      = 15;
-		g_BlockLightValue[E_BLOCK_END_PORTAL]           = 15;
-		g_BlockLightValue[E_BLOCK_REDSTONE_LAMP_ON]     = 15;
-		g_BlockLightValue[E_BLOCK_TORCH]                = 14;
-		g_BlockLightValue[E_BLOCK_BURNING_FURNACE]      = 13;
-		g_BlockLightValue[E_BLOCK_NETHER_PORTAL]        = 11;
-		g_BlockLightValue[E_BLOCK_REDSTONE_ORE_GLOWING] = 9;
-		g_BlockLightValue[E_BLOCK_REDSTONE_REPEATER_ON] = 9;
-		g_BlockLightValue[E_BLOCK_REDSTONE_TORCH_ON]    = 7;
-		g_BlockLightValue[E_BLOCK_BREWING_STAND]        = 1;
-		g_BlockLightValue[E_BLOCK_BROWN_MUSHROOM]       = 1;
-		g_BlockLightValue[E_BLOCK_DRAGON_EGG]           = 1;
-
-		// Spread blocks
-		g_BlockSpreadLightFalloff[E_BLOCK_AIR]              = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_CAKE]             = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_CHEST]            = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_COBWEB]           = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_CROPS]            = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_FENCE]            = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_FENCE_GATE]       = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_FIRE]             = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_GLASS]            = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_GLASS_PANE]       = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_GLOWSTONE]        = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_IRON_BARS]        = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_IRON_DOOR]        = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_LEAVES]           = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_SIGN_POST]        = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_TORCH]            = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_VINES]            = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_WALLSIGN]         = 1;
-		g_BlockSpreadLightFalloff[E_BLOCK_WOODEN_DOOR]      = 1;
-
-		// Light in water and lava dissapears faster:
-		g_BlockSpreadLightFalloff[E_BLOCK_LAVA]             = 3;
-		g_BlockSpreadLightFalloff[E_BLOCK_STATIONARY_LAVA]  = 3;
-		g_BlockSpreadLightFalloff[E_BLOCK_STATIONARY_WATER] = 3;
-		g_BlockSpreadLightFalloff[E_BLOCK_WATER]            = 3;
-
-		// Transparent blocks
-		g_BlockTransparent[E_BLOCK_ACTIVATOR_RAIL]        = true;
-		g_BlockTransparent[E_BLOCK_AIR]                   = true;
-		g_BlockTransparent[E_BLOCK_BIG_FLOWER]            = true;
-		g_BlockTransparent[E_BLOCK_BROWN_MUSHROOM]        = true;
-		g_BlockTransparent[E_BLOCK_CARROTS]               = true;
-		g_BlockTransparent[E_BLOCK_CHEST]                 = true;
-		g_BlockTransparent[E_BLOCK_COBWEB]                = true;
-		g_BlockTransparent[E_BLOCK_CROPS]                 = true;
-		g_BlockTransparent[E_BLOCK_DANDELION]             = true;
-		g_BlockTransparent[E_BLOCK_DETECTOR_RAIL]         = true;
-		g_BlockTransparent[E_BLOCK_ENDER_CHEST]           = true;
-		g_BlockTransparent[E_BLOCK_FENCE]                 = true;
-		g_BlockTransparent[E_BLOCK_FENCE_GATE]            = true;
-		g_BlockTransparent[E_BLOCK_FIRE]                  = true;
-		g_BlockTransparent[E_BLOCK_FLOWER]                = true;
-		g_BlockTransparent[E_BLOCK_FLOWER_POT]            = true;
-		g_BlockTransparent[E_BLOCK_GLASS]                 = true;
-		g_BlockTransparent[E_BLOCK_GLASS_PANE]            = true;
-		g_BlockTransparent[E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE] = true;
-		g_BlockTransparent[E_BLOCK_ICE]                   = true;
-		g_BlockTransparent[E_BLOCK_IRON_DOOR]             = true;
-		g_BlockTransparent[E_BLOCK_LAVA]                  = true;
-		g_BlockTransparent[E_BLOCK_LEAVES]                = true;
-		g_BlockTransparent[E_BLOCK_LEVER]                 = true;
-		g_BlockTransparent[E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE] = true;
-		g_BlockTransparent[E_BLOCK_MELON_STEM]            = true;
-		g_BlockTransparent[E_BLOCK_NETHER_BRICK_FENCE]    = true;
-		g_BlockTransparent[E_BLOCK_NEW_LEAVES]            = true;
-		g_BlockTransparent[E_BLOCK_POTATOES]              = true;
-		g_BlockTransparent[E_BLOCK_POWERED_RAIL]          = true;
-		g_BlockTransparent[E_BLOCK_PISTON_EXTENSION]      = true;
-		g_BlockTransparent[E_BLOCK_PUMPKIN_STEM]          = true;
-		g_BlockTransparent[E_BLOCK_RAIL]                  = true;
-		g_BlockTransparent[E_BLOCK_RED_MUSHROOM]          = true;
-		g_BlockTransparent[E_BLOCK_SIGN_POST]             = true;
-		g_BlockTransparent[E_BLOCK_SNOW]                  = true;
-		g_BlockTransparent[E_BLOCK_STAINED_GLASS]         = true;
-		g_BlockTransparent[E_BLOCK_STAINED_GLASS_PANE]    = true;
-		g_BlockTransparent[E_BLOCK_STATIONARY_LAVA]       = true;
-		g_BlockTransparent[E_BLOCK_STATIONARY_WATER]      = true;
-		g_BlockTransparent[E_BLOCK_STONE_BUTTON]          = true;
-		g_BlockTransparent[E_BLOCK_STONE_PRESSURE_PLATE]  = true;
-		g_BlockTransparent[E_BLOCK_TALL_GRASS]            = true;
-		g_BlockTransparent[E_BLOCK_TORCH]                 = true;
-		g_BlockTransparent[E_BLOCK_VINES]                 = true;
-		g_BlockTransparent[E_BLOCK_WALLSIGN]              = true;
-		g_BlockTransparent[E_BLOCK_WATER]                 = true;
-		g_BlockTransparent[E_BLOCK_WOODEN_BUTTON]         = true;
-		g_BlockTransparent[E_BLOCK_WOODEN_DOOR]           = true;
-		g_BlockTransparent[E_BLOCK_WOODEN_PRESSURE_PLATE] = true;
-
-		// TODO: Any other transparent blocks?
-
-		// One hit break blocks:
-		g_BlockOneHitDig[E_BLOCK_ACTIVE_COMPARATOR]     = true;
-		g_BlockOneHitDig[E_BLOCK_BIG_FLOWER]            = true;
-		g_BlockOneHitDig[E_BLOCK_BROWN_MUSHROOM]        = true;
-		g_BlockOneHitDig[E_BLOCK_CARROTS]               = true;
-		g_BlockOneHitDig[E_BLOCK_CROPS]                 = true;
-		g_BlockOneHitDig[E_BLOCK_DANDELION]             = true;
-		g_BlockOneHitDig[E_BLOCK_FIRE]                  = true;
-		g_BlockOneHitDig[E_BLOCK_FLOWER]                = true;
-		g_BlockOneHitDig[E_BLOCK_FLOWER_POT]            = true;
-		g_BlockOneHitDig[E_BLOCK_INACTIVE_COMPARATOR]   = true;
-		g_BlockOneHitDig[E_BLOCK_MELON_STEM]            = true;
-		g_BlockOneHitDig[E_BLOCK_POTATOES]              = true;
-		g_BlockOneHitDig[E_BLOCK_PUMPKIN_STEM]          = true;
-		g_BlockOneHitDig[E_BLOCK_REDSTONE_REPEATER_OFF] = true;
-		g_BlockOneHitDig[E_BLOCK_REDSTONE_REPEATER_ON]  = true;
-		g_BlockOneHitDig[E_BLOCK_REDSTONE_TORCH_OFF]    = true;
-		g_BlockOneHitDig[E_BLOCK_REDSTONE_TORCH_ON]     = true;
-		g_BlockOneHitDig[E_BLOCK_REDSTONE_WIRE]         = true;
-		g_BlockOneHitDig[E_BLOCK_RED_MUSHROOM]          = true;
-		g_BlockOneHitDig[E_BLOCK_REEDS]                 = true;
-		g_BlockOneHitDig[E_BLOCK_SAPLING]               = true;
-		g_BlockOneHitDig[E_BLOCK_TNT]                   = true;
-		g_BlockOneHitDig[E_BLOCK_TALL_GRASS]            = true;
-		g_BlockOneHitDig[E_BLOCK_TORCH]                 = true;
-
-		// Blocks that break when pushed by piston:
-		g_BlockPistonBreakable[E_BLOCK_ACTIVE_COMPARATOR]     = true;
-		g_BlockPistonBreakable[E_BLOCK_AIR]                   = true;
-		g_BlockPistonBreakable[E_BLOCK_BED]                   = true;
-		g_BlockPistonBreakable[E_BLOCK_BIG_FLOWER]            = true;
-		g_BlockPistonBreakable[E_BLOCK_BROWN_MUSHROOM]        = true;
-		g_BlockPistonBreakable[E_BLOCK_COBWEB]                = true;
-		g_BlockPistonBreakable[E_BLOCK_CROPS]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_DANDELION]             = true;
-		g_BlockPistonBreakable[E_BLOCK_DEAD_BUSH]             = true;
-		g_BlockPistonBreakable[E_BLOCK_FIRE]                  = true;
-		g_BlockPistonBreakable[E_BLOCK_FLOWER]                = true;
-		g_BlockPistonBreakable[E_BLOCK_INACTIVE_COMPARATOR]   = true;
-		g_BlockPistonBreakable[E_BLOCK_IRON_DOOR]             = true;
-		g_BlockPistonBreakable[E_BLOCK_JACK_O_LANTERN]        = true;
-		g_BlockPistonBreakable[E_BLOCK_LADDER]                = true;
-		g_BlockPistonBreakable[E_BLOCK_LAVA]                  = true;
-		g_BlockPistonBreakable[E_BLOCK_LEVER]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_MELON]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_MELON_STEM]            = true;
-		g_BlockPistonBreakable[E_BLOCK_PUMPKIN]               = true;
-		g_BlockPistonBreakable[E_BLOCK_PUMPKIN_STEM]          = true;
-		g_BlockPistonBreakable[E_BLOCK_REDSTONE_REPEATER_OFF] = true;
-		g_BlockPistonBreakable[E_BLOCK_REDSTONE_REPEATER_ON]  = true;
-		g_BlockPistonBreakable[E_BLOCK_REDSTONE_TORCH_OFF]    = true;
-		g_BlockPistonBreakable[E_BLOCK_REDSTONE_TORCH_ON]     = true;
-		g_BlockPistonBreakable[E_BLOCK_REDSTONE_WIRE]         = true;
-		g_BlockPistonBreakable[E_BLOCK_RED_MUSHROOM]          = true;
-		g_BlockPistonBreakable[E_BLOCK_REEDS]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_SNOW]                  = true;
-		g_BlockPistonBreakable[E_BLOCK_STATIONARY_LAVA]       = true;
-		g_BlockPistonBreakable[E_BLOCK_STATIONARY_WATER]      = true;
-		g_BlockPistonBreakable[E_BLOCK_STONE_BUTTON]          = true;
-		g_BlockPistonBreakable[E_BLOCK_STONE_PRESSURE_PLATE]  = true;
-		g_BlockPistonBreakable[E_BLOCK_TALL_GRASS]            = true;
-		g_BlockPistonBreakable[E_BLOCK_TORCH]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_VINES]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_WATER]                 = true;
-		g_BlockPistonBreakable[E_BLOCK_WOODEN_BUTTON]         = true;
-		g_BlockPistonBreakable[E_BLOCK_WOODEN_DOOR]           = true;
-		g_BlockPistonBreakable[E_BLOCK_WOODEN_PRESSURE_PLATE] = true;
-
-
-		// Blocks that cannot be snowed over:
-		g_BlockIsSnowable[E_BLOCK_ACTIVE_COMPARATOR]     = false;
-		g_BlockIsSnowable[E_BLOCK_AIR]                   = false;
-		g_BlockIsSnowable[E_BLOCK_BIG_FLOWER]            = false;
-		g_BlockIsSnowable[E_BLOCK_BROWN_MUSHROOM]        = false;
-		g_BlockIsSnowable[E_BLOCK_CACTUS]                = false;
-		g_BlockIsSnowable[E_BLOCK_CHEST]                 = false;
-		g_BlockIsSnowable[E_BLOCK_CROPS]                 = false;
-		g_BlockIsSnowable[E_BLOCK_DANDELION]             = false;
-		g_BlockIsSnowable[E_BLOCK_FIRE]                  = false;
-		g_BlockIsSnowable[E_BLOCK_FLOWER]                = false;
-		g_BlockIsSnowable[E_BLOCK_GLASS]                 = false;
-		g_BlockIsSnowable[E_BLOCK_ICE]                   = false;
-		g_BlockIsSnowable[E_BLOCK_INACTIVE_COMPARATOR]   = false;
-		g_BlockIsSnowable[E_BLOCK_LAVA]                  = false;
-		g_BlockIsSnowable[E_BLOCK_LILY_PAD]              = false;
-		g_BlockIsSnowable[E_BLOCK_REDSTONE_REPEATER_OFF] = false;
-		g_BlockIsSnowable[E_BLOCK_REDSTONE_REPEATER_ON]  = false;
-		g_BlockIsSnowable[E_BLOCK_REDSTONE_TORCH_OFF]    = false;
-		g_BlockIsSnowable[E_BLOCK_REDSTONE_TORCH_ON]     = false;
-		g_BlockIsSnowable[E_BLOCK_REDSTONE_WIRE]         = false;
-		g_BlockIsSnowable[E_BLOCK_RED_MUSHROOM]          = false;
-		g_BlockIsSnowable[E_BLOCK_REEDS]                 = false;
-		g_BlockIsSnowable[E_BLOCK_SAPLING]               = false;
-		g_BlockIsSnowable[E_BLOCK_SIGN_POST]             = false;
-		g_BlockIsSnowable[E_BLOCK_SNOW]                  = false;
-		g_BlockIsSnowable[E_BLOCK_STAINED_GLASS]         = false;
-		g_BlockIsSnowable[E_BLOCK_STAINED_GLASS_PANE]    = false;
-		g_BlockIsSnowable[E_BLOCK_STATIONARY_LAVA]       = false;
-		g_BlockIsSnowable[E_BLOCK_STATIONARY_WATER]      = false;
-		g_BlockIsSnowable[E_BLOCK_TALL_GRASS]            = false;
-		g_BlockIsSnowable[E_BLOCK_TNT]                   = false;
-		g_BlockIsSnowable[E_BLOCK_TORCH]                 = false;
-		g_BlockIsSnowable[E_BLOCK_VINES]                 = false;
-		g_BlockIsSnowable[E_BLOCK_WALLSIGN]              = false;
-		g_BlockIsSnowable[E_BLOCK_WATER]                 = false;
-		
-
-		// Blocks that don't drop without a special tool:
-		g_BlockRequiresSpecialTool[E_BLOCK_BRICK]                = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_CAULDRON]             = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_COAL_ORE]             = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_COBBLESTONE]          = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_COBBLESTONE_STAIRS]   = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_COBWEB]               = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_DIAMOND_BLOCK]        = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_DIAMOND_ORE]          = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_DOUBLE_STONE_SLAB]    = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_EMERALD_ORE]          = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_END_STONE]            = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_GOLD_BLOCK]           = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_GOLD_ORE]             = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_IRON_BLOCK]           = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_IRON_ORE]             = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_LAPIS_BLOCK]          = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_LAPIS_ORE]            = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_MOSSY_COBBLESTONE]    = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_NETHERRACK]           = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_NETHER_BRICK]         = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_NETHER_BRICK_STAIRS]  = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_OBSIDIAN]             = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_REDSTONE_ORE]         = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_REDSTONE_ORE_GLOWING] = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_SANDSTONE]            = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_SANDSTONE_STAIRS]     = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_SNOW]                 = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_STONE]                = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_STONE_BRICKS]         = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_STONE_BRICK_STAIRS]   = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_STONE_PRESSURE_PLATE] = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_STONE_SLAB]           = true;
-		g_BlockRequiresSpecialTool[E_BLOCK_VINES]                = true;
-
-		// Nonsolid blocks:
-		g_BlockIsSolid[E_BLOCK_ACTIVATOR_RAIL]        = false;
-		g_BlockIsSolid[E_BLOCK_AIR]                   = false;
-		g_BlockIsSolid[E_BLOCK_BIG_FLOWER]            = false;
-		g_BlockIsSolid[E_BLOCK_BROWN_MUSHROOM]        = false;
-		g_BlockIsSolid[E_BLOCK_CARROTS]               = false;
-		g_BlockIsSolid[E_BLOCK_COBWEB]                = false;
-		g_BlockIsSolid[E_BLOCK_CROPS]                 = false;
-		g_BlockIsSolid[E_BLOCK_DANDELION]             = false;
-		g_BlockIsSolid[E_BLOCK_DETECTOR_RAIL]         = false;
-		g_BlockIsSolid[E_BLOCK_END_PORTAL]            = false;
-		g_BlockIsSolid[E_BLOCK_FIRE]                  = false;
-		g_BlockIsSolid[E_BLOCK_FLOWER]                = false;
-		g_BlockIsSolid[E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE] = false;
-		g_BlockIsSolid[E_BLOCK_LAVA]                  = false;
-		g_BlockIsSolid[E_BLOCK_LEVER]                 = false;
-		g_BlockIsSolid[E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE] = false;
-		g_BlockIsSolid[E_BLOCK_MELON_STEM]            = false;
-		g_BlockIsSolid[E_BLOCK_NETHER_PORTAL]         = false;
-		g_BlockIsSolid[E_BLOCK_PISTON_EXTENSION]      = false;
-		g_BlockIsSolid[E_BLOCK_POWERED_RAIL]          = false;
-		g_BlockIsSolid[E_BLOCK_RAIL]                  = false;
-		g_BlockIsSolid[E_BLOCK_REDSTONE_TORCH_OFF]    = false;
-		g_BlockIsSolid[E_BLOCK_REDSTONE_TORCH_ON]     = false;
-		g_BlockIsSolid[E_BLOCK_REDSTONE_WIRE]         = false;
-		g_BlockIsSolid[E_BLOCK_RED_MUSHROOM]          = false;
-		g_BlockIsSolid[E_BLOCK_REEDS]                 = false;
-		g_BlockIsSolid[E_BLOCK_SAPLING]               = false;
-		g_BlockIsSolid[E_BLOCK_SIGN_POST]             = false;
-		g_BlockIsSolid[E_BLOCK_SNOW]                  = false;
-		g_BlockIsSolid[E_BLOCK_STATIONARY_LAVA]       = false;
-		g_BlockIsSolid[E_BLOCK_STATIONARY_WATER]      = false;
-		g_BlockIsSolid[E_BLOCK_STONE_BUTTON]          = false;
-		g_BlockIsSolid[E_BLOCK_STONE_PRESSURE_PLATE]  = false;
-		g_BlockIsSolid[E_BLOCK_TALL_GRASS]            = false;
-		g_BlockIsSolid[E_BLOCK_TORCH]                 = false;
-		g_BlockIsSolid[E_BLOCK_TRIPWIRE]              = false;
-		g_BlockIsSolid[E_BLOCK_VINES]                 = false;
-		g_BlockIsSolid[E_BLOCK_WALLSIGN]              = false;
-		g_BlockIsSolid[E_BLOCK_WATER]                 = false;
-		g_BlockIsSolid[E_BLOCK_WOODEN_BUTTON]         = false;
-		g_BlockIsSolid[E_BLOCK_WOODEN_PRESSURE_PLATE] = false;
-		g_BlockIsSolid[E_BLOCK_WOODEN_SLAB]           = false;
-
-		// Torch placeable blocks:
-		g_BlockFullyOccupiesVoxel[E_BLOCK_BEDROCK]               = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_BLOCK_OF_COAL]         = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_BLOCK_OF_REDSTONE]     = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_BOOKCASE]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_BRICK]                 = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_CLAY]                  = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_COAL_ORE]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_COBBLESTONE]           = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_COMMAND_BLOCK]         = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_CRAFTING_TABLE]        = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DIAMOND_BLOCK]         = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DIAMOND_ORE]           = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DIRT]                  = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DISPENSER]             = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DOUBLE_STONE_SLAB]     = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DOUBLE_WOODEN_SLAB]    = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_DROPPER]               = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_EMERALD_BLOCK]         = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_EMERALD_ORE]           = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_END_STONE]             = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_FURNACE]               = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_GLOWSTONE]             = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_GOLD_BLOCK]            = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_GOLD_ORE]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_GRASS]                 = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_GRAVEL]                = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_HARDENED_CLAY]         = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_HAY_BALE]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_HUGE_BROWN_MUSHROOM]   = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_HUGE_RED_MUSHROOM]     = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_IRON_BLOCK]            = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_IRON_ORE]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_JACK_O_LANTERN]        = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_JUKEBOX]               = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_LAPIS_BLOCK]           = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_LAPIS_ORE]             = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_LOG]                   = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_MELON]                 = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_MOSSY_COBBLESTONE]     = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_MYCELIUM]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_NETHERRACK]            = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_NETHER_BRICK]          = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_NETHER_QUARTZ_ORE]     = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_NOTE_BLOCK]            = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_OBSIDIAN]              = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_PACKED_ICE]            = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_PLANKS]                = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_PUMPKIN]               = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_QUARTZ_BLOCK]          = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_REDSTONE_LAMP_OFF]     = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_REDSTONE_LAMP_ON]      = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_REDSTONE_ORE]          = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_REDSTONE_ORE_GLOWING]  = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_SANDSTONE]             = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_SAND]                  = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_SILVERFISH_EGG]        = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_SPONGE]                = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_STAINED_CLAY]          = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_WOOL]                  = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_STONE]                 = true;
-		g_BlockFullyOccupiesVoxel[E_BLOCK_STONE_BRICKS]          = true;
-	}
-} BlockPropertiesInitializer;
-
-
-
-
 
diff --git a/src/BlockID.h b/src/BlockID.h
index b31c589b9..2fec512e2 100644
--- a/src/BlockID.h
+++ b/src/BlockID.h
@@ -266,7 +266,7 @@ enum ENUM_ITEM_ID
 	E_ITEM_FLINT = 318,
 	E_ITEM_RAW_PORKCHOP = 319,
 	E_ITEM_COOKED_PORKCHOP = 320,
-	E_ITEM_PAINTINGS = 321,
+	E_ITEM_PAINTING = 321,
 	E_ITEM_GOLDEN_APPLE = 322,
 	E_ITEM_SIGN = 323,
 	E_ITEM_WOODEN_DOOR = 324,
@@ -466,6 +466,10 @@ enum
 	E_META_FLOWER_PINK_TULIP      = 7,
 	E_META_FLOWER_OXEYE_DAISY     = 8,
 	
+	// E_BLOCK_JUKEBOX metas
+	E_META_JUKEBOX_OFF            = 0,
+	E_META_JUKEBOX_ON             = 1,
+	
 	// E_BLOCK_HOPPER metas:
 	E_META_HOPPER_FACING_YM  = 0,
 	E_META_HOPPER_UNATTACHED = 1,  // Hopper doesn't move items up, there's no YP
@@ -500,6 +504,11 @@ enum
 	E_META_PLANKS_BIRCH   = 2,
 	E_META_PLANKS_JUNGLE  = 3,
 	
+	// E_BLOCK_QUARTZ_BLOCK metas:
+	E_META_QUARTZ_NORMAL = 0,
+	E_META_QUARTZ_CHISELLED = 1,
+	E_META_QUARTZ_PILLAR = 2,
+
 	// E_BLOCK_RAIL metas
 	E_META_RAIL_ZM_ZP              = 0,
 	E_META_RAIL_XM_XP              = 1,
@@ -522,10 +531,12 @@ enum
 	E_META_SANDSTONE_SMOOTH   = 2,
 	
 	// E_BLOCK_SAPLING metas (lowest 3 bits):
-	E_META_SAPLING_APPLE   = 0,
-	E_META_SAPLING_CONIFER = 1,
-	E_META_SAPLING_BIRCH   = 2,
-	E_META_SAPLING_JUNGLE  = 3,
+	E_META_SAPLING_APPLE    = 0,
+	E_META_SAPLING_CONIFER  = 1,
+	E_META_SAPLING_BIRCH    = 2,
+	E_META_SAPLING_JUNGLE   = 3,
+	E_META_SAPLING_ACACIA   = 4,
+	E_META_SAPLING_DARK_OAK = 5,
 	
 	// E_BLOCK_SILVERFISH_EGG metas:
 	E_META_SILVERFISH_EGG_STONE       = 0,
@@ -801,6 +812,7 @@ enum eDamageType
 	dtPotionOfHarming,
 	dtEnderPearl,       // Thrown an ender pearl, teleported by it
 	dtAdmin,            // Damage applied by an admin command
+	dtExplosion,        // Damage applied by an explosion
 	
 	// Some common synonyms:
 	dtPawnAttack   = dtAttack,
@@ -841,9 +853,30 @@ enum eExplosionSource
 	esWitherSkullBlue,
 	esWitherBirth,
 	esPlugin,
-	
-	// Obsolete constants, kept for compatibility, will be removed after some time:
-	esCreeper = esMonster,
+} ;
+
+
+
+
+
+enum eShrapnelLevel
+{
+	slNone,
+	slGravityAffectedOnly,
+	slAll
+} ;
+
+
+
+
+
+enum eSpreadSource
+{
+	ssFireSpread,
+	ssGrassSpread,
+	ssMushroomSpread,
+	ssMycelSpread,
+	ssVineSpread,
 } ;
 
 // tolua_end
@@ -897,17 +930,3 @@ extern cItem GetIniItemSet(cIniFile & a_IniFile, const char * a_Section, const c
 
 
 
-// Block properties:
-extern NIBBLETYPE g_BlockLightValue[256];
-extern NIBBLETYPE g_BlockSpreadLightFalloff[256];
-extern bool       g_BlockTransparent[256];
-extern bool       g_BlockOneHitDig[256];
-extern bool       g_BlockPistonBreakable[256];
-extern bool       g_BlockIsSnowable[256];
-extern bool       g_BlockRequiresSpecialTool[256];
-extern bool       g_BlockIsSolid[256];
-extern bool       g_BlockFullyOccupiesVoxel[256];
-
-
-
-
diff --git a/src/BlockInServerPluginInterface.h b/src/BlockInServerPluginInterface.h
new file mode 100644
index 000000000..e82435364
--- /dev/null
+++ b/src/BlockInServerPluginInterface.h
@@ -0,0 +1,19 @@
+
+#pragma once
+
+#include "Blocks/BlockPluginInterface.h"
+#include "World.h"
+#include "Root.h"
+#include "Bindings/PluginManager.h"
+
+class cBlockInServerPluginInterface : public cBlockPluginInterface
+{
+public:
+	cBlockInServerPluginInterface(cWorld & a_World) : m_World(a_World) {}
+	virtual bool CallHookBlockToPickups(cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) override
+	{
+		return cRoot::Get()->GetPluginManager()->CallHookBlockToPickups(&m_World, a_Digger, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_Pickups);
+	}
+private:
+	cWorld & m_World;
+};
diff --git a/src/BlockInfo.cpp b/src/BlockInfo.cpp
new file mode 100644
index 000000000..6fb5aa5b3
--- /dev/null
+++ b/src/BlockInfo.cpp
@@ -0,0 +1,451 @@
+
+#include "Globals.h"
+
+#include "BlockInfo.h"
+#include "Blocks/BlockHandler.h"
+
+
+
+
+
+cBlockInfo cBlockInfo::ms_Info[256];
+
+
+
+
+
+cBlockInfo::cBlockInfo()
+	: m_LightValue(0x00)
+	, m_SpreadLightFalloff(0x0f)
+	, m_Transparent(false)
+	, m_OneHitDig(false)
+	, m_PistonBreakable(false)
+	, m_IsSnowable(true)
+	, m_RequiresSpecialTool(false)
+	, m_IsSolid(true)
+	, m_FullyOccupiesVoxel(false)
+	, m_Handler(NULL)
+{}
+
+
+
+
+
+cBlockInfo::~cBlockInfo()
+{
+	delete m_Handler;
+}
+
+
+
+
+
+cBlockInfo & cBlockInfo::Get(BLOCKTYPE a_Type)
+{
+	return ms_Info[a_Type];
+}
+
+
+
+
+
+void cBlockInfo::Initialize(void)
+{
+	for (unsigned int i = 0; i < 256; ++i)
+	{
+		if (ms_Info[i].m_Handler == NULL)
+		{
+			ms_Info[i].m_Handler = cBlockHandler::CreateBlockHandler((BLOCKTYPE) i);
+		}
+	}
+
+	// Emissive blocks
+	ms_Info[E_BLOCK_FIRE                ].m_LightValue = 15;
+	ms_Info[E_BLOCK_GLOWSTONE           ].m_LightValue = 15;
+	ms_Info[E_BLOCK_JACK_O_LANTERN      ].m_LightValue = 15;
+	ms_Info[E_BLOCK_LAVA                ].m_LightValue = 15;
+	ms_Info[E_BLOCK_STATIONARY_LAVA     ].m_LightValue = 15;
+	ms_Info[E_BLOCK_END_PORTAL          ].m_LightValue = 15;
+	ms_Info[E_BLOCK_REDSTONE_LAMP_ON    ].m_LightValue = 15;
+	ms_Info[E_BLOCK_TORCH               ].m_LightValue = 14;
+	ms_Info[E_BLOCK_BURNING_FURNACE     ].m_LightValue = 13;
+	ms_Info[E_BLOCK_NETHER_PORTAL       ].m_LightValue = 11;
+	ms_Info[E_BLOCK_REDSTONE_ORE_GLOWING].m_LightValue = 9;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_ON].m_LightValue = 9;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_ON   ].m_LightValue = 7;
+	ms_Info[E_BLOCK_BREWING_STAND       ].m_LightValue = 1;
+	ms_Info[E_BLOCK_BROWN_MUSHROOM      ].m_LightValue = 1;
+	ms_Info[E_BLOCK_DRAGON_EGG          ].m_LightValue = 1;
+
+
+	// Spread blocks
+	ms_Info[E_BLOCK_AIR                 ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_CAKE                ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_CHEST               ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_COBWEB              ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_CROPS               ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_FENCE               ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_FENCE_GATE          ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_FIRE                ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_GLASS               ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_GLASS_PANE          ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_GLOWSTONE           ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_IRON_BARS           ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_IRON_DOOR           ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_LEAVES              ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_NEW_LEAVES          ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_SIGN_POST           ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_TORCH               ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_VINES               ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_WALLSIGN            ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_WOODEN_DOOR         ].m_SpreadLightFalloff = 1;
+
+	// Light in water and lava dissapears faster:
+	ms_Info[E_BLOCK_LAVA                ].m_SpreadLightFalloff = 3;
+	ms_Info[E_BLOCK_STATIONARY_LAVA     ].m_SpreadLightFalloff = 3;
+	ms_Info[E_BLOCK_STATIONARY_WATER    ].m_SpreadLightFalloff = 3;
+	ms_Info[E_BLOCK_WATER               ].m_SpreadLightFalloff = 3;
+
+
+	// Transparent blocks
+	ms_Info[E_BLOCK_ACTIVATOR_RAIL      ].m_Transparent = true;
+	ms_Info[E_BLOCK_AIR                 ].m_Transparent = true;
+	ms_Info[E_BLOCK_BIG_FLOWER          ].m_Transparent = true;
+	ms_Info[E_BLOCK_BROWN_MUSHROOM      ].m_Transparent = true;
+	ms_Info[E_BLOCK_CARROTS             ].m_Transparent = true;
+	ms_Info[E_BLOCK_CHEST               ].m_Transparent = true;
+	ms_Info[E_BLOCK_COBWEB              ].m_Transparent = true;
+	ms_Info[E_BLOCK_CROPS               ].m_Transparent = true;
+	ms_Info[E_BLOCK_DANDELION           ].m_Transparent = true;
+	ms_Info[E_BLOCK_DETECTOR_RAIL       ].m_Transparent = true;
+	ms_Info[E_BLOCK_ENDER_CHEST         ].m_Transparent = true;
+	ms_Info[E_BLOCK_FENCE               ].m_Transparent = true;
+	ms_Info[E_BLOCK_FENCE_GATE          ].m_Transparent = true;
+	ms_Info[E_BLOCK_FIRE                ].m_Transparent = true;
+	ms_Info[E_BLOCK_FLOWER              ].m_Transparent = true;
+	ms_Info[E_BLOCK_FLOWER_POT          ].m_Transparent = true;
+	ms_Info[E_BLOCK_GLASS               ].m_Transparent = true;
+	ms_Info[E_BLOCK_GLASS_PANE          ].m_Transparent = true;
+	ms_Info[E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE].m_Transparent = true;
+	ms_Info[E_BLOCK_ICE                 ].m_Transparent = true;
+	ms_Info[E_BLOCK_IRON_DOOR           ].m_Transparent = true;
+	ms_Info[E_BLOCK_LAVA                ].m_Transparent = true;
+	ms_Info[E_BLOCK_LEAVES              ].m_Transparent = true;
+	ms_Info[E_BLOCK_LEVER               ].m_Transparent = true;
+	ms_Info[E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE].m_Transparent = true;
+	ms_Info[E_BLOCK_MELON_STEM          ].m_Transparent = true;
+	ms_Info[E_BLOCK_NETHER_BRICK_FENCE  ].m_Transparent = true;
+	ms_Info[E_BLOCK_NEW_LEAVES          ].m_Transparent = true;
+	ms_Info[E_BLOCK_POTATOES            ].m_Transparent = true;
+	ms_Info[E_BLOCK_POWERED_RAIL        ].m_Transparent = true;
+	ms_Info[E_BLOCK_PISTON_EXTENSION    ].m_Transparent = true;
+	ms_Info[E_BLOCK_PUMPKIN_STEM        ].m_Transparent = true;
+	ms_Info[E_BLOCK_RAIL                ].m_Transparent = true;
+	ms_Info[E_BLOCK_RED_MUSHROOM        ].m_Transparent = true;
+	ms_Info[E_BLOCK_SIGN_POST           ].m_Transparent = true;
+	ms_Info[E_BLOCK_SNOW                ].m_Transparent = true;
+	ms_Info[E_BLOCK_STAINED_GLASS       ].m_Transparent = true;
+	ms_Info[E_BLOCK_STAINED_GLASS_PANE  ].m_Transparent = true;
+	ms_Info[E_BLOCK_STATIONARY_LAVA     ].m_Transparent = true;
+	ms_Info[E_BLOCK_STATIONARY_WATER    ].m_Transparent = true;
+	ms_Info[E_BLOCK_STONE_BUTTON        ].m_Transparent = true;
+	ms_Info[E_BLOCK_STONE_PRESSURE_PLATE].m_Transparent = true;
+	ms_Info[E_BLOCK_TALL_GRASS          ].m_Transparent = true;
+	ms_Info[E_BLOCK_TORCH               ].m_Transparent = true;
+	ms_Info[E_BLOCK_VINES               ].m_Transparent = true;
+	ms_Info[E_BLOCK_WALLSIGN            ].m_Transparent = true;
+	ms_Info[E_BLOCK_WATER               ].m_Transparent = true;
+	ms_Info[E_BLOCK_WOODEN_BUTTON       ].m_Transparent = true;
+	ms_Info[E_BLOCK_WOODEN_DOOR         ].m_Transparent = true;
+	ms_Info[E_BLOCK_WOODEN_PRESSURE_PLATE].m_Transparent = true;
+
+	// TODO: Any other transparent blocks?
+
+
+	// One hit break blocks:
+	ms_Info[E_BLOCK_ACTIVE_COMPARATOR   ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_BIG_FLOWER          ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_BROWN_MUSHROOM      ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_CARROTS             ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_CROPS               ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_DANDELION           ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_FIRE                ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_FLOWER              ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_FLOWER_POT          ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_INACTIVE_COMPARATOR ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_MELON_STEM          ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_POTATOES            ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_PUMPKIN_STEM        ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_OFF].m_OneHitDig = true;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_ON].m_OneHitDig = true;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_OFF  ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_ON   ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_REDSTONE_WIRE       ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_RED_MUSHROOM        ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_REEDS               ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_SAPLING             ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_TNT                 ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_TALL_GRASS          ].m_OneHitDig = true;
+	ms_Info[E_BLOCK_TORCH               ].m_OneHitDig = true;
+
+
+	// Blocks that break when pushed by piston:
+	ms_Info[E_BLOCK_ACTIVE_COMPARATOR   ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_AIR                 ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_BED                 ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_BIG_FLOWER          ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_BROWN_MUSHROOM      ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_COBWEB              ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_CROPS               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_DANDELION           ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_DEAD_BUSH           ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_FIRE                ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_FLOWER              ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_INACTIVE_COMPARATOR ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_IRON_DOOR           ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_JACK_O_LANTERN      ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_LADDER              ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_LAVA                ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_LEVER               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_MELON               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_MELON_STEM          ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_PUMPKIN             ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_PUMPKIN_STEM        ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_OFF].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_ON].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_OFF  ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_ON   ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_REDSTONE_WIRE       ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_RED_MUSHROOM        ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_REEDS               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_SNOW                ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_STATIONARY_LAVA     ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_STATIONARY_WATER    ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_STONE_BUTTON        ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_STONE_PRESSURE_PLATE].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_TALL_GRASS          ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_TORCH               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_VINES               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_WATER               ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_WOODEN_BUTTON       ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_WOODEN_DOOR         ].m_PistonBreakable = true;
+	ms_Info[E_BLOCK_WOODEN_PRESSURE_PLATE].m_PistonBreakable = true;
+
+
+	// Blocks that cannot be snowed over:
+	ms_Info[E_BLOCK_ACTIVE_COMPARATOR   ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_AIR                 ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_BIG_FLOWER          ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_BROWN_MUSHROOM      ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_CACTUS              ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_CHEST               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_CROPS               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_DANDELION           ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_FIRE                ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_FLOWER              ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_GLASS               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_ICE                 ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_INACTIVE_COMPARATOR ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_LAVA                ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_LILY_PAD            ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_OFF].m_IsSnowable = false;
+	ms_Info[E_BLOCK_REDSTONE_REPEATER_ON].m_IsSnowable = false;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_OFF  ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_ON   ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_REDSTONE_WIRE       ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_RED_MUSHROOM        ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_REEDS               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_SAPLING             ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_SIGN_POST           ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_SNOW                ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_STAINED_GLASS       ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_STAINED_GLASS_PANE  ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_STATIONARY_LAVA     ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_STATIONARY_WATER    ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_TALL_GRASS          ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_TNT                 ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_TORCH               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_VINES               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_WALLSIGN            ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_WATER               ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_RAIL                ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_ACTIVATOR_RAIL      ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_POWERED_RAIL        ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_DETECTOR_RAIL       ].m_IsSnowable = false;
+	ms_Info[E_BLOCK_COBWEB              ].m_IsSnowable = false;
+
+
+	// Blocks that don't drop without a special tool:
+	ms_Info[E_BLOCK_BRICK               ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_CAULDRON            ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_COAL_ORE            ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_COBBLESTONE         ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_COBBLESTONE_STAIRS  ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_COBWEB              ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_DIAMOND_BLOCK       ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_DIAMOND_ORE         ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_DOUBLE_STONE_SLAB   ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_EMERALD_ORE         ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_END_STONE           ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_GOLD_BLOCK          ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_GOLD_ORE            ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_IRON_BLOCK          ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_IRON_ORE            ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_LAPIS_BLOCK         ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_LAPIS_ORE           ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_MOSSY_COBBLESTONE   ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_NETHERRACK          ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_NETHER_BRICK        ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_NETHER_BRICK_STAIRS ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_OBSIDIAN            ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_REDSTONE_ORE        ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_REDSTONE_ORE_GLOWING].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_SANDSTONE           ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_SANDSTONE_STAIRS    ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_SNOW                ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_STONE               ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_STONE_BRICKS        ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_STONE_BRICK_STAIRS  ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_STONE_PRESSURE_PLATE].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_STONE_SLAB          ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_VINES               ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_FURNACE             ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_LIT_FURNACE         ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_ANVIL               ].m_RequiresSpecialTool = true;
+	ms_Info[E_BLOCK_ENCHANTMENT_TABLE   ].m_RequiresSpecialTool = true;
+
+
+	// Nonsolid blocks:
+	ms_Info[E_BLOCK_ACTIVATOR_RAIL      ].m_IsSolid = false;
+	ms_Info[E_BLOCK_AIR                 ].m_IsSolid = false;
+	ms_Info[E_BLOCK_BIG_FLOWER          ].m_IsSolid = false;
+	ms_Info[E_BLOCK_BROWN_MUSHROOM      ].m_IsSolid = false;
+	ms_Info[E_BLOCK_CARROTS             ].m_IsSolid = false;
+	ms_Info[E_BLOCK_COBWEB              ].m_IsSolid = false;
+	ms_Info[E_BLOCK_CROPS               ].m_IsSolid = false;
+	ms_Info[E_BLOCK_DANDELION           ].m_IsSolid = false;
+	ms_Info[E_BLOCK_DETECTOR_RAIL       ].m_IsSolid = false;
+	ms_Info[E_BLOCK_END_PORTAL          ].m_IsSolid = false;
+	ms_Info[E_BLOCK_FIRE                ].m_IsSolid = false;
+	ms_Info[E_BLOCK_FLOWER              ].m_IsSolid = false;
+	ms_Info[E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE].m_IsSolid = false;
+	ms_Info[E_BLOCK_LAVA                ].m_IsSolid = false;
+	ms_Info[E_BLOCK_LEVER               ].m_IsSolid = false;
+	ms_Info[E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE].m_IsSolid = false;
+	ms_Info[E_BLOCK_MELON_STEM          ].m_IsSolid = false;
+	ms_Info[E_BLOCK_NETHER_PORTAL       ].m_IsSolid = false;
+	ms_Info[E_BLOCK_PISTON_EXTENSION    ].m_IsSolid = false;
+	ms_Info[E_BLOCK_POTATOES            ].m_IsSolid = false;
+	ms_Info[E_BLOCK_POWERED_RAIL        ].m_IsSolid = false;
+	ms_Info[E_BLOCK_RAIL                ].m_IsSolid = false;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_OFF  ].m_IsSolid = false;
+	ms_Info[E_BLOCK_REDSTONE_TORCH_ON   ].m_IsSolid = false;
+	ms_Info[E_BLOCK_REDSTONE_WIRE       ].m_IsSolid = false;
+	ms_Info[E_BLOCK_RED_MUSHROOM        ].m_IsSolid = false;
+	ms_Info[E_BLOCK_REEDS               ].m_IsSolid = false;
+	ms_Info[E_BLOCK_SAPLING             ].m_IsSolid = false;
+	ms_Info[E_BLOCK_SIGN_POST           ].m_IsSolid = false;
+	ms_Info[E_BLOCK_SNOW                ].m_IsSolid = false;
+	ms_Info[E_BLOCK_STATIONARY_LAVA     ].m_IsSolid = false;
+	ms_Info[E_BLOCK_STATIONARY_WATER    ].m_IsSolid = false;
+	ms_Info[E_BLOCK_STONE_BUTTON        ].m_IsSolid = false;
+	ms_Info[E_BLOCK_STONE_PRESSURE_PLATE].m_IsSolid = false;
+	ms_Info[E_BLOCK_TALL_GRASS          ].m_IsSolid = false;
+	ms_Info[E_BLOCK_TORCH               ].m_IsSolid = false;
+	ms_Info[E_BLOCK_TRIPWIRE            ].m_IsSolid = false;
+	ms_Info[E_BLOCK_VINES               ].m_IsSolid = false;
+	ms_Info[E_BLOCK_WALLSIGN            ].m_IsSolid = false;
+	ms_Info[E_BLOCK_WATER               ].m_IsSolid = false;
+	ms_Info[E_BLOCK_WOODEN_BUTTON       ].m_IsSolid = false;
+	ms_Info[E_BLOCK_WOODEN_PRESSURE_PLATE].m_IsSolid = false;
+	ms_Info[E_BLOCK_WOODEN_SLAB         ].m_IsSolid = false;
+
+
+	// Blocks that fully occupy their voxel - used as a guide for torch placeable blocks, amongst other things:
+	ms_Info[E_BLOCK_NEW_LOG             ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_BEDROCK             ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_BLOCK_OF_COAL       ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_BLOCK_OF_REDSTONE   ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_BOOKCASE            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_BRICK               ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_CLAY                ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_COAL_ORE            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_COBBLESTONE         ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_COMMAND_BLOCK       ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_CRAFTING_TABLE      ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DIAMOND_BLOCK       ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DIAMOND_ORE         ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DIRT                ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DISPENSER           ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DOUBLE_STONE_SLAB   ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DOUBLE_WOODEN_SLAB  ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_DROPPER             ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_EMERALD_BLOCK       ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_EMERALD_ORE         ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_END_STONE           ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_FURNACE             ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_GLOWSTONE           ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_GOLD_BLOCK          ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_GOLD_ORE            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_GRASS               ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_GRAVEL              ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_HARDENED_CLAY       ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_HAY_BALE            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_HUGE_BROWN_MUSHROOM ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_HUGE_RED_MUSHROOM   ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_ICE                 ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_IRON_BLOCK          ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_IRON_ORE            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_JACK_O_LANTERN      ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_JUKEBOX             ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_LAPIS_BLOCK         ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_LAPIS_ORE           ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_LOG                 ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_MELON               ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_MOSSY_COBBLESTONE   ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_MYCELIUM            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_NETHERRACK          ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_NETHER_BRICK        ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_NETHER_QUARTZ_ORE   ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_NOTE_BLOCK          ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_OBSIDIAN            ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_PACKED_ICE          ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_PLANKS              ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_PUMPKIN             ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_QUARTZ_BLOCK        ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_REDSTONE_LAMP_OFF   ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_REDSTONE_LAMP_ON    ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_REDSTONE_ORE        ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_REDSTONE_ORE_GLOWING].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_SANDSTONE           ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_SAND                ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_SILVERFISH_EGG      ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_SPONGE              ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_STAINED_CLAY        ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_WOOL                ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_STONE               ].m_FullyOccupiesVoxel = true;
+	ms_Info[E_BLOCK_STONE_BRICKS        ].m_FullyOccupiesVoxel = true;
+}
+
+
+
+
+
+// This is actually just some code that needs to run at program startup, so it is wrapped into a global var's constructor:
+class cBlockInfoInitializer
+{
+public:
+	cBlockInfoInitializer(void)
+	{
+		cBlockInfo::Initialize();
+	}
+} BlockInfoInitializer;
+
+
+
+
+
diff --git a/src/BlockInfo.h b/src/BlockInfo.h
new file mode 100644
index 000000000..40c1db867
--- /dev/null
+++ b/src/BlockInfo.h
@@ -0,0 +1,103 @@
+
+#pragma once
+
+
+
+
+
+// fwd:
+class cBlockHandler;
+
+
+
+
+
+// tolua_begin
+class cBlockInfo
+{
+public:
+	// tolua_end
+
+	cBlockInfo();
+
+	~cBlockInfo();
+
+	/** (Re-)Initializes the internal BlockInfo structures. */
+	static void Initialize(void);
+
+	// tolua_begin
+
+	/** Returns the associated BlockInfo structure. */
+	static cBlockInfo & Get(BLOCKTYPE a_Type);
+
+
+	/** How much light do the blocks emit on their own? */
+	NIBBLETYPE m_LightValue;
+
+	/** How much light do the blocks consume? */
+	NIBBLETYPE m_SpreadLightFalloff;
+
+	/** Is a block completely transparent? (light doesn't get decreased(?)) */
+	bool m_Transparent;
+
+	/** Is a block destroyed after a single hit? */
+	bool m_OneHitDig;
+
+	/** Can a piston break this block? */
+	bool m_PistonBreakable;
+
+	/** Can this block hold snow atop? */
+	bool m_IsSnowable;
+
+	/** Does this block require a tool to drop? */
+	bool m_RequiresSpecialTool;
+
+	/** Is this block solid (player cannot walk through)? */
+	bool m_IsSolid;
+
+	/** Does this block fully occupy its voxel - is it a 'full' block? */
+	bool m_FullyOccupiesVoxel;
+
+	// tolua_end
+
+	/** Associated block handler. */
+	cBlockHandler * m_Handler;
+
+	// tolua_begin
+
+	inline static NIBBLETYPE GetLightValue        (BLOCKTYPE a_Type) { return Get(a_Type).m_LightValue;          }
+	inline static NIBBLETYPE GetSpreadLightFalloff(BLOCKTYPE a_Type) { return Get(a_Type).m_SpreadLightFalloff;  }
+	inline static bool IsTransparent              (BLOCKTYPE a_Type) { return Get(a_Type).m_Transparent;         }
+	inline static bool IsOneHitDig                (BLOCKTYPE a_Type) { return Get(a_Type).m_OneHitDig;           }
+	inline static bool IsPistonBreakable          (BLOCKTYPE a_Type) { return Get(a_Type).m_PistonBreakable;     }
+	inline static bool IsSnowable                 (BLOCKTYPE a_Type) { return Get(a_Type).m_IsSnowable;          }
+	inline static bool RequiresSpecialTool        (BLOCKTYPE a_Type) { return Get(a_Type).m_RequiresSpecialTool; }
+	inline static bool IsSolid                    (BLOCKTYPE a_Type) { return Get(a_Type).m_IsSolid;             }
+	inline static bool FullyOccupiesVoxel         (BLOCKTYPE a_Type) { return Get(a_Type).m_FullyOccupiesVoxel;  }
+
+	// tolua_end
+
+	inline static cBlockHandler * GetHandler      (BLOCKTYPE a_Type) { return Get(a_Type).m_Handler;             }
+
+
+protected:
+
+	// TODO xdot: Change to std::vector to support dynamic block IDs
+	static cBlockInfo ms_Info[256];
+
+
+}; // tolua_export
+
+
+
+
+
+// Shortcut to get the blockhandler for a specific block
+inline cBlockHandler * BlockHandler(BLOCKTYPE a_BlockType)
+{
+	return cBlockInfo::Get(a_BlockType).m_Handler;
+}
+
+
+
+
diff --git a/src/BlockTracer.h b/src/BlockTracer.h
index 40d80da1a..a18c8df4d 100644
--- a/src/BlockTracer.h
+++ b/src/BlockTracer.h
@@ -28,6 +28,9 @@ public:
 	class cCallbacks abstract
 	{
 	public:
+		// Force a virtual destructor in descendants:
+		virtual ~cCallbacks() {}
+		
 		/** Called on each block encountered along the path, including the first block (path start)
 		When this callback returns true, the tracing is aborted.
 		*/
diff --git a/src/Blocks/BlockAnvil.h b/src/Blocks/BlockAnvil.h
new file mode 100644
index 000000000..93a796ef7
--- /dev/null
+++ b/src/Blocks/BlockAnvil.h
@@ -0,0 +1,61 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cBlockAnvilHandler :
+	public cBlockHandler
+{
+public:
+	cBlockAnvilHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_ANVIL, 1, a_BlockMeta >> 2));
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		NIBBLETYPE HighBits = a_BlockMeta & 0x0c;  // Only highest two bits are preserved
+		int Direction = (int)floor(a_Player->GetYaw() * 4.0 / 360.0 + 1.5) & 0x3;
+		switch (Direction)
+		{
+			case 0: a_BlockMeta = 0x2 | HighBits; break;
+			case 1: a_BlockMeta = 0x3 | HighBits; break;
+			case 2: a_BlockMeta = 0x0 | HighBits; break;
+			case 3: a_BlockMeta = 0x1 | HighBits; break;
+			default:
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+
+	virtual bool IsUseable() override
+	{
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index 66eb9130c..6a3c6a55b 100644
--- a/src/Blocks/BlockBed.cpp
+++ b/src/Blocks/BlockBed.cpp
@@ -6,8 +6,8 @@
 
 
 void cBlockBedHandler::OnPlacedByPlayer(
-	cWorld * a_World, cPlayer * a_Player,
-	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+	cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 	int a_CursorX, int a_CursorY, int a_CursorZ,
 	BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 )
@@ -15,7 +15,7 @@ void cBlockBedHandler::OnPlacedByPlayer(
 	if (a_BlockMeta < 8)
 	{
 		Vector3i Direction = MetaDataToDirection(a_BlockMeta);
-		a_World->SetBlock(a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z, E_BLOCK_BED, a_BlockMeta | 0x8);
+		a_ChunkInterface.SetBlock(a_WorldInterface,a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z, E_BLOCK_BED, a_BlockMeta | 0x8);
 	}
 }
 
@@ -23,26 +23,26 @@ void cBlockBedHandler::OnPlacedByPlayer(
 
 
 
-void cBlockBedHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockBedHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	NIBBLETYPE OldMeta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	NIBBLETYPE OldMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 
 	Vector3i ThisPos( a_BlockX, a_BlockY, a_BlockZ );
 	Vector3i Direction = MetaDataToDirection( OldMeta & 0x7 );
 	if (OldMeta & 0x8)
 	{
 		// Was pillow
-		if (a_World->GetBlock(ThisPos - Direction) == E_BLOCK_BED)
+		if (a_ChunkInterface.GetBlock(ThisPos - Direction) == E_BLOCK_BED)
 		{
-			a_World->FastSetBlock(ThisPos - Direction, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(ThisPos - Direction, E_BLOCK_AIR, 0);
 		}
 	}
 	else
 	{
 		// Was foot end
-		if (a_World->GetBlock(ThisPos + Direction) == E_BLOCK_BED)
+		if (a_ChunkInterface.GetBlock(ThisPos + Direction) == E_BLOCK_BED)
 		{
-			a_World->FastSetBlock(ThisPos + Direction, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(ThisPos + Direction, E_BLOCK_AIR, 0);
 		}
 	}
 }
@@ -51,34 +51,102 @@ void cBlockBedHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY,
 
 
 
-void cBlockBedHandler::OnUse(cWorld *a_World, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
+class cTimeFastForwardTester :
+	public cPlayerListCallback
 {
-	if (a_World->GetDimension() != dimOverworld)
+	virtual bool Item(cPlayer * a_Player) override
+	{
+		if (!a_Player->IsInBed())
+		{
+			return true;
+		}
+
+		return false;
+	}
+};
+
+
+
+
+
+class cPlayerBedStateUnsetter :
+	public cPlayerListCallback
+{
+public:
+	cPlayerBedStateUnsetter(Vector3i a_Position, cWorldInterface & a_WorldInterface) :
+		m_Position(a_Position), m_WorldInterface(a_WorldInterface)
+	{
+	}
+
+	virtual bool Item(cPlayer * a_Player) override
+	{
+		a_Player->SetIsInBed(false);
+		m_WorldInterface.GetBroadcastManager().BroadcastEntityAnimation(*a_Player, 2);
+		return false;
+	}
+
+private:
+	Vector3i m_Position;
+	cWorldInterface & m_WorldInterface;
+};
+
+
+
+
+
+void cBlockBedHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
+{
+	if (a_WorldInterface.GetDimension() != dimOverworld)
 	{
 		Vector3i Coords(a_BlockX, a_BlockY, a_BlockZ);
-		a_World->DoExplosionAt(5, a_BlockX, a_BlockY, a_BlockZ, true, esBed, &Coords);
+		a_WorldInterface.DoExplosionAt(5, a_BlockX, a_BlockY, a_BlockZ, true, esBed, &Coords);
 	}
 	else
 	{
-		if (a_World->GetTimeOfDay() > 13000)
+		if (a_WorldInterface.GetTimeOfDay() > 13000)
 		{
-			NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-			if (Meta & 0x8)
+			NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+			if (Meta & 0x4)
 			{
-				// Is pillow	
-				a_World->BroadcastUseBed(*a_Player, a_BlockX, a_BlockY, a_BlockZ);
+				a_Player->SendMessageFailure("This bed is occupied.");
 			}
 			else
 			{
-				// Is foot end
-				Vector3i Direction = MetaDataToDirection( Meta & 0x7 );
-				if (a_World->GetBlock(a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z) == E_BLOCK_BED) // Must always use pillow location for sleeping
+				Vector3i PillowDirection(0, 0, 0);
+
+				if (Meta & 0x8)
 				{
-					a_World->BroadcastUseBed(*a_Player, a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z);
+					// Is pillow	
+					a_WorldInterface.GetBroadcastManager().BroadcastUseBed(*a_Player, a_BlockX, a_BlockY, a_BlockZ);
 				}
-			}
-		} else {
-			a_Player->SendMessage("You can only sleep at night");
+				else
+				{
+					// Is foot end
+					VERIFY((Meta & 0x4) != 0x4); // Occupied flag should never be set, else our compilator (intended) is broken
+
+					PillowDirection = MetaDataToDirection(Meta & 0x7);
+					if (a_ChunkInterface.GetBlock(a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z) == E_BLOCK_BED) // Must always use pillow location for sleeping
+					{
+						a_WorldInterface.GetBroadcastManager().BroadcastUseBed(*a_Player, a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z);
+					}
+				}
+
+				a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta | 0x4); // Where 0x4 = occupied bit
+				a_Player->SetIsInBed(true);
+
+				cTimeFastForwardTester Tester;
+				if (a_WorldInterface.ForEachPlayer(Tester))
+				{
+					cPlayerBedStateUnsetter Unsetter(Vector3i(a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z), a_WorldInterface);
+					a_WorldInterface.ForEachPlayer(Unsetter);
+					a_WorldInterface.SetTimeOfDay(0);
+					a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta & 0xB); // Where 0xB = 1011, and zero is to make sure 'occupied' bit is always unset
+				}
+			}			
+		}
+		else
+		{
+			a_Player->SendMessageFailure("You can only sleep at night");
 		}
 	}
 }
@@ -86,3 +154,5 @@ void cBlockBedHandler::OnUse(cWorld *a_World, cPlayer *a_Player, int a_BlockX, i
 
 
 
+
+
diff --git a/src/Blocks/BlockBed.h b/src/Blocks/BlockBed.h
index 8a289b22c..92804aaac 100644
--- a/src/Blocks/BlockBed.h
+++ b/src/Blocks/BlockBed.h
@@ -2,7 +2,9 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../World.h"
+#include "ChunkInterface.h"
+#include "WorldInterface.h"
+#include "MetaRotator.h"
 #include "../Entities/Player.h"
 
 
@@ -10,18 +12,18 @@
 
 
 class cBlockBedHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01, true>
 {
 public:
 	cBlockBedHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01,true>(a_BlockType)
 	{
 	}
 
 
-	virtual void OnPlacedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
-	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
+	virtual void OnPlacedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
 
 
 	virtual bool IsUseable(void) override
diff --git a/src/Blocks/BlockBigFlower.h b/src/Blocks/BlockBigFlower.h
new file mode 100644
index 000000000..39fd3cac8
--- /dev/null
+++ b/src/Blocks/BlockBigFlower.h
@@ -0,0 +1,131 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockBigFlowerHandler :
+	public cBlockHandler
+{
+public:
+	typedef cBlockHandler super;
+
+	cBlockBigFlowerHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		if (Meta & 0x8)
+		{
+			super::DropBlock(a_ChunkInterface, a_WorldInterface, a_BlockPluginInterface, a_Digger, a_BlockX, a_BlockY - 1, a_BlockZ);
+		}
+		else
+		{
+			super::DropBlock(a_ChunkInterface, a_WorldInterface, a_BlockPluginInterface, a_Digger, a_BlockX, a_BlockY, a_BlockZ);
+		}
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		NIBBLETYPE Meta = a_BlockMeta & 0x7;
+		
+		if ((Meta == 2) || (Meta == 3))
+		{
+			return;
+		}
+		
+		a_Pickups.push_back(cItem(E_BLOCK_BIG_FLOWER, 1, Meta));
+	}
+
+
+	virtual void OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		if (Meta & 0x8)
+		{
+			Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY - 1, a_BlockZ);
+		}
+		
+		NIBBLETYPE FlowerMeta = Meta & 0x7;
+		if (!a_Player->IsGameModeCreative())
+		{
+			if (((FlowerMeta == 2) || (FlowerMeta == 3)) && (a_Player->GetEquippedItem().m_ItemType == E_ITEM_SHEARS))
+			{
+				MTRand r1;
+				if (r1.randInt(10) == 5)
+				{
+					cItems Pickups;
+					if (FlowerMeta == 2)
+					{
+						Pickups.Add(E_BLOCK_TALL_GRASS, 2, 1);
+					}
+					else if (FlowerMeta == 3)
+					{
+						Pickups.Add(E_BLOCK_TALL_GRASS, 2, 2);
+					}
+					a_WorldInterface.SpawnItemPickups(Pickups, a_BlockX, a_BlockY, a_BlockZ);
+				}
+				a_Player->UseEquippedItem();
+			}
+		}
+	}
+
+
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR) && (a_RelY < cChunkDef::Height) && ((a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ) == E_BLOCK_AIR) || (a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ) == E_BLOCK_BIG_FLOWER)));
+	}
+
+
+	virtual void OnPlacedByPlayer(
+		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
+	) override
+	{
+		int Meta = (((int)floor(a_Player->GetYaw() * 4.0 / 360.0 + 0.5) & 0x3) + 2) % 4;
+		a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY + 1, a_BlockZ, m_BlockType, 0x8 | Meta);
+	}
+
+
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		NIBBLETYPE OldMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+		if (OldMeta & 0x8)
+		{
+			// Was upper part of flower
+			if (a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ) == m_BlockType)
+			{
+				a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			}
+		}
+		else
+		{
+			// Was lower part
+			if (a_ChunkInterface.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ) == m_BlockType)
+			{
+				a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY + 1, a_BlockZ, E_BLOCK_AIR, 0);
+			}
+		}
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockButton.h b/src/Blocks/BlockButton.h
index c898a0466..4b2f6f618 100644
--- a/src/Blocks/BlockButton.h
+++ b/src/Blocks/BlockButton.h
@@ -1,31 +1,32 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "Chunk.h"
+#include "MetaRotator.h"
 
 
 
 
 class cBlockButtonHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>
 {
 public:
 	cBlockButtonHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>(a_BlockType)
 	{
 	}
 
 	
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
 		// Set p the ON bit to on
-		NIBBLETYPE Meta = (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) | 0x08);
+		NIBBLETYPE Meta = (a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) | 0x08);
 
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
-		a_World->BroadcastSoundEffect("random.click", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, (Meta & 0x08) ? 0.6f : 0.5f);
+		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+		a_WorldInterface.GetBroadcastManager().BroadcastSoundEffect("random.click", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, (Meta & 0x08) ? 0.6f : 0.5f);
 
 		// Queue a button reset (unpress)
-		a_World->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_BlockType, (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x07), m_BlockType == E_BLOCK_STONE_BUTTON ? 20 : 30, m_BlockType);
+		a_ChunkInterface.QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_BlockType, (a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x07), m_BlockType == E_BLOCK_STONE_BUTTON ? 20 : 30, m_BlockType, a_WorldInterface);
 	}
 
 	
@@ -43,8 +44,8 @@ public:
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -61,7 +62,7 @@ public:
 	}
 
 
-	inline static NIBBLETYPE BlockFaceToMetaData(char a_BlockFace)
+	inline static NIBBLETYPE BlockFaceToMetaData(eBlockFace a_BlockFace)
 	{
 		switch (a_BlockFace)
 		{
@@ -77,7 +78,7 @@ public:
 		}
 	}
 
-	inline static NIBBLETYPE BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
+	inline static eBlockFace BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
 	{
 		switch (a_Meta & 0x7)
 		{
@@ -93,7 +94,7 @@ public:
 		}
 	}
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		NIBBLETYPE Meta;
 		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
@@ -101,7 +102,7 @@ public:
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, BlockMetaDataToBlockFace(Meta), true);
 		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && (g_BlockIsSolid[BlockIsOn]);
+		return (a_RelY > 0) && (cBlockInfo::IsSolid(BlockIsOn));
 	}
 } ;
 
diff --git a/src/Blocks/BlockCactus.h b/src/Blocks/BlockCactus.h
index 88be25dc0..ed441517d 100644
--- a/src/Blocks/BlockCactus.h
+++ b/src/Blocks/BlockCactus.h
@@ -24,7 +24,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if (a_RelY <= 0)
 		{
@@ -54,7 +54,7 @@ public:
 			NIBBLETYPE BlockMeta;
 			if (
 				a_Chunk.UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta) &&
-				(g_BlockIsSolid[BlockType])
+				cBlockInfo::IsSolid(BlockType)
 			)
 			{
 				return false;
@@ -65,7 +65,7 @@ public:
 	}
 	
 
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		a_Chunk.GetWorld()->GrowCactus(a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width, 1);
 	}
diff --git a/src/Blocks/BlockCake.h b/src/Blocks/BlockCake.h
new file mode 100644
index 000000000..36e133388
--- /dev/null
+++ b/src/Blocks/BlockCake.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockCakeHandler :
+	public cBlockHandler
+{
+public:
+	cBlockCakeHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+		if (!a_Player->Feed(2, 0.1))
+		{
+			return;
+		}
+		
+		if (Meta >= 5)
+		{
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+		}
+		else
+		{
+			a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta + 1);
+		}
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Give nothing
+	}
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.cloth";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockCarpet.h b/src/Blocks/BlockCarpet.h
index 5eafd8c21..33dc1da6c 100644
--- a/src/Blocks/BlockCarpet.h
+++ b/src/Blocks/BlockCarpet.h
@@ -31,8 +31,8 @@ public:
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -49,7 +49,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return (a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR);
 	}
diff --git a/src/Blocks/BlockCauldron.h b/src/Blocks/BlockCauldron.h
index b0e00f869..41b79b6c3 100644
--- a/src/Blocks/BlockCauldron.h
+++ b/src/Blocks/BlockCauldron.h
@@ -21,24 +21,30 @@ public:
 		a_Pickups.push_back(cItem(E_ITEM_CAULDRON, 1, 0));
 	}
 
-	void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
-		char Meta = a_World->GetBlockMeta( a_BlockX, a_BlockY, a_BlockZ );
-		switch( a_Player->GetEquippedItem().m_ItemType )
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		switch (a_Player->GetEquippedItem().m_ItemType)
 		{
 			case E_ITEM_WATER_BUCKET:
 			{
-				a_World->SetBlockMeta( a_BlockX, a_BlockY, a_BlockZ, 3 );
-				a_Player->GetInventory().RemoveOneEquippedItem();
-				cItem NewItem(E_ITEM_BUCKET, 1);
-				a_Player->GetInventory().AddItem(NewItem);
+				if (Meta < 3)
+				{
+					a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 3);
+					if (!a_Player->IsGameModeCreative())
+					{
+						a_Player->GetInventory().RemoveOneEquippedItem();
+						cItem NewItem(E_ITEM_BUCKET, 1);
+						a_Player->GetInventory().AddItem(NewItem);
+					}
+				}
 				break;
 			}
 			case E_ITEM_GLASS_BOTTLE:
 			{
-				if( Meta > 0 )
+				if (Meta > 0)
 				{
-					a_World->SetBlockMeta( a_BlockX, a_BlockY, a_BlockZ, --Meta);
+					a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, --Meta);
 					a_Player->GetInventory().RemoveOneEquippedItem();
 					cItem NewItem(E_ITEM_POTIONS, 1, 0);
 					a_Player->GetInventory().AddItem(NewItem);
diff --git a/src/Blocks/BlockChest.h b/src/Blocks/BlockChest.h
index 88f7c4b32..a1ded4c26 100644
--- a/src/Blocks/BlockChest.h
+++ b/src/Blocks/BlockChest.h
@@ -2,27 +2,27 @@
 #pragma once
 
 #include "BlockEntity.h"
-#include "../World.h"
 #include "../BlockArea.h"
 #include "../Entities/Player.h"
+#include "MetaRotator.h"
 
 
 
 
 
 class cBlockChestHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockChestHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -30,7 +30,7 @@ public:
 		a_BlockType = m_BlockType;
 		
 		// Is there a doublechest already next to this block?
-		if (!CanBeAt(a_World, a_BlockX, a_BlockY, a_BlockZ))
+		if (!CanBeAt(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ))
 		{
 			// Yup, cannot form a triple-chest, refuse:
 			return false;
@@ -38,7 +38,7 @@ public:
 		
 		// Check if this forms a doublechest, if so, need to adjust the meta:
 		cBlockArea Area;
-		if (!Area.Read(a_World, a_BlockX - 1, a_BlockX + 1, a_BlockY, a_BlockY, a_BlockZ - 1, a_BlockZ + 1))
+		if (!Area.Read(&a_ChunkInterface, a_BlockX - 1, a_BlockX + 1, a_BlockY, a_BlockY, a_BlockZ - 1, a_BlockZ + 1))
 		{
 			return false;
 		}
@@ -67,15 +67,15 @@ public:
 	
 
 	virtual void OnPlacedByPlayer(
-		cWorld * a_World, cPlayer * a_Player, 
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	) override
 	{
 		// Check if this forms a doublechest, if so, need to adjust the meta:
 		cBlockArea Area;
-		if (!Area.Read(a_World, a_BlockX - 1, a_BlockX + 1, a_BlockY, a_BlockY, a_BlockZ - 1, a_BlockZ + 1))
+		if (!Area.Read(&a_ChunkInterface, a_BlockX - 1, a_BlockX + 1, a_BlockY, a_BlockY, a_BlockZ - 1, a_BlockZ + 1))
 		{
 			return;
 		}
@@ -84,8 +84,8 @@ public:
 		// Choose meta from player rotation, choose only between 2 or 3
 		NIBBLETYPE NewMeta = ((rot >= -90) && (rot < 90)) ? 2 : 3;
 		if (
-			CheckAndAdjustNeighbor(a_World, Area, 0, 1, NewMeta) ||
-			CheckAndAdjustNeighbor(a_World, Area, 2, 1, NewMeta)
+			CheckAndAdjustNeighbor(a_ChunkInterface, Area, 0, 1, NewMeta) ||
+			CheckAndAdjustNeighbor(a_ChunkInterface, Area, 2, 1, NewMeta)
 		)
 		{
 			// Forming a double chest in the X direction
@@ -94,8 +94,8 @@ public:
 		// Choose meta from player rotation, choose only between 4 or 5
 		NewMeta = (rot < 0) ? 4 : 5;
 		if (
-			CheckAndAdjustNeighbor(a_World, Area, 1, 0, NewMeta) ||
-			CheckAndAdjustNeighbor(a_World, Area, 2, 2, NewMeta)
+			CheckAndAdjustNeighbor(a_ChunkInterface, Area, 1, 0, NewMeta) ||
+			CheckAndAdjustNeighbor(a_ChunkInterface, Area, 2, 2, NewMeta)
 		)
 		{
 			// Forming a double chest in the Z direction
@@ -111,11 +111,18 @@ public:
 		return "step.wood";
 	}
 	
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+		int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+		return CanBeAt(a_ChunkInterface, BlockX, a_RelY, BlockZ);
+	}
+
 	
-	virtual bool CanBeAt(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		cBlockArea Area;
-		if (!Area.Read(a_World, a_BlockX - 2, a_BlockX + 2, a_BlockY, a_BlockY, a_BlockZ - 2, a_BlockZ + 2))
+		if (!Area.Read(&a_ChunkInterface, a_BlockX - 2, a_BlockX + 2, a_BlockY, a_BlockY, a_BlockZ - 2, a_BlockZ + 2))
 		{
 			// Cannot read the surroundings, probably at the edge of loaded chunks. Disallow.
 			return false;
@@ -207,15 +214,21 @@ public:
 	
 	
 	/// If there's a chest in the a_Area in the specified coords, modifies its meta to a_NewMeta and returns true.
-	bool CheckAndAdjustNeighbor(cWorld * a_World, const cBlockArea & a_Area, int a_RelX, int a_RelZ, NIBBLETYPE a_NewMeta)
+	bool CheckAndAdjustNeighbor(cChunkInterface & a_ChunkInterface, const cBlockArea & a_Area, int a_RelX, int a_RelZ, NIBBLETYPE a_NewMeta)
 	{
 		if (a_Area.GetRelBlockType(a_RelX, 0, a_RelZ) != E_BLOCK_CHEST)
 		{
 			return false;
 		}
-		a_World->SetBlockMeta(a_Area.GetOriginX() + a_RelX, a_Area.GetOriginY(), a_Area.GetOriginZ() + a_RelZ, a_NewMeta);
+		a_ChunkInterface.SetBlockMeta(a_Area.GetOriginX() + a_RelX, a_Area.GetOriginY(), a_Area.GetOriginZ() + a_RelZ, a_NewMeta);
 		return true;
 	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_CHEST, 1, 0));
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockComparator.h b/src/Blocks/BlockComparator.h
index 5a8e54eda..4dd05366d 100644
--- a/src/Blocks/BlockComparator.h
+++ b/src/Blocks/BlockComparator.h
@@ -3,26 +3,34 @@
 
 #include "BlockHandler.h"
 #include "BlockRedstoneRepeater.h"
+#include "MetaRotator.h"
 
 
 
 
 
 class cBlockComparatorHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>
 {
 public:
 	cBlockComparatorHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>(a_BlockType)
 	{
 	}
 
 	
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
-		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		Meta ^= 0x04; // Toggle 3rd (addition/subtraction) bit with XOR
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+	}
+
+
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		UNUSED(a_ChunkInterface);
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
 	}
 
 
@@ -39,15 +47,15 @@ public:
 	}
 	
 	
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
 	}
 	
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 		) override
diff --git a/src/Blocks/BlockCrops.h b/src/Blocks/BlockCrops.h
index 9c4964e02..8606cf3f3 100644
--- a/src/Blocks/BlockCrops.h
+++ b/src/Blocks/BlockCrops.h
@@ -2,8 +2,7 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
-#include "../World.h"
+#include "../FastRandom.h"
 
 
 
@@ -22,7 +21,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_Meta) override
 	{
-		MTRand rand;
+		cFastRandom rand;
 
 		if (a_Meta == 0x7)
 		{
@@ -32,18 +31,18 @@ public:
 				case E_BLOCK_CROPS:
 				{
 					a_Pickups.push_back(cItem(E_ITEM_WHEAT, 1, 0));
-					a_Pickups.push_back(cItem(E_ITEM_SEEDS, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));  // [1 .. 3] with high preference of 2
+					a_Pickups.push_back(cItem(E_ITEM_SEEDS, (char)(1 + (rand.NextInt(3) + rand.NextInt(3)) / 2), 0));  // [1 .. 3] with high preference of 2
 					break;
 				}
 				case E_BLOCK_CARROTS:
 				{
-					a_Pickups.push_back(cItem(E_ITEM_CARROT, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));  // [1 .. 3] with high preference of 2
+					a_Pickups.push_back(cItem(E_ITEM_CARROT, (char)(1 + (rand.NextInt(3) + rand.NextInt(3)) / 2), 0));  // [1 .. 3] with high preference of 2
 					break;
 				}
 				case E_BLOCK_POTATOES:
 				{
-					a_Pickups.push_back(cItem(E_ITEM_POTATO, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));  // [1 .. 3] with high preference of 2
-					if (rand.randInt(20) == 0)
+					a_Pickups.push_back(cItem(E_ITEM_POTATO, (char)(1 + (rand.NextInt(3) + rand.NextInt(3)) / 2), 0));  // [1 .. 3] with high preference of 2
+					if (rand.NextInt(21) == 0)
 					{
 						// With a 5% chance, drop a poisonous potato as well
 						a_Pickups.push_back(cItem(E_ITEM_POISONOUS_POTATO, 1, 0));
@@ -75,7 +74,7 @@ public:
 	}	
 	
 	
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		NIBBLETYPE Meta     = a_Chunk.GetMeta      (a_RelX, a_RelY, a_RelZ);
 		NIBBLETYPE Light    = a_Chunk.GetBlockLight(a_RelX, a_RelY, a_RelZ);
@@ -88,7 +87,7 @@ public:
 		
 		if ((Meta < 7) && (Light > 8))
 		{
-			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_CROPS, ++Meta);
+			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, m_BlockType, ++Meta);
 		}
 		else if (Light < 9)
 		{
@@ -97,7 +96,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_FARMLAND));
 	}
diff --git a/src/Blocks/BlockDeadBush.h b/src/Blocks/BlockDeadBush.h
index 14617d006..5b687c710 100644
--- a/src/Blocks/BlockDeadBush.h
+++ b/src/Blocks/BlockDeadBush.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../World.h"
 
 
 
@@ -24,7 +23,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return (a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_SAND);
 	}
diff --git a/src/Blocks/BlockDirt.h b/src/Blocks/BlockDirt.h
index 46210e406..aa24b8668 100644
--- a/src/Blocks/BlockDirt.h
+++ b/src/Blocks/BlockDirt.h
@@ -2,8 +2,7 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
-#include "../World.h"
+#include "../FastRandom.h"
 
 
 
@@ -26,7 +25,7 @@ public:
 	}
 	
 	
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		if (m_BlockType != E_BLOCK_GRASS)
 		{
@@ -37,7 +36,7 @@ public:
 		if (a_RelY < cChunkDef::Height - 1)
 		{
 			BLOCKTYPE Above = a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ);
-			if ((!g_BlockTransparent[Above] && !g_BlockOneHitDig[Above]) || IsBlockWater(Above))
+			if ((!cBlockInfo::IsTransparent(Above) && !cBlockInfo::IsOneHitDig(Above)) || IsBlockWater(Above))
 			{
 				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, E_META_DIRT_NORMAL);
 				return;
@@ -45,12 +44,12 @@ public:
 		}
 		
 		// Grass spreads to adjacent dirt blocks:
-		MTRand rand;  // TODO: Replace with cFastRandom
+		cFastRandom rand;
 		for (int i = 0; i < 2; i++)  // Pick two blocks to grow to
 		{
-			int OfsX = rand.randInt(2) - 1;  // [-1 .. 1]
-			int OfsY = rand.randInt(4) - 3;  // [-3 .. 1]
-			int OfsZ = rand.randInt(2) - 1;  // [-1 .. 1]
+			int OfsX = rand.NextInt(3, a_RelX) - 1;  // [-1 .. 1]
+			int OfsY = rand.NextInt(5, a_RelY) - 3;  // [-3 .. 1]
+			int OfsZ = rand.NextInt(3, a_RelZ) - 1;  // [-1 .. 1]
 	
 			BLOCKTYPE  DestBlock;
 			NIBBLETYPE DestMeta;
@@ -78,9 +77,12 @@ public:
 			BLOCKTYPE AboveDest;
 			NIBBLETYPE AboveMeta;
 			Chunk->GetBlockTypeMeta(BlockX, BlockY + 1, BlockZ, AboveDest, AboveMeta);
-			if ((g_BlockOneHitDig[AboveDest] || g_BlockTransparent[AboveDest]) && !IsBlockWater(AboveDest))
+			if ((cBlockInfo::IsOneHitDig(AboveDest) || cBlockInfo::IsTransparent(AboveDest)) && !IsBlockWater(AboveDest))
 			{
-				Chunk->FastSetBlock(BlockX, BlockY, BlockZ, E_BLOCK_GRASS, 0);
+				if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, BlockX * cChunkDef::Width, BlockY, BlockZ * cChunkDef::Width, ssGrassSpread))
+				{
+					Chunk->FastSetBlock(BlockX, BlockY, BlockZ, E_BLOCK_GRASS, 0);
+				}
 			}
 		}  // for i - repeat twice
 	}
diff --git a/src/Blocks/BlockDoor.cpp b/src/Blocks/BlockDoor.cpp
index e91211559..479c68153 100644
--- a/src/Blocks/BlockDoor.cpp
+++ b/src/Blocks/BlockDoor.cpp
@@ -2,7 +2,6 @@
 #include "Globals.h"
 #include "BlockDoor.h"
 #include "../Item.h"
-#include "../World.h"
 #include "../Entities/Player.h"
 
 
@@ -10,7 +9,7 @@
 
 
 cBlockDoorHandler::cBlockDoorHandler(BLOCKTYPE a_BlockType)
-	: cBlockHandler(a_BlockType)
+	: super(a_BlockType)
 {
 }
 
@@ -18,24 +17,24 @@ cBlockDoorHandler::cBlockDoorHandler(BLOCKTYPE a_BlockType)
 
 
 
-void cBlockDoorHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockDoorHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	NIBBLETYPE OldMeta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	NIBBLETYPE OldMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 
 	if (OldMeta & 8)
 	{
 		// Was upper part of door
-		if (IsDoor(a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ)))
+		if (IsDoor(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ)))
 		{
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
 		}
 	}
 	else
 	{
 		// Was lower part
-		if (IsDoor(a_World->GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ)))
+		if (IsDoor(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ)))
 		{
-			a_World->FastSetBlock(a_BlockX, a_BlockY + 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY + 1, a_BlockZ, E_BLOCK_AIR, 0);
 		}
 	}
 }
@@ -44,11 +43,34 @@ void cBlockDoorHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY
 
 
 
-void cBlockDoorHandler::OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
+void cBlockDoorHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
 {
-	if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_WOODEN_DOOR)
+	if (a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_WOODEN_DOOR)
 	{
-		ChangeDoor(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		ChangeDoor(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
+	}
+}
+
+
+
+
+
+void cBlockDoorHandler::OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace)
+{
+	UNUSED(a_ChunkInterface);
+	
+	a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	
+	if (Meta & 8)
+	{
+		// Current block is top of the door
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY - 1, a_BlockZ, a_Player);
+	}
+	else
+	{
+		// Current block is bottom of the door
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, a_Player);
 	}
 }
 
@@ -57,23 +79,23 @@ void cBlockDoorHandler::OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX
 
 
 void cBlockDoorHandler::OnPlacedByPlayer(
-	cWorld * a_World, cPlayer * a_Player,
-	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+	cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 	int a_CursorX, int a_CursorY, int a_CursorZ,
 	BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 )
 {
 	NIBBLETYPE a_TopBlockMeta = 8;
 	if (
-		((a_BlockMeta == 0) && (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ - 1) == m_BlockType)) ||
-		((a_BlockMeta == 1) && (a_World->GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ) == m_BlockType)) ||
-		((a_BlockMeta == 2) && (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1) == m_BlockType)) ||
-		((a_BlockMeta == 3) && (a_World->GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ) == m_BlockType))
+		((a_BlockMeta == 0) && (a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ - 1) == m_BlockType)) ||
+		((a_BlockMeta == 1) && (a_ChunkInterface.GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ) == m_BlockType)) ||
+		((a_BlockMeta == 2) && (a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1) == m_BlockType)) ||
+		((a_BlockMeta == 3) && (a_ChunkInterface.GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ) == m_BlockType))
 	)
 	{
 		a_TopBlockMeta = 9;
 	}
-	a_World->SetBlock(a_BlockX, a_BlockY + 1, a_BlockZ, m_BlockType, a_TopBlockMeta);
+	a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX, a_BlockY + 1, a_BlockZ, m_BlockType, a_TopBlockMeta);
 }
 
 
@@ -88,3 +110,87 @@ const char * cBlockDoorHandler::GetStepSound(void)
 
 
 
+
+NIBBLETYPE cBlockDoorHandler::MetaRotateCCW(NIBBLETYPE a_Meta)
+{
+	if (a_Meta & 0x08)
+	{
+		return a_Meta;
+	}
+	else
+	{
+		return super::MetaRotateCCW(a_Meta);
+	}
+}
+
+
+
+NIBBLETYPE cBlockDoorHandler::MetaRotateCW(NIBBLETYPE a_Meta)
+{
+	if (a_Meta & 0x08)
+	{
+		return a_Meta;
+	}
+	else
+	{
+		return super::MetaRotateCW(a_Meta);
+	}
+}
+
+
+
+NIBBLETYPE cBlockDoorHandler::MetaMirrorXY(NIBBLETYPE a_Meta)
+{
+	// Top bit (0x08) contains door panel type (Top/Bottom panel)  Only Bottom panels contain position data
+	// Return a_Meta if panel is a top panel (0x08 bit is set to 1)
+
+	// Note: Currently, you can not properly mirror the hinges on a double door.  The orientation of the door is stored
+	// in only the bottom tile while the hinge position is in the top tile.  This function only operates on one tile at a time, 
+	// so the function can only see either the hinge position or orientation, but not both, at any given time.  The class itself
+	// needs extra datamembers.
+	if (a_Meta & 0x08) return a_Meta;
+
+	// Holds open/closed meta data. 0x0C == 1100.
+	NIBBLETYPE OtherMeta = a_Meta & 0x0C;
+
+	// Mirrors according to a table.  0x03 == 0011.
+	switch (a_Meta & 0x03)
+	{
+		case 0x03: return 0x01 + OtherMeta;  // South -> North
+		case 0x01: return 0x03 + OtherMeta;  // North -> South
+	}
+
+	// Not Facing North or South; No change.
+	return a_Meta;
+}
+
+
+
+NIBBLETYPE cBlockDoorHandler::MetaMirrorYZ(NIBBLETYPE a_Meta)
+{
+	// Top bit (0x08) contains door panel type (Top/Bottom panel)  Only Bottom panels contain position data
+	// Return a_Meta if panel is a top panel (0x08 bit is set to 1)
+
+	// Note: Currently, you can not properly mirror the hinges on a double door.  The orientation of the door is stored
+	// in only the bottom tile while the hinge position is in the top tile.  This function only operates on one tile at a time, 
+	// so the function can only see either the hinge position or orientation, but not both, at any given time.The class itself
+	// needs extra datamembers.
+
+	if (a_Meta & 0x08) return a_Meta;
+
+	// Holds open/closed meta data. 0x0C == 1100.
+	NIBBLETYPE OtherMeta = a_Meta & 0x0C;
+
+	// Mirrors according to a table.  0x03 == 0011.
+	switch (a_Meta & 0x03)
+	{
+		case 0x00: return 0x02 + OtherMeta;  // West  -> East
+		case 0x02: return 0x00 + OtherMeta;  // East  -> West
+	}
+
+	// Not Facing North or South; No change.
+	return a_Meta;
+}
+
+
+
diff --git a/src/Blocks/BlockDoor.h b/src/Blocks/BlockDoor.h
index 1e86446dd..797fe484c 100644
--- a/src/Blocks/BlockDoor.h
+++ b/src/Blocks/BlockDoor.h
@@ -2,27 +2,33 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../World.h"
 #include "../Entities/Player.h"
-
+#include "Chunk.h"
+#include "MetaRotator.h"
 
 
 
 
 class cBlockDoorHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true>
 {
+	typedef cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true> super;
 public:
 	cBlockDoorHandler(BLOCKTYPE a_BlockType);
 
-	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override;
 	virtual const char * GetStepSound(void) override;
 	
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override;
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta)  override;
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -34,8 +40,8 @@ public:
 		}
 
 		if (
-			!CanReplaceBlock(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ)) ||
-			!CanReplaceBlock(a_World->GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ))
+			!CanReplaceBlock(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)) ||
+			!CanReplaceBlock(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ))
 		)
 		{
 			return false;
@@ -54,8 +60,8 @@ public:
 
 
 	virtual void OnPlacedByPlayer(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	) override;
@@ -67,7 +73,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
 	}
@@ -137,37 +143,35 @@ public:
 
 
 	/// Changes the door at the specified coords from open to close or vice versa
-	static void ChangeDoor(cWorld * a_World, int a_X, int a_Y, int a_Z)
+	static void ChangeDoor(cChunkInterface & a_ChunkInterface, int a_X, int a_Y, int a_Z)
 	{
-		NIBBLETYPE OldMetaData = a_World->GetBlockMeta(a_X, a_Y, a_Z);
-		
-		a_World->SetBlockMeta(a_X, a_Y, a_Z, ChangeStateMetaData(OldMetaData));
-		
+		NIBBLETYPE OldMetaData = a_ChunkInterface.GetBlockMeta(a_X, a_Y, a_Z);
+
+		a_ChunkInterface.SetBlockMeta(a_X, a_Y, a_Z, ChangeStateMetaData(OldMetaData));
+
 		if (OldMetaData & 8)
 		{
 			// Current block is top of the door
-			BLOCKTYPE  BottomBlock = a_World->GetBlock(a_X, a_Y - 1, a_Z);
-			NIBBLETYPE BottomMeta  = a_World->GetBlockMeta(a_X, a_Y - 1, a_Z);
+			BLOCKTYPE  BottomBlock = a_ChunkInterface.GetBlock(a_X, a_Y - 1, a_Z);
+			NIBBLETYPE BottomMeta = a_ChunkInterface.GetBlockMeta(a_X, a_Y - 1, a_Z);
 
 			if (IsDoor(BottomBlock) && !(BottomMeta & 8))
 			{
-				a_World->SetBlockMeta(a_X, a_Y - 1, a_Z, ChangeStateMetaData(BottomMeta));
+				a_ChunkInterface.SetBlockMeta(a_X, a_Y - 1, a_Z, ChangeStateMetaData(BottomMeta));
 			}
 		}
 		else
 		{
 			// Current block is bottom of the door
-			BLOCKTYPE  TopBlock = a_World->GetBlock(a_X, a_Y + 1, a_Z);
-			NIBBLETYPE TopMeta = a_World->GetBlockMeta(a_X, a_Y + 1, a_Z);
+			BLOCKTYPE  TopBlock = a_ChunkInterface.GetBlock(a_X, a_Y + 1, a_Z);
+			NIBBLETYPE TopMeta = a_ChunkInterface.GetBlockMeta(a_X, a_Y + 1, a_Z);
 
 			if (IsDoor(TopBlock) && (TopMeta & 8))
 			{
-				a_World->SetBlockMeta(a_X, a_Y + 1, a_Z, ChangeStateMetaData(TopMeta));
+				a_ChunkInterface.SetBlockMeta(a_X, a_Y + 1, a_Z, ChangeStateMetaData(TopMeta));
 			}
 		}
 	}
-	
-	
 } ;
 
 
diff --git a/src/Blocks/BlockDropSpenser.h b/src/Blocks/BlockDropSpenser.h
index ce9cc0c5d..88b61a418 100644
--- a/src/Blocks/BlockDropSpenser.h
+++ b/src/Blocks/BlockDropSpenser.h
@@ -6,24 +6,25 @@
 #pragma once
 
 #include "../Piston.h"
+#include "MetaRotator.h"
 
 
 
 
 
 class cBlockDropSpenserHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockDropSpenserHandler(BLOCKTYPE a_BlockType) :
-		cBlockEntityHandler(a_BlockType)
+		cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 	
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -34,6 +35,20 @@ public:
 		a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
 		return true;
 	}
+	
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag. Lowest three bits are position. 0x08 == 1000
+		NIBBLETYPE OtherMeta = a_Meta & 0x08;
+		// Mirrors defined by by a table. (Source, mincraft.gamepedia.com) 0x07 == 0111
+		switch (a_Meta & 0x07)
+		{
+			case 0x00: return 0x01 + OtherMeta; // Down -> Up
+			case 0x01: return 0x00 + OtherMeta; // Up -> Down
+		}
+		// Not Facing Up or Down; No change.
+		return a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockEnderchest.h b/src/Blocks/BlockEnderchest.h
index b648248d0..67955f8ce 100644
--- a/src/Blocks/BlockEnderchest.h
+++ b/src/Blocks/BlockEnderchest.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockEntity.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockEnderchestHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockEnderchestHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
@@ -23,8 +23,8 @@ public:
 	}
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 		) override
diff --git a/src/Blocks/BlockEntity.h b/src/Blocks/BlockEntity.h
index 9c6b23665..7f86a22b2 100644
--- a/src/Blocks/BlockEntity.h
+++ b/src/Blocks/BlockEntity.h
@@ -15,9 +15,9 @@ public:
 	{
 	}
 	
-	virtual void OnUse(cWorld * a_World, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
-		a_World->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
+		a_ChunkInterface.UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
 	}
 	
 	virtual bool IsUseable() override
diff --git a/src/Blocks/BlockFarmland.h b/src/Blocks/BlockFarmland.h
index a69d9b775..b720ccd14 100644
--- a/src/Blocks/BlockFarmland.h
+++ b/src/Blocks/BlockFarmland.h
@@ -28,7 +28,7 @@ public:
 	}
 
 
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		bool Found = false;
 		
@@ -90,6 +90,8 @@ public:
 		switch (a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ))
 		{
 			case E_BLOCK_CROPS:
+			case E_BLOCK_POTATOES:
+			case E_BLOCK_CARROTS:
 			case E_BLOCK_MELON_STEM:
 			case E_BLOCK_PUMPKIN_STEM:
 			{
diff --git a/src/Blocks/BlockFenceGate.h b/src/Blocks/BlockFenceGate.h
index 779f12ee1..e202c6610 100644
--- a/src/Blocks/BlockFenceGate.h
+++ b/src/Blocks/BlockFenceGate.h
@@ -2,24 +2,24 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockFenceGateHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>
 {
 public:
 	cBlockFenceGateHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cMetaRotator<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>(a_BlockType)
 	{
 	}
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -30,24 +30,30 @@ public:
 	}
 
 
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
-		NIBBLETYPE OldMetaData = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		NIBBLETYPE OldMetaData = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		NIBBLETYPE NewMetaData = PlayerYawToMetaData(a_Player->GetYaw());
 		OldMetaData ^= 4;  // Toggle the gate
 		if ((OldMetaData & 1) == (NewMetaData & 1))
 		{
 			// Standing in front of the gate - apply new direction
-			a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, (OldMetaData & 4) | (NewMetaData & 3));
+			a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, (OldMetaData & 4) | (NewMetaData & 3));
 		}
 		else
 		{
 			// Standing aside - use last direction
-			a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, OldMetaData);
+			a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, OldMetaData);
 		}
 	}
 
 
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+
+
 	virtual bool IsUseable(void) override
 	{
 		return true;
diff --git a/src/Blocks/BlockFire.h b/src/Blocks/BlockFire.h
index a69fe2131..c8f158e7e 100644
--- a/src/Blocks/BlockFire.h
+++ b/src/Blocks/BlockFire.h
@@ -17,30 +17,32 @@ public:
 	}
 
 	/// Portal boundary and direction variables
-	int XZP, XZM, Dir; // For wont of a better name...
+	// 2014_03_30 _X: What are these used for? Why do we need extra variables?
+	int XZP, XZM;
+	NIBBLETYPE Dir;
 
-	virtual void OnPlaced(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
+	virtual void OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
 	{
 		/*
 		PORTAL FINDING ALGORITH
 		=======================
-		-Get clicked base block
-		-Trace upwards to find first obsidian block; aborts if anything other than obsidian or air is encountered.
-		 Uses this value as a reference (the 'ceiling')
-		-For both directions (if one fails, try the other), BASE (clicked) block:
-		 -Go in one direction, only stop if a non obsidian block is encountered (abort) OR a portal border is encountered (FindObsidianCeiling returns -1)
-		 -If a border was encountered, go the other direction and repeat above
-		 -Write borders to XZP and XZM, write direction portal faces to Dir
-		-Loop through boundary variables, and fill with portal blocks based on Dir with meta from Dir		
+		- Get clicked base block
+		- Trace upwards to find first obsidian block; aborts if anything other than obsidian or air is encountered.
+			Uses this value as a reference (the 'ceiling')
+		- For both directions (if one fails, try the other), BASE (clicked) block:
+			- Go in one direction, only stop if a non obsidian block is encountered (abort) OR a portal border is encountered (FindObsidianCeiling returns -1)
+			- If a border was encountered, go the other direction and repeat above
+			- Write borders to XZP and XZM, write direction portal faces to Dir
+		- Loop through boundary variables, and fill with portal blocks based on Dir with meta from Dir
 		*/
 
 		a_BlockY--; // Because we want the block below the fire
-		FindAndSetPortalFrame(a_BlockX, a_BlockY, a_BlockZ, a_World); // Brought to you by Aperture Science
+		FindAndSetPortalFrame(a_BlockX, a_BlockY, a_BlockZ, a_ChunkInterface, a_WorldInterface);
 	}
 
-	virtual void OnDigging(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	virtual void OnDigging(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
-		a_World->DigBlock(a_BlockX, a_BlockY, a_BlockZ);
+		a_ChunkInterface.DigBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
 	}
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
@@ -60,9 +62,9 @@ public:
 
 	/// Traces along YP until it finds an obsidian block, returns Y difference or 0 if no portal, and -1 for border
 	/// Takes the X, Y, and Z of the base block; with an optional MaxY for portal border finding
-	int FindObsidianCeiling(int X, int Y, int Z, cWorld * a_World, int MaxY = 0)
+	int FindObsidianCeiling(int X, int Y, int Z, cChunkInterface & a_ChunkInterface, int MaxY = 0)
 	{
-		if (a_World->GetBlock(X, Y, Z) != E_BLOCK_OBSIDIAN)
+		if (a_ChunkInterface.GetBlock(X, Y, Z) != E_BLOCK_OBSIDIAN)
 		{
 			return 0;
 		}
@@ -70,7 +72,7 @@ public:
 		
 		for (int newY = Y + 1; newY < cChunkDef::Height; newY++)
 		{
-			BLOCKTYPE Block = a_World->GetBlock(X, newY, Z);
+			BLOCKTYPE Block = a_ChunkInterface.GetBlock(X, newY, Z);
 			if ((Block == E_BLOCK_AIR) || (Block == E_BLOCK_FIRE))
 			{
 				continue;
@@ -82,7 +84,7 @@ public:
 				// This is because the frame is a solid obsidian pillar
 				if ((MaxY != 0) && (newY == Y + 1))
 				{
-					return EvaluatePortalBorder(X, newY, Z, MaxY, a_World);
+					return EvaluatePortalBorder(X, newY, Z, MaxY, a_ChunkInterface);
 				}
 				else
 				{
@@ -97,11 +99,11 @@ public:
 	}
 
 	/// Evaluates if coords have a valid border on top, based on MaxY
-	int EvaluatePortalBorder(int X, int FoundObsidianY, int Z, int MaxY, cWorld * a_World)
+	int EvaluatePortalBorder(int X, int FoundObsidianY, int Z, int MaxY, cChunkInterface & a_ChunkInterface)
 	{
 		for (int checkBorder = FoundObsidianY + 1; checkBorder <= MaxY - 1; checkBorder++) // FoundObsidianY + 1: FoundObsidianY has already been checked in FindObsidianCeiling; MaxY - 1: portal doesn't need corners
 		{
-			if (a_World->GetBlock(X, checkBorder, Z) != E_BLOCK_OBSIDIAN)
+			if (a_ChunkInterface.GetBlock(X, checkBorder, Z) != E_BLOCK_OBSIDIAN)
 			{
 				// Base obsidian, base + 1 obsidian, base + x NOT obsidian -> not complete portal
 				return 0;
@@ -112,9 +114,9 @@ public:
 	}
 
 	/// Finds entire frame in any direction with the coordinates of a base block and fills hole with nether portal (START HERE)
-	void FindAndSetPortalFrame(int X, int Y, int Z, cWorld * a_World)
+	void FindAndSetPortalFrame(int X, int Y, int Z, cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface)
 	{
-		int MaxY = FindObsidianCeiling(X, Y, Z, a_World); // Get topmost obsidian block as reference for all other checks
+		int MaxY = FindObsidianCeiling(X, Y, Z, a_ChunkInterface); // Get topmost obsidian block as reference for all other checks
 		int X1 = X + 1, Z1 = Z + 1, X2 = X - 1, Z2 = Z - 1; // Duplicate XZ values, add/subtract one as we've checked the original already the line above
 
 		if (MaxY == 0) // Oh noes! Not a portal coordinate :(
@@ -122,9 +124,9 @@ public:
 			return;
 		}
 
-		if (!FindPortalSliceX(X1, X2, Y, Z, MaxY, a_World))
+		if (!FindPortalSliceX(X1, X2, Y, Z, MaxY, a_ChunkInterface))
 		{
-			if (!FindPortalSliceZ(X, Y, Z1, Z2, MaxY, a_World))
+			if (!FindPortalSliceZ(X, Y, Z1, Z2, MaxY, a_ChunkInterface))
 			{
 				return; // No eligible portal construct, abort abort abort!!
 			}
@@ -136,11 +138,11 @@ public:
 			{
 				if (Dir == 1)
 				{
-					a_World->SetBlock(Width, Height, Z, E_BLOCK_NETHER_PORTAL, Dir);
+					a_ChunkInterface.SetBlock(a_WorldInterface, Width, Height, Z, E_BLOCK_NETHER_PORTAL, Dir);
 				}
 				else
 				{
-					a_World->SetBlock(X, Height, Width, E_BLOCK_NETHER_PORTAL, Dir);
+					a_ChunkInterface.SetBlock(a_WorldInterface, X, Height, Width, E_BLOCK_NETHER_PORTAL, Dir);
 				}
 			}
 		}
@@ -150,14 +152,14 @@ public:
 
 	/// Evaluates if coordinates are a portal going XP/XM; returns true if so, and writes boundaries to variable
 	/// Takes coordinates of base block and Y coord of target obsidian ceiling
-	bool FindPortalSliceX(int X1, int X2, int Y, int Z, int MaxY, cWorld * a_World)
+	bool FindPortalSliceX(int X1, int X2, int Y, int Z, int MaxY, cChunkInterface & a_ChunkInterface)
 	{
 		Dir = 1; // Set assumed direction (will change if portal turns out to be facing the other direction)
 		bool FoundFrameXP = false, FoundFrameXM = false;
-		for (; ((a_World->GetBlock(X1, Y, Z) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X1, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X1++) // Check XP for obsidian blocks, exempting corners
+		for (; ((a_ChunkInterface.GetBlock(X1, Y, Z) == E_BLOCK_OBSIDIAN) || (a_ChunkInterface.GetBlock(X1, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X1++) // Check XP for obsidian blocks, exempting corners
 		{
-			int Value = FindObsidianCeiling(X1, Y, Z, a_World, MaxY);
-			int ValueTwo = FindObsidianCeiling(X1, Y + 1, Z, a_World, MaxY); // For corners without obsidian
+			int Value = FindObsidianCeiling(X1, Y, Z, a_ChunkInterface, MaxY);
+			int ValueTwo = FindObsidianCeiling(X1, Y + 1, Z, a_ChunkInterface, MaxY); // For corners without obsidian
 			if ((Value == -1) || (ValueTwo == -1)) // FindObsidianCeiling returns -1 upon frame-find
 			{
 				FoundFrameXP = true; // Found a frame border in this direction, proceed in other direction (don't go further)
@@ -168,10 +170,10 @@ public:
 				return false; // Not valid slice, no portal can be formed
 			}
 		} XZP = X1 - 1; // Set boundary of frame interior, note that for some reason, the loop of X and the loop of Z go to different numbers, hence -1 here and -2 there
-		for (; ((a_World->GetBlock(X2, Y, Z) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X2, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X2--) // Go the other direction (XM)
+		for (; ((a_ChunkInterface.GetBlock(X2, Y, Z) == E_BLOCK_OBSIDIAN) || (a_ChunkInterface.GetBlock(X2, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X2--) // Go the other direction (XM)
 		{
-			int Value = FindObsidianCeiling(X2, Y, Z, a_World, MaxY);
-			int ValueTwo = FindObsidianCeiling(X2, Y + 1, Z, a_World, MaxY);
+			int Value = FindObsidianCeiling(X2, Y, Z, a_ChunkInterface, MaxY);
+			int ValueTwo = FindObsidianCeiling(X2, Y + 1, Z, a_ChunkInterface, MaxY);
 			if ((Value == -1) || (ValueTwo == -1))
 			{
 				FoundFrameXM = true;
@@ -186,14 +188,14 @@ public:
 	}
 
 	/// Evaluates if coords are a portal going ZP/ZM; returns true if so, and writes boundaries to variable
-	bool FindPortalSliceZ(int X, int Y, int Z1, int Z2, int MaxY, cWorld * a_World)
+	bool FindPortalSliceZ(int X, int Y, int Z1, int Z2, int MaxY, cChunkInterface & a_ChunkInterface)
 	{
 		Dir = 2;
 		bool FoundFrameZP = false, FoundFrameZM = false;
-		for (; ((a_World->GetBlock(X, Y, Z1) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X, Y + 1, Z1) == E_BLOCK_OBSIDIAN)); Z1++)
+		for (; ((a_ChunkInterface.GetBlock(X, Y, Z1) == E_BLOCK_OBSIDIAN) || (a_ChunkInterface.GetBlock(X, Y + 1, Z1) == E_BLOCK_OBSIDIAN)); Z1++)
 		{
-			int Value = FindObsidianCeiling(X, Y, Z1, a_World, MaxY);
-			int ValueTwo = FindObsidianCeiling(X, Y + 1, Z1, a_World, MaxY);
+			int Value = FindObsidianCeiling(X, Y, Z1, a_ChunkInterface, MaxY);
+			int ValueTwo = FindObsidianCeiling(X, Y + 1, Z1, a_ChunkInterface, MaxY);
 			if ((Value == -1) || (ValueTwo == -1))
 			{
 				FoundFrameZP = true;
@@ -204,10 +206,10 @@ public:
 				return false;
 			}
 		} XZP = Z1 - 2;
-		for (; ((a_World->GetBlock(X, Y, Z2) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X, Y + 1, Z2) == E_BLOCK_OBSIDIAN)); Z2--)
+		for (; ((a_ChunkInterface.GetBlock(X, Y, Z2) == E_BLOCK_OBSIDIAN) || (a_ChunkInterface.GetBlock(X, Y + 1, Z2) == E_BLOCK_OBSIDIAN)); Z2--)
 		{
-			int Value = FindObsidianCeiling(X, Y, Z2, a_World, MaxY);
-			int ValueTwo = FindObsidianCeiling(X, Y + 1, Z2, a_World, MaxY);
+			int Value = FindObsidianCeiling(X, Y, Z2, a_ChunkInterface, MaxY);
+			int ValueTwo = FindObsidianCeiling(X, Y + 1, Z2, a_ChunkInterface, MaxY);
 			if ((Value == -1) || (ValueTwo == -1))
 			{
 				FoundFrameZM = true;
diff --git a/src/Blocks/BlockFlower.h b/src/Blocks/BlockFlower.h
index 421e2d5d8..e8fd4c7f6 100644
--- a/src/Blocks/BlockFlower.h
+++ b/src/Blocks/BlockFlower.h
@@ -24,7 +24,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return (a_RelY > 0) && IsBlockTypeOfDirt(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ));
 	}
diff --git a/src/Blocks/BlockFlowerPot.h b/src/Blocks/BlockFlowerPot.h
index b0faf5218..fc75ef638 100644
--- a/src/Blocks/BlockFlowerPot.h
+++ b/src/Blocks/BlockFlowerPot.h
@@ -2,101 +2,24 @@
 #pragma once
 
 #include "BlockHandler.h"
+#include "BlockEntity.h"
 
 
 
 
 
 class cBlockFlowerPotHandler :
-	public cBlockHandler
+	public cBlockEntityHandler
 {
 public:
 	cBlockFlowerPotHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cBlockEntityHandler(a_BlockType)
 	{
 	}
 
-
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		a_Pickups.push_back(cItem(E_ITEM_FLOWER_POT, 1, 0));
-		if (a_BlockMeta == 0)
-		{
-			return;
-		}
-		cItem Plant;
-		switch (a_BlockMeta)
-		{
-			case 1:  Plant = cItem(E_BLOCK_RED_ROSE, 1, 0); break;
-			case 2:  Plant = cItem(E_BLOCK_YELLOW_FLOWER, 1, 0); break;
-			case 3:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_APPLE); break;
-			case 4:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_CONIFER); break;
-			case 5:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_BIRCH); break;
-			case 6:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_JUNGLE); break;
-			case 7:  Plant = cItem(E_BLOCK_RED_MUSHROOM, 1, 0); break;
-			case 8:  Plant = cItem(E_BLOCK_BROWN_MUSHROOM, 1, 0); break;
-			case 9:  Plant = cItem(E_BLOCK_CACTUS, 1, 0); break;
-			case 10: Plant = cItem(E_BLOCK_DEAD_BUSH, 1, 0); break;
-			case 11: Plant = cItem(E_BLOCK_TALL_GRASS, 1, E_META_TALL_GRASS_FERN); break;
-			default: return;
-		}
-		a_Pickups.push_back(Plant);
-	}
-
-
-	void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		NIBBLETYPE Meta = a_World->GetBlockMeta( a_BlockX, a_BlockY, a_BlockZ );
-		if (Meta != 0)
-		{
-			// Already filled
-			return;
-		}
-		
-		switch (a_Player->GetEquippedItem().m_ItemType)
-		{
-			case E_BLOCK_RED_ROSE: Meta = 1; break;
-			case E_BLOCK_YELLOW_FLOWER: Meta = 2; break;
-			case E_BLOCK_SAPLING:
-			{
-				switch (a_Player->GetEquippedItem().m_ItemDamage)
-				{
-					case E_META_SAPLING_APPLE: Meta = 3; break;
-					case E_META_SAPLING_CONIFER: Meta = 4; break;
-					case E_META_SAPLING_BIRCH: Meta = 5; break;
-					case E_META_SAPLING_JUNGLE: Meta = 6; break;
-				}
-				break;
-			}
-			case E_BLOCK_RED_MUSHROOM: Meta = 7; break;
-			case E_BLOCK_BROWN_MUSHROOM: Meta = 8; break;
-			case E_BLOCK_CACTUS: Meta = 9; break;
-			case E_BLOCK_DEAD_BUSH: Meta = 10; break;
-			case E_BLOCK_TALL_GRASS:
-			{
-				if (a_Player->GetEquippedItem().m_ItemDamage == E_META_TALL_GRASS_FERN)
-				{
-					Meta = 11;
-				}
-				else
-				{
-					return;
-				}
-				break;
-			}
-		}
-		
-		if (a_Player->GetGameMode() != gmCreative)
-		{
-			a_Player->GetInventory().RemoveOneEquippedItem();
-		}
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
-	}
-
-
-	virtual bool IsUseable(void) override
-	{
-		return true;
 	}
 } ;
 
diff --git a/src/Blocks/BlockFluid.h b/src/Blocks/BlockFluid.h
index bce5064bc..d486d642d 100644
--- a/src/Blocks/BlockFluid.h
+++ b/src/Blocks/BlockFluid.h
@@ -32,7 +32,7 @@ public:
 	}
 	
 	
-	virtual void Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) override
+	virtual void Check(cChunkInterface & a_ChunkInterface, cBlockPluginInterface & a_PluginInterface, int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) override
 	{
 		switch (m_BlockType)
 		{
@@ -47,7 +47,7 @@ public:
 				break;
 			}
 		}
-		super::Check(a_RelX, a_RelY, a_RelZ, a_Chunk);
+		super::Check(a_ChunkInterface, a_PluginInterface, a_RelX, a_RelY, a_RelZ, a_Chunk);
 	}
 } ;
 
@@ -68,7 +68,7 @@ public:
 	
 	
 	/// Called to tick the block
-	virtual void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		if (a_Chunk.GetWorld()->ShouldLavaSpawnFire())
 		{
@@ -93,6 +93,7 @@ public:
 		// Check if it's fuel:
 		BLOCKTYPE BlockType;
 		if (
+			((a_RelY + y < 0) || (a_RelY + y > cChunkDef::Height)) ||
 			!a_Chunk.UnboundedRelGetBlockType(a_RelX + x, a_RelY + y, a_RelZ + z, BlockType) ||
 			!cFireSimulator::IsFuel(BlockType)
 		)
@@ -119,6 +120,7 @@ public:
 		for (size_t i = 0; i < ARRAYCOUNT(CrossCoords); i++)
 		{
 			if (
+				((RelY + CrossCoords[i].y >= 0) && (RelY + CrossCoords[i].y <= cChunkDef::Height)) &&
 				a_Chunk.UnboundedRelGetBlockType(RelX + CrossCoords[i].x, RelY + CrossCoords[i].y, RelZ + CrossCoords[i].z, BlockType) &&
 				(BlockType == E_BLOCK_AIR)
 			)
diff --git a/src/Blocks/BlockFurnace.h b/src/Blocks/BlockFurnace.h
index 693eac331..a7a807957 100644
--- a/src/Blocks/BlockFurnace.h
+++ b/src/Blocks/BlockFurnace.h
@@ -4,17 +4,17 @@
 #include "BlockEntity.h"
 #include "../World.h"
 #include "../Piston.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockFurnaceHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
-	cBlockFurnaceHandler(BLOCKTYPE a_BlockType) :
-		cBlockEntityHandler(a_BlockType)
+	cBlockFurnaceHandler(BLOCKTYPE a_BlockType) 
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
@@ -26,8 +26,8 @@ public:
 
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index 8d09b5559..a764c6f44 100644
--- a/src/Blocks/BlockHandler.cpp
+++ b/src/Blocks/BlockHandler.cpp
@@ -5,10 +5,14 @@
 #include "../World.h"
 #include "../Root.h"
 #include "../Bindings/PluginManager.h"
+#include "../Chunk.h"
+#include "BlockAnvil.h"
 #include "BlockBed.h"
+#include "BlockBigFlower.h"
 #include "BlockBrewingStand.h"
 #include "BlockButton.h"
 #include "BlockCactus.h"
+#include "BlockCake.h"
 #include "BlockCarpet.h"
 #include "BlockCauldron.h"
 #include "BlockChest.h"
@@ -34,10 +38,13 @@
 #include "BlockGlass.h"
 #include "BlockGlowstone.h"
 #include "BlockGravel.h"
+#include "BlockMobHead.h"
 #include "BlockHopper.h"
 #include "BlockIce.h"
 #include "BlockLadder.h"
 #include "BlockLeaves.h"
+#include "BlockLilypad.h"
+#include "BlockNewLeaves.h"
 #include "BlockLever.h"
 #include "BlockMelon.h"
 #include "BlockMushroom.h"
@@ -49,13 +56,16 @@
 #include "BlockPlanks.h"
 #include "BlockPortal.h"
 #include "BlockPumpkin.h"
+#include "BlockQuartz.h"
 #include "BlockRail.h"
 #include "BlockRedstone.h"
 #include "BlockRedstoneLamp.h"
 #include "BlockRedstoneRepeater.h"
 #include "BlockRedstoneTorch.h"
+#include "BlockTNT.h"
 #include "BlockSand.h"
 #include "BlockSapling.h"
+#include "BlockSideways.h"
 #include "BlockSign.h"
 #include "BlockSlab.h"
 #include "BlockSnow.h"
@@ -67,52 +77,28 @@
 #include "BlockTorch.h"
 #include "BlockTrapdoor.h"
 #include "BlockVine.h"
-#include "BlockWood.h"
 #include "BlockWorkbench.h"
 
 
 
 
 
-bool            cBlockHandler::m_HandlerInitialized = false;
-cBlockHandler * cBlockHandler::m_BlockHandler[256];
-
-
-
-
-
-cBlockHandler * cBlockHandler::GetBlockHandler(BLOCKTYPE a_BlockType)
-{
-	if (!m_HandlerInitialized)
-	{
-		// We have to initialize
-		memset(m_BlockHandler, 0, sizeof(m_BlockHandler));
-		m_HandlerInitialized = true;
-	}
-	if (m_BlockHandler[a_BlockType] != NULL)
-	{
-		return m_BlockHandler[a_BlockType];
-	}
-
-	return m_BlockHandler[a_BlockType] = CreateBlockHandler(a_BlockType);
-}
-
-
-
-
-
 cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 {
 	switch(a_BlockType)
 	{
 		// Block handlers, alphabetically sorted:
+		case E_BLOCK_ACACIA_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_ACTIVATOR_RAIL:        return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_ANVIL:                 return new cBlockAnvilHandler           (a_BlockType);
 		case E_BLOCK_BED:                   return new cBlockBedHandler             (a_BlockType);
+		case E_BLOCK_BIG_FLOWER:            return new cBlockBigFlowerHandler       (a_BlockType);
 		case E_BLOCK_BIRCH_WOOD_STAIRS:     return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_BREWING_STAND:         return new cBlockBrewingStandHandler    (a_BlockType);
 		case E_BLOCK_BRICK_STAIRS:          return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_BROWN_MUSHROOM:        return new cBlockMushroomHandler        (a_BlockType);
 		case E_BLOCK_CACTUS:                return new cBlockCactusHandler          (a_BlockType);
+		case E_BLOCK_CAKE:                  return new cBlockCakeHandler            (a_BlockType);
 		case E_BLOCK_CARROTS:               return new cBlockCropsHandler           (a_BlockType);
 		case E_BLOCK_CARPET:                return new cBlockCarpetHandler          (a_BlockType);
 		case E_BLOCK_CAULDRON:              return new cBlockCauldronHandler        (a_BlockType);
@@ -124,6 +110,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_COBBLESTONE_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_COBWEB:                return new cBlockCobWebHandler          (a_BlockType);
 		case E_BLOCK_CROPS:                 return new cBlockCropsHandler           (a_BlockType);
+		case E_BLOCK_DARK_OAK_WOOD_STAIRS:  return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_DEAD_BUSH:             return new cBlockDeadBushHandler        (a_BlockType);
 		case E_BLOCK_DETECTOR_RAIL:         return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_DIAMOND_ORE:           return new cBlockOreHandler             (a_BlockType);
@@ -145,6 +132,8 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_GLASS:                 return new cBlockGlassHandler           (a_BlockType);
 		case E_BLOCK_GRASS:                 return new cBlockDirtHandler            (a_BlockType);
 		case E_BLOCK_GRAVEL:                return new cBlockGravelHandler          (a_BlockType);
+		case E_BLOCK_HAY_BALE:              return new cBlockSidewaysHandler        (a_BlockType);
+		case E_BLOCK_HEAD:                  return new cBlockMobHeadHandler         (a_BlockType);
 		case E_BLOCK_HOPPER:                return new cBlockHopperHandler          (a_BlockType);
 		case E_BLOCK_ICE:                   return new cBlockIceHandler             (a_BlockType);
 		case E_BLOCK_INACTIVE_COMPARATOR:   return new cBlockComparatorHandler      (a_BlockType);
@@ -158,14 +147,18 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_LAPIS_ORE:             return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_LAVA:                  return new cBlockLavaHandler            (a_BlockType);
 		case E_BLOCK_LEAVES:                return new cBlockLeavesHandler          (a_BlockType);
+		case E_BLOCK_LILY_PAD:              return new cBlockLilypadHandler         (a_BlockType);
 		case E_BLOCK_LIT_FURNACE:           return new cBlockFurnaceHandler         (a_BlockType);
-		case E_BLOCK_LOG:                   return new cBlockWoodHandler            (a_BlockType);
+		case E_BLOCK_LOG:                   return new cBlockSidewaysHandler        (a_BlockType);
 		case E_BLOCK_MELON:                 return new cBlockMelonHandler           (a_BlockType);
 		case E_BLOCK_MELON_STEM:            return new cBlockStemsHandler           (a_BlockType);
 		case E_BLOCK_MYCELIUM:              return new cBlockMyceliumHandler        (a_BlockType);
 		case E_BLOCK_NETHER_BRICK_STAIRS:   return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_NETHER_PORTAL:         return new cBlockPortalHandler          (a_BlockType);
 		case E_BLOCK_NETHER_WART:           return new cBlockNetherWartHandler      (a_BlockType);
+		case E_BLOCK_NETHER_QUARTZ_ORE:     return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_NEW_LEAVES:            return new cBlockNewLeavesHandler       (a_BlockType);
+		case E_BLOCK_NEW_LOG:               return new cBlockSidewaysHandler        (a_BlockType);
 		case E_BLOCK_NOTE_BLOCK:            return new cBlockNoteHandler            (a_BlockType);
 		case E_BLOCK_PISTON:                return new cBlockPistonHandler          (a_BlockType);
 		case E_BLOCK_PISTON_EXTENSION:      return new cBlockPistonHeadHandler      (           );
@@ -174,6 +167,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_POWERED_RAIL:          return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_PUMPKIN:               return new cBlockPumpkinHandler         (a_BlockType);
 		case E_BLOCK_PUMPKIN_STEM:          return new cBlockStemsHandler           (a_BlockType);
+		case E_BLOCK_QUARTZ_BLOCK:          return new cBlockQuartzHandler          (a_BlockType);
 		case E_BLOCK_QUARTZ_STAIRS:         return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_RAIL:                  return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_REDSTONE_LAMP_ON:      return new cBlockRedstoneLampHandler    (a_BlockType); // We need this to change pickups to an off lamp; else 1.7+ clients crash
@@ -183,7 +177,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_REDSTONE_REPEATER_ON:  return new cBlockRedstoneRepeaterHandler(a_BlockType);
 		case E_BLOCK_REDSTONE_TORCH_OFF:    return new cBlockRedstoneTorchHandler   (a_BlockType);
 		case E_BLOCK_REDSTONE_TORCH_ON:     return new cBlockRedstoneTorchHandler   (a_BlockType);
-		case E_BLOCK_REDSTONE_WIRE:	        return new cBlockRedstoneHandler        (a_BlockType);
+		case E_BLOCK_REDSTONE_WIRE:         return new cBlockRedstoneHandler        (a_BlockType);
 		case E_BLOCK_RED_MUSHROOM:          return new cBlockMushroomHandler        (a_BlockType);
 		case E_BLOCK_RED_ROSE:              return new cBlockFlowerHandler          (a_BlockType);
 		case E_BLOCK_SAND:                  return new cBlockSandHandler            (a_BlockType);
@@ -203,6 +197,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_TALL_GRASS:            return new cBlockTallGrassHandler       (a_BlockType);
 		case E_BLOCK_TORCH:                 return new cBlockTorchHandler           (a_BlockType);
 		case E_BLOCK_TRAPDOOR:              return new cBlockTrapdoorHandler        (a_BlockType);
+		case E_BLOCK_TNT:                   return new cBlockTNTHandler             (a_BlockType);
 		case E_BLOCK_VINES:                 return new cBlockVineHandler            (a_BlockType);
 		case E_BLOCK_WALLSIGN:              return new cBlockSignHandler            (a_BlockType);
 		case E_BLOCK_WATER:                 return new cBlockFluidHandler           (a_BlockType);
@@ -222,20 +217,6 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 
 
 
-void cBlockHandler::Deinit()
-{
-	for (int i = 0; i < 256; i++)
-	{
-		delete m_BlockHandler[i];
-	}
-	memset(m_BlockHandler, 0, sizeof(m_BlockHandler));  // Don't leave any dangling pointers around, just in case
-	m_HandlerInitialized = false;
-}
-
-
-
-
-
 cBlockHandler::cBlockHandler(BLOCKTYPE a_BlockType)
 {
 	m_BlockType = a_BlockType;
@@ -246,8 +227,8 @@ cBlockHandler::cBlockHandler(BLOCKTYPE a_BlockType)
 
 
 bool cBlockHandler::GetPlacementBlockTypeMeta(
-	cWorld * a_World, cPlayer * a_Player,
-	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+	cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 	int a_CursorX, int a_CursorY, int a_CursorZ,
 	BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 )
@@ -262,7 +243,7 @@ bool cBlockHandler::GetPlacementBlockTypeMeta(
 
 
 
-void cBlockHandler::OnUpdate(cChunk & a_Chunk, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 }
 
@@ -270,7 +251,7 @@ void cBlockHandler::OnUpdate(cChunk & a_Chunk, int a_BlockX, int a_BlockY, int a
 
 
 
-void cBlockHandler::OnPlacedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+void cBlockHandler::OnPlacedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
 }
 
@@ -278,7 +259,7 @@ void cBlockHandler::OnPlacedByPlayer(cWorld * a_World, cPlayer * a_Player, int a
 
 
 
-void cBlockHandler::OnDestroyedByPlayer(cWorld *a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 }
 
@@ -286,41 +267,41 @@ void cBlockHandler::OnDestroyedByPlayer(cWorld *a_World, cPlayer * a_Player, int
 
 
 
-void cBlockHandler::OnPlaced(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+void cBlockHandler::OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
 	// Notify the neighbors
-	NeighborChanged(a_World, a_BlockX - 1, a_BlockY, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX + 1, a_BlockY, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ - 1);
-	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ + 1);
+	NeighborChanged(a_ChunkInterface, a_BlockX - 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX + 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ - 1);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ + 1);
 }
 
 
 
 
 
-void cBlockHandler::OnDestroyed(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 	// Notify the neighbors
-	NeighborChanged(a_World, a_BlockX - 1, a_BlockY, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX + 1, a_BlockY, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ);
-	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ - 1);
-	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ + 1);
+	NeighborChanged(a_ChunkInterface, a_BlockX - 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX + 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ - 1);
+	NeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ + 1);
 }
 
 
 
 
 
-void cBlockHandler::NeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::NeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 	if ((a_BlockY >= 0) && (a_BlockY < cChunkDef::Height))
 	{
-		GetBlockHandler(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnNeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		cBlockInfo::GetHandler(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
 	}
 }
 
@@ -328,7 +309,15 @@ void cBlockHandler::NeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY,
 
 
 
-void cBlockHandler::OnNeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::OnNeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnDigging(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 }
 
@@ -336,7 +325,7 @@ void cBlockHandler::OnNeighborChanged(cWorld *a_World, int a_BlockX, int a_Block
 
 
 
-void cBlockHandler::OnDigging(cWorld *a_World, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
 {
 }
 
@@ -344,7 +333,7 @@ void cBlockHandler::OnDigging(cWorld *a_World, cPlayer *a_Player, int a_BlockX,
 
 
 
-void cBlockHandler::OnUse(cWorld *a_World, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
+void cBlockHandler::OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace)
 {
 }
 
@@ -362,14 +351,14 @@ void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
 
 
 
-void cBlockHandler::DropBlock(cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 	cItems Pickups;
-	NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 	ConvertToPickups(Pickups, Meta);
 	
 	// Allow plugins to modify the pickups:
-	cRoot::Get()->GetPluginManager()->CallHookBlockToPickups(a_World, a_Digger, a_BlockX, a_BlockY, a_BlockZ, m_BlockType, Meta, Pickups);
+	a_BlockPluginInterface.CallHookBlockToPickups(a_Digger, a_BlockX, a_BlockY, a_BlockZ, m_BlockType, Meta, Pickups);
 	
 	if (!Pickups.empty())
 	{
@@ -385,7 +374,7 @@ void cBlockHandler::DropBlock(cWorld * a_World, cEntity * a_Digger, int a_BlockX
 		MicroX += r1.rand(1) - 0.5;
 		MicroZ += r1.rand(1) - 0.5;
 
-		a_World->SpawnItemPickups(Pickups, MicroX, MicroY, MicroZ);
+		a_WorldInterface.SpawnItemPickups(Pickups, MicroX, MicroY, MicroZ);
 	}
 }
 
@@ -402,7 +391,7 @@ const char * cBlockHandler::GetStepSound()
 
 
 
-bool cBlockHandler::CanBeAt(int a_BlockX, int a_BlockY, int a_BlockZ, const cChunk & a_Chunk)
+bool cBlockHandler::CanBeAt(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, const cChunk & a_Chunk)
 {
 	return true;
 }
@@ -447,15 +436,15 @@ bool cBlockHandler::DoesDropOnUnsuitable(void)
 
 
 
-void cBlockHandler::Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk)
+void cBlockHandler::Check(cChunkInterface & a_ChunkInterface, cBlockPluginInterface & a_PluginInterface, int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk)
 {
-	if (!CanBeAt(a_RelX, a_RelY, a_RelZ, a_Chunk))
+	if (!CanBeAt(a_ChunkInterface, a_RelX, a_RelY, a_RelZ, a_Chunk))
 	{
 		if (DoesDropOnUnsuitable())
 		{
 			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
 			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
-			DropBlock(a_Chunk.GetWorld(), NULL, BlockX, a_RelY, BlockZ);
+			DropBlock(a_ChunkInterface, *a_Chunk.GetWorld(), a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
 		}
 		
 		a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
index a732aa797..3a3efb3cc 100644
--- a/src/Blocks/BlockHandler.h
+++ b/src/Blocks/BlockHandler.h
@@ -3,15 +3,17 @@
 
 #include "../Defines.h"
 #include "../Item.h"
-#include "../Chunk.h"
+#include "WorldInterface.h"
+#include "ChunkInterface.h"
+#include "BlockPluginInterface.h"
 
 
 
 
 
 // fwd:
-class cWorld;
 class cPlayer;
+class cChunk;
 
 
 
@@ -21,10 +23,12 @@ class cBlockHandler
 {
 public:
 	cBlockHandler(BLOCKTYPE a_BlockType);
+	
+	virtual ~cBlockHandler() {}
 
 	/// Called when the block gets ticked either by a random tick or by a queued tick.
 	/// Note that the coords are chunk-relative!
-	virtual void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ);
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ);
 
 	/** Called before a block is placed	into a world. 
 	The handler should return true to allow placement, false to refuse.
@@ -32,52 +36,55 @@ public:
 	Called by cItemHandler::GetPlacementBlockTypeMeta() if the item is a block
 	*/
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	);
 
 	/// Called by cWorld::SetBlock() after the block has been set
-	virtual void OnPlaced(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	virtual void OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
 	/// Called by cClientHandle::HandlePlaceBlock() after the player has placed a new block. Called after OnPlaced().
 	virtual void OnPlacedByPlayer(
-		cWorld * a_World, cPlayer * a_Player, 
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	);
 	
 	/// Called before the player has destroyed a block
-	virtual void OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
+	virtual void OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/// Called before a block gets destroyed / replaced with air
-	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ);
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/// Called when a direct neighbor of this block has been changed (The position is the own position, not the neighbor position)
-	virtual void OnNeighborChanged(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ);
+	virtual void OnNeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/// Notifies all neighbors of the given block about a change
-	static void NeighborChanged(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ);
+	static void NeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/// Called while the player diggs the block.
-	virtual void OnDigging(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
+	virtual void OnDigging(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/// Called if the user right clicks the block and the block is useable
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ);
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ);
+	
+	/** Called when a Right Click to this Block is cancelled */
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace);
 	
 	/// <summary>Called when the item is mined to convert it into pickups. Pickups may specify multiple items. Appends items to a_Pickups, preserves its original contents</summary>
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta);
 	
 	/// Handles the dropping of a block based on what ConvertToDrops() returns. This will not destroy the block. a_Digger is the entity causing the drop; it may be NULL
-	virtual void DropBlock(cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ);
+	virtual void DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/// Returns step sound name of block
 	virtual const char * GetStepSound(void);
 	
 	/// Checks if the block can stay at the specified relative coords in the chunk
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk);
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk);
 	
 	/** Checks if the block can be placed at this point.
 	Default: CanBeAt(...) 
@@ -112,7 +119,7 @@ public:
 	By default drops if position no more suitable (CanBeAt(), DoesDropOnUnsuitable(), Drop()),
 	and wakes up all simulators on the block.
 	*/
-	virtual void Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk);
+	virtual void Check(cChunkInterface & ChunkInterface, cBlockPluginInterface & a_PluginInterface, int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk);
 	
 	/// <summary>Rotates a given block meta counter-clockwise. Default: no change</summary>
 	/// <returns>Block meta following rotation</returns>
@@ -134,30 +141,14 @@ public:
 	/// <returns>Block meta following mirroring</returns>
 	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) { return a_Meta; }
 	
-	/// <summary>Get the blockhandler for a specific block id</summary>
-	static cBlockHandler * GetBlockHandler(BLOCKTYPE a_BlockType);
-
-	/// <summary>Deletes all initialised block handlers</summary>
-	static void Deinit();
-	
 protected:
 	BLOCKTYPE m_BlockType;
 	
 	// Creates a new blockhandler for the given block type. For internal use only, use ::GetBlockHandler() instead.
-	static cBlockHandler *CreateBlockHandler(BLOCKTYPE a_BlockType);
-	static cBlockHandler *m_BlockHandler[256];
-	static bool m_HandlerInitialized;	//used to detect if the blockhandlers are initialized
-};
-
+	static cBlockHandler * CreateBlockHandler(BLOCKTYPE a_BlockType);
 
-
-
-
-// Shortcut to get the blockhandler for a specific block
-inline cBlockHandler * BlockHandler(BLOCKTYPE a_BlockType)
-{
-	return cBlockHandler::GetBlockHandler(a_BlockType);
-}
+	friend class cBlockInfo;
+};
 
 
 
diff --git a/src/Blocks/BlockHopper.h b/src/Blocks/BlockHopper.h
index 3998276d7..a882bb077 100644
--- a/src/Blocks/BlockHopper.h
+++ b/src/Blocks/BlockHopper.h
@@ -3,23 +3,23 @@
 
 // Declares the cBlockHopperHandler class representing the handler for the Hopper block
 
-
+#include "MetaRotator.h"
 
 
 
 class cBlockHopperHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockHopperHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -39,6 +39,21 @@ public:
 		}
 		return true;
 	}
+
+
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag.  Lowest three bits are position.  0x08 == 1000
+		NIBBLETYPE OtherMeta = a_Meta & 0x08;
+		// Mirrors defined by by a table. (Source, mincraft.gamepedia.com) 0x07 == 0111
+		switch (a_Meta & 0x07)
+		{
+			case 0x00: return 0x01 + OtherMeta;  // Down -> Up
+			case 0x01: return 0x00 + OtherMeta;  // Up   -> Down
+		}
+		// Not Facing Up or Down; No change.
+		return a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockIce.h b/src/Blocks/BlockIce.h
index af4961114..8dfe7ddac 100644
--- a/src/Blocks/BlockIce.h
+++ b/src/Blocks/BlockIce.h
@@ -24,10 +24,10 @@ public:
 	}
 	
 	
-	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
 		// TODO: Ice destroyed with air below it should turn into air instead of water
-		a_World->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_WATER, 0);
+		a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_WATER, 0);
 		// This is called later than the real destroying of this ice block
 	}	
 } ;
diff --git a/src/Blocks/BlockLadder.h b/src/Blocks/BlockLadder.h
index c0aa25f60..a605edf3f 100644
--- a/src/Blocks/BlockLadder.h
+++ b/src/Blocks/BlockLadder.h
@@ -9,25 +9,25 @@
 
 
 class cBlockLadderHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockLadderHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}	
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
-		if (!LadderCanBePlacedAt(a_World, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace))
+		if (!LadderCanBePlacedAt(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace))
 		{
-			a_BlockFace = FindSuitableBlockFace(a_World, a_BlockX, a_BlockY, a_BlockZ);
+			a_BlockFace = FindSuitableBlockFace(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
 			
 			if (a_BlockFace == BLOCK_FACE_BOTTOM)
 			{
@@ -41,38 +41,39 @@ public:
 	}
 
 
-	static NIBBLETYPE DirectionToMetaData(char a_Direction)  // tolua_export
+	static NIBBLETYPE DirectionToMetaData(eBlockFace a_Direction)  // tolua_export
 	{  // tolua_export
 		switch (a_Direction)
 		{
-			case 0x2: return 0x2;
-			case 0x3: return 0x3;
-			case 0x4: return 0x4;
-			case 0x5: return 0x5;
+			case BLOCK_FACE_ZM: return 0x2;
+			case BLOCK_FACE_ZP: return 0x3;
+			case BLOCK_FACE_XM: return 0x4;
+			case BLOCK_FACE_XP: return 0x5;
 			default:  return 0x2;
 		}
 	}  // tolua_export
 
 
-	static char MetaDataToDirection(NIBBLETYPE a_MetaData)  // tolua_export
+	static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)  // tolua_export
 	{														// tolua_export
 		switch (a_MetaData)
 		{
-			case 0x2: return 0x2;
-			case 0x3: return 0x3;
-			case 0x4: return 0x4;
-			case 0x5: return 0x5;
-			default:  return 0x2;
+			case 0x2: return BLOCK_FACE_ZM;
+			case 0x3: return BLOCK_FACE_ZP;
+			case 0x4: return BLOCK_FACE_XM;
+			case 0x5: return BLOCK_FACE_XP;
+			default:  return BLOCK_FACE_ZM;
 		}
 	}  // tolua_export
 
 
 	/// Finds a suitable Direction for the Ladder. Returns BLOCK_FACE_BOTTOM on failure
-	static char FindSuitableBlockFace(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	static eBlockFace FindSuitableBlockFace(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
-		for (int Face = 2; Face <= 5; Face++)
+		for (int FaceInt = BLOCK_FACE_ZM; FaceInt <= BLOCK_FACE_XP; FaceInt++)
 		{
-			if (LadderCanBePlacedAt(a_World, a_BlockX, a_BlockY, a_BlockZ, Face))
+			eBlockFace Face = static_cast<eBlockFace>(FaceInt);
+			if (LadderCanBePlacedAt(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, Face))
 			{
 				return Face;
 			}
@@ -81,7 +82,7 @@ public:
 	}
 	
 
-	static bool LadderCanBePlacedAt(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+	static bool LadderCanBePlacedAt(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace)
 	{
 		if ((a_BlockFace == BLOCK_FACE_BOTTOM) || (a_BlockFace == BLOCK_FACE_TOP))
 		{
@@ -90,17 +91,17 @@ public:
 
 		AddFaceDirection( a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true);
 
-		return g_BlockIsSolid[a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ)];
+		return cBlockInfo::IsSolid(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ));
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface,int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		// TODO: Use AdjustCoordsByMeta(), then cChunk::UnboundedRelGetBlock() and finally some comparison
-		char BlockFace = MetaDataToDirection(a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+		eBlockFace BlockFace = MetaDataToDirection(a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
 		int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
 		int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
-		return LadderCanBePlacedAt(a_Chunk.GetWorld(), BlockX, a_RelY, BlockZ, BlockFace);
+		return LadderCanBePlacedAt(a_ChunkInterface, BlockX, a_RelY, BlockZ, BlockFace);
 	}
 
 
diff --git a/src/Blocks/BlockLeaves.h b/src/Blocks/BlockLeaves.h
index 539d12a49..8af14686e 100644
--- a/src/Blocks/BlockLeaves.h
+++ b/src/Blocks/BlockLeaves.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
+#include "../FastRandom.h"
 #include "../World.h"
 #include "../BlockArea.h"
 
@@ -16,6 +16,7 @@
 	{ \
 		case E_BLOCK_LEAVES: a_Area.SetBlockType(x, y, z, (BLOCKTYPE)(E_BLOCK_SPONGE + i + 1)); break; \
 		case E_BLOCK_LOG: return true; \
+		case E_BLOCK_NEW_LOG: return true; \
 	}
 
 bool HasNearLog(cBlockArea &a_Area, int a_BlockX, int a_BlockY, int a_BlockZ);
@@ -36,16 +37,18 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		MTRand rand;
+		cFastRandom rand;
 
 		// Only the first 2 bits contain the display information, the others are for growing
-		if (rand.randInt(5) == 0)
+		if (rand.NextInt(6) == 0)
 		{
 			a_Pickups.push_back(cItem(E_BLOCK_SAPLING, 1, a_BlockMeta & 3));
 		}
-		if ((a_BlockMeta & 3) == E_META_SAPLING_APPLE)
+		
+		// 1 % chance of dropping an apple, if the leaves' type is Apple Leaves
+		if ((a_BlockMeta & 3) == E_META_LEAVES_APPLE)
 		{
-			if (rand.rand(100) == 0)
+			if (rand.NextInt(101) == 0)
 			{
 				a_Pickups.push_back(cItem(E_ITEM_RED_APPLE, 1, 0));
 			}
@@ -53,31 +56,30 @@ public:
 	}
 
 
-	void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
-		cBlockHandler::OnDestroyed(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		cBlockHandler::OnDestroyed(a_ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
 		
-		//0.5% chance of dropping an apple
-		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-		//check if Oak (0x1 and 0x2 bit not set)
-		MTRand rand;
-		if(!(Meta & 3) && rand.randInt(200) == 100)
+		// 0.5% chance of dropping an apple, if the leaves' type is Apple Leaves:
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		cFastRandom rand;
+		if (((Meta & 3) == E_META_LEAVES_APPLE) && (rand.NextInt(201) == 100))
 		{
 			cItems Drops;
 			Drops.push_back(cItem(E_ITEM_RED_APPLE, 1, 0));
-			a_World->SpawnItemPickups(Drops, a_BlockX, a_BlockY, a_BlockZ);
+			a_WorldInterface.SpawnItemPickups(Drops, a_BlockX, a_BlockY, a_BlockZ);
 		}
 	}
 	
 	
-	virtual void OnNeighborChanged(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	virtual void OnNeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
-		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta & 0x7);	 // Unset 0x8 bit so it gets checked for decay
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta & 0x7);	 // Unset 0x8 bit so it gets checked for decay
 	}
 	
 	
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
 		if ((Meta & 0x04) != 0)
@@ -116,8 +118,8 @@ public:
 		}
 
 		// Decay the leaves:
-		DropBlock(a_Chunk.GetWorld(), NULL, BlockX, a_RelY, BlockZ);
-		a_Chunk.GetWorld()->DigBlock(BlockX, a_RelY, BlockZ);
+		DropBlock(a_ChunkInterface, a_WorldInterface, a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
+		a_ChunkInterface.DigBlock(a_WorldInterface, BlockX, a_RelY, BlockZ);
 	}
 
 
@@ -139,6 +141,8 @@ bool HasNearLog(cBlockArea & a_Area, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		switch (Types[i])
 		{
+			case E_BLOCK_NEW_LEAVES:
+			case E_BLOCK_NEW_LOG:
 			case E_BLOCK_LEAVES:
 			case E_BLOCK_LOG:
 			{
diff --git a/src/Blocks/BlockLever.h b/src/Blocks/BlockLever.h
index 5b0c89127..ad2ae29e5 100644
--- a/src/Blocks/BlockLever.h
+++ b/src/Blocks/BlockLever.h
@@ -1,27 +1,28 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockLeverHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x04, 0x02, 0x03, 0x01, false>
 {
+	typedef cMetaRotator<cBlockHandler, 0x07, 0x04, 0x02, 0x03, 0x01, false> super;
 public:
 	cBlockLeverHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x04, 0x02, 0x03, 0x01, false>(a_BlockType)
 	{
 	}
 	
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
 		// Flip the ON bit on/off using the XOR bitwise operation
-		NIBBLETYPE Meta = (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x08);
+		NIBBLETYPE Meta = (a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x08);
 
-		a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_LEVER, Meta); // SetMeta doesn't work for unpowering levers, so setblock
-		a_World->BroadcastSoundEffect("random.click", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, (Meta & 0x08) ? 0.6f : 0.5f);
+		a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_LEVER, Meta); // SetMeta doesn't work for unpowering levers, so setblock
+		a_WorldInterface.GetBroadcastManager().BroadcastSoundEffect("random.click", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, (Meta & 0x08) ? 0.6f : 0.5f);
 	}
 
 
@@ -39,8 +40,8 @@ public:
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -51,7 +52,7 @@ public:
 	}
 
 
-	inline static NIBBLETYPE LeverDirectionToMetaData(char a_Dir)
+	inline static NIBBLETYPE LeverDirectionToMetaData(eBlockFace a_Dir)
 	{
 		// Determine lever direction:
 		switch (a_Dir)
@@ -73,7 +74,7 @@ public:
 	}
 
 
-	inline static NIBBLETYPE BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
+	inline static eBlockFace BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
 	{
 		switch (a_Meta & 0x7)
 		{
@@ -94,7 +95,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		NIBBLETYPE Meta;
 		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
@@ -102,7 +103,37 @@ public:
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, BlockMetaDataToBlockFace(Meta), true);
 		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && (g_BlockIsSolid[BlockIsOn]);
+		return (a_RelY > 0) && cBlockInfo::IsSolid(BlockIsOn);
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		switch (a_Meta)
+		{
+			case 0x00: return 0x07;  // Ceiling rotation
+			case 0x07: return 0x00;
+
+			case 0x05: return 0x06;  // Ground rotation
+			case 0x06: return 0x05;
+
+			default:  return super::MetaRotateCCW(a_Meta);  // Wall Rotation
+		}
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		switch (a_Meta)
+		{
+			case 0x00: return 0x07;  // Ceiling rotation
+			case 0x07: return 0x00;
+
+			case 0x05: return 0x06;  // Ground rotation
+			case 0x06: return 0x05;
+
+			default:  return super::MetaRotateCCW(a_Meta);  // Wall Rotation
+		}
 	}
 } ;
 
diff --git a/src/Blocks/BlockLilypad.h b/src/Blocks/BlockLilypad.h
new file mode 100644
index 000000000..2dd4ec768
--- /dev/null
+++ b/src/Blocks/BlockLilypad.h
@@ -0,0 +1,28 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "Entities/Pickup.h"
+
+
+
+
+class cBlockLilypadHandler :
+	public cBlockHandler
+{
+public:
+	cBlockLilypadHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to zero
+		a_Pickups.push_back(cItem(E_BLOCK_LILY_PAD, 1, 0));
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockMobHead.h b/src/Blocks/BlockMobHead.h
new file mode 100644
index 000000000..acd1c88fb
--- /dev/null
+++ b/src/Blocks/BlockMobHead.h
@@ -0,0 +1,186 @@
+
+#pragma once
+
+#include "BlockEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+
+
+
+
+
+class cBlockMobHeadHandler :
+	public cBlockEntityHandler
+{
+public:
+	cBlockMobHeadHandler(BLOCKTYPE a_BlockType)
+		: cBlockEntityHandler(a_BlockType)
+	{
+	}
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_ITEM_HEAD, 1, 0));
+	}
+
+	bool TrySpawnWither(cChunkInterface & a_ChunkInterface, cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		if (a_BlockY < 2)
+		{
+			return false;
+		}
+
+		class cCallback : public cMobHeadCallback
+		{
+			bool m_IsWither;
+			
+			virtual bool Item (cMobHeadEntity * a_MobHeadEntity)
+			{
+				m_IsWither = (a_MobHeadEntity->GetType() == SKULL_TYPE_WITHER);
+
+				return false;
+			}
+		
+		public:
+			cCallback () : m_IsWither(false) {}
+
+			bool IsWither(void) const { return m_IsWither; }
+
+			void Reset(void) { m_IsWither = false; }
+		} CallbackA, CallbackB;
+
+		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, CallbackA);
+
+		if (!CallbackA.IsWither())
+		{
+			return false;
+		}
+
+		CallbackA.Reset();
+		
+		BLOCKTYPE BlockY1 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
+		BLOCKTYPE BlockY2 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 2, a_BlockZ);
+
+		if ((BlockY1 != E_BLOCK_SOULSAND) || (BlockY2 != E_BLOCK_SOULSAND))
+		{
+			return false;
+		}
+		
+		a_World->DoWithMobHeadAt(a_BlockX - 1, a_BlockY, a_BlockZ, CallbackA);
+		a_World->DoWithMobHeadAt(a_BlockX + 1, a_BlockY, a_BlockZ, CallbackB);
+
+		BLOCKTYPE Block1 = a_ChunkInterface.GetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ);
+		BLOCKTYPE Block2 = a_ChunkInterface.GetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ);
+
+		if ((Block1 == E_BLOCK_SOULSAND) && (Block2 == E_BLOCK_SOULSAND) && CallbackA.IsWither() && CallbackB.IsWither())
+		{
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
+
+			// Block entities
+			a_World->SetBlock(a_BlockX + 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX,     a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX - 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+
+			// Spawn the wither:
+			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+
+			return true;
+		}
+
+		CallbackA.Reset();
+		CallbackB.Reset();
+		
+		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ - 1, CallbackA);
+		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ + 1, CallbackB);
+
+		Block1 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1);
+		Block2 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1);
+
+		if ((Block1 == E_BLOCK_SOULSAND) && (Block2 == E_BLOCK_SOULSAND) && CallbackA.IsWither() && CallbackB.IsWither())
+		{
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
+
+			// Block entities
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ + 1, E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ - 1, E_BLOCK_AIR, 0);
+
+			// Spawn the wither:
+			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+
+			return true;
+		}
+
+		return false;
+	}
+	
+	virtual void OnPlacedByPlayer(
+		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
+	) override
+	{
+		class cCallback : public cMobHeadCallback
+		{
+			cPlayer * m_Player;
+			NIBBLETYPE m_OldBlockMeta;
+			NIBBLETYPE m_NewBlockMeta;
+			
+			virtual bool Item (cMobHeadEntity * a_MobHeadEntity)
+			{
+				int Rotation = 0;
+				if (m_NewBlockMeta == 1)
+				{
+					Rotation = (int) floor(m_Player->GetYaw() * 16.0F / 360.0F + 0.5) & 0xF;
+				}
+				
+				a_MobHeadEntity->SetType(static_cast<eMobHeadType>(m_OldBlockMeta));
+				a_MobHeadEntity->SetRotation(static_cast<eMobHeadRotation>(Rotation));
+				a_MobHeadEntity->GetWorld()->BroadcastBlockEntity(a_MobHeadEntity->GetPosX(), a_MobHeadEntity->GetPosY(), a_MobHeadEntity->GetPosZ(), m_Player->GetClientHandle());
+				return false;
+			}
+		
+		public:
+			cCallback (cPlayer * a_CBPlayer, NIBBLETYPE a_OldBlockMeta, NIBBLETYPE a_NewBlockMeta) :
+				m_Player(a_CBPlayer),
+				m_OldBlockMeta(a_OldBlockMeta),
+				m_NewBlockMeta(a_NewBlockMeta)
+			{}
+		};
+		cCallback Callback(a_Player, a_BlockMeta, static_cast<NIBBLETYPE>(a_BlockFace));
+		
+		a_BlockMeta = (NIBBLETYPE)a_BlockFace;
+		cWorld * World = (cWorld *) &a_WorldInterface;
+		World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, Callback);
+		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta);
+
+		if (a_BlockMeta == SKULL_TYPE_WITHER)
+		{
+			static const Vector3i Coords[] =
+			{
+				Vector3i( 0, 0,  0),
+				Vector3i( 1, 0,  0),
+				Vector3i(-1, 0,  0),
+				Vector3i( 0, 0,  1),
+				Vector3i( 0, 0, -1),
+			};
+			for (size_t i = 0; i < ARRAYCOUNT(Coords); ++i)
+			{
+				if (TrySpawnWither(a_ChunkInterface, World, a_BlockX + Coords[i].x, a_BlockY, a_BlockZ + Coords[i].z))
+				{
+					break;
+				}
+			}  // for i - Coords[]
+		}
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockMushroom.h b/src/Blocks/BlockMushroom.h
index 2846a6317..135d418d7 100644
--- a/src/Blocks/BlockMushroom.h
+++ b/src/Blocks/BlockMushroom.h
@@ -17,6 +17,9 @@ public:
 	}
 
 
+	// TODO: Add Mushroom Spread
+
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
@@ -24,7 +27,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if (a_RelY <= 0)
 		{
@@ -39,6 +42,7 @@ public:
 			case E_BLOCK_CACTUS:
 			case E_BLOCK_ICE:
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			case E_BLOCK_AIR:
 			{
 				return false;
diff --git a/src/Blocks/BlockMycelium.h b/src/Blocks/BlockMycelium.h
index 7f897c72a..2a8ef5fca 100644
--- a/src/Blocks/BlockMycelium.h
+++ b/src/Blocks/BlockMycelium.h
@@ -16,6 +16,8 @@ public:
 	{
 	}
 
+	// TODO: Add Mycel Spread
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		a_Pickups.push_back(cItem(E_BLOCK_DIRT, 1, 0));
diff --git a/src/Blocks/BlockNetherWart.h b/src/Blocks/BlockNetherWart.h
index 4cc3d989a..812cf906f 100644
--- a/src/Blocks/BlockNetherWart.h
+++ b/src/Blocks/BlockNetherWart.h
@@ -2,14 +2,13 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
+#include "../FastRandom.h"
 #include "../World.h"
 
 
 
 
 
-/// Common class that takes care of carrots, potatoes and wheat
 class cBlockNetherWartHandler :
 	public cBlockHandler
 {
@@ -22,12 +21,12 @@ public:
 	
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_Meta) override
 	{
-		MTRand rand;
+		cFastRandom rand;
 
 		if (a_Meta == 0x7)
 		{
-			// Is fully grown, drop the entire produce:
-			a_Pickups.push_back(cItem(E_ITEM_NETHER_WART, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));
+			// Fully grown, drop the entire produce:
+			a_Pickups.push_back(cItem(E_ITEM_NETHER_WART, (char)(1 + (rand.NextInt(3) + rand.NextInt(3))) / 2, 0));
 		}
 		else
 		{
@@ -35,18 +34,20 @@ public:
 		}
 	}
 
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
-	{
-		NIBBLETYPE Meta     = a_Chunk.GetMeta      (a_RelX, a_RelY, a_RelZ);
 
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
 		if (Meta < 7)
 		{
 			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_NETHER_WART, ++Meta);
 		}
 	}
+	
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
+		// Needs to be placed on top of a Soulsand block:
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_SOULSAND));
 	}
-} ;
\ No newline at end of file
+} ;
diff --git a/src/Blocks/BlockNewLeaves.h b/src/Blocks/BlockNewLeaves.h
new file mode 100644
index 000000000..5a267e8c6
--- /dev/null
+++ b/src/Blocks/BlockNewLeaves.h
@@ -0,0 +1,42 @@
+#pragma once
+#include "BlockHandler.h"
+#include "BlockLeaves.h"
+#include "../World.h"
+
+
+
+
+
+
+class cBlockNewLeavesHandler :
+	public cBlockLeavesHandler
+{
+public:
+	cBlockNewLeavesHandler(BLOCKTYPE a_BlockType)
+		: cBlockLeavesHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		MTRand rand;
+
+		// Only the first 2 bits contain the display information, the others are for growing
+		if (rand.randInt(5) == 0)
+		{
+			a_Pickups.push_back(cItem(E_BLOCK_SAPLING, 1, (a_BlockMeta & 3) + 4));
+		}
+	}
+
+
+	void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		cBlockHandler::OnDestroyed(a_ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
+	}
+} ;
+
+
+
+
+
diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp
index 88259d96e..542eb33b5 100644
--- a/src/Blocks/BlockPiston.cpp
+++ b/src/Blocks/BlockPiston.cpp
@@ -33,18 +33,18 @@ cBlockPistonHandler::cBlockPistonHandler(BLOCKTYPE a_BlockType)
 
 
 
-void cBlockPistonHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockPistonHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	NIBBLETYPE OldMeta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	NIBBLETYPE OldMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 
 	int newX = a_BlockX;
 	int newY = a_BlockY;
 	int newZ = a_BlockZ;
 	AddPistonDir(newX, newY, newZ, OldMeta & ~(8), 1);
 
-	if (a_World->GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION)
+	if (a_ChunkInterface.GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION)
 	{
-		a_World->SetBlock(newX, newY, newZ, E_BLOCK_AIR, 0);
+		a_ChunkInterface.SetBlock(a_WorldInterface, newX, newY, newZ, E_BLOCK_AIR, 0);
 	}
 }
 
@@ -53,8 +53,8 @@ void cBlockPistonHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_Bloc
 
 
 bool cBlockPistonHandler::GetPlacementBlockTypeMeta(
-	cWorld * a_World, cPlayer * a_Player,
-	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+	cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 	int a_CursorX, int a_CursorY, int a_CursorZ,
 	BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 )
@@ -80,19 +80,19 @@ cBlockPistonHeadHandler::cBlockPistonHeadHandler(void) :
 
 
 
-void cBlockPistonHeadHandler::OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+void cBlockPistonHeadHandler::OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
-	NIBBLETYPE OldMeta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	NIBBLETYPE OldMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 
 	int newX = a_BlockX;
 	int newY = a_BlockY;
 	int newZ = a_BlockZ;
 	AddPistonDir(newX, newY, newZ, OldMeta & ~(8), -1);
 
-	BLOCKTYPE Block = a_World->GetBlock(newX, newY, newZ);
+	BLOCKTYPE Block = a_ChunkInterface.GetBlock(newX, newY, newZ);
 	if ((Block == E_BLOCK_STICKY_PISTON) || (Block == E_BLOCK_PISTON))
 	{
-		a_World->DigBlock(newX, newY, newZ);
+		a_ChunkInterface.DigBlock(a_WorldInterface, newX, newY, newZ);
 		if (a_Player->IsGameModeCreative())
 		{
 			return; // No pickups if creative
@@ -100,7 +100,7 @@ void cBlockPistonHeadHandler::OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_
 
 		cItems Pickups;
 		Pickups.push_back(cItem(Block, 1));
-		a_World->SpawnItemPickups(Pickups, a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5);
+		a_WorldInterface.SpawnItemPickups(Pickups, a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5);
 	}
 }
 
diff --git a/src/Blocks/BlockPiston.h b/src/Blocks/BlockPiston.h
index 36fa6a572..7632b5e5a 100644
--- a/src/Blocks/BlockPiston.h
+++ b/src/Blocks/BlockPiston.h
@@ -13,11 +13,11 @@ class cBlockPistonHandler :
 public:
 	cBlockPistonHandler(BLOCKTYPE a_BlockType);
 	
-	virtual void OnDestroyed(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override;
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override;
@@ -35,7 +35,7 @@ class cBlockPistonHeadHandler :
 public:
 	cBlockPistonHeadHandler(void);
 	
-	virtual void OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override;
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
diff --git a/src/Blocks/BlockPlanks.h b/src/Blocks/BlockPlanks.h
index f3b8dbfb6..2a99a455e 100644
--- a/src/Blocks/BlockPlanks.h
+++ b/src/Blocks/BlockPlanks.h
@@ -17,8 +17,8 @@ public:
 
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Blocks/BlockPluginInterface.h b/src/Blocks/BlockPluginInterface.h
new file mode 100644
index 000000000..3a36c40b1
--- /dev/null
+++ b/src/Blocks/BlockPluginInterface.h
@@ -0,0 +1,14 @@
+
+#pragma once
+
+/** This interface is used to decouple block handlers from the cPluginManager dependancy through cWorld.
+The block handlers call this interface, which is then implemented by the specific classes that
+the caller provides.
+*/
+class cBlockPluginInterface
+{
+public:
+	virtual ~cBlockPluginInterface() {}
+	
+	virtual bool CallHookBlockToPickups(cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) = 0;
+};
diff --git a/src/Blocks/BlockPortal.h b/src/Blocks/BlockPortal.h
index d88d14fc9..21bcbdeea 100644
--- a/src/Blocks/BlockPortal.h
+++ b/src/Blocks/BlockPortal.h
@@ -17,8 +17,8 @@ public:
 	}
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -39,7 +39,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if ((a_RelY - 1 < 0) || (a_RelY + 1 > cChunkDef::Height))
 		{
diff --git a/src/Blocks/BlockPumpkin.h b/src/Blocks/BlockPumpkin.h
index 5187f24eb..ac2b9817a 100644
--- a/src/Blocks/BlockPumpkin.h
+++ b/src/Blocks/BlockPumpkin.h
@@ -1,20 +1,20 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 class cBlockPumpkinHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x02, 0x03, 0x00, 0x01, false>
 {
 public:
 	cBlockPumpkinHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x02, 0x03, 0x00, 0x01, false>(a_BlockType)
 	{
 	}
 	
-	virtual void OnPlacedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
+	virtual void OnPlacedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
 	{
 		// Check whether the pumpkin is a part of a golem or a snowman
 		
@@ -24,16 +24,16 @@ public:
 			return;
 		}
 		
-		BLOCKTYPE BlockY1 = a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
-		BLOCKTYPE BlockY2 = a_World->GetBlock(a_BlockX, a_BlockY - 2, a_BlockZ);
+		BLOCKTYPE BlockY1 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
+		BLOCKTYPE BlockY2 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 2, a_BlockZ);
 		
 		// Check for a snow golem:
 		if ((BlockY1 == E_BLOCK_SNOW_BLOCK) && (BlockY2 == E_BLOCK_SNOW_BLOCK))
 		{
-			a_World->FastSetBlock(a_BlockX, a_BlockY,     a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtSnowGolem);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY,     a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtSnowGolem);
 			return;
 		}
 		
@@ -46,41 +46,41 @@ public:
 		
 		// Now check both orientations for hands:
 		if (
-			(a_World->GetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ) == E_BLOCK_IRON_BLOCK) &&
-			(a_World->GetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ) == E_BLOCK_IRON_BLOCK)
+			(a_ChunkInterface.GetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ) == E_BLOCK_IRON_BLOCK) &&
+			(a_ChunkInterface.GetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ) == E_BLOCK_IRON_BLOCK)
 		)
 		{
 			// Remove the iron blocks:
-			a_World->FastSetBlock(a_BlockX,     a_BlockY,     a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX,     a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY,     a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
 			
 			// Spawn the golem:
-			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem);
 		}
 		else if (
-			(a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1) == E_BLOCK_IRON_BLOCK) &&
-			(a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1) == E_BLOCK_IRON_BLOCK)
+			(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1) == E_BLOCK_IRON_BLOCK) &&
+			(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1) == E_BLOCK_IRON_BLOCK)
 		)
 		{
 			// Remove the iron blocks:
-			a_World->FastSetBlock(a_BlockX, a_BlockY,     a_BlockZ,     E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ,     E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1, E_BLOCK_AIR, 0);
-			a_World->FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY,     a_BlockZ,     E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
 			
 			// Spawn the golem:
-			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem); 
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem); 
 		}
 	}
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Blocks/BlockQuartz.h b/src/Blocks/BlockQuartz.h
new file mode 100644
index 000000000..9cc51490f
--- /dev/null
+++ b/src/Blocks/BlockQuartz.h
@@ -0,0 +1,67 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockQuartzHandler : public cBlockHandler
+{
+public:
+	cBlockQuartzHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
+		if (Meta != E_META_QUARTZ_PILLAR) // Check if the block is a pillar block.
+		{
+			a_BlockMeta = Meta;
+			return true;
+		}
+
+		a_BlockMeta = BlockFaceToMetaData(a_BlockFace, Meta);
+		return true;
+	}
+
+	inline static NIBBLETYPE BlockFaceToMetaData(eBlockFace a_BlockFace, NIBBLETYPE a_QuartzMeta)
+	{
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_YM:
+			case BLOCK_FACE_YP:
+			{
+				return a_QuartzMeta; // Top or bottom, just return original
+			}
+
+			case BLOCK_FACE_ZP:
+			case BLOCK_FACE_ZM:
+			{
+				return 0x4; // North or south
+			}
+
+			case BLOCK_FACE_XP:
+			case BLOCK_FACE_XM:
+			{
+				return 0x3; // East or west
+			}
+
+			default:
+			{
+				ASSERT(!"Unhandled block face!");
+				return a_QuartzMeta; // No idea, give a special meta (all sides the same)
+			}
+		}
+	}
+} ;
diff --git a/src/Blocks/BlockRail.h b/src/Blocks/BlockRail.h
index 55cadfa48..ad78d290a 100644
--- a/src/Blocks/BlockRail.h
+++ b/src/Blocks/BlockRail.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockEntity.h"
-#include "../World.h"
 
 
 
@@ -31,58 +30,58 @@ public:
 	}
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
 		a_BlockType = m_BlockType;
-		a_BlockMeta = FindMeta(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		a_BlockMeta = FindMeta(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
 		return true;
 	}
 
 
-	virtual void OnPlaced(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
+	virtual void OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
 	{
-		super::OnPlaced(a_World, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+		super::OnPlaced(a_ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 
 		// Alert diagonal rails
-		OnNeighborChanged(a_World, a_BlockX + 1, a_BlockY + 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX - 1, a_BlockY + 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ + 1);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ - 1);
-
-		OnNeighborChanged(a_World, a_BlockX + 1, a_BlockY - 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX - 1, a_BlockY - 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ + 1);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ - 1);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX + 1, a_BlockY + 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX - 1, a_BlockY + 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ + 1);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ - 1);
+
+		OnNeighborChanged(a_ChunkInterface, a_BlockX + 1, a_BlockY - 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX - 1, a_BlockY - 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ + 1);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ - 1);
 	}
 
 
-	virtual void OnDestroyed(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
-		super::OnDestroyed(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		super::OnDestroyed(a_ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
 
 		// Alert diagonal rails
-		OnNeighborChanged(a_World, a_BlockX + 1, a_BlockY + 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX - 1, a_BlockY + 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ + 1);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ - 1);
-
-		OnNeighborChanged(a_World, a_BlockX + 1, a_BlockY - 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX - 1, a_BlockY - 1, a_BlockZ);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ + 1);
-		OnNeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ - 1);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX + 1, a_BlockY + 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX - 1, a_BlockY + 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ + 1);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ - 1);
+
+		OnNeighborChanged(a_ChunkInterface, a_BlockX + 1, a_BlockY - 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX - 1, a_BlockY - 1, a_BlockZ);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ + 1);
+		OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ - 1);
 	}
 
 
-	virtual void OnNeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	virtual void OnNeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
-		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-		if (IsUnstable(a_World, a_BlockX, a_BlockY, a_BlockZ) && (Meta != FindMeta(a_World, a_BlockX, a_BlockY, a_BlockZ)))
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		if (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ) && (Meta != FindMeta(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ)))
 		{
-			a_World->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_BlockType, FindMeta(a_World, a_BlockX, a_BlockY, a_BlockZ));
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_BlockType, FindMeta(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ));
 		}
 	}
 
@@ -93,13 +92,13 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if (a_RelY <= 0)
 		{
 			return false;
 		}
-		if (!g_BlockIsSolid[a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)])
+		if (!cBlockInfo::IsSolid(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)))
 		{
 			return false;
 		}
@@ -131,33 +130,33 @@ public:
 					// Too close to the edge, cannot simulate
 					return true;
 				}
-				return g_BlockIsSolid[BlockType];
+				return cBlockInfo::IsSolid(BlockType);
 			}
 		}
 		return true;
 	}
 
-	NIBBLETYPE FindMeta(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	NIBBLETYPE FindMeta(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		NIBBLETYPE Meta = 0;
 		char RailsCnt = 0;
 		bool Neighbors[8]; // 0 - EAST, 1 - WEST, 2 - NORTH, 3 - SOUTH, 4 - EAST UP, 5 - WEST UP, 6 - NORTH UP, 7 - SOUTH UP
 		memset(Neighbors, false, sizeof(Neighbors));
-		Neighbors[0] = (IsUnstable(a_World, a_BlockX + 1, a_BlockY, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST, E_PURE_DOWN));
-		Neighbors[1] = (IsUnstable(a_World, a_BlockX - 1, a_BlockY, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST, E_PURE_DOWN));
-		Neighbors[2] = (IsUnstable(a_World, a_BlockX, a_BlockY, a_BlockZ - 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_DOWN));
-		Neighbors[3] = (IsUnstable(a_World, a_BlockX, a_BlockY, a_BlockZ + 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_DOWN));
-		Neighbors[4] = (IsUnstable(a_World, a_BlockX + 1, a_BlockY + 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_EAST, E_PURE_NONE));
-		Neighbors[5] = (IsUnstable(a_World, a_BlockX - 1, a_BlockY + 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_WEST, E_PURE_NONE));
-		Neighbors[6] = (IsUnstable(a_World, a_BlockX, a_BlockY + 1, a_BlockZ - 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_NONE));
-		Neighbors[7] = (IsUnstable(a_World, a_BlockX, a_BlockY + 1, a_BlockZ + 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_NONE));
-		if (IsUnstable(a_World, a_BlockX + 1, a_BlockY - 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_EAST))
+		Neighbors[0] = (IsUnstable(a_ChunkInterface, a_BlockX + 1, a_BlockY, a_BlockZ) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST, E_PURE_DOWN));
+		Neighbors[1] = (IsUnstable(a_ChunkInterface, a_BlockX - 1, a_BlockY, a_BlockZ) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST, E_PURE_DOWN));
+		Neighbors[2] = (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ - 1) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_DOWN));
+		Neighbors[3] = (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ + 1) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_DOWN));
+		Neighbors[4] = (IsUnstable(a_ChunkInterface, a_BlockX + 1, a_BlockY + 1, a_BlockZ) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_EAST, E_PURE_NONE));
+		Neighbors[5] = (IsUnstable(a_ChunkInterface, a_BlockX - 1, a_BlockY + 1, a_BlockZ) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_WEST, E_PURE_NONE));
+		Neighbors[6] = (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ - 1) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_NONE));
+		Neighbors[7] = (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ + 1) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_NONE));
+		if (IsUnstable(a_ChunkInterface, a_BlockX + 1, a_BlockY - 1, a_BlockZ) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_EAST))
 			Neighbors[0] = true;
-		if (IsUnstable(a_World, a_BlockX - 1, a_BlockY - 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_WEST))
+		if (IsUnstable(a_ChunkInterface, a_BlockX - 1, a_BlockY - 1, a_BlockZ) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_WEST))
 			Neighbors[1] = true;
-		if (IsUnstable(a_World, a_BlockX, a_BlockY - 1, a_BlockZ - 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_NORTH))
+		if (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ - 1) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_NORTH))
 			Neighbors[2] = true;
-		if (IsUnstable(a_World, a_BlockX, a_BlockY - 1, a_BlockZ + 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_SOUTH))
+		if (IsUnstable(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ + 1) || !IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_SOUTH))
 			Neighbors[3] = true;
 		for (int i = 0; i < 8; i++)
 		{
@@ -186,36 +185,46 @@ public:
 		}
 		if (RailsCnt > 1)
 		{
-			if      (Neighbors[3] && Neighbors[0]) return E_META_RAIL_CURVED_ZP_XP;
-			else if (Neighbors[3] && Neighbors[1]) return E_META_RAIL_CURVED_ZP_XM;
-			else if (Neighbors[2] && Neighbors[0]) return E_META_RAIL_CURVED_ZM_XP;
-			else if (Neighbors[2] && Neighbors[1]) return E_META_RAIL_CURVED_ZM_XM;
+			if      (Neighbors[3] && Neighbors[0] && CanThisRailCurve()) return E_META_RAIL_CURVED_ZP_XP;
+			else if (Neighbors[3] && Neighbors[1] && CanThisRailCurve()) return E_META_RAIL_CURVED_ZP_XM;
+			else if (Neighbors[2] && Neighbors[0] && CanThisRailCurve()) return E_META_RAIL_CURVED_ZM_XP;
+			else if (Neighbors[2] && Neighbors[1] && CanThisRailCurve()) return E_META_RAIL_CURVED_ZM_XM;
 			else if (Neighbors[7] && Neighbors[2]) return E_META_RAIL_ASCEND_ZP;
 			else if (Neighbors[3] && Neighbors[6]) return E_META_RAIL_ASCEND_ZM;
 			else if (Neighbors[5] && Neighbors[0]) return E_META_RAIL_ASCEND_XM;
 			else if (Neighbors[4] && Neighbors[1]) return E_META_RAIL_ASCEND_XP;
 			else if (Neighbors[0] && Neighbors[1]) return E_META_RAIL_XM_XP;
 			else if (Neighbors[2] && Neighbors[3]) return E_META_RAIL_ZM_ZP;
-			ASSERT(!"Weird neighbor count");
+
+			if (CanThisRailCurve())
+			{
+				ASSERT(!"Weird neighbor count");
+			}
 		}
 		return Meta;
 	}
 
 
-	bool IsUnstable(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	inline bool CanThisRailCurve(void)
+	{
+		return m_BlockType == E_BLOCK_RAIL;
+	}
+
+
+	bool IsUnstable(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
-		if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) != E_BLOCK_RAIL)
+		if (!IsBlockRail(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)))
 		{
 			return false;
 		}
-		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		switch (Meta)
 		{
 			case E_META_RAIL_ZM_ZP:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_DOWN) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_DOWN)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_DOWN) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_DOWN)
 				)
 				{
 					return true;
@@ -226,8 +235,8 @@ public:
 			case E_META_RAIL_XM_XP:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST, E_PURE_DOWN) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST, E_PURE_DOWN)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST, E_PURE_DOWN) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST, E_PURE_DOWN)
 				)
 				{
 					return true;
@@ -238,8 +247,8 @@ public:
 			case E_META_RAIL_ASCEND_XP:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_EAST) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_EAST) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
 				)
 				{
 					return true;
@@ -250,8 +259,8 @@ public:
 			case E_META_RAIL_ASCEND_XM:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_WEST)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_WEST)
 				)
 				{
 					return true;
@@ -262,8 +271,8 @@ public:
 			case E_META_RAIL_ASCEND_ZM:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_NORTH) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH)
 				)
 				{
 					return true;
@@ -274,8 +283,8 @@ public:
 			case E_META_RAIL_ASCEND_ZP:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_SOUTH)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_SOUTH)
 				)
 				{
 					return true;
@@ -286,8 +295,8 @@ public:
 			case E_META_RAIL_CURVED_ZP_XP:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST)
 				)
 				{
 					return true;
@@ -298,8 +307,8 @@ public:
 			case E_META_RAIL_CURVED_ZP_XM:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
 				)
 				{
 					return true;
@@ -310,8 +319,8 @@ public:
 			case E_META_RAIL_CURVED_ZM_XM:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
 				)
 				{
 					return true;
@@ -322,8 +331,8 @@ public:
 			case E_META_RAIL_CURVED_ZM_XP:
 			{
 				if (
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
-					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST)
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST)
 				)
 				{
 					return true;
@@ -335,31 +344,31 @@ public:
 	}
 
 
-	bool IsNotConnected(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Pure = 0)
+	bool IsNotConnected(cChunkInterface  & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, char a_Pure = 0)
 	{
 		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, false);
 		NIBBLETYPE Meta;
-		if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) != E_BLOCK_RAIL)
+		if (!IsBlockRail(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)))
 		{
-			if ((a_World->GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ) != E_BLOCK_RAIL) || (a_Pure != E_PURE_UPDOWN))
+			if (!IsBlockRail(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ)) || (a_Pure != E_PURE_UPDOWN))
 			{
-				if ((a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ) != E_BLOCK_RAIL) || (a_Pure == E_PURE_NONE))
+				if (!IsBlockRail(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ)) || (a_Pure == E_PURE_NONE))
 				{
 					return true;
 				}
 				else
 				{
-					Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY - 1, a_BlockZ);
+					Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY - 1, a_BlockZ);
 				}
 			}
 			else
 			{
-				Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY + 1, a_BlockZ);
+				Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY + 1, a_BlockZ);
 			}
 		}
 		else
 		{
-			Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+			Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		}
 		
 		switch (a_BlockFace)
@@ -422,9 +431,145 @@ public:
 				}
 				break;
 			}
+			default: break;
 		}
 		return true;
 	}
+
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag when a_Meta is in the range 0x00--0x05 and 0x0A--0x0F.
+		// Bit 0x08 specifies direction when a_Meta is in the range 0x06-0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Rotates according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x00: return 0x01 + OtherMeta;  // North/South -> East/West
+				case 0x01: return 0x00 + OtherMeta;  // East/West   -> North/South
+
+				case 0x02: return 0x04 + OtherMeta;  // Asc. East   -> Asc. North
+				case 0x04: return 0x03 + OtherMeta;  // Asc. North  -> Asc. West
+				case 0x03: return 0x05 + OtherMeta;  // Asc. West   -> Asc. South
+				case 0x05: return 0x02 + OtherMeta;  // Asc. South  -> Asc. East
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x09;  // Northwest Cnr. -> Southwest Cnr.
+				case 0x07: return 0x06;  // Northeast Cnr. -> Northwest Cnr.
+				case 0x08: return 0x07;  // Southeast Cnr. -> Northeast Cnr.
+				case 0x09: return 0x08;  // Southwest Cnr. -> Southeast Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag for value in the range 0x00--0x05 and specifies direction for values withint 0x006--0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Rotates according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x00: return 0x01 + OtherMeta;  // North/South -> East/West
+				case 0x01: return 0x00 + OtherMeta;  // East/West   -> North/South
+
+				case 0x02: return 0x05 + OtherMeta;  // Asc. East   -> Asc. South
+				case 0x05: return 0x03 + OtherMeta;  // Asc. South  -> Asc. West
+				case 0x03: return 0x04 + OtherMeta;  // Asc. West   -> Asc. North
+				case 0x04: return 0x02 + OtherMeta;  // Asc. North  -> Asc. East
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x07;  // Northwest Cnr. -> Northeast Cnr.
+				case 0x07: return 0x08;  // Northeast Cnr. -> Southeast Cnr.
+				case 0x08: return 0x09;  // Southeast Cnr. -> Southwest Cnr.
+				case 0x09: return 0x06;  // Southwest Cnr. -> Northwest Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag for value in the range 0x00--0x05 and specifies direction for values withint 0x006--0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Mirrors according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x05: return 0x04 + OtherMeta;  // Asc. South  -> Asc. North
+				case 0x04: return 0x05 + OtherMeta;  // Asc. North  -> Asc. South
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x09;  // Northwest Cnr. -> Southwest Cnr.
+				case 0x07: return 0x08;  // Northeast Cnr. -> Southeast Cnr.
+				case 0x08: return 0x07;  // Southeast Cnr. -> Northeast Cnr.
+				case 0x09: return 0x06;  // Southwest Cnr. -> Northwest Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag for value in the range 0x00--0x05 and specifies direction for values withint 0x006--0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Mirrors according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x02: return 0x03 + OtherMeta;  // Asc. East   -> Asc. West
+				case 0x03: return 0x02 + OtherMeta;  // Asc. West   -> Asc. East
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x07;  // Northwest Cnr. -> Northeast Cnr.
+				case 0x07: return 0x06;  // Northeast Cnr. -> Northwest Cnr.
+				case 0x08: return 0x09;  // Southeast Cnr. -> Southwest Cnr.
+				case 0x09: return 0x08;  // Southwest Cnr. -> Southeast Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockRedstone.h b/src/Blocks/BlockRedstone.h
index 5ffb77fb6..a898c9acb 100644
--- a/src/Blocks/BlockRedstone.h
+++ b/src/Blocks/BlockRedstone.h
@@ -18,9 +18,9 @@ public:
 	}
 	
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
-		return ((a_RelY > 0) && g_BlockFullyOccupiesVoxel[a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)]);
+		return ((a_RelY > 0) && cBlockInfo::FullyOccupiesVoxel(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)));
 	}
 	
 	
diff --git a/src/Blocks/BlockRedstoneRepeater.h b/src/Blocks/BlockRedstoneRepeater.h
index 713664659..fe6cd21b9 100644
--- a/src/Blocks/BlockRedstoneRepeater.h
+++ b/src/Blocks/BlockRedstoneRepeater.h
@@ -2,24 +2,25 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "Chunk.h"
+#include "MetaRotator.h"
 
 
 
 
 class cBlockRedstoneRepeaterHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>
 {
 public:
 	cBlockRedstoneRepeaterHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>(a_BlockType)
 	{
 	}
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 		) override
@@ -28,11 +29,18 @@ public:
 		a_BlockMeta = RepeaterRotationToMetaData(a_Player->GetYaw());
 		return true;
 	}
-	
 
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, ((a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) + 0x04) & 0x0f));
+	}
+
+
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
 	{
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, ((a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) + 0x04) & 0x0f));
+		UNUSED(a_ChunkInterface);
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
 	}
 
 
@@ -49,7 +57,7 @@ public:
 	}
 	
 	
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
 	}
diff --git a/src/Blocks/BlockSapling.h b/src/Blocks/BlockSapling.h
index 0dcae1f93..3d925029a 100644
--- a/src/Blocks/BlockSapling.h
+++ b/src/Blocks/BlockSapling.h
@@ -25,13 +25,13 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return (a_RelY > 0) && IsBlockTypeOfDirt(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ));
 	}
 	
 
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
 		
diff --git a/src/Blocks/BlockSideways.h b/src/Blocks/BlockSideways.h
new file mode 100644
index 000000000..d67c3aa24
--- /dev/null
+++ b/src/Blocks/BlockSideways.h
@@ -0,0 +1,78 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockSidewaysHandler : public cBlockHandler
+{
+public:
+	cBlockSidewaysHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
+		a_BlockMeta = BlockFaceToMetaData(a_BlockFace, Meta);
+		return true;
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.Add(m_BlockType, 1, a_BlockMeta & 0x3);
+	}
+
+
+	inline static NIBBLETYPE BlockFaceToMetaData(eBlockFace a_BlockFace, NIBBLETYPE a_WoodMeta)
+	{
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_YM:
+			case BLOCK_FACE_YP:
+			{
+				return a_WoodMeta; // Top or bottom, just return original
+			}
+
+			case BLOCK_FACE_ZP:
+			case BLOCK_FACE_ZM:
+			{
+				return a_WoodMeta | 0x8; // North or south
+			}
+
+			case BLOCK_FACE_XP:
+			case BLOCK_FACE_XM:
+			{
+				return a_WoodMeta | 0x4; // East or west
+			}
+
+			default:
+			{
+				ASSERT(!"Unhandled block face!");
+				return a_WoodMeta | 0xC; // No idea, give a special meta (all sides bark)
+			}
+		}
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockSign.h b/src/Blocks/BlockSign.h
index 7fbe61893..9d6fede21 100644
--- a/src/Blocks/BlockSign.h
+++ b/src/Blocks/BlockSign.h
@@ -2,8 +2,8 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../World.h"
 #include "../Entities/Player.h"
+#include "Chunk.h"
 
 
 
@@ -31,7 +31,7 @@ public:
 	}
 
 
-	static char RotationToMetaData(double a_Rotation)
+	static NIBBLETYPE RotationToMetaData(double a_Rotation)
 	{
 		a_Rotation += 180 + (180 / 16);  // So it's not aligned with axis
 		if (a_Rotation > 360)
@@ -45,7 +45,7 @@ public:
 	}
 	
 	
-	static char DirectionToMetaData(char a_Direction)
+	static NIBBLETYPE DirectionToMetaData(eBlockFace a_Direction)
 	{
 		switch (a_Direction)
 		{
@@ -63,14 +63,45 @@ public:
 
 
 	virtual void OnPlacedByPlayer(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	) override
 	{
 		a_Player->GetClientHandle()->SendEditSign(a_BlockX, a_BlockY, a_BlockZ);
 	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		return (++a_Meta) & 0x0F;
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		return (--a_Meta) & 0x0F;
+	}
+
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
+	{
+		//  Mirrors signs over the XY plane (North-South Mirroring)
+
+		//  There are 16 meta values which correspond to different directions.
+		//  These values are equated to angles on a circle; 0x08 = 180 degrees.
+		return (a_Meta < 0x08) ? 0x08 + a_Meta : 0x08 - a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
+	{
+		//  Mirrors signs over the YZ plane (East-West Mirroring)
+
+		//  There are 16 meta values which correspond to different directions.
+		//  These values are equated to angles on a circle; 0x10 = 360 degrees.
+		return 0x10 - a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockSlab.h b/src/Blocks/BlockSlab.h
index 7c1251b28..76f5ed0e7 100644
--- a/src/Blocks/BlockSlab.h
+++ b/src/Blocks/BlockSlab.h
@@ -11,8 +11,7 @@
 
 #include "BlockHandler.h"
 #include "../Items/ItemHandler.h"
-
-
+#include "Root.h"
 
 
 
@@ -28,53 +27,21 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		a_Pickups.push_back(cItem(m_BlockType, 1, a_BlockMeta));
+		a_Pickups.push_back(cItem(m_BlockType, 1, a_BlockMeta & 0x7));
 	}
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
 		a_BlockType = m_BlockType;
-		BLOCKTYPE  Type = (BLOCKTYPE) (a_Player->GetEquippedItem().m_ItemType);
-		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage & 0x07);
+		NIBBLETYPE Meta = (NIBBLETYPE) a_Player->GetEquippedItem().m_ItemDamage;
 		
-		// HandlePlaceBlock wants a cItemHandler pointer thing, so let's give it one
-		cItemHandler * ItemHandler = cItemHandler::GetItemHandler(GetDoubleSlabType(Type));
-
-		// Check if the block at the coordinates is a slab. Eligibility for combining has already been processed in ClientHandle
-		if (IsAnySlabType(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			// Call the function in ClientHandle that places a block when the client sends the packet,
-			// so that plugins may interfere with the placement.
-			
-			if ((a_BlockFace == BLOCK_FACE_TOP) || (a_BlockFace == BLOCK_FACE_BOTTOM))
-			{
-				// Top and bottom faces need no parameter modification
-				a_Player->GetClientHandle()->HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
-			}
-			else
-			{
-				// The other faces need to distinguish between top and bottom cursor positions
-				if (a_CursorY > 7)
-				{
-					// Edit the call to use BLOCK_FACE_BOTTOM, otherwise it places incorrectly
-					a_Player->GetClientHandle()->HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_TOP, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
-				}
-				else
-				{
-					// Edit the call to use BLOCK_FACE_TOP, otherwise it places incorrectly
-					a_Player->GetClientHandle()->HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_BOTTOM, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
-				}
-			}
-			return false;  // Cancel the event, because dblslabs were already placed, nothing else needed
-		}
-		
-		// Place the single-slab with correct metas:
+		// Set the correct metadata based on player equipped item (i.e. a_BlockMeta not initialised yet)
 		switch (a_BlockFace)
 		{
 			case BLOCK_FACE_TOP:
@@ -105,7 +72,16 @@ public:
 					a_BlockMeta = Meta & 0x7; break;
 				}
 			}
+			case BLOCK_FACE_NONE: return false;
 		}  // switch (a_BlockFace)
+
+		// Check if the block at the coordinates is a single slab. Eligibility for combining has already been processed in ClientHandle
+		// Changed to-be-placed to a double slab if we are clicking on a single slab, as opposed to placing one for the first time
+		if (IsAnySlabType(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			a_BlockType = GetDoubleSlabType(m_BlockType);
+		}
+
 		return true;
 	}
 	
@@ -159,21 +135,39 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		if (m_BlockType ==  E_BLOCK_DOUBLE_STONE_SLAB)
+		BLOCKTYPE Block = GetSingleSlabType(m_BlockType);
+		a_Pickups.push_back(cItem(Block, 2, a_BlockMeta & 0x7));
+	}
+	
+	inline static BLOCKTYPE GetSingleSlabType(BLOCKTYPE a_BlockType)
+	{
+		switch (a_BlockType)
 		{
-			m_BlockType = E_BLOCK_STONE_SLAB;
+			case E_BLOCK_DOUBLE_STONE_SLAB:  return E_BLOCK_STONE_SLAB;
+			case E_BLOCK_DOUBLE_WOODEN_SLAB: return E_BLOCK_WOODEN_SLAB;
 		}
-		else
+		ASSERT(!"Unhandled double slab type!");
+		return a_BlockType;
+	}
+	
+	virtual const char * GetStepSound(void) override
+	{
+		switch (m_BlockType)
 		{
-			m_BlockType = E_BLOCK_WOODEN_SLAB;
+			case E_BLOCK_DOUBLE_STONE_SLAB:  return "step.stone";
+			case E_BLOCK_DOUBLE_WOODEN_SLAB: return "step.wood";
 		}
-		a_Pickups.push_back(cItem(m_BlockType, 2, a_BlockMeta));
+		ASSERT(!"Unhandled double slab type!");
+		return "";
 	}
 
-	
-	virtual const char * GetStepSound(void) override
-	{		
-		return ((m_BlockType == E_BLOCK_DOUBLE_WOODEN_SLAB) || (m_BlockType == E_BLOCK_DOUBLE_WOODEN_SLAB)) ?  "step.wood" : "step.stone";
+
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
+	{
+		NIBBLETYPE OtherMeta = a_Meta & 0x07;  // Contains unrelated meta data.
+
+		// 8th bit is up/down.  1 right-side-up, 0 is up-side-down.
+		return (a_Meta & 0x08) ? 0x00 + OtherMeta : 0x01 + OtherMeta;
 	}
 } ;
 
diff --git a/src/Blocks/BlockSnow.h b/src/Blocks/BlockSnow.h
index d7fd1e19e..b21995d3c 100644
--- a/src/Blocks/BlockSnow.h
+++ b/src/Blocks/BlockSnow.h
@@ -18,8 +18,8 @@ public:
 
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -28,7 +28,7 @@ public:
 
 		BLOCKTYPE BlockBeforePlacement;
 		NIBBLETYPE MetaBeforePlacement;
-		a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockBeforePlacement, MetaBeforePlacement);
+		a_ChunkInterface.GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockBeforePlacement, MetaBeforePlacement);
 
 		if ((BlockBeforePlacement == E_BLOCK_SNOW) && (MetaBeforePlacement < 7))
 		{
@@ -65,14 +65,14 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if (a_RelY > 0)
 		{
 			BLOCKTYPE BlockBelow = a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ);
 			NIBBLETYPE MetaBelow = a_Chunk.GetMeta(a_RelX, a_RelY - 1, a_RelZ);
 			
-			if (g_BlockIsSnowable[BlockBelow] || ((BlockBelow == E_BLOCK_SNOW) && (MetaBelow == 7)))
+			if (cBlockInfo::IsSnowable(BlockBelow) || ((BlockBelow == E_BLOCK_SNOW) && (MetaBelow == 7)))
 			{
 				// If block below is snowable, or it is a thin slow block and has a meta of 7 (full thin snow block), say yay
 				return true;
diff --git a/src/Blocks/BlockStairs.h b/src/Blocks/BlockStairs.h
index e463612f5..09ff254a6 100644
--- a/src/Blocks/BlockStairs.h
+++ b/src/Blocks/BlockStairs.h
@@ -2,29 +2,35 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockStairsHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>
 {
 public:
 	cBlockStairsHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cMetaRotator<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>(a_BlockType)
 	{
 
 	}
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
+		UNUSED(a_ChunkInterface);
+		UNUSED(a_BlockX);
+		UNUSED(a_BlockY);
+		UNUSED(a_BlockZ);
+		UNUSED(a_CursorX);
+		UNUSED(a_CursorZ);
 		a_BlockType = m_BlockType;
 		a_BlockMeta = RotationToMetaData(a_Player->GetYaw());
 		switch (a_BlockFace)
@@ -43,10 +49,12 @@ public:
 				}
 				break;
 			}
+			case BLOCK_FACE_NONE: return false;
 		}
 		return true;
 	}
 	
+	
 	virtual const char * GetStepSound(void) override
 	{
 		if (
@@ -96,54 +104,6 @@ public:
 	}
 
 
-	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x03;  // East -> North
-			case 0x01: return TopBits | 0x02;  // West -> South
-			case 0x02: return TopBits | 0x00;  // South -> East
-			case 0x03: return TopBits | 0x01;  // North -> West
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
-
-
-	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x02;  // East -> South
-			case 0x01: return TopBits | 0x03;  // West -> North
-			case 0x02: return TopBits | 0x01;  // South -> West
-			case 0x03: return TopBits | 0x00;  // North -> East
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
-
-
-	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x00;  // East -> East
-			case 0x01: return TopBits | 0x01;  // West -> West
-			case 0x02: return TopBits | 0x03;  // South -> North
-			case 0x03: return TopBits | 0x02;  // North -> South
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
-
-
 	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
 	{
 		// Toggle bit 3:
@@ -151,20 +111,6 @@ public:
 	}
 
 
-	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x01;  // East -> West
-			case 0x01: return TopBits | 0x00;  // West -> East
-			case 0x02: return TopBits | 0x02;  // South -> South
-			case 0x03: return TopBits | 0x03;  // North -> North
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockStems.h b/src/Blocks/BlockStems.h
index d860639a5..b726a0901 100644
--- a/src/Blocks/BlockStems.h
+++ b/src/Blocks/BlockStems.h
@@ -17,14 +17,15 @@ public:
 	{
 	}
 
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		int ItemType = (m_BlockType == E_BLOCK_MELON_STEM) ? E_ITEM_MELON_SEEDS : E_ITEM_PUMPKIN_SEEDS;
+		short ItemType = (m_BlockType == E_BLOCK_MELON_STEM) ? E_ITEM_MELON_SEEDS : E_ITEM_PUMPKIN_SEEDS;
 		a_Pickups.push_back(cItem(ItemType, 1, 0));
 	}
 
 	
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
 		if (Meta >= 7)
@@ -42,7 +43,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_FARMLAND));
 	}
diff --git a/src/Blocks/BlockSugarcane.h b/src/Blocks/BlockSugarcane.h
index 9cff94800..84d3b2e7d 100644
--- a/src/Blocks/BlockSugarcane.h
+++ b/src/Blocks/BlockSugarcane.h
@@ -23,7 +23,7 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if (a_RelY <= 0)
 		{
@@ -73,7 +73,7 @@ public:
 	}
 	
 	
-	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
 		a_Chunk.GetWorld()->GrowSugarcane(a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width, 1);
 	}
diff --git a/src/Blocks/BlockTNT.h b/src/Blocks/BlockTNT.h
new file mode 100644
index 000000000..283a03730
--- /dev/null
+++ b/src/Blocks/BlockTNT.h
@@ -0,0 +1,32 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockTNTHandler :
+	public cBlockHandler
+{
+public:
+	cBlockTNTHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockTallGrass.h b/src/Blocks/BlockTallGrass.h
index cd27ab7e6..ba1f2e0f6 100644
--- a/src/Blocks/BlockTallGrass.h
+++ b/src/Blocks/BlockTallGrass.h
@@ -15,14 +15,14 @@ public:
 		: cBlockHandler(a_BlockType)
 	{
 	}
-	
-	
+
+
 	virtual bool DoesIgnoreBuildCollision(void) override
 	{
 		return true;
 	}
-	
-	
+
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Drop seeds, sometimes
@@ -34,11 +34,25 @@ public:
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual void OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		
+		if ((!a_Player->IsGameModeCreative()) && (a_Player->GetEquippedItem().m_ItemType == E_ITEM_SHEARS))
+		{
+			cItems Pickups;
+			Pickups.Add(E_BLOCK_TALL_GRASS, 1, Meta);
+			a_WorldInterface.SpawnItemPickups(Pickups, a_BlockX, a_BlockY, a_BlockZ);
+		}
+		a_Player->UseEquippedItem();
+	}
+
+
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
 	}
-	
+
 
 	virtual const char * GetStepSound(void) override
 	{
diff --git a/src/Blocks/BlockTorch.h b/src/Blocks/BlockTorch.h
index faba9c4f5..8ddec8de1 100644
--- a/src/Blocks/BlockTorch.h
+++ b/src/Blocks/BlockTorch.h
@@ -1,25 +1,25 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../World.h"
-
+#include "../Chunk.h"
+#include "MetaRotator.h"
 
 
 
 
 class cBlockTorchHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>
 {
 public:
 	cBlockTorchHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>(a_BlockType)
 	{
 	}
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -28,7 +28,7 @@ public:
 
 		if ((a_BlockFace == BLOCK_FACE_TOP) || (a_BlockFace == BLOCK_FACE_BOTTOM))
 		{
-			a_BlockFace = FindSuitableFace(a_World, a_BlockX, a_BlockY, a_BlockZ); // Top or bottom faces clicked, find a suitable face
+			a_BlockFace = FindSuitableFace(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ); // Top or bottom faces clicked, find a suitable face
 			if (a_BlockFace == BLOCK_FACE_NONE)
 			{
 				// Client wouldn't have sent anything anyway, but whatever
@@ -38,11 +38,12 @@ public:
 		else
 		{
 			// Not top or bottom faces, try to preserve whatever face was clicked
-			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true);
-			if (!CanBePlacedOn(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ), a_BlockFace))
+			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true); // Set to clicked block
+			if (!CanBePlacedOn(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ), a_BlockFace))
 			{
+				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, false); // Reset to torch block
 				// Torch couldn't be placed on whatever face was clicked, last ditch resort - find another face
-				a_BlockFace = FindSuitableFace(a_World, a_BlockX, a_BlockY, a_BlockZ);
+				a_BlockFace = FindSuitableFace(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
 				if (a_BlockFace == BLOCK_FACE_NONE)
 				{
 					return false;
@@ -56,7 +57,7 @@ public:
 	}
 	
 
-	inline static NIBBLETYPE DirectionToMetaData(char a_Direction)
+	inline static NIBBLETYPE DirectionToMetaData(eBlockFace a_Direction)
 	{
 		switch (a_Direction)
 		{
@@ -76,7 +77,7 @@ public:
 	}
 	
 
-	inline static char MetaDataToDirection(NIBBLETYPE a_MetaData)
+	inline static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)
 	{
 		switch (a_MetaData)
 		{
@@ -92,13 +93,13 @@ public:
 				break;
 			}
 		}
-		return 0;
+		return BLOCK_FACE_TOP;
 	}
 
 
-	static bool CanBePlacedOn(BLOCKTYPE a_BlockType, char a_BlockFace)
+	static bool CanBePlacedOn(BLOCKTYPE a_BlockType, eBlockFace a_BlockFace)
 	{
-		if ( !g_BlockFullyOccupiesVoxel[a_BlockType] )
+		if ( !cBlockInfo::FullyOccupiesVoxel(a_BlockType) )
 		{
 			return (a_BlockFace == BLOCK_FACE_TOP);  // Allow placement only when torch upright (for glass, etc.); exceptions won't even be sent by client, no need to handle
 		}
@@ -110,41 +111,42 @@ public:
 	
 	
 	/// Finds a suitable face to place the torch, returning BLOCK_FACE_NONE on failure
-	static char FindSuitableFace(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	static eBlockFace FindSuitableFace(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		for (int i = BLOCK_FACE_YM; i <= BLOCK_FACE_XP; i++) // Loop through all directions
 		{
-			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, i, true);
-			BLOCKTYPE BlockInQuestion = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+			eBlockFace Face = static_cast<eBlockFace>(i);
+			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, Face, true);
+			BLOCKTYPE BlockInQuestion = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ);
 
 			if ( // If on a block that can only hold a torch if torch is standing on it, return that face
 				((BlockInQuestion == E_BLOCK_GLASS) ||
 				(BlockInQuestion == E_BLOCK_FENCE) ||
 				(BlockInQuestion == E_BLOCK_NETHER_BRICK_FENCE) ||
 				(BlockInQuestion == E_BLOCK_COBBLESTONE_WALL)) &&
-				(i == BLOCK_FACE_TOP)
+				(Face == BLOCK_FACE_TOP)
 				)
 			{
-				return i;
+				return Face;
 			}
-			else if ((g_BlockFullyOccupiesVoxel[BlockInQuestion]) && (i != BLOCK_FACE_BOTTOM))
+			else if (cBlockInfo::FullyOccupiesVoxel(BlockInQuestion) && (i != BLOCK_FACE_BOTTOM))
 			{
 				// Otherwise, if block in that direction is torch placeable and we haven't gotten to it via the bottom face, return that face
-				return i;
+				return Face;
 			}
 			else
 			{
 				// Reset coords in preparation for next iteration
-				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, i, false);
+				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, Face, false);
 			}
 		}
 		return BLOCK_FACE_NONE;
 	}
 
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
-		char Face = MetaDataToDirection(a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+		eBlockFace Face = MetaDataToDirection(a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
 
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, Face, true);
 		BLOCKTYPE BlockInQuestion;
@@ -161,7 +163,7 @@ public:
 			// No need to check for upright orientation, it was done when the torch was placed
 			return true;
 		}
-		else if ( !g_BlockFullyOccupiesVoxel[BlockInQuestion] )
+		else if ( !cBlockInfo::FullyOccupiesVoxel(BlockInQuestion) )
 		{
 			return false;
 		}
@@ -183,67 +185,6 @@ public:
 	{
 		return "step.wood";
 	}
-	
-	
-	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x01: return TopBits | 0x04;  // East  -> North
-			case 0x02: return TopBits | 0x03;  // West  -> South
-			case 0x03: return TopBits | 0x01;  // South -> East
-			case 0x04: return TopBits | 0x02;  // North -> West
-			default:   return a_Meta;          // Floor -> Floor
-		}
-	}
-
-
-	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x01: return TopBits | 0x03;  // East  -> South
-			case 0x02: return TopBits | 0x04;  // West  -> North
-			case 0x03: return TopBits | 0x02;  // South -> West
-			case 0x04: return TopBits | 0x01;  // North -> East
-			default:   return a_Meta;          // Floor -> Floor
-		}
-	}
-
-
-	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x03: return TopBits | 0x04;  // South -> North
-			case 0x04: return TopBits | 0x03;  // North -> South
-			default:   return a_Meta;          // Keep the rest
-		}
-	}
-
-
-	// Mirroring around the XZ plane doesn't make sense for floor torches,
-	// the others stay the same, so let's keep all the metas the same.
-	// The base class does tht for us, no need to override MetaMirrorXZ()
-
-	
-	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x01: return TopBits | 0x02;  // East -> West
-			case 0x02: return TopBits | 0x01;  // West -> East
-			default:   return a_Meta;          // Keep the rest
-		}
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockTrapdoor.h b/src/Blocks/BlockTrapdoor.h
index 57718b45f..6a36ab874 100644
--- a/src/Blocks/BlockTrapdoor.h
+++ b/src/Blocks/BlockTrapdoor.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockTrapdoorHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x00, 0x03, false>
 {
 public:
 	cBlockTrapdoorHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x00, 0x03, false>(a_BlockType)
 	{
 	}
 
@@ -32,17 +32,25 @@ public:
 		return true;
 	}
 
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
 		// Flip the ON bit on/off using the XOR bitwise operation
-		NIBBLETYPE Meta = (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x04);
+		NIBBLETYPE Meta = (a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x04);
+		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+		
+		cWorld * World = (cWorld *) &a_WorldInterface;
+		World->BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0, a_Player->GetClientHandle());
+	}
 
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		UNUSED(a_ChunkInterface);
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
 	}
 
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 		) override
@@ -57,7 +65,7 @@ public:
 		return true;
 	}
 	
-	inline static NIBBLETYPE BlockFaceToMetaData(char a_BlockFace)
+	inline static NIBBLETYPE BlockFaceToMetaData(eBlockFace a_BlockFace)
 	{
 		switch (a_BlockFace)
 		{
@@ -68,12 +76,12 @@ public:
 			default:
 			{
 				ASSERT(!"Unhandled block face!");
-				return 0x0;
+				return 0;
 			}
 		}
 	}
 
-	inline static NIBBLETYPE BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
+	inline static eBlockFace BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
 	{
 		switch (a_Meta & 0x3)
 		{
@@ -89,7 +97,7 @@ public:
 		}
 	}
 
-	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		NIBBLETYPE Meta;
 		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
@@ -97,7 +105,7 @@ public:
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, BlockMetaDataToBlockFace(Meta), true);
 		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && (g_BlockIsSolid[BlockIsOn]);
+		return (a_RelY > 0) && cBlockInfo::IsSolid(BlockIsOn);
 	}
 };
 
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
index 60aaa9e4b..7bb9dc484 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -1,8 +1,7 @@
-
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
@@ -18,16 +17,20 @@ public:
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
+		UNUSED(a_Player);
+		UNUSED(a_CursorX);
+		UNUSED(a_CursorY);
+		UNUSED(a_CursorZ);
 		// TODO: Disallow placement where the vine doesn't attach to something properly
 		BLOCKTYPE BlockType = 0;
 		NIBBLETYPE BlockMeta;
-		a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
+		a_ChunkInterface.GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
 		if (BlockType == m_BlockType)
 		{
 			a_BlockMeta = BlockMeta | DirectionToMetaData(a_BlockFace);
@@ -70,7 +73,7 @@ public:
 	/// Returns true if the specified block type is good for vines to attach to
 	static bool IsBlockAttachable(BLOCKTYPE a_BlockType)
 	{
-		return (a_BlockType == E_BLOCK_LEAVES) || g_BlockIsSolid[a_BlockType];
+		return (a_BlockType == E_BLOCK_LEAVES) || (a_BlockType == E_BLOCK_NEW_LEAVES) || cBlockInfo::IsSolid(a_BlockType);
 	}
 
 
@@ -80,7 +83,7 @@ public:
 		static const struct
 		{
 			int x, z;
-			int Bit;
+			NIBBLETYPE Bit;
 		} Coords[] =
 		{
 			{ 0,  1, 1},  // south, ZP
@@ -88,7 +91,7 @@ public:
 			{ 0, -1, 4},  // north, ZM
 			{ 1,  0, 8},  // east,  XP
 		} ;
-		int res = 0;
+		NIBBLETYPE res = 0;
 		for (size_t i = 0; i < ARRAYCOUNT(Coords); i++)
 		{
 			BLOCKTYPE  BlockType;
@@ -105,7 +108,7 @@ public:
 	}
 	
 	
-	void Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) override
+	void Check(cChunkInterface & a_ChunkInterface, cBlockPluginInterface & a_PluginInterface, int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) override
 	{
 		NIBBLETYPE CurMeta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
 		NIBBLETYPE MaxMeta = GetMaxMeta(a_Chunk, a_RelX, a_RelY, a_RelZ);
@@ -128,7 +131,7 @@ public:
 				{
 					int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
 					int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
-					DropBlock(a_Chunk.GetWorld(), NULL, BlockX, a_RelY, BlockZ);
+					DropBlock(a_ChunkInterface, *a_Chunk.GetWorld(), a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
 				}
 				a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);
 				return;
@@ -162,11 +165,20 @@ public:
 		return false;
 	}
 	
-	virtual void OnUpdate(cWorld * a_World, int X, int Y, int Z)
+	virtual void OnUpdate(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
 	{
-		if (a_World->GetBlock(X, Y - 1, Z) == E_BLOCK_AIR)
+		UNUSED(a_ChunkInterface);
+		UNUSED(a_WorldInterface);
+		UNUSED(a_BlockPluginInterface);
+
+		BLOCKTYPE Block;
+		a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY - 1, a_RelZ, Block);
+		if (Block == E_BLOCK_AIR)
 		{
-			a_World->SetBlock(X, Y - 1, Z, E_BLOCK_VINES, a_World->GetBlockMeta(X, Y, Z));
+			if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, a_RelX * cChunkDef::Width, a_RelY - 1, a_RelZ * cChunkDef::Width, ssVineSpread))
+			{
+				a_Chunk.UnboundedRelSetBlock(a_RelX, a_RelY - 1, a_RelZ, E_BLOCK_VINES, a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+			}
 		}
 	}
 	
@@ -180,20 +192,21 @@ public:
 	{
 		return ((a_Meta << 1) | (a_Meta >> 3)) & 0x0f;  // Rotate bits to the left
 	}
-	
-	
+
+
 	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
 	{
 		// Bits 2 and 4 stay, bits 1 and 3 swap
-		return ((a_Meta & 0x0a) | ((a_Meta & 0x01) << 2) | ((a_Meta & 0x04) >> 2));
+		return (NIBBLETYPE)((a_Meta & 0x0a) | ((a_Meta & 0x01) << 2) | ((a_Meta & 0x04) >> 2));
 	}
 
 
 	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
 	{
 		// Bits 1 and 3 stay, bits 2 and 4 swap
-		return ((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2));
+		return (NIBBLETYPE)((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2));
 	}
+
 } ;
 
 
diff --git a/src/Blocks/BlockWood.h b/src/Blocks/BlockWood.h
deleted file mode 100644
index cb5ee995a..000000000
--- a/src/Blocks/BlockWood.h
+++ /dev/null
@@ -1,72 +0,0 @@
-
-#pragma once
-
-#include "BlockHandler.h"
-
-
-
-
-
-class cBlockWoodHandler : public cBlockHandler
-{
-public:
-	cBlockWoodHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
-	{
-	}
-
-	
-	virtual bool GetPlacementBlockTypeMeta(
-		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
-		int a_CursorX, int a_CursorY, int a_CursorZ,
-		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
-	) override
-	{
-		a_BlockType = m_BlockType;
-		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
-		a_BlockMeta = BlockFaceToMetaData(a_BlockFace, Meta);
-		return true;
-	}
-
-	
-	inline static NIBBLETYPE BlockFaceToMetaData(char a_BlockFace, NIBBLETYPE a_WoodMeta)
-	{
-		switch (a_BlockFace)
-		{
-			case BLOCK_FACE_YM:
-			case BLOCK_FACE_YP:
-			{
-				return a_WoodMeta; // Top or bottom, just return original
-			}
-
-			case BLOCK_FACE_ZP:
-			case BLOCK_FACE_ZM:
-			{
-				return a_WoodMeta | 0x8; // North or south
-			}
-
-			case BLOCK_FACE_XP:
-			case BLOCK_FACE_XM:
-			{
-				return a_WoodMeta | 0x4; // East or west
-			}
-
-			default:
-			{
-				ASSERT(!"Unhandled block face!");
-				return a_WoodMeta | 0xC; // No idea, give a special meta (all sides bark)
-			}
-		}
-	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
-} ;
-
-
-
-
diff --git a/src/Blocks/BlockWorkbench.h b/src/Blocks/BlockWorkbench.h
index a2cc6119c..70468369c 100644
--- a/src/Blocks/BlockWorkbench.h
+++ b/src/Blocks/BlockWorkbench.h
@@ -19,7 +19,7 @@ public:
 	}
 	
 	
-	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
 		cWindow * Window = new cCraftingWindow(a_BlockX, a_BlockY, a_BlockZ);
 		a_Player->OpenWindow(Window);
diff --git a/src/Blocks/BroadcastInterface.h b/src/Blocks/BroadcastInterface.h
new file mode 100644
index 000000000..b1b450690
--- /dev/null
+++ b/src/Blocks/BroadcastInterface.h
@@ -0,0 +1,12 @@
+
+#pragma once
+
+class cBroadcastInterface 
+{
+public:
+	virtual ~cBroadcastInterface() {}
+	
+	virtual void BroadcastUseBed     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ ) = 0;
+	virtual void BroadcastSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL) = 0;
+	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) = 0;
+};
diff --git a/src/Blocks/ChunkInterface.cpp b/src/Blocks/ChunkInterface.cpp
new file mode 100644
index 000000000..540581ae7
--- /dev/null
+++ b/src/Blocks/ChunkInterface.cpp
@@ -0,0 +1,12 @@
+
+#include "Globals.h"
+
+#include "ChunkInterface.h"
+#include "BlockHandler.h"
+
+bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z)
+{
+	cBlockHandler * Handler = cBlockInfo::GetHandler(GetBlock(a_X, a_Y, a_Z));
+	Handler->OnDestroyed(*this, a_WorldInterface, a_X, a_Y, a_Z);
+	return m_ChunkMap->DigBlock(a_X, a_Y, a_Z);
+}
diff --git a/src/Blocks/ChunkInterface.h b/src/Blocks/ChunkInterface.h
new file mode 100644
index 000000000..be7c2e0e5
--- /dev/null
+++ b/src/Blocks/ChunkInterface.h
@@ -0,0 +1,92 @@
+
+#pragma once
+
+#include "../ChunkMap.h"
+#include "../ForEachChunkProvider.h"
+#include "WorldInterface.h"
+
+
+
+
+
+class cChunkInterface:
+	public cForEachChunkProvider
+{
+public:
+
+	cChunkInterface(cChunkMap * a_ChunkMap) : m_ChunkMap(a_ChunkMap) {}
+
+	BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		return m_ChunkMap->GetBlock(a_BlockX,a_BlockY,a_BlockZ);
+	}
+	BLOCKTYPE GetBlock(const Vector3i & a_Pos)
+	{ 
+		return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
+	}
+	NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	}
+
+	bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+	{
+		return m_ChunkMap->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+	}
+	
+	/** Sets the block at the specified coords to the specified value.
+	Full processing, incl. updating neighbors, is performed.
+	*/
+	void SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+	{
+		m_ChunkMap->SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+	}
+	
+	void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
+	{
+		m_ChunkMap->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_MetaData);
+	}
+	
+	void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface)
+	{
+		m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_WorldInterface.GetWorldAge() + a_TickDelay, a_PreviousBlockType);
+	}
+	
+	/** Sets the block at the specified coords to the specified value.
+	The replacement doesn't trigger block updates.
+	The replaced blocks aren't checked for block entities (block entity is leaked if it exists at this block)
+	*/
+	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+	{
+		m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+	}
+	
+	void FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta )
+	{
+		FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta );
+	}
+
+	void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		m_ChunkMap->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
+	}
+	
+	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override
+	{
+		return m_ChunkMap->ForEachChunkInRect(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ, a_Callback);
+	}
+	
+	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override
+	{
+		return m_ChunkMap->WriteBlockArea(a_Area, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
+	}
+	
+	bool DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z);
+	
+private:
+	cChunkMap * m_ChunkMap;
+};
+
+
+
+
diff --git a/src/Blocks/MetaRotator.h b/src/Blocks/MetaRotator.h
new file mode 100644
index 000000000..899c583e1
--- /dev/null
+++ b/src/Blocks/MetaRotator.h
@@ -0,0 +1,120 @@
+// MetaRotator.h
+
+// Provides a mixin for rotations and reflections
+
+#pragma once
+
+// MSVC generates warnings for the templated AssertIfNotMatched parameter conditions, so disable it:
+#ifdef _MSC_VER
+	#pragma warning(disable: 4127) // Conditional expression is constant
+#endif
+
+
+
+
+
+/*
+Provides a mixin for rotations and reflections following the standard pattern of apply mask then use case.
+
+Usage:
+Inherit from this class providing your base class as Base, the BitMask for the direction bits in bitmask and the masked value for the directions in North, East, South, West. There is also an aptional parameter AssertIfNotMatched. Set this if it is invalid for a block to exist in any other state.
+*/
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched = false>
+class cMetaRotator : public Base
+{
+public:
+
+	cMetaRotator(BLOCKTYPE a_BlockType) :
+		Base(a_BlockType)
+	{}
+	
+	virtual ~cMetaRotator() {}
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta)  override;
+};
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCW(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case South: return West  | OtherMeta; 
+		case West:  return North | OtherMeta; 
+		case North: return East  | OtherMeta;
+		case East:  return South | OtherMeta;
+	}
+	if (AssertIfNotMatched)
+	{
+		ASSERT(!"Invalid Meta value");
+	}
+	return a_Meta;
+}
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCCW(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case South: return East  | OtherMeta; 
+		case East:  return North | OtherMeta;
+		case North: return West  | OtherMeta;
+		case West:  return South | OtherMeta;
+	}
+	if (AssertIfNotMatched)
+	{
+		ASSERT(!"Invalid Meta value");
+	}
+	return a_Meta;
+}
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorXY(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case South: return North | OtherMeta;
+		case North: return South | OtherMeta;
+	}
+	// Not Facing North or South; No change.
+	return a_Meta;
+}
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorYZ(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case West: return East | OtherMeta;
+		case East: return West | OtherMeta;
+	}
+	// Not Facing East or West; No change.
+	return a_Meta;
+}
+
+
+
+
diff --git a/src/Blocks/WorldInterface.h b/src/Blocks/WorldInterface.h
new file mode 100644
index 000000000..bfbb053d9
--- /dev/null
+++ b/src/Blocks/WorldInterface.h
@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include "BroadcastInterface.h"
+#include "../Mobs/Monster.h"
+
+class cItems;
+
+class cWorldInterface
+{
+public:
+	virtual ~cWorldInterface() {}
+	
+	virtual Int64 GetTimeOfDay(void) const = 0;
+	virtual Int64 GetWorldAge(void)  const = 0;
+	
+	virtual eDimension GetDimension(void) const = 0;
+	
+	virtual cBroadcastInterface & GetBroadcastManager() = 0;
+	
+	virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData) = 0; 
+	
+	/** Spawns item pickups for each item in the list. May compress pickups if too many entities: */
+	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0, bool IsPlayerCreated = false) = 0;
+	
+	/** Spawns item pickups for each item in the list. May compress pickups if too many entities. All pickups get the speed specified: */
+	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated = false) = 0;
+	
+	/** Spawns a mob of the specified type. Returns the mob's EntityID if recognized and spawned, <0 otherwise */
+	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType) = 0;
+
+	/** Sends the block on those coords to the player */
+	virtual void SendBlockTo(int a_BlockX, int a_BlockY, int a_BlockZ, cPlayer * a_Player) = 0;
+
+	/** Calls the callback for each player in the list; returns true if all players processed, false if the callback aborted by returning true */
+	virtual bool ForEachPlayer(cItemCallback<cPlayer> & a_Callback) = 0;
+
+	virtual void SetTimeOfDay(Int64 a_TimeOfDay) = 0;
+
+};
diff --git a/src/BoundingBox.cpp b/src/BoundingBox.cpp
index d0943d42a..482f9923f 100644
--- a/src/BoundingBox.cpp
+++ b/src/BoundingBox.cpp
@@ -1,4 +1,3 @@
-
 // BoundingBox.cpp
 
 // Implements the cBoundingBox class representing an axis-aligned bounding box with floatingpoint coords
@@ -11,41 +10,60 @@
 
 
 
-#if 0
+#ifdef SELF_TEST
 
-/// A simple self-test that is executed on program start, used to verify bbox functionality
-class SelfTest
+/** A simple self-test that is executed on program start, used to verify bbox functionality */
+static class SelfTest_BoundingBox
 {
 public:
-	SelfTest(void)
+	SelfTest_BoundingBox(void)
 	{
 		Vector3d Min(1, 1, 1);
 		Vector3d Max(2, 2, 2);
 		Vector3d LineDefs[] =
 		{
-			Vector3d(1.5,   4, 1.5), Vector3d(1.5,   3, 1.5),  // Should intersect at 2, face 1 (YP)
+			Vector3d(1.5,   4, 1.5), Vector3d(1.5,   3, 1.5),  // Should intersect at 2,    face 1 (YP)
 			Vector3d(1.5,   0, 1.5), Vector3d(1.5,   4, 1.5),  // Should intersect at 0.25, face 0 (YM)
 			Vector3d(0,     0,   0), Vector3d(2,     2,   2),  // Should intersect at 0.5,  face 0, 3 or 5 (anyM)
 			Vector3d(0.999, 0, 1.5), Vector3d(0.999, 4, 1.5),  // Should not intersect
 			Vector3d(1.999, 0, 1.5), Vector3d(1.999, 4, 1.5),  // Should intersect at 0.25, face 0 (YM)
 			Vector3d(2.001, 0, 1.5), Vector3d(2.001, 4, 1.5),  // Should not intersect
 		} ;
+		bool Results[] = {true, true, true, false, true, false};
+		double LineCoeffs[] = {2, 0.25, 0.5, 0, 0.25, 0};
+		
 		for (size_t i = 0; i < ARRAYCOUNT(LineDefs) / 2; i++)
 		{
 			double LineCoeff;
-			char Face;
+			eBlockFace Face;
 			Vector3d Line1 = LineDefs[2 * i];
 			Vector3d Line2 = LineDefs[2 * i + 1];
 			bool res = cBoundingBox::CalcLineIntersection(Min, Max, Line1, Line2, LineCoeff, Face);
-			printf("LineIntersection({%.02f, %.02f, %.02f}, {%.02f, %.02f, %.02f}) -> %d, %.05f, %d\n",
-				Line1.x, Line1.y, Line1.z,
-				Line2.x, Line2.y, Line2.z,
-				res ? 1 : 0, LineCoeff, Face
-			);
+			if (res != Results[i])
+			{
+				fprintf(stderr, "LineIntersection({%.02f, %.02f, %.02f}, {%.02f, %.02f, %.02f}) -> %d, %.05f, %d\n",
+					Line1.x, Line1.y, Line1.z,
+					Line2.x, Line2.y, Line2.z,
+					res ? 1 : 0, LineCoeff, Face
+				);
+				abort();
+			}
+			if (res)
+			{
+				if (LineCoeff != LineCoeffs[i])
+				{
+					fprintf(stderr, "LineIntersection({%.02f, %.02f, %.02f}, {%.02f, %.02f, %.02f}) -> %d, %.05f, %d\n",
+						Line1.x, Line1.y, Line1.z,
+						Line2.x, Line2.y, Line2.z,
+						res ? 1 : 0, LineCoeff, Face
+					);
+					abort();
+				}
+			}
 		}  // for i - LineDefs[]
-		printf("BoundingBox selftest complete.");
+		fprintf(stderr, "BoundingBox selftest complete.\n");
 	}
-} Test;
+} gTest;
 
 #endif
 
@@ -228,7 +246,7 @@ bool cBoundingBox::IsInside(const Vector3d & a_Min, const Vector3d & a_Max, doub
 
 
 
-bool cBoundingBox::CalcLineIntersection(const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, char & a_Face)
+bool cBoundingBox::CalcLineIntersection(const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, eBlockFace & a_Face)
 {
 	return CalcLineIntersection(m_Min, m_Max, a_Line1, a_Line2, a_LineCoeff, a_Face);
 }
@@ -237,7 +255,7 @@ bool cBoundingBox::CalcLineIntersection(const Vector3d & a_Line1, const Vector3d
 
 
 
-bool cBoundingBox::CalcLineIntersection(const Vector3d & a_Min, const Vector3d & a_Max, const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, char & a_Face)
+bool cBoundingBox::CalcLineIntersection(const Vector3d & a_Min, const Vector3d & a_Max, const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, eBlockFace & a_Face)
 {
 	if (IsInside(a_Min, a_Max, a_Line1))
 	{
@@ -247,7 +265,7 @@ bool cBoundingBox::CalcLineIntersection(const Vector3d & a_Min, const Vector3d &
 		return true;
 	}
 	
-	char Face = BLOCK_FACE_NONE;
+	eBlockFace Face = BLOCK_FACE_NONE;
 	double Coeff = Vector3d::NO_INTERSECTION;
 	
 	// Check each individual bbox face for intersection with the line, remember the one with the lowest coeff
diff --git a/src/BoundingBox.h b/src/BoundingBox.h
index ff9963989..a7c6c3eea 100644
--- a/src/BoundingBox.h
+++ b/src/BoundingBox.h
@@ -8,7 +8,8 @@
 
 #pragma once
 
-#include "Vector3d.h"
+#include "Vector3.h"
+#include "Defines.h"
 
 
 
@@ -66,13 +67,13 @@ public:
 	Also calculates the distance along the line in which the intersection occurs (0 .. 1)
 	Only forward collisions (a_LineCoeff >= 0) are returned.
 	*/
-	bool CalcLineIntersection(const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, char & a_Face);
+	bool CalcLineIntersection(const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, eBlockFace & a_Face);
 	
 	/** Returns true if the specified bounding box is intersected by the line specified by its two points
 	Also calculates the distance along the line in which the intersection occurs (0 .. 1) and the face hit (BLOCK_FACE_ constants)
 	Only forward collisions (a_LineCoeff >= 0) are returned.
 	*/
-	static bool CalcLineIntersection(const Vector3d & a_Min, const Vector3d & a_Max, const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, char & a_Face);
+	static bool CalcLineIntersection(const Vector3d & a_Min, const Vector3d & a_Max, const Vector3d & a_Line1, const Vector3d & a_Line2, double & a_LineCoeff, eBlockFace & a_Face);
 	
 	// tolua_end
 	
diff --git a/src/ByteBuffer.cpp b/src/ByteBuffer.cpp
index e06f63a0e..1893d89a8 100644
--- a/src/ByteBuffer.cpp
+++ b/src/ByteBuffer.cpp
@@ -44,16 +44,17 @@
 
 
 
-#if 0
+#ifdef SELF_TEST
 
 /// Self-test of the VarInt-reading and writing code
-class cByteBufferSelfTest
+static class cByteBufferSelfTest
 {
 public:
 	cByteBufferSelfTest(void)
 	{
 		TestRead();
 		TestWrite();
+		TestWrap();
 	}
 	
 	void TestRead(void)
@@ -61,11 +62,11 @@ public:
 		cByteBuffer buf(50);
 		buf.Write("\x05\xac\x02\x00", 4);
 		UInt32 v1;
-		ASSERT(buf.ReadVarInt(v1) && (v1 == 5));
+		assert_test(buf.ReadVarInt(v1) && (v1 == 5));
 		UInt32 v2;
-		ASSERT(buf.ReadVarInt(v2) && (v2 == 300));
+		assert_test(buf.ReadVarInt(v2) && (v2 == 300));
 		UInt32 v3;
-		ASSERT(buf.ReadVarInt(v3) && (v3 == 0));
+		assert_test(buf.ReadVarInt(v3) && (v3 == 0));
 	}
 	
 	void TestWrite(void)
@@ -76,9 +77,30 @@ public:
 		buf.WriteVarInt(0);
 		AString All;
 		buf.ReadAll(All);
-		ASSERT(All.size() == 4);
-		ASSERT(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
+		assert_test(All.size() == 4);
+		assert_test(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
 	}
+	
+	void TestWrap(void)
+	{
+		cByteBuffer buf(3);
+		for (int i = 0; i < 1000; i++)
+		{
+			size_t FreeSpace = buf.GetFreeSpace();
+			assert_test(buf.GetReadableSpace() == 0);
+			assert_test(FreeSpace > 0);
+			assert_test(buf.Write("a", 1));
+			assert_test(buf.CanReadBytes(1));
+			assert_test(buf.GetReadableSpace() == 1);
+			unsigned char v = 0;
+			assert_test(buf.ReadByte(v));
+			assert_test(v == 'a');
+			assert_test(buf.GetReadableSpace() == 0);
+			buf.CommitRead();
+			assert_test(buf.GetFreeSpace() == FreeSpace);  // We're back to normal
+		}
+	}
+	
 } g_ByteBufferTest;
 
 #endif
@@ -149,21 +171,22 @@ cByteBuffer::~cByteBuffer()
 
 
 
-bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
+bool cByteBuffer::Write(const char * a_Bytes, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
 
 	// Store the current free space for a check after writing:
-	int CurFreeSpace = GetFreeSpace();
-	int CurReadableSpace = GetReadableSpace();
-	int WrittenBytes = 0;
+	size_t CurFreeSpace = GetFreeSpace();
+	size_t CurReadableSpace = GetReadableSpace();
+	size_t WrittenBytes = 0;
 	
-	if (GetFreeSpace() < a_Count)
+	if (CurFreeSpace < a_Count)
 	{
 		return false;
 	}
-	int TillEnd = m_BufferSize - m_WritePos;
+	ASSERT(m_BufferSize >= m_WritePos);
+	size_t TillEnd = m_BufferSize - m_WritePos;
 	if (TillEnd <= a_Count)
 	{
 		// Need to wrap around the ringbuffer end
@@ -194,16 +217,20 @@ bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
 
 
 
-int cByteBuffer::GetFreeSpace(void) const
+size_t cByteBuffer::GetFreeSpace(void) const
 {
 	CHECK_THREAD;
 	CheckValid();
 	if (m_WritePos >= m_DataStart)
 	{
 		// Wrap around the buffer end:
+		ASSERT(m_BufferSize >= m_WritePos);
+		ASSERT((m_BufferSize - m_WritePos + m_DataStart) >= 1);
 		return m_BufferSize - m_WritePos + m_DataStart - 1;
 	}
 	// Single free space partition:
+	ASSERT(m_BufferSize >= m_WritePos);
+	ASSERT(m_BufferSize - m_WritePos >= 1);
 	return m_DataStart - m_WritePos - 1;
 }
 
@@ -212,10 +239,12 @@ int cByteBuffer::GetFreeSpace(void) const
 
 
 /// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
-int cByteBuffer::GetUsedSpace(void) const
+size_t cByteBuffer::GetUsedSpace(void) const
 {
 	CHECK_THREAD;
 	CheckValid();
+	ASSERT(m_BufferSize >= GetFreeSpace());
+	ASSERT((m_BufferSize - GetFreeSpace()) >= 1);
 	return m_BufferSize - GetFreeSpace() - 1;
 }
 
@@ -224,16 +253,18 @@ int cByteBuffer::GetUsedSpace(void) const
 
 
 /// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
-int cByteBuffer::GetReadableSpace(void) const
+size_t cByteBuffer::GetReadableSpace(void) const
 {
 	CHECK_THREAD;
 	CheckValid();
 	if (m_ReadPos > m_WritePos)
 	{
 		// Wrap around the buffer end:
+		ASSERT(m_BufferSize >= m_ReadPos);
 		return m_BufferSize - m_ReadPos + m_WritePos;
 	}
 	// Single readable space partition:
+	ASSERT(m_WritePos >= m_ReadPos);
 	return m_WritePos - m_ReadPos ;
 }
 
@@ -241,7 +272,7 @@ int cByteBuffer::GetReadableSpace(void) const
 
 
 
-bool cByteBuffer::CanReadBytes(int a_Count) const
+bool cByteBuffer::CanReadBytes(size_t a_Count) const
 {
 	CHECK_THREAD;
 	CheckValid();
@@ -252,7 +283,7 @@ bool cByteBuffer::CanReadBytes(int a_Count) const
 
 
 
-bool cByteBuffer::CanWriteBytes(int a_Count) const
+bool cByteBuffer::CanWriteBytes(size_t a_Count) const
 {
 	CHECK_THREAD;
 	CheckValid();
@@ -428,7 +459,7 @@ bool cByteBuffer::ReadVarUTF8String(AString & a_Value)
 	}
 	if (Size > MAX_STRING_SIZE)
 	{
-		LOGWARNING("%s: String too large: %llu (%llu KiB)", __FUNCTION__, Size, Size / 1024);
+		LOGWARNING("%s: String too large: %u (%u KiB)", __FUNCTION__, Size, Size / 1024);
 	}
 	return ReadString(a_Value, (int)Size);
 }
@@ -628,15 +659,14 @@ bool cByteBuffer::WriteLEInt(int a_Value)
 
 
 
-bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
+bool cByteBuffer::ReadBuf(void * a_Buffer, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	NEEDBYTES(a_Count);
 	char * Dst = (char *)a_Buffer;  // So that we can do byte math
-	int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
-	ASSERT(BytesToEndOfBuffer >= 0);  // Sanity check
+	ASSERT(m_BufferSize >= m_ReadPos);
+	size_t BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
 	if (BytesToEndOfBuffer <= a_Count)
 	{
 		// Reading across the ringbuffer end, read the first part and adjust parameters:
@@ -662,14 +692,14 @@ bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
 
 
 
-bool cByteBuffer::WriteBuf(const void * a_Buffer, int a_Count)
+bool cByteBuffer::WriteBuf(const void * a_Buffer, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	PUTBYTES(a_Count);
 	char * Src = (char *)a_Buffer;  // So that we can do byte math
-	int BytesToEndOfBuffer = m_BufferSize - m_WritePos;
+	ASSERT(m_BufferSize >= m_ReadPos);
+	size_t BytesToEndOfBuffer = m_BufferSize - m_WritePos;
 	if (BytesToEndOfBuffer <= a_Count)
 	{
 		// Reading across the ringbuffer end, read the first part and adjust parameters:
@@ -692,22 +722,22 @@ bool cByteBuffer::WriteBuf(const void * a_Buffer, int a_Count)
 
 
 
-bool cByteBuffer::ReadString(AString & a_String, int a_Count)
+bool cByteBuffer::ReadString(AString & a_String, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	NEEDBYTES(a_Count);
 	a_String.clear();
 	a_String.reserve(a_Count);
-	int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
-	ASSERT(BytesToEndOfBuffer >= 0);  // Sanity check
+	ASSERT(m_BufferSize >= m_ReadPos);
+	size_t BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
 	if (BytesToEndOfBuffer <= a_Count)
 	{
 		// Reading across the ringbuffer end, read the first part and adjust parameters:
 		if (BytesToEndOfBuffer > 0)
 		{
 			a_String.assign(m_Buffer + m_ReadPos, BytesToEndOfBuffer);
+			ASSERT(a_Count >= BytesToEndOfBuffer);
 			a_Count -= BytesToEndOfBuffer;
 		}
 		m_ReadPos = 0;
@@ -737,7 +767,7 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
 	{
 		return false;
 	}
-	RawBEToUTF8((short *)(RawData.data()), a_NumChars, a_String);
+	RawBEToUTF8(RawData.data(), a_NumChars, a_String);
 	return true;
 }
 
@@ -745,11 +775,10 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
 
 
 
-bool cByteBuffer::SkipRead(int a_Count)
+bool cByteBuffer::SkipRead(size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	if (!CanReadBytes(a_Count))
 	{
 		return false;
@@ -787,6 +816,7 @@ bool cByteBuffer::ReadToByteBuffer(cByteBuffer & a_Dst, size_t a_NumBytes)
 		size_t num = (a_NumBytes > sizeof(buf)) ? sizeof(buf) : a_NumBytes;
 		VERIFY(ReadBuf(buf, num));
 		VERIFY(a_Dst.Write(buf, num));
+		ASSERT(a_NumBytes >= num);
 		a_NumBytes -= num;
 	}
 	return true;
@@ -824,13 +854,15 @@ void cByteBuffer::ReadAgain(AString & a_Out)
 	// Used by ProtoProxy to repeat communication twice, once for parsing and the other time for the remote party
 	CHECK_THREAD;
 	CheckValid();
-	int DataStart = m_DataStart;
+	size_t DataStart = m_DataStart;
 	if (m_ReadPos < m_DataStart)
 	{
 		// Across the ringbuffer end, read the first part and adjust next part's start:
+		ASSERT(m_BufferSize >= m_DataStart);
 		a_Out.append(m_Buffer + m_DataStart, m_BufferSize - m_DataStart);
 		DataStart = 0;
 	}
+	ASSERT(m_ReadPos >= DataStart);
 	a_Out.append(m_Buffer + DataStart, m_ReadPos - DataStart);
 }
 
@@ -838,7 +870,7 @@ void cByteBuffer::ReadAgain(AString & a_Out)
 
 
 
-void cByteBuffer::AdvanceReadPos(int a_Count)
+void cByteBuffer::AdvanceReadPos(size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
@@ -864,3 +896,4 @@ void cByteBuffer::CheckValid(void) const
 
 
 
+
diff --git a/src/ByteBuffer.h b/src/ByteBuffer.h
index cbce119b1..1915467f3 100644
--- a/src/ByteBuffer.h
+++ b/src/ByteBuffer.h
@@ -31,25 +31,25 @@ public:
 	~cByteBuffer();
 	
 	/// Writes the bytes specified to the ringbuffer. Returns true if successful, false if not
-	bool Write(const char * a_Bytes, int a_Count);
+	bool Write(const char * a_Bytes, size_t a_Count);
 	
 	/// Returns the number of bytes that can be successfully written to the ringbuffer
-	int  GetFreeSpace(void) const;
+	size_t GetFreeSpace(void) const;
 	
 	/// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
-	int  GetUsedSpace(void) const;
+	size_t GetUsedSpace(void) const;
 	
 	/// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
-	int  GetReadableSpace(void) const;
+	size_t GetReadableSpace(void) const;
 	
 	/// Returns the current data start index. For debugging purposes.
-	int  GetDataStart(void) const { return m_DataStart; }
+	size_t  GetDataStart(void) const { return m_DataStart; }
 	
 	/// Returns true if the specified amount of bytes are available for reading
-	bool CanReadBytes(int a_Count) const;
+	bool CanReadBytes(size_t a_Count) const;
 
 	/// Returns true if the specified amount of bytes are available for writing
-	bool CanWriteBytes(int a_Count) const;
+	bool CanWriteBytes(size_t a_Count) const;
 
 	// Read the specified datatype and advance the read pointer; return true if successfully read:
 	bool ReadChar           (char & a_Value);
@@ -92,19 +92,19 @@ public:
 	bool WriteLEInt          (int a_Value);
 	
 	/// Reads a_Count bytes into a_Buffer; returns true if successful
-	bool ReadBuf(void * a_Buffer, int a_Count);
+	bool ReadBuf(void * a_Buffer, size_t a_Count);
 	
 	/// Writes a_Count bytes into a_Buffer; returns true if successful
-	bool WriteBuf(const void * a_Buffer, int a_Count);
+	bool WriteBuf(const void * a_Buffer, size_t a_Count);
 	
 	/// Reads a_Count bytes into a_String; returns true if successful
-	bool ReadString(AString & a_String, int a_Count);
+	bool ReadString(AString & a_String, size_t a_Count);
 	
 	/// Reads 2 * a_NumChars bytes and interprets it as a UTF16-BE string, converting it into UTF8 string a_String
 	bool ReadUTF16String(AString & a_String, int a_NumChars);
 	
 	/// Skips reading by a_Count bytes; returns false if not enough bytes in the ringbuffer
-	bool SkipRead(int a_Count);
+	bool SkipRead(size_t a_Count);
 	
 	/// Reads all available data into a_Data
 	void ReadAll(AString & a_Data);
@@ -126,18 +126,18 @@ public:
 
 protected:
 	char * m_Buffer;
-	int    m_BufferSize;  // Total size of the ringbuffer
+	size_t m_BufferSize;  // Total size of the ringbuffer
 	
 	#ifdef _DEBUG
 	volatile unsigned long m_ThreadID;  // Thread that is currently accessing the object, checked via cSingleThreadAccessChecker
 	#endif  // _DEBUG
 	
-	int    m_DataStart;  // Where the data starts in the ringbuffer
-	int    m_WritePos;   // Where the data ends in the ringbuffer
-	int    m_ReadPos;    // Where the next read will start in the ringbuffer
+	size_t m_DataStart;  // Where the data starts in the ringbuffer
+	size_t m_WritePos;   // Where the data ends in the ringbuffer
+	size_t m_ReadPos;    // Where the next read will start in the ringbuffer
 	
 	/// Advances the m_ReadPos by a_Count bytes
-	void AdvanceReadPos(int a_Count);
+	void AdvanceReadPos(size_t a_Count);
 } ;
 
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 275099540..30e9dbfd4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,16 +1,122 @@
-
 cmake_minimum_required (VERSION 2.8.2)
 project (MCServer)
 
 include_directories (SYSTEM "${PROJECT_SOURCE_DIR}/../lib/")
 include_directories (SYSTEM "${PROJECT_SOURCE_DIR}/../lib/jsoncpp/include")
+include_directories (SYSTEM "${PROJECT_SOURCE_DIR}/../lib/polarssl/include")
 
-set(FOLDERS OSSupport HTTPServer Bindings Items Blocks Protocol Generating) 
-set(FOLDERS ${FOLDERS} WorldStorage Mobs Entities Simulator UI BlockEntities)
-
+set(FOLDERS OSSupport HTTPServer Items Blocks Protocol Generating) 
+set(FOLDERS ${FOLDERS} WorldStorage Mobs Entities Simulator UI BlockEntities Generating/Prefabs)
 
 
 if (NOT MSVC)
+
+	# Bindings need to reference other folders, so they are done here instead
+	
+	# lib dependencies are not included
+	
+	set(BINDING_DEPENDECIES
+		tolua
+		${CMAKE_CURRENT_SOURCE_DIR}/Bindings/virtual_method_hooks.lua
+		${CMAKE_CURRENT_SOURCE_DIR}/Bindings/AllToLua.pkg
+		Bindings/LuaFunctions.h
+		Bindings/LuaWindow.h
+		Bindings/Plugin.h
+		Bindings/PluginLua.h
+		Bindings/PluginManager.h
+		Bindings/WebPlugin.h
+		BiomeDef.h
+		BlockArea.h
+		BlockEntities/BlockEntity.h
+		BlockEntities/BlockEntityWithItems.h
+		BlockEntities/ChestEntity.h
+		BlockEntities/DispenserEntity.h
+		BlockEntities/DropSpenserEntity.h
+		BlockEntities/DropperEntity.h
+		BlockEntities/FurnaceEntity.h
+		BlockEntities/HopperEntity.h
+		BlockEntities/JukeboxEntity.h
+		BlockEntities/NoteEntity.h
+		BlockEntities/SignEntity.h
+		BlockEntities/MobHeadEntity.h
+		BlockEntities/FlowerPotEntity.h
+		BlockID.h
+		BoundingBox.h
+		ChatColor.h
+		ChunkDef.h
+		ClientHandle.h
+		CraftingRecipes.h
+		Cuboid.h
+		Defines.h
+		Enchantments.h
+		Entities/Effects.h
+		Entities/Entity.h
+		Entities/Floater.h
+		Entities/Pawn.h
+		Entities/Painting.h
+		Entities/Pickup.h
+		Entities/Player.h
+		Entities/ProjectileEntity.h
+		Entities/TNTEntity.h
+		Entities/ExpOrb.h
+		Entities/HangingEntity.h
+		Entities/ItemFrame.h
+		Generating/ChunkDesc.h
+		Group.h
+		Inventory.h
+		Item.h
+		ItemGrid.h
+		Mobs/Monster.h
+		OSSupport/File.h
+		Root.h
+		Server.h
+		StringUtils.h
+		Tracer.h
+		UI/Window.h
+		Vector3.h
+		WebAdmin.h
+		World.h
+	)
+	
+	include_directories(Bindings)
+	include_directories(.)
+	
+	ADD_CUSTOM_COMMAND(
+		# add any new generated bindings here
+		OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/Bindings.cpp ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/Bindings.h
+	
+		# command execuded to regerate bindings
+		COMMAND tolua -L virtual_method_hooks.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/
+	
+		# add any new generation dependencies here
+		DEPENDS ${BINDING_DEPENDECIES}
+	)
+	#add cpp files here
+	add_library(Bindings
+		Bindings/Bindings
+		Bindings/DeprecatedBindings
+		Bindings/LuaChunkStay
+		Bindings/LuaState
+		Bindings/LuaWindow
+		Bindings/ManualBindings
+		Bindings/Plugin
+		Bindings/PluginLua
+		Bindings/PluginManager
+		Bindings/WebPlugin
+	)
+
+	target_link_libraries(Bindings lua sqlite tolualib)
+
+	#clear file
+	file(WRITE ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/BindingDependecies.txt)
+	foreach(dependecy ${BINDING_DEPENDECIES})
+		#write each dependecy on a seperate line
+		file(APPEND ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/BindingDependecies.txt "${dependecy}\n")
+	endforeach()
+
+	set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "Bindings.cpp Bindings.h")
+
 	foreach(folder ${FOLDERS})
 		add_subdirectory(${folder})
 	endforeach(folder)
@@ -31,6 +137,7 @@ if (NOT MSVC)
 
 
 else ()
+	# MSVC-specific handling: Put all files into one project, separate by the folders:
 
 	# Generate the Bindings if they don't exist:
 	if (NOT EXISTS "${PROJECT_SOURCE_DIR}/Bindings/Bindings.cpp")
@@ -42,30 +149,34 @@ else ()
 		)
 	endif()
 
+	# Get all files in this folder:
+	file(GLOB_RECURSE SOURCE
+		"*.cpp"
+		"*.h"
+		"*.pkg"
+	)
+	source_group("" FILES ${SOURCE})
+
 	# Add all subfolders as solution-folders:
 	list(APPEND FOLDERS "Resources")
+	list(APPEND FOLDERS "Bindings")
 	function(includefolder PATH)
 		FILE(GLOB FOLDER_FILES
 			"${PATH}/*.cpp"
 			"${PATH}/*.h"
 			"${PATH}/*.rc"
+			"${PATH}/*.pkg"
 		)
-		source_group("${PATH}" FILES ${FOLDER_FILES})
+		string(REPLACE "/" "\\" PROJECT_PATH ${PATH})
+		source_group("${PROJECT_PATH}" FILES ${FOLDER_FILES})
 	endfunction(includefolder)
 
 	foreach(folder ${FOLDERS})
 		includefolder(${folder})
 	endforeach(folder)
 
-	file(GLOB_RECURSE SOURCE
-		"*.cpp"
-		"*.h"
-	)
-
 	include_directories("${PROJECT_SOURCE_DIR}")
 
-	source_group("" FILES ${SOURCE})
-
 	# Precompiled headers (1st part)
 	SET_SOURCE_FILES_PROPERTIES(
 		Globals.cpp PROPERTIES COMPILE_FLAGS "/Yc\"Globals.h\""
@@ -78,6 +189,13 @@ else ()
 		"StackWalker.cpp LeakFinder.h" PROPERTIES COMPILE_FLAGS "/Yc\"Globals.h\""
 	)
 	list(APPEND SOURCE "Resources/MCServer.rc")
+
+	# Make MSVC generate the PDB files even for the release build:
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+	set(CMAKE_C_FLAGS_RELEASE   "${CMAKE_C_FLAGS_RELEASE}   /Zi")
+	set(CMAKE_EXE_LINKER_FLAGS_RELEASE    "${CMAKE_EXE_LINKER_FLAGS_RELEASE}    /DEBUG")
+	set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG")
+	set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /DEBUG")
 endif()
 
 set(EXECUTABLE MCServer)
@@ -114,10 +232,10 @@ endif ()
 
 if (NOT MSVC)
 	target_link_libraries(${EXECUTABLE} OSSupport HTTPServer Bindings Items Blocks)
-	target_link_libraries(${EXECUTABLE} Protocol Generating WorldStorage)
+	target_link_libraries(${EXECUTABLE} Protocol Generating Generating_Prefabs WorldStorage)
 	target_link_libraries(${EXECUTABLE} Mobs Entities Simulator UI BlockEntities)
 endif ()
 if (WIN32)
 	target_link_libraries(${EXECUTABLE} expat tolualib ws2_32.lib Psapi.lib)
 endif()
-target_link_libraries(${EXECUTABLE} md5 luaexpat iniFile jsoncpp cryptopp zlib lua sqlite)
+target_link_libraries(${EXECUTABLE} md5 luaexpat iniFile jsoncpp polarssl zlib lua sqlite)
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index a72464ec3..22b33c595 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -19,6 +19,8 @@
 #include "BlockEntities/JukeboxEntity.h"
 #include "BlockEntities/NoteEntity.h"
 #include "BlockEntities/SignEntity.h"
+#include "BlockEntities/MobHeadEntity.h"
+#include "BlockEntities/FlowerPotEntity.h"
 #include "Entities/Pickup.h"
 #include "Item.h"
 #include "Noise.h"
@@ -31,7 +33,7 @@
 #include "Simulator/FluidSimulator.h"
 #include "MobCensus.h"
 #include "MobSpawner.h"
-
+#include "BlockInServerPluginInterface.h"
 
 #include "json/json.h"
 
@@ -422,7 +424,6 @@ bool cChunk::HasBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 
 
-/// Sets or resets the internal flag that prevents chunk from being unloaded
 void cChunk::Stay(bool a_Stay)
 {
 	m_StayCount += (a_Stay ? 1 : -1);
@@ -562,13 +563,6 @@ void cChunk::Tick(float a_Dt)
 {
 	BroadcastPendingBlockChanges();
 
-	// Unload the chunk from all clients that have queued unloading:
-	for (cClientHandleList::iterator itr = m_UnloadQuery.begin(), end = m_UnloadQuery.end(); itr != end; ++itr)
-	{
-		(*itr)->SendUnloadChunk(m_PosX, m_PosZ);
-	}
-	m_UnloadQuery.clear();
-	
 	// Set all blocks that have been queued for setting later:
 	ProcessQueuedSetBlocks();
 
@@ -638,7 +632,9 @@ void cChunk::TickBlock(int a_RelX, int a_RelY, int a_RelZ)
 	unsigned Index = MakeIndex(a_RelX, a_RelY, a_RelZ);
 	cBlockHandler * Handler = BlockHandler(m_BlockTypes[Index]);
 	ASSERT(Handler != NULL);  // Happenned on server restart, FS #243
-	Handler->OnUpdate(*this, a_RelX, a_RelY, a_RelZ);
+	cChunkInterface ChunkInterface(this->GetWorld()->GetChunkMap());
+	cBlockInServerPluginInterface PluginInterface(*this->GetWorld());
+	Handler->OnUpdate(ChunkInterface, *this->GetWorld(), PluginInterface,*this, a_RelX, a_RelY, a_RelZ);
 }
 
 
@@ -753,7 +749,7 @@ void cChunk::BroadcastPendingBlockChanges(void)
 
 
 
-void cChunk::CheckBlocks(void)
+void cChunk::CheckBlocks()
 {
 	if (m_ToTickBlocks.size() == 0)
 	{
@@ -762,13 +758,16 @@ void cChunk::CheckBlocks(void)
 	std::vector<unsigned int> ToTickBlocks;
 	std::swap(m_ToTickBlocks, ToTickBlocks);
 	
+	cChunkInterface ChunkInterface(m_World->GetChunkMap());
+	cBlockInServerPluginInterface PluginInterface(*m_World);
+	
 	for (std::vector<unsigned int>::const_iterator itr = ToTickBlocks.begin(), end = ToTickBlocks.end(); itr != end; ++itr)
 	{
 		unsigned int index = (*itr);
 		Vector3i BlockPos = IndexToCoordinate(index);
 
 		cBlockHandler * Handler = BlockHandler(GetBlock(index));
-		Handler->Check(BlockPos.x, BlockPos.y, BlockPos.z, *this);
+		Handler->Check(ChunkInterface, PluginInterface, BlockPos.x, BlockPos.y, BlockPos.z, *this);
 	}  // for itr - ToTickBlocks[]
 }
 
@@ -786,6 +785,9 @@ void cChunk::TickBlocks(void)
 	int TickX = m_BlockTickX;
 	int TickY = m_BlockTickY;
 	int TickZ = m_BlockTickZ;
+	
+	cChunkInterface ChunkInterface(this->GetWorld()->GetChunkMap());
+	cBlockInServerPluginInterface PluginInterface(*this->GetWorld());
 
 	// This for loop looks disgusting, but it actually does a simple thing - first processes m_BlockTick, then adds random to it
 	// This is so that SetNextBlockTick() works
@@ -811,7 +813,7 @@ void cChunk::TickBlocks(void)
 		unsigned int Index = MakeIndexNoCheck(m_BlockTickX, m_BlockTickY, m_BlockTickZ);
 		cBlockHandler * Handler = BlockHandler(m_BlockTypes[Index]);
 		ASSERT(Handler != NULL);  // Happenned on server restart, FS #243
-		Handler->OnUpdate(*this, m_BlockTickX, m_BlockTickY, m_BlockTickZ);
+		Handler->OnUpdate(ChunkInterface, *this->GetWorld(), PluginInterface, *this, m_BlockTickX, m_BlockTickY, m_BlockTickZ);
 	}  // for i - tickblocks
 }
 
@@ -882,7 +884,7 @@ void cChunk::ApplyWeatherToTop()
 					FastSetBlock(X, Height, Z, E_BLOCK_SNOW, TopMeta - 1);
 				}
 			}
-			else if (g_BlockIsSnowable[TopBlock])
+			else if (cBlockInfo::IsSnowable(TopBlock) && (Height + 1 < cChunkDef::Height))
 			{
 				SetBlock(X, Height + 1, Z, E_BLOCK_SNOW, 0);
 			}
@@ -1307,8 +1309,10 @@ void cChunk::CreateBlockEntities(void)
 					case E_BLOCK_HOPPER:
 					case E_BLOCK_SIGN_POST:
 					case E_BLOCK_WALLSIGN:
+					case E_BLOCK_HEAD:
 					case E_BLOCK_NOTE_BLOCK:
 					case E_BLOCK_JUKEBOX:
+					case E_BLOCK_FLOWER_POT:
 					{
 						if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
 						{
@@ -1435,8 +1439,10 @@ void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType,
 		case E_BLOCK_HOPPER:
 		case E_BLOCK_SIGN_POST:
 		case E_BLOCK_WALLSIGN:
+		case E_BLOCK_HEAD:
 		case E_BLOCK_NOTE_BLOCK:
 		case E_BLOCK_JUKEBOX:
+		case E_BLOCK_FLOWER_POT:
 		{
 			AddBlockEntity(cBlockEntity::CreateByBlockType(a_BlockType, a_BlockMeta, WorldPos.x, WorldPos.y, WorldPos.z, m_World));
 			break;
@@ -1537,10 +1543,10 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
 	SetNibble(m_BlockMeta, index, a_BlockMeta);
 
 	// ONLY recalculate lighting if it's necessary!
-	if(
-		(g_BlockLightValue[OldBlockType ]        != g_BlockLightValue[a_BlockType]) ||
-		(g_BlockSpreadLightFalloff[OldBlockType] != g_BlockSpreadLightFalloff[a_BlockType]) ||
-		(g_BlockTransparent[OldBlockType]        != g_BlockTransparent[a_BlockType])
+	if (
+		(cBlockInfo::GetLightValue        (OldBlockType) != cBlockInfo::GetLightValue        (a_BlockType)) ||
+		(cBlockInfo::GetSpreadLightFalloff(OldBlockType) != cBlockInfo::GetSpreadLightFalloff(a_BlockType)) ||
+		(cBlockInfo::IsTransparent        (OldBlockType) != cBlockInfo::IsTransparent        (a_BlockType))
 	)
 	{
 		m_IsLightValid = false;
@@ -1645,6 +1651,38 @@ void cChunk::UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z)
 
 
 
+void cChunk::SetBiomeAt(int a_RelX, int a_RelZ, EMCSBiome a_Biome)
+{
+	cChunkDef::SetBiome(m_BiomeMap, a_RelX, a_RelZ, a_Biome);
+	MarkDirty();
+}
+
+
+
+
+
+void cChunk::SetAreaBiome(int a_MinRelX, int a_MaxRelX, int a_MinRelZ, int a_MaxRelZ, EMCSBiome a_Biome)
+{
+	for (int z = a_MinRelZ; z <= a_MaxRelZ; z++)
+	{
+		for (int x = a_MinRelX; x <= a_MaxRelX; x++)
+		{
+			cChunkDef::SetBiome(m_BiomeMap, x, z, a_Biome);
+		}
+	}
+	MarkDirty();
+	
+	// Re-send the chunk to all clients:
+	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
+	{
+		m_World->ForceSendChunkTo(m_PosX, m_PosZ, (*itr));
+	}  // for itr - m_LoadedByClient[]
+}
+
+
+
+
+
 void cChunk::CollectPickupsByPlayer(cPlayer * a_Player)
 {
 	double PosX = a_Player->GetPosX();
@@ -2302,6 +2340,70 @@ bool cChunk::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCom
 
 
 
+bool cChunk::DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback & a_Callback)
+{
+	// The blockentity list is locked by the parent chunkmap's CS
+	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(), itr2 = itr; itr != m_BlockEntities.end(); itr = itr2)
+	{
+		++itr2;
+		if (((*itr)->GetPosX() != a_BlockX) || ((*itr)->GetPosY() != a_BlockY) || ((*itr)->GetPosZ() != a_BlockZ))
+		{
+			continue;
+		}
+		if ((*itr)->GetBlockType() != E_BLOCK_HEAD)
+		{
+			// There is a block entity here, but of different type. No other block entity can be here, so we can safely bail out
+			return false;
+		}
+		
+		// The correct block entity is here, 
+		if (a_Callback.Item((cMobHeadEntity *)*itr))
+		{
+			return false;
+		}
+		return true;
+	}  // for itr - m_BlockEntitites[]
+	
+	// Not found:
+	return false;
+}
+
+
+
+
+
+bool cChunk::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback & a_Callback)
+{
+	// The blockentity list is locked by the parent chunkmap's CS
+	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(), itr2 = itr; itr != m_BlockEntities.end(); itr = itr2)
+	{
+		++itr2;
+		if (((*itr)->GetPosX() != a_BlockX) || ((*itr)->GetPosY() != a_BlockY) || ((*itr)->GetPosZ() != a_BlockZ))
+		{
+			continue;
+		}
+		if ((*itr)->GetBlockType() != E_BLOCK_FLOWER_POT)
+		{
+			// There is a block entity here, but of different type. No other block entity can be here, so we can safely bail out
+			return false;
+		}
+		
+		// The correct block entity is here, 
+		if (a_Callback.Item((cFlowerPotEntity *)*itr))
+		{
+			return false;
+		}
+		return true;
+	}  // for itr - m_BlockEntitites[]
+	
+	// Not found:
+	return false;
+}
+
+
+
+
+
 bool cChunk::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4)
 {
 	// The blockentity list is locked by the parent chunkmap's CS
@@ -2408,6 +2510,17 @@ cChunk * cChunk::GetNeighborChunk(int a_BlockX, int a_BlockZ)
 
 cChunk * cChunk::GetRelNeighborChunk(int a_RelX, int a_RelZ)
 {
+	// If the relative coords are too far away, use the parent's chunk lookup instead:
+	if ((a_RelX < 128) || (a_RelX > 128) || (a_RelZ < -128) || (a_RelZ > 128))
+	{
+		int BlockX = m_PosX * cChunkDef::Width + a_RelX;
+		int BlockZ = m_PosZ * cChunkDef::Width + a_RelZ;
+		int BlockY, ChunkX, ChunkZ;
+		AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
+		return m_ChunkMap->GetChunkNoLoad(ChunkX, ZERO_CHUNK_Y, ChunkZ);
+	}
+
+	// Walk the neighbors:
 	bool ReturnThis = true;
 	if (a_RelX < 0)
 	{
diff --git a/src/Chunk.h b/src/Chunk.h
index 4ac38c46c..b3fa563cc 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -6,7 +6,7 @@
 
 #include "Simulator/FireSimulator.h"
 #include "Simulator/SandSimulator.h"
-#include "Simulator/RedstoneSimulator.h"
+#include "Simulator/IncrementalRedstoneSimulator.h"
 
 
 
@@ -31,6 +31,8 @@ class cChestEntity;
 class cDispenserEntity;
 class cFurnaceEntity;
 class cNoteEntity;
+class cMobHeadEntity;
+class cFlowerPotEntity;
 class cBlockArea;
 class cPawn;
 class cPickup;
@@ -47,6 +49,8 @@ typedef cItemCallback<cDispenserEntity>    cDispenserCallback;
 typedef cItemCallback<cFurnaceEntity>      cFurnaceCallback;
 typedef cItemCallback<cNoteEntity>         cNoteBlockCallback;
 typedef cItemCallback<cCommandBlockEntity> cCommandBlockCallback;
+typedef cItemCallback<cMobHeadEntity>      cMobHeadCallback;
+typedef cItemCallback<cFlowerPotEntity>    cFlowerPotCallback;
 
 
 
@@ -85,10 +89,10 @@ public:
 	void MarkLoaded(void);  // Marks the chunk as freshly loaded. Fails if the chunk is already valid
 	void MarkLoadFailed(void);  // Marks the chunk as failed to load. Ignored is the chunk is already valid
 	
-	/// Gets all chunk data, calls the a_Callback's methods for each data type
+	/** Gets all chunk data, calls the a_Callback's methods for each data type */
 	void GetAllData(cChunkDataCallback & a_Callback);
 	
-	/// Sets all chunk data
+	/** Sets all chunk data */
 	void SetAllData(
 		const BLOCKTYPE *  a_BlockTypes, 
 		const NIBBLETYPE * a_BlockMeta,
@@ -104,27 +108,29 @@ public:
 		const cChunkDef::BlockNibbles & a_SkyLight
 	);
 	
-	/// Copies m_BlockData into a_BlockTypes, only the block types
+	/** Copies m_BlockData into a_BlockTypes, only the block types */
 	void GetBlockTypes(BLOCKTYPE  * a_BlockTypes);
 	
-	/// Writes the specified cBlockArea at the coords specified. Note that the coords may extend beyond the chunk!
+	/** Writes the specified cBlockArea at the coords specified. Note that the coords may extend beyond the chunk! */
 	void WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);
 
-	/// Returns true if there is a block entity at the coords specified
+	/** Returns true if there is a block entity at the coords specified */
 	bool HasBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ);
 	
-	/// Sets or resets the internal flag that prevents chunk from being unloaded
+	/** Sets or resets the internal flag that prevents chunk from being unloaded.
+	The flag is cumulative - it can be set multiple times and then needs to be un-set that many times
+	before the chunk is unloadable again. */
 	void Stay(bool a_Stay = true);
 	
-	/// Recence all mobs proximities to players in order to know what to do with them
+	/** Recence all mobs proximities to players in order to know what to do with them */
 	void CollectMobCensus(cMobCensus& toFill);
 
-	/// Try to Spawn Monsters inside chunk
+	/** Try to Spawn Monsters inside chunk */
 	void SpawnMobs(cMobSpawner& a_MobSpawner);
 
 	void Tick(float a_Dt);
 	
-	/// Ticks a single block. Used by cWorld::TickQueuedBlocks() to tick the queued blocks
+	/** Ticks a single block. Used by cWorld::TickQueuedBlocks() to tick the queued blocks */
 	void TickBlock(int a_RelX, int a_RelY, int a_RelZ);
 
 	int GetPosX(void) const { return m_PosX; }
@@ -137,13 +143,13 @@ public:
 	// SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense
 	void SetBlock( const Vector3i & a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta ) { SetBlock( a_RelBlockPos.x, a_RelBlockPos.y, a_RelBlockPos.z, a_BlockType, a_BlockMeta ); }
 	
-	/// Queues a block change till the specified world tick
+	/** Queues a block change till the specified world tick */
 	void QueueSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, Int64 a_Tick, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR);
 	
-	/// Queues block for ticking (m_ToTickQueue)
+	/** Queues block for ticking (m_ToTickQueue) */
 	void QueueTickBlock(int a_RelX, int a_RelY, int a_RelZ);
 	
-	/// Queues all 6 neighbors of the specified block for ticking (m_ToTickQueue). If any are outside the chunk, relays the checking to the proper neighboring chunk
+	/** Queues all 6 neighbors of the specified block for ticking (m_ToTickQueue). If any are outside the chunk, relays the checking to the proper neighboring chunk */
 	void QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ);
 
 	void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta );  // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc.
@@ -173,16 +179,24 @@ public:
 	
 	EMCSBiome GetBiomeAt(int a_RelX, int a_RelZ) const {return cChunkDef::GetBiome(m_BiomeMap, a_RelX, a_RelZ); }
 	
+	/** Sets the biome at the specified relative coords.
+	Doesn't resend the chunk to clients. */
+	void SetBiomeAt(int a_RelX, int a_RelZ, EMCSBiome a_Biome);
+	
+	/** Sets the biome in the specified relative coords area. All the coords are inclusive.
+	Sends the chunk to all relevant clients. */
+	void SetAreaBiome(int a_MinRelX, int a_MaxRelX, int a_MinRelZ, int a_MaxRelZ, EMCSBiome a_Biome);
+	
 	void CollectPickupsByPlayer(cPlayer * a_Player);
 	
-	/// Sets the sign text. Returns true if successful. Also sends update packets to all clients in the chunk
+	/** Sets the sign text. Returns true if successful. Also sends update packets to all clients in the chunk */
 	bool SetSignLines(int a_RelX, int a_RelY, int a_RelZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
 
 	int  GetHeight( int a_X, int a_Z );
 
 	void SendBlockTo(int a_RelX, int a_RelY, int a_RelZ, cClientHandle * a_Client);
 
-	/// Adds a client to the chunk; returns true if added, false if already there
+	/** Adds a client to the chunk; returns true if added, false if already there */
 	bool AddClient    (cClientHandle* a_Client );
 	
 	void RemoveClient (cClientHandle* a_Client );
@@ -193,55 +207,61 @@ public:
 	void RemoveEntity(cEntity * a_Entity);
 	bool HasEntity(int a_EntityID);
 	
-	/// Calls the callback for each entity; returns true if all entities processed, false if the callback aborted by returning true
+	/** Calls the callback for each entity; returns true if all entities processed, false if the callback aborted by returning true */
 	bool ForEachEntity(cEntityCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found.
+	/** Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found. */
 	bool DoWithEntityByID(int a_EntityID, cEntityCallback & a_Callback, bool & a_CallbackResult);  // Lua-accessible
 
-	/// Calls the callback for each block entity; returns true if all block entities processed, false if the callback aborted by returning true
+	/** Calls the callback for each block entity; returns true if all block entities processed, false if the callback aborted by returning true */
 	bool ForEachBlockEntity(cBlockEntityCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for each chest; returns true if all chests processed, false if the callback aborted by returning true
+	/** Calls the callback for each chest; returns true if all chests processed, false if the callback aborted by returning true */
 	bool ForEachChest(cChestCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for each dispenser; returns true if all dispensers processed, false if the callback aborted by returning true
+	/** Calls the callback for each dispenser; returns true if all dispensers processed, false if the callback aborted by returning true */
 	bool ForEachDispenser(cDispenserCallback & a_Callback);
 
-	/// Calls the callback for each dropper; returns true if all droppers processed, false if the callback aborted by returning true
+	/** Calls the callback for each dropper; returns true if all droppers processed, false if the callback aborted by returning true */
 	bool ForEachDropper(cDropperCallback & a_Callback);
 
-	/// Calls the callback for each dropspenser; returns true if all dropspensers processed, false if the callback aborted by returning true
+	/** Calls the callback for each dropspenser; returns true if all dropspensers processed, false if the callback aborted by returning true */
 	bool ForEachDropSpenser(cDropSpenserCallback & a_Callback);
 
-	/// Calls the callback for each furnace; returns true if all furnaces processed, false if the callback aborted by returning true
+	/** Calls the callback for each furnace; returns true if all furnaces processed, false if the callback aborted by returning true */
 	bool ForEachFurnace(cFurnaceCallback & a_Callback);  // Lua-accessible
 	
-	/// Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found
+	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
 	bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback & a_Callback);  // Lua-acessible
 
-	/// Calls the callback for the chest at the specified coords; returns false if there's no chest at those coords, true if found
+	/** Calls the callback for the chest at the specified coords; returns false if there's no chest at those coords, true if found */
 	bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback & a_Callback);  // Lua-acessible
 
-	/// Calls the callback for the dispenser at the specified coords; returns false if there's no dispenser at those coords or callback returns true, returns true if found
+	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dispenser at those coords or callback returns true, returns true if found */
 	bool DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback & a_Callback);
 
-	/// Calls the callback for the dispenser at the specified coords; returns false if there's no dropper at those coords or callback returns true, returns true if found
+	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dropper at those coords or callback returns true, returns true if found */
 	bool DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback & a_Callback);
 
-	/// Calls the callback for the dispenser at the specified coords; returns false if there's no dropspenser at those coords or callback returns true, returns true if found
+	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dropspenser at those coords or callback returns true, returns true if found */
 	bool DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback & a_Callback);
 
-	/// Calls the callback for the furnace at the specified coords; returns false if there's no furnace at those coords or callback returns true, returns true if found
+	/** Calls the callback for the furnace at the specified coords; returns false if there's no furnace at those coords or callback returns true, returns true if found */
 	bool DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for the noteblock at the specified coords; returns false if there's no noteblock at those coords or callback returns true, returns true if found
+	/** Calls the callback for the noteblock at the specified coords; returns false if there's no noteblock at those coords or callback returns true, returns true if found */
 	bool DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback & a_Callback);
 
-	/// Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found
-	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback & a_Callback); 
+	/** Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found */
+	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback & a_Callback);
+	
+	/** Calls the callback for the mob head block at the specified coords; returns false if there's no mob head block at those coords or callback returns true, returns true if found */
+	bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback & a_Callback);
+
+	/** Calls the callback for the flower pot at the specified coords; returns false if there's no flower pot at those coords or callback returns true, returns true if found */
+	bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback & a_Callback);
 
-	/// Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found
+	/** Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found */
 	bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Lua-accessible
 
 	void UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z);  // [x, y, z] in world block coords
@@ -292,7 +312,7 @@ public:
 		m_IsSaving = false;
 	}
 	
-	/// Sets the blockticking to start at the specified block. Only one blocktick may be set, second call overwrites the first call
+	/** Sets the blockticking to start at the specified block. Only one blocktick may be set, second call overwrites the first call */
 	inline void SetNextBlockTick(int a_RelX, int a_RelY, int a_RelZ)
 	{
 		m_BlockTickX = a_RelX;
@@ -310,43 +330,48 @@ public:
 	inline NIBBLETYPE GetBlockLight(int a_Idx) const {return cChunkDef::GetNibble(m_BlockLight, a_Idx); }
 	inline NIBBLETYPE GetSkyLight  (int a_Idx) const {return cChunkDef::GetNibble(m_BlockSkyLight, a_Idx); }
 	
-	/// Same as GetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as GetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 	
-	/// Same as GetBlockType(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as GetBlockType(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelGetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType) const;
 	
-	/// Same as GetBlockMeta(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as GetBlockMeta(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelGetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockMeta) const;
 	
-	/// Same as GetBlockBlockLight(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as GetBlockBlockLight(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelGetBlockBlockLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockLight) const;
 
-	/// Same as GetBlockSkyLight(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as GetBlockSkyLight(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelGetBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_SkyLight) const;
 
-	/// Queries both BlockLight and SkyLight, relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Queries both BlockLight and SkyLight, relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelGetBlockLights(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockLight, NIBBLETYPE & a_SkyLight) const;
 
-	/// Same as SetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as SetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
-	/// Same as FastSetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	/** Same as FastSetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
 	bool UnboundedRelFastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
-	/// Same as QueueTickBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s in such a case), ignores unsuccessful attempts
+	/** Same as QueueTickBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s in such a case), ignores unsuccessful attempts */
 	void UnboundedQueueTickBlock(int a_RelX, int a_RelY, int a_RelZ);
 
-	/// Light alterations based on time
+	/** Light alterations based on time */
 	NIBBLETYPE GetTimeAlteredLight(NIBBLETYPE a_Skylight) const;
 
 
-	// Simulator data:
+	// Per-chunk simulator data:
 	cFireSimulatorChunkData & GetFireSimulatorData (void) { return m_FireSimulatorData; }
 	cFluidSimulatorData *     GetWaterSimulatorData(void) { return m_WaterSimulatorData; }
 	cFluidSimulatorData *     GetLavaSimulatorData (void) { return m_LavaSimulatorData; }
 	cSandSimulatorChunkData & GetSandSimulatorData (void) { return m_SandSimulatorData; }
-	cRedstoneSimulatorChunkData & GetRedstoneSimulatorData(void) { return m_RedstoneSimulatorData; }
+
+	cRedstoneSimulatorChunkData * GetRedstoneSimulatorData(void) { return &m_RedstoneSimulatorData; }
+	cIncrementalRedstoneSimulator::PoweredBlocksList * GetRedstoneSimulatorPoweredBlocksList(void) { return &m_RedstoneSimulatorPoweredBlocksList; }
+	cIncrementalRedstoneSimulator::LinkedBlocksList * GetRedstoneSimulatorLinkedBlocksList(void) { return &m_RedstoneSimulatorLinkedBlocksList; };
+	cIncrementalRedstoneSimulator::SimulatedPlayerToggleableList * GetRedstoneSimulatorSimulatedPlayerToggleableList(void) { return &m_RedstoneSimulatorSimulatedPlayerToggleableList; };
+	cIncrementalRedstoneSimulator::RepeatersDelayList * GetRedstoneSimulatorRepeatersDelayList(void) { return &m_RedstoneSimulatorRepeatersDelayList; };
 
 	cBlockEntity * GetBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ);
 	cBlockEntity * GetBlockEntity(const Vector3i & a_BlockPos) { return GetBlockEntity(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z); }
@@ -385,11 +410,10 @@ private:
 	
 	// A critical section is not needed, because all chunk access is protected by its parent ChunkMap's csLayers
 	cClientHandleList  m_LoadedByClient;
-	cClientHandleList  m_UnloadQuery;
 	cEntityList        m_Entities;
 	cBlockEntityList   m_BlockEntities;
 	
-	/// Number of times the chunk has been requested to stay (by various cChunkStay objects); if zero, the chunk can be unloaded
+	/** Number of times the chunk has been requested to stay (by various cChunkStay objects); if zero, the chunk can be unloaded */
 	int m_StayCount;
 
 	int m_PosX, m_PosY, m_PosZ;
@@ -417,7 +441,12 @@ private:
 	cFluidSimulatorData *   m_WaterSimulatorData;
 	cFluidSimulatorData *   m_LavaSimulatorData;
 	cSandSimulatorChunkData m_SandSimulatorData;
+
 	cRedstoneSimulatorChunkData m_RedstoneSimulatorData;
+	cIncrementalRedstoneSimulator::PoweredBlocksList m_RedstoneSimulatorPoweredBlocksList;
+	cIncrementalRedstoneSimulator::LinkedBlocksList m_RedstoneSimulatorLinkedBlocksList;
+	cIncrementalRedstoneSimulator::SimulatedPlayerToggleableList m_RedstoneSimulatorSimulatedPlayerToggleableList;
+	cIncrementalRedstoneSimulator::RepeatersDelayList m_RedstoneSimulatorRepeatersDelayList;
 
 
 	// pick up a random block of this chunk
@@ -427,40 +456,40 @@ private:
 	void RemoveBlockEntity(cBlockEntity * a_BlockEntity);
 	void AddBlockEntity   (cBlockEntity * a_BlockEntity);
 
-	/// Creates a block entity for each block that needs a block entity and doesn't have one in the list
+	/** Creates a block entity for each block that needs a block entity and doesn't have one in the list */
 	void CreateBlockEntities(void);
 	
-	/// Wakes up each simulator for its specific blocks; through all the blocks in the chunk
+	/** Wakes up each simulator for its specific blocks; through all the blocks in the chunk */
 	void WakeUpSimulators(void);
 	
 	// Makes a copy of the list
 	cClientHandleList GetAllClients(void) const {return m_LoadedByClient; }
 
-	/// Sends m_PendingSendBlocks to all clients
+	/** Sends m_PendingSendBlocks to all clients */
 	void BroadcastPendingBlockChanges(void);
 	
-	/// Checks the block scheduled for checking in m_ToTickBlocks[]
-	void CheckBlocks(void);
+	/** Checks the block scheduled for checking in m_ToTickBlocks[] */
+	void CheckBlocks();
 	
-	/// Ticks several random blocks in the chunk
+	/** Ticks several random blocks in the chunk */
 	void TickBlocks(void);
 	
-	/// Adds snow to the top of snowy biomes and hydrates farmland / fills cauldrons in rainy biomes
+	/** Adds snow to the top of snowy biomes and hydrates farmland / fills cauldrons in rainy biomes */
 	void ApplyWeatherToTop(void);
 	
-	/// Grows sugarcane by the specified number of blocks, but no more than 3 blocks high (used by both bonemeal and ticking)
+	/** Grows sugarcane by the specified number of blocks, but no more than 3 blocks high (used by both bonemeal and ticking) */
 	void GrowSugarcane   (int a_RelX, int a_RelY, int a_RelZ, int a_NumBlocks);
 	
-	/// Grows cactus by the specified number of blocks, but no more than 3 blocks high (used by both bonemeal and ticking)
+	/** Grows cactus by the specified number of blocks, but no more than 3 blocks high (used by both bonemeal and ticking) */
 	void GrowCactus      (int a_RelX, int a_RelY, int a_RelZ, int a_NumBlocks);
 
-	/// Grows a melon or a pumpkin next to the block specified (assumed to be the stem)
+	/** Grows a melon or a pumpkin next to the block specified (assumed to be the stem) */
 	void GrowMelonPumpkin(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, MTRand & a_Random);
 	
-	/// Called by Tick() when an entity moves out of this chunk into a neighbor; moves the entity and sends spawn / despawn packet to clients
+	/** Called by Tick() when an entity moves out of this chunk into a neighbor; moves the entity and sends spawn / despawn packet to clients */
 	void MoveEntityToNewChunk(cEntity * a_Entity);
 	
-	/// Processes all blocks that have been scheduled for replacement by the QueueSetBlock() function
+	/** Processes all blocks that have been scheduled for replacement by the QueueSetBlock() function */
 	void ProcessQueuedSetBlocks(void);
 };
 
diff --git a/src/ChunkDef.h b/src/ChunkDef.h
index d1288994c..9c7753820 100644
--- a/src/ChunkDef.h
+++ b/src/ChunkDef.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "Vector3i.h"
+#include "Vector3.h"
 #include "BiomeDef.h"
 
 
@@ -62,16 +62,12 @@ typedef unsigned char HEIGHTTYPE;
 class cChunkDef
 {
 public:
-	enum
-	{
-		// Chunk dimensions:
-		Width = 16,
-		Height = 256,
-		NumBlocks = Width * Height * Width,
-		
-		/// If the data is collected into a single buffer, how large it needs to be:
-		BlockDataSize = cChunkDef::NumBlocks * 2 + (cChunkDef::NumBlocks / 2),  // 2.5 * numblocks
-	} ;
+	// Chunk dimensions:
+	static const int Width = 16;
+	static const int Height = 256;
+	static const int NumBlocks = Width * Height * Width;
+	/// If the data is collected into a single buffer, how large it needs to be:
+	static const int BlockDataSize = cChunkDef::NumBlocks * 2 + (cChunkDef::NumBlocks / 2);  // 2.5 * numblocks
 
 	/// The type used for any heightmap operations and storage; idx = x + Width * z; Height points to the highest non-air block in the column
 	typedef HEIGHTTYPE HeightMap[Width * Width];
@@ -116,7 +112,7 @@ public:
 	}
 
 
-	inline static unsigned int MakeIndex(int x, int y, int z )
+	inline static int MakeIndex(int x, int y, int z )
 	{
 		if (
 			(x < Width)  && (x > -1) &&
@@ -132,7 +128,7 @@ public:
 	}
 
 
-	inline static unsigned int MakeIndexNoCheck(int x, int y, int z)
+	inline static int MakeIndexNoCheck(int x, int y, int z)
 	{
 		#if AXIS_ORDER == AXIS_ORDER_XZY
 			// For some reason, NOT using the Horner schema is faster. Weird.
@@ -255,7 +251,7 @@ public:
 			ASSERT(!"cChunkDef::SetNibble(): index out of range!");
 			return;
 		}
-		a_Buffer[a_BlockIdx / 2] = (
+		a_Buffer[a_BlockIdx / 2] = static_cast<NIBBLETYPE>(
 			(a_Buffer[a_BlockIdx / 2] & (0xf0 >> ((a_BlockIdx & 1) * 4))) |  // The untouched nibble
 			((a_Nibble & 0x0f) << ((a_BlockIdx & 1) * 4))  // The nibble being set
 		);
@@ -275,20 +271,20 @@ public:
 		}
 
 		int Index = MakeIndexNoCheck(x, y, z);
-		a_Buffer[Index / 2] = (
+		a_Buffer[Index / 2] = static_cast<NIBBLETYPE>(
 			(a_Buffer[Index / 2] & (0xf0 >> ((Index & 1) * 4))) |  // The untouched nibble
 			((a_Nibble & 0x0f) << ((Index & 1) * 4))  // The nibble being set
 		);
 	}
 
 
-	inline static char GetNibble(const NIBBLETYPE * a_Buffer, const Vector3i & a_BlockPos )
+	inline static NIBBLETYPE GetNibble(const NIBBLETYPE * a_Buffer, const Vector3i & a_BlockPos )
 	{
 		return GetNibble(a_Buffer, a_BlockPos.x, a_BlockPos.y, a_BlockPos.z );
 	}
 	
 	
-	inline static void SetNibble(NIBBLETYPE * a_Buffer, const Vector3i & a_BlockPos, char a_Value )
+	inline static void SetNibble(NIBBLETYPE * a_Buffer, const Vector3i & a_BlockPos, NIBBLETYPE a_Value )
 	{
 		SetNibble( a_Buffer, a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, a_Value );
 	}
@@ -306,6 +302,9 @@ The virtual methods are called in the same order as they're declared here.
 class cChunkDataCallback abstract
 {
 public:
+
+	virtual ~cChunkDataCallback() {}
+
 	/** Called before any other callbacks to inform of the current coords 
 	(only in processes where multiple chunks can be processed, such as cWorld::ForEachChunkInRect()). 
 	If false is returned, the chunk is skipped.
@@ -432,6 +431,9 @@ Used primarily for entity moving while both chunks are locked.
 class cClientDiffCallback
 {
 public:
+
+	virtual ~cClientDiffCallback() {}
+
 	/// Called for clients that are in Chunk1 and not in Chunk2,
 	virtual void Removed(cClientHandle * a_Client) = 0;
 	
@@ -482,6 +484,7 @@ public:
 } ;
 
 typedef std::list<cChunkCoords> cChunkCoordsList;
+typedef std::vector<cChunkCoords> cChunkCoordsVector;
 
 
 
@@ -491,6 +494,9 @@ typedef std::list<cChunkCoords> cChunkCoordsList;
 class cChunkCoordCallback
 {
 public:
+
+	virtual ~cChunkCoordCallback() {}
+
 	virtual void Call(int a_ChunkX, int a_ChunkZ) = 0;
 } ;
 
@@ -498,7 +504,7 @@ public:
 
 
 
-/// Generic template that can store any kind of data together with a triplet of 3 coords:
+/** Generic template that can store any kind of data together with a triplet of 3 coords*/
 template <typename X> class cCoordWithData
 {
 public:
@@ -518,12 +524,40 @@ public:
 	}
 } ;
 
-// Illegal in C++03: typedef std::list< cCoordWithData<X> > cCoordWithDataList<X>;
 typedef cCoordWithData<int>        cCoordWithInt;
 typedef cCoordWithData<BLOCKTYPE>  cCoordWithBlock;
+
 typedef std::list<cCoordWithInt>   cCoordWithIntList;
 typedef std::vector<cCoordWithInt> cCoordWithIntVector;
-typedef std::vector<cCoordWithBlock> cCoordWithBlockVector;
+
+
+
+
+
+/** Generic template that can store two types of any kind of data together with a triplet of 3 coords */
+template <typename X, typename Z> class cCoordWithDoubleData
+{
+public:
+	int x;
+	int y;
+	int z;
+	X   Data;
+	Z   DataTwo;
+
+	cCoordWithDoubleData(int a_X, int a_Y, int a_Z) :
+		x(a_X), y(a_Y), z(a_Z)
+	{
+	}
+
+	cCoordWithDoubleData(int a_X, int a_Y, int a_Z, const X & a_Data, const Z & a_DataTwo) :
+		x(a_X), y(a_Y), z(a_Z), Data(a_Data), DataTwo(a_DataTwo)
+	{
+	}
+};
+
+typedef cCoordWithDoubleData <BLOCKTYPE, bool> cCoordWithBlockAndBool;
+
+typedef std::vector<cCoordWithBlockAndBool> cCoordWithBlockAndBoolVector;
 
 
 
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index 5797eb453..e695f0ab2 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -15,6 +15,9 @@
 #include "Blocks/BlockHandler.h"
 #include "MobCensus.h"
 #include "MobSpawner.h"
+#include "BoundingBox.h"
+
+#include "Entities/Pickup.h"
 
 #ifndef _WIN32
 	#include <cstdlib> // abs
@@ -131,7 +134,7 @@ cChunkMap::cChunkLayer * cChunkMap::GetLayerForChunk(int a_ChunkX, int a_ChunkZ)
 
 
 
-cChunkPtr cChunkMap::GetChunk( int a_ChunkX, int a_ChunkY, int a_ChunkZ )
+cChunkPtr cChunkMap::GetChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
 {
 	// No need to lock m_CSLayers, since it's already locked by the operation that called us
 	ASSERT(m_CSLayers.IsLockedByCurrentThread());
@@ -802,6 +805,10 @@ void cChunkMap::WakeUpSimulators(int a_BlockX, int a_BlockY, int a_BlockZ)
 /// Wakes up the simulators for the specified area of blocks
 void cChunkMap::WakeUpSimulatorsInArea(int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ)
 {
+	// Limit the Y coords:
+	a_MinBlockY = std::max(a_MinBlockY, 0);
+	a_MaxBlockY = std::min(a_MaxBlockY, cChunkDef::Height - 1);
+	
 	cSimulatorManager * SimMgr = m_World->GetSimulatorManager();
 	int MinChunkX, MinChunkZ, MaxChunkX, MaxChunkZ;
 	cChunkDef::BlockToChunk(a_MinBlockX, a_MinBlockZ, MinChunkX, MinChunkZ);
@@ -894,17 +901,34 @@ void cChunkMap::SetChunkData(
 	bool a_MarkDirty
 )
 {
-	cCSLock Lock(m_CSLayers);
-	cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, ZERO_CHUNK_Y, a_ChunkZ);
-	if (Chunk == NULL)
 	{
-		return;
-	}
-	Chunk->SetAllData(a_BlockTypes, a_BlockMeta, a_BlockLight, a_BlockSkyLight, a_HeightMap, a_BiomeMap, a_BlockEntities);
-	
-	if (a_MarkDirty)
-	{
-		Chunk->MarkDirty();
+		cCSLock Lock(m_CSLayers);
+		cChunkPtr Chunk = GetChunkNoLoad(a_ChunkX, ZERO_CHUNK_Y, a_ChunkZ);
+		if (Chunk == NULL)
+		{
+			return;
+		}
+		Chunk->SetAllData(a_BlockTypes, a_BlockMeta, a_BlockLight, a_BlockSkyLight, a_HeightMap, a_BiomeMap, a_BlockEntities);
+		
+		if (a_MarkDirty)
+		{
+			Chunk->MarkDirty();
+		}
+		
+		// Notify relevant ChunkStays:
+		for (cChunkStays::iterator itr = m_ChunkStays.begin(); itr != m_ChunkStays.end(); )
+		{
+			if ((*itr)->ChunkAvailable(a_ChunkX, a_ChunkZ))
+			{
+				cChunkStays::iterator cur = itr;
+				++itr;
+				m_ChunkStays.erase(cur);
+			}
+			else
+			{
+				++itr;
+			}
+		}  // for itr - m_ChunkStays[]
 	}
 
 	// Notify plugins of the chunk becoming available
@@ -1117,6 +1141,21 @@ void cChunkMap::CollectPickupsByPlayer(cPlayer * a_Player)
 
 BLOCKTYPE cChunkMap::GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
 {
+	// First check if it isn't queued in the m_FastSetBlockQueue:
+	{
+		int X = a_BlockX, Y = a_BlockY, Z = a_BlockZ;
+		int ChunkX, ChunkY, ChunkZ;
+		cChunkDef::AbsoluteToRelative(X, Y, Z, ChunkX, ChunkZ);
+		ChunkY = 0;
+		cCSLock Lock(m_CSFastSetBlock);
+		for (sSetBlockList::iterator itr = m_FastSetBlockQueue.begin(); itr != m_FastSetBlockQueue.end(); ++itr)
+		{
+			if ((itr->x == X) && (itr->y == Y) && (itr->z == Z) && (itr->ChunkX == ChunkX) && (itr->ChunkZ == ChunkZ))
+			{
+				return itr->BlockType;
+			}
+		}  // for itr - m_FastSetBlockQueue[]
+	}
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ );
 	
@@ -1135,6 +1174,17 @@ BLOCKTYPE cChunkMap::GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 NIBBLETYPE cChunkMap::GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
 {
+	// First check if it isn't queued in the m_FastSetBlockQueue:
+	{
+		cCSLock Lock(m_CSFastSetBlock);
+		for (sSetBlockList::iterator itr = m_FastSetBlockQueue.begin(); itr != m_FastSetBlockQueue.end(); ++itr)
+		{
+			if ((itr->x == a_BlockX) && (itr->y == a_BlockY) && (itr->z == a_BlockZ))
+			{
+				return itr->BlockMeta;
+			}
+		}  // for itr - m_FastSetBlockQueue[]
+	}
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ );
 	
@@ -1207,8 +1257,14 @@ void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYP
 
 
 
-void cChunkMap::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta)
+void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta)
 {
+	cChunkInterface ChunkInterface(this);
+	if (a_BlockType == E_BLOCK_AIR)
+	{
+		BlockHandler(GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnDestroyed(ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
+	}
+
 	int ChunkX, ChunkZ, X = a_BlockX, Y = a_BlockY, Z = a_BlockZ;
 	cChunkDef::AbsoluteToRelative( X, Y, Z, ChunkX, ChunkZ );
 
@@ -1219,6 +1275,7 @@ void cChunkMap::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_B
 		Chunk->SetBlock(X, Y, Z, a_BlockType, a_BlockMeta );
 		m_World->GetSimulatorManager()->WakeUp(a_BlockX, a_BlockY, a_BlockZ, Chunk);
 	}
+	BlockHandler(a_BlockType)->OnPlaced(ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 }
 
 
@@ -1319,8 +1376,9 @@ void cChunkMap::ReplaceTreeBlocks(const sSetBlockVector & a_Blocks)
 				break;
 			}
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			{
-				if (itr->BlockType == E_BLOCK_LOG)
+				if ((itr->BlockType == E_BLOCK_LOG) || (itr->BlockType == E_BLOCK_NEW_LOG))
 				{
 					Chunk->SetBlock(itr->x, itr->y, itr->z, itr->BlockType, itr->BlockMeta);
 				}
@@ -1337,10 +1395,10 @@ void cChunkMap::ReplaceTreeBlocks(const sSetBlockVector & a_Blocks)
 EMCSBiome cChunkMap::GetBiomeAt (int a_BlockX, int a_BlockZ)
 {
 	int ChunkX, ChunkZ, X = a_BlockX, Y = 0, Z = a_BlockZ;
-	cChunkDef::AbsoluteToRelative( X, Y, Z, ChunkX, ChunkZ );
+	cChunkDef::AbsoluteToRelative(X, Y, Z, ChunkX, ChunkZ);
 
 	cCSLock Lock(m_CSLayers);
-	cChunkPtr Chunk = GetChunk( ChunkX, ZERO_CHUNK_Y, ChunkZ );
+	cChunkPtr Chunk = GetChunk(ChunkX, ZERO_CHUNK_Y, ChunkZ);
 	if ((Chunk != NULL) && Chunk->IsValid())
 	{
 		return Chunk->GetBiomeAt(X, Z);
@@ -1355,6 +1413,63 @@ EMCSBiome cChunkMap::GetBiomeAt (int a_BlockX, int a_BlockZ)
 
 
 
+bool cChunkMap::SetBiomeAt(int a_BlockX, int a_BlockZ, EMCSBiome a_Biome)
+{
+	int ChunkX, ChunkZ, X = a_BlockX, Y = 0, Z = a_BlockZ;
+	cChunkDef::AbsoluteToRelative(X, Y, Z, ChunkX, ChunkZ);
+
+	cCSLock Lock(m_CSLayers);
+	cChunkPtr Chunk = GetChunk(ChunkX, ZERO_CHUNK_Y, ChunkZ);
+	if ((Chunk != NULL) && Chunk->IsValid())
+	{
+		Chunk->SetBiomeAt(X, Z, a_Biome);
+		return true;
+	}
+	return false;
+}
+
+
+
+
+
+bool cChunkMap::SetAreaBiome(int a_MinX, int a_MaxX, int a_MinZ, int a_MaxZ, EMCSBiome a_Biome)
+{
+	// Translate coords to relative:
+	int Y = 0;
+	int MinChunkX, MinChunkZ, MinX = a_MinX, MinZ = a_MinZ;
+	int MaxChunkX, MaxChunkZ, MaxX = a_MaxX, MaxZ = a_MaxZ;
+	cChunkDef::AbsoluteToRelative(MinX, Y, MinZ, MinChunkX, MinChunkZ);
+	cChunkDef::AbsoluteToRelative(MaxX, Y, MaxZ, MaxChunkX, MaxChunkZ);
+	
+	// Go through all chunks, set:
+	bool res = true;
+	cCSLock Lock(m_CSLayers);
+	for (int x = MinChunkX; x <= MaxChunkX; x++)
+	{
+		int MinRelX = (x == MinChunkX) ? MinX : 0;
+		int MaxRelX = (x == MaxChunkX) ? MaxX : cChunkDef::Width - 1;
+		for (int z = MinChunkZ; z <= MaxChunkZ; z++)
+		{
+			int MinRelZ = (z == MinChunkZ) ? MinZ : 0;
+			int MaxRelZ = (z == MaxChunkZ) ? MaxZ : cChunkDef::Width - 1;
+			cChunkPtr Chunk = GetChunkNoLoad(x, ZERO_CHUNK_Y, z);
+			if ((Chunk != NULL) && Chunk->IsValid())
+			{
+				Chunk->SetAreaBiome(MinRelX, MaxRelX, MinRelZ, MaxRelZ, a_Biome);
+			}
+			else
+			{
+				res = false;
+			}
+		}  // for z
+	}  // for x
+	return res;
+}
+
+
+
+
+
 bool cChunkMap::GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure)
 {
 	bool res = true;
@@ -1624,105 +1739,203 @@ void cChunkMap::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_
 	{
 		return;
 	}
-	
+
+	bool ShouldDestroyBlocks = true;
+
 	// Don't explode if the explosion center is inside a liquid block:
-	switch (m_World->GetBlock((int)floor(a_BlockX), (int)floor(a_BlockY), (int)floor(a_BlockZ)))
+	if (IsBlockLiquid(m_World->GetBlock((int)floor(a_BlockX), (int)floor(a_BlockY), (int)floor(a_BlockZ))))
 	{
-		case E_BLOCK_WATER:
-		case E_BLOCK_STATIONARY_WATER:
-		case E_BLOCK_LAVA:
-		case E_BLOCK_STATIONARY_LAVA:
-		{
-			return;
-		}
+		ShouldDestroyBlocks = false;
 	}
-	
-	cBlockArea area;
+
+	int ExplosionSizeInt = (int)ceil(a_ExplosionSize);
+	int ExplosionSizeSq = ExplosionSizeInt * ExplosionSizeInt;
+
 	int bx = (int)floor(a_BlockX);
 	int by = (int)floor(a_BlockY);
 	int bz = (int)floor(a_BlockZ);
-	int ExplosionSizeInt = (int) ceil(a_ExplosionSize);
-	int ExplosionSizeSq =  ExplosionSizeInt * ExplosionSizeInt;
-	a_BlocksAffected.reserve(8 * ExplosionSizeInt * ExplosionSizeInt * ExplosionSizeInt);
+
 	int MinY = std::max((int)floor(a_BlockY - ExplosionSizeInt), 0);
 	int MaxY = std::min((int)ceil(a_BlockY + ExplosionSizeInt), cChunkDef::Height - 1);
-	area.Read(m_World, bx - ExplosionSizeInt, (int)ceil(a_BlockX + ExplosionSizeInt), MinY, MaxY, bz - ExplosionSizeInt, (int)ceil(a_BlockZ + ExplosionSizeInt));
-	for (int x = -ExplosionSizeInt; x < ExplosionSizeInt; x++)
+
+	if (ShouldDestroyBlocks)
 	{
-		for (int y = -ExplosionSizeInt; y < ExplosionSizeInt; y++)
+		cBlockArea area;
+
+		a_BlocksAffected.reserve(8 * ExplosionSizeInt * ExplosionSizeInt * ExplosionSizeInt);
+
+		area.Read(m_World, bx - ExplosionSizeInt, (int)ceil(a_BlockX + ExplosionSizeInt), MinY, MaxY, bz - ExplosionSizeInt, (int)ceil(a_BlockZ + ExplosionSizeInt));
+		for (int x = -ExplosionSizeInt; x < ExplosionSizeInt; x++)
 		{
-			if ((by + y >= cChunkDef::Height) || (by + y < 0))
-			{
-				// Outside of the world
-				continue;
-			}
-			for (int z = -ExplosionSizeInt; z < ExplosionSizeInt; z++)
+			for (int y = -ExplosionSizeInt; y < ExplosionSizeInt; y++)
 			{
-				if ((x * x + y * y + z * z) > ExplosionSizeSq)
+				if ((by + y >= cChunkDef::Height) || (by + y < 0))
 				{
-					// Too far away
+					// Outside of the world
 					continue;
 				}
-
-				BLOCKTYPE Block = area.GetBlockType(bx + x, by + y, bz + z);
-				switch (Block)
+				for (int z = -ExplosionSizeInt; z < ExplosionSizeInt; z++)
 				{
-					case E_BLOCK_TNT:
-					{
-						// Activate the TNT, with a random fuse between 10 to 30 game ticks
-						double FuseTime = (double)(10 + m_World->GetTickRandomNumber(20)) / 20;
-						m_World->SpawnPrimedTNT(a_BlockX + x + 0.5, a_BlockY + y + 0.5, a_BlockZ + z + 0.5, FuseTime);
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
-						a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
-						break;
-					}
-					case E_BLOCK_OBSIDIAN:
-					case E_BLOCK_BEDROCK:
-					case E_BLOCK_WATER:
-					case E_BLOCK_LAVA:
+					if ((x * x + y * y + z * z) > ExplosionSizeSq)
 					{
-						// These blocks are not affected by explosions
-						break;
+						// Too far away
+						continue;
 					}
 
-					case E_BLOCK_STATIONARY_WATER:
+					BLOCKTYPE Block = area.GetBlockType(bx + x, by + y, bz + z);
+					switch (Block)
 					{
-						// Turn into simulated water:
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_WATER);
-						break;
-					}
-					
-					case E_BLOCK_STATIONARY_LAVA:
-					{
-						// Turn into simulated lava:
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_LAVA);
-						break;
-					}
-					
-					case E_BLOCK_AIR:
-					{
-						// No pickups for air
-						break;
-					}
-					
-					default:
-					{
-						if (m_World->GetTickRandomNumber(100) <= 25) // 25% chance of pickups
+						case E_BLOCK_TNT:
+						{
+							// Activate the TNT, with a random fuse between 10 to 30 game ticks
+							int FuseTime = 10 + m_World->GetTickRandomNumber(20);
+							m_World->SpawnPrimedTNT(a_BlockX + x + 0.5, a_BlockY + y + 0.5, a_BlockZ + z + 0.5, FuseTime);
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
+							a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
+							break;
+						}
+						
+						case E_BLOCK_OBSIDIAN:
+						case E_BLOCK_BEDROCK:
+						case E_BLOCK_WATER:
+						case E_BLOCK_LAVA:
 						{
-							cItems Drops;
-							cBlockHandler * Handler = BlockHandler(Block);
+							// These blocks are not affected by explosions
+							break;
+						}
 
-							Handler->ConvertToPickups(Drops, area.GetBlockMeta(bx + x, by + y, bz + z)); // Stone becomes cobblestone, coal ore becomes coal, etc.
-							m_World->SpawnItemPickups(Drops, bx + x, by + y, bz + z);
+						case E_BLOCK_STATIONARY_WATER:
+						{
+							// Turn into simulated water:
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_WATER);
+							break;
 						}
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
-						a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
-					}
-				}  // switch (BlockType)
-			}  // for z
-		}  // for y
-	}  // for x
-	area.Write(m_World, bx - ExplosionSizeInt, MinY, bz - ExplosionSizeInt);
+
+						case E_BLOCK_STATIONARY_LAVA:
+						{
+							// Turn into simulated lava:
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_LAVA);
+							break;
+						}
+
+						case E_BLOCK_AIR:
+						{
+							// No pickups for air
+							break;
+						}
+
+						default:
+						{
+							if (m_World->GetTickRandomNumber(100) <= 25) // 25% chance of pickups
+							{
+								cItems Drops;
+								cBlockHandler * Handler = BlockHandler(Block);
+
+								Handler->ConvertToPickups(Drops, area.GetBlockMeta(bx + x, by + y, bz + z)); // Stone becomes cobblestone, coal ore becomes coal, etc.
+								m_World->SpawnItemPickups(Drops, bx + x, by + y, bz + z);
+							}
+							else if ((m_World->GetTNTShrapnelLevel() > slNone) && (m_World->GetTickRandomNumber(100) < 20)) // 20% chance of flinging stuff around
+							{
+								if (!cBlockInfo::FullyOccupiesVoxel(Block))
+								{
+									break;
+								}
+								else if ((m_World->GetTNTShrapnelLevel() == slGravityAffectedOnly) && ((Block != E_BLOCK_SAND) && (Block != E_BLOCK_GRAVEL)))
+								{
+									break;
+								}
+								m_World->SpawnFallingBlock(bx + x, by + y + 5, bz + z, Block, area.GetBlockMeta(bx + x, by + y, bz + z));
+							}
+
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
+							a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
+							break;
+							
+						}
+					}  // switch (BlockType)
+				}  // for z
+			}  // for y
+		}  // for x
+		area.Write(m_World, bx - ExplosionSizeInt, MinY, bz - ExplosionSizeInt);
+	}
+
+	class cTNTDamageCallback :
+		public cEntityCallback
+	{
+	public:
+		cTNTDamageCallback(cBoundingBox & a_bbTNT, Vector3d a_ExplosionPos, int a_ExplosionSize) :
+			m_bbTNT(a_bbTNT),
+			m_ExplosionPos(a_ExplosionPos),
+			m_ExplosionSize(a_ExplosionSize)
+		{
+		}
+
+		virtual bool Item(cEntity * a_Entity) override
+		{
+			if (a_Entity->IsPickup())
+			{
+				if (((cPickup *)a_Entity)->GetAge() < 20) // If pickup age is smaller than one second, it is invincible (so we don't kill pickups that were just spawned)
+				{
+					return false;
+				}
+			}
+
+			Vector3d EntityPos = a_Entity->GetPosition();
+			cBoundingBox bbEntity(EntityPos, a_Entity->GetWidth() / 2, a_Entity->GetHeight());
+
+			if (!m_bbTNT.IsInside(bbEntity)) // IsInside actually acts like DoesSurround
+			{
+				return false;
+			}
+			
+			Vector3d AbsoluteEntityPos(abs(EntityPos.x), abs(EntityPos.y), abs(EntityPos.z));
+
+			// Work out how far we are from the edge of the TNT's explosive effect
+			AbsoluteEntityPos -= m_ExplosionPos;
+
+			// All to positive
+			AbsoluteEntityPos.x = abs(AbsoluteEntityPos.x);
+			AbsoluteEntityPos.y = abs(AbsoluteEntityPos.y);
+			AbsoluteEntityPos.z = abs(AbsoluteEntityPos.z);
+
+			double FinalDamage = (((1 / AbsoluteEntityPos.x) + (1 / AbsoluteEntityPos.y) + (1 / AbsoluteEntityPos.z)) * 2) * m_ExplosionSize;
+
+			// Clip damage values
+			if (FinalDamage > a_Entity->GetMaxHealth())
+				FinalDamage = a_Entity->GetMaxHealth();
+			else if (FinalDamage < 0)
+				FinalDamage = 0;
+
+			if (!a_Entity->IsTNT() && !a_Entity->IsFallingBlock()) // Don't apply damage to other TNT entities and falling blocks, they should be invincible
+			{
+				a_Entity->TakeDamage(dtExplosion, NULL, (int)FinalDamage, 0);
+			}
+
+			// Apply force to entities around the explosion - code modified from World.cpp DoExplosionAt()
+			Vector3d distance_explosion = a_Entity->GetPosition() - m_ExplosionPos;
+			if (distance_explosion.SqrLength() < 4096.0)
+			{
+				distance_explosion.Normalize();
+				distance_explosion *= m_ExplosionSize * m_ExplosionSize;
+
+				a_Entity->AddSpeed(distance_explosion);
+			}
+			
+			return false;
+		}
+
+	protected:
+		cBoundingBox & m_bbTNT;
+		Vector3d m_ExplosionPos;
+		int m_ExplosionSize;
+	};
+
+	cBoundingBox bbTNT(Vector3d(a_BlockX, a_BlockY, a_BlockZ), 0.5, 1);
+	bbTNT.Expand(ExplosionSizeInt * 2, ExplosionSizeInt * 2, ExplosionSizeInt * 2);
+
+
+	cTNTDamageCallback TNTDamageCallback(bbTNT, Vector3d(a_BlockX, a_BlockY, a_BlockZ), ExplosionSizeInt);
+	ForEachEntity(TNTDamageCallback);
 
 	// Wake up all simulators for the area, so that water and lava flows and sand falls into the blasted holes (FS #391):
 	WakeUpSimulatorsInArea(
@@ -1986,6 +2199,42 @@ bool cChunkMap::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, c
 
 
 
+bool cChunkMap::DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback & a_Callback)
+{
+	int ChunkX, ChunkZ;
+	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
+	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
+	cCSLock Lock(m_CSLayers);
+	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ZERO_CHUNK_Y, ChunkZ);
+	if ((Chunk == NULL) && !Chunk->IsValid())
+	{
+		return false;
+	}
+	return Chunk->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+}
+
+
+
+
+
+bool cChunkMap::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback & a_Callback)
+{
+	int ChunkX, ChunkZ;
+	int BlockX = a_BlockX, BlockY = a_BlockY, BlockZ = a_BlockZ;
+	cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
+	cCSLock Lock(m_CSLayers);
+	cChunkPtr Chunk = GetChunkNoGen(ChunkX, ZERO_CHUNK_Y, ChunkZ);
+	if ((Chunk == NULL) && !Chunk->IsValid())
+	{
+		return false;
+	}
+	return Chunk->DoWithFlowerPotAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+}
+
+
+
+
+
 bool cChunkMap::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4)
 {
 	int ChunkX, ChunkZ;
@@ -2088,24 +2337,6 @@ bool cChunkMap::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const ASt
 
 
 
-void cChunkMap::ChunksStay(const cChunkCoordsList & a_Chunks, bool a_Stay)
-{
-	cCSLock Lock(m_CSLayers);
-	for (cChunkCoordsList::const_iterator itr = a_Chunks.begin(); itr != a_Chunks.end(); ++itr)
-	{
-		cChunkPtr Chunk = GetChunkNoLoad(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ);
-		if (Chunk == NULL)
-		{
-			continue;
-		}
-		Chunk->Stay(a_Stay);
-	}
-}
-
-
-
-
-
 void cChunkMap::MarkChunkRegenerating(int a_ChunkX, int a_ChunkZ)
 {
 	cCSLock Lock(m_CSLayers);
@@ -2692,113 +2923,103 @@ void cChunkMap::cChunkLayer::UnloadUnusedChunks(void)
 
 
 
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cChunkStay:
-
-cChunkStay::cChunkStay(cWorld * a_World) :
-	m_World(a_World),
-	m_IsEnabled(false)
-{
-}
-
-
-
-
-
-cChunkStay::~cChunkStay()
+void cChunkMap::FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
-	Clear();
+	cCSLock Lock(m_CSFastSetBlock);
+	m_FastSetBlockQueue.push_back(sSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta)); 
 }
 
 
 
 
 
-void cChunkStay::Clear(void)
+void cChunkMap::FastSetQueuedBlocks()
 {
-	if (m_IsEnabled)
+	// Asynchronously set blocks:
+	sSetBlockList FastSetBlockQueueCopy;
 	{
-		Disable();
+		cCSLock Lock(m_CSFastSetBlock);
+		std::swap(FastSetBlockQueueCopy, m_FastSetBlockQueue);
+	}
+	this->FastSetBlocks(FastSetBlockQueueCopy);
+	if (!FastSetBlockQueueCopy.empty())
+	{
+		// Some blocks failed, store them for next tick:
+		cCSLock Lock(m_CSFastSetBlock);
+		m_FastSetBlockQueue.splice(m_FastSetBlockQueue.end(), FastSetBlockQueueCopy);
 	}
-	m_Chunks.clear();
 }
 
 
 
 
 
-void cChunkStay::Add(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
+void cChunkMap::AddChunkStay(cChunkStay & a_ChunkStay)
 {
-	ASSERT(!m_IsEnabled);
-
-	for (cChunkCoordsList::const_iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
+	cCSLock Lock(m_CSLayers);
+	
+	// Add it to the list:
+	ASSERT(std::find(m_ChunkStays.begin(), m_ChunkStays.end(), &a_ChunkStay) == m_ChunkStays.end());  // Has not yet been added
+	m_ChunkStays.push_back(&a_ChunkStay);
+	
+	// Schedule all chunks to be loaded / generated, and mark each as locked:
+	const cChunkCoordsVector & WantedChunks = a_ChunkStay.GetChunks();
+	for (cChunkCoordsVector::const_iterator itr = WantedChunks.begin(); itr != WantedChunks.end(); ++itr)
 	{
-		if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkY == a_ChunkY) && (itr->m_ChunkZ == a_ChunkZ))
+		cChunkPtr Chunk = GetChunk(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ);
+		if (Chunk == NULL)
 		{
-			// Already present
-			return;
+			continue;
 		}
-	}  // for itr - Chunks[]
-	m_Chunks.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));
+		Chunk->Stay(true);
+		if (Chunk->IsValid())
+		{
+			a_ChunkStay.ChunkAvailable(itr->m_ChunkX, itr->m_ChunkZ);
+		}
+	}  // for itr - WantedChunks[]
 }
 
 
 
 
 
-void cChunkStay::Remove(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
+/** Removes the specified cChunkStay descendant from the internal list of ChunkStays. */
+void cChunkMap::DelChunkStay(cChunkStay & a_ChunkStay)
 {
-	ASSERT(!m_IsEnabled);
-
-	for (cChunkCoordsList::iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
+	cCSLock Lock(m_CSLayers);
+	
+	// Remove from the list of active chunkstays:
+	bool HasFound = false;
+	for (cChunkStays::iterator itr = m_ChunkStays.begin(), end = m_ChunkStays.end(); itr != end; ++itr)
 	{
-		if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkY == a_ChunkY) && (itr->m_ChunkZ == a_ChunkZ))
+		if (*itr == &a_ChunkStay)
 		{
-			// Found, un-"stay"
-			m_Chunks.erase(itr);
-			return;
+			m_ChunkStays.erase(itr);
+			HasFound = true;
+			break;
 		}
-	}  // for itr - m_Chunks[]
-}
-
-
-
-
-
-void cChunkStay::Enable(void)
-{
-	ASSERT(!m_IsEnabled);
+	}  // for itr - m_ChunkStays[]
 	
-	m_World->ChunksStay(*this, true);
-	m_IsEnabled = true;
-}
-
-
-
-
-
-void cChunkStay::Load(void)
-{
-	for (cChunkCoordsList::iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
+	if (!HasFound)
 	{
-		m_World->TouchChunk(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ);
-	}  // for itr - m_Chunks[]
-}
-
-
-
-
-
-void cChunkStay::Disable(void)
-{
-	ASSERT(m_IsEnabled);
+		ASSERT(!"Removing a cChunkStay that hasn't been added!");
+		return;
+	}
 	
-	m_World->ChunksStay(*this, false);
-	m_IsEnabled = false;
+	// Unmark all contained chunks:
+	const cChunkCoordsVector & Chunks = a_ChunkStay.GetChunks();
+	for (cChunkCoordsVector::const_iterator itr = Chunks.begin(), end = Chunks.end(); itr != end; ++itr)
+	{
+		cChunkPtr Chunk = GetChunkNoLoad(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ);
+		if (Chunk == NULL)
+		{
+			continue;
+		}
+		Chunk->Stay(false);
+	}  // for itr - Chunks[]
 }
 
 
 
 
+
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index e9d8ee30b..9d973f2a9 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -12,6 +12,7 @@
 
 
 class cWorld;
+class cWorldInterface;
 class cItem;
 class MTRand;
 class cChunkStay;
@@ -24,6 +25,8 @@ class cDropSpenserEntity;
 class cFurnaceEntity;
 class cNoteEntity;
 class cCommandBlockEntity;
+class cMobHeadEntity;
+class cFlowerPotEntity;
 class cPawn;
 class cPickup;
 class cChunkDataSerializer;
@@ -39,9 +42,11 @@ typedef cItemCallback<cChestEntity>        cChestCallback;
 typedef cItemCallback<cDispenserEntity>    cDispenserCallback;
 typedef cItemCallback<cDropperEntity>      cDropperCallback;
 typedef cItemCallback<cDropSpenserEntity>  cDropSpenserCallback;
+typedef cItemCallback<cFlowerPotEntity>    cFlowerPotCallback;
 typedef cItemCallback<cFurnaceEntity>      cFurnaceCallback;
 typedef cItemCallback<cNoteEntity>         cNoteBlockCallback;
 typedef cItemCallback<cCommandBlockEntity> cCommandBlockCallback;
+typedef cItemCallback<cMobHeadEntity>      cMobHeadCallback;
 typedef cItemCallback<cChunk>              cChunkCallback;
 
 
@@ -84,19 +89,19 @@ public:
 	void BroadcastThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
 	void BroadcastUseBed(const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ );
 	
-	/// Sends the block entity, if it is at the coords specified, to a_Client
+	/** Sends the block entity, if it is at the coords specified, to a_Client */
 	void SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client);
 	
-	/// a_Player rclked block entity at the coords specified, handle it
+	/** a_Player rclked block entity at the coords specified, handle it */
 	void UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z);
 	
-	/// Calls the callback for the chunk specified, with ChunkMapCS locked; returns false if the chunk doesn't exist, otherwise returns the same value as the callback
+	/** Calls the callback for the chunk specified, with ChunkMapCS locked; returns false if the chunk doesn't exist, otherwise returns the same value as the callback */
 	bool DoWithChunk(int a_ChunkX, int a_ChunkZ, cChunkCallback & a_Callback);
 
-	/// Wakes up simulators for the specified block
+	/** Wakes up simulators for the specified block */
 	void WakeUpSimulators(int a_BlockX, int a_BlockY, int a_BlockZ);
 
-	/// Wakes up the simulators for the specified area of blocks
+	/** Wakes up the simulators for the specified area of blocks */
 	void WakeUpSimulatorsInArea(int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ);
 
 	void MarkChunkDirty     (int a_ChunkX, int a_ChunkZ);
@@ -129,13 +134,16 @@ public:
 	
 	bool GetChunkData       (int a_ChunkX, int a_ChunkZ, cChunkDataCallback & a_Callback);
 	
-	/// Copies the chunk's blocktypes into a_Blocks; returns true if successful
+	/** Copies the chunk's blocktypes into a_Blocks; returns true if successful */
 	bool GetChunkBlockTypes (int a_ChunkX, int a_ChunkZ, BLOCKTYPE * a_Blocks);
 	
 	bool      IsChunkValid       (int a_ChunkX, int a_ChunkZ);
 	bool      HasChunkAnyClients (int a_ChunkX, int a_ChunkZ);
 	int       GetHeight          (int a_BlockX, int a_BlockZ);  // Waits for the chunk to get loaded / generated
 	bool      TryGetHeight       (int a_BlockX, int a_BlockZ, int & a_Height);  // Returns false if chunk not loaded / generated
+	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	
+	void FastSetQueuedBlocks();
 	void      FastSetBlocks      (sSetBlockList & a_BlockList);
 	void      CollectPickupsByPlayer(cPlayer * a_Player);
 	
@@ -144,159 +152,171 @@ public:
 	NIBBLETYPE GetBlockSkyLight  (int a_BlockX, int a_BlockY, int a_BlockZ);
 	NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ);
 	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockMeta);
-	void       SetBlock          (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta);
+	void       SetBlock          (cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta);
 	void       QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, Int64 a_Tick, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR);
 	bool       GetBlockTypeMeta  (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
 	bool       GetBlockInfo      (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);
 
-	/// Replaces world blocks with a_Blocks, if they are of type a_FilterBlockType
+	/** Replaces world blocks with a_Blocks, if they are of type a_FilterBlockType */
 	void      ReplaceBlocks(const sSetBlockVector & a_Blocks, BLOCKTYPE a_FilterBlockType);
 	
-	/// Special function used for growing trees, replaces only blocks that tree may overwrite
+	/** Special function used for growing trees, replaces only blocks that tree may overwrite */
 	void      ReplaceTreeBlocks(const sSetBlockVector & a_Blocks);
 	
+	/** Returns the biome at the specified coords. Reads the biome from the chunk, if loaded, otherwise uses the world generator to provide the biome value */
 	EMCSBiome GetBiomeAt (int a_BlockX, int a_BlockZ);
 	
-	/// Retrieves block types of the specified blocks. If a chunk is not loaded, doesn't modify the block. Returns true if all blocks were read.
+	/** Sets the biome at the specified coords. Returns true if successful, false if not (chunk not loaded).
+	Doesn't resend the chunk to clients. */
+	bool SetBiomeAt(int a_BlockX, int a_BlockZ, EMCSBiome a_Biome);
+	
+	/** Sets the biome at the area. Returns true if successful, false if any subarea failed (chunk not loaded).
+	(Re)sends the chunks to their relevant clients if successful. */
+	bool SetAreaBiome(int a_MinX, int a_MaxX, int a_MinZ, int a_MaxZ, EMCSBiome a_Biome);
+	
+	/** Retrieves block types of the specified blocks. If a chunk is not loaded, doesn't modify the block. Returns true if all blocks were read. */
 	bool GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure);
 
 	bool DigBlock   (int a_X, int a_Y, int a_Z);
 	void SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer * a_Player);
 	
-	/// Compares clients of two chunks, calls the callback accordingly
+	/** Compares clients of two chunks, calls the callback accordingly */
 	void CompareChunkClients(int a_ChunkX1, int a_ChunkZ1, int a_ChunkX2, int a_ChunkZ2, cClientDiffCallback & a_Callback);
 	
-	/// Compares clients of two chunks, calls the callback accordingly
+	/** Compares clients of two chunks, calls the callback accordingly */
 	void CompareChunkClients(cChunk * a_Chunk1, cChunk * a_Chunk2, cClientDiffCallback & a_Callback);
 
-	/// Adds client to a chunk, if not already present; returns true if added, false if present
+	/** Adds client to a chunk, if not already present; returns true if added, false if present */
 	bool AddChunkClient(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
 
-	/// Removes the client from the chunk
+	/** Removes the client from the chunk */
 	void RemoveChunkClient(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
 	
-	/// Removes the client from all chunks it is present in
+	/** Removes the client from all chunks it is present in */
 	void RemoveClientFromChunks(cClientHandle * a_Client);
 
-	/// Adds the entity to its appropriate chunk, takes ownership of the entity pointer
+	/** Adds the entity to its appropriate chunk, takes ownership of the entity pointer */
 	void AddEntity(cEntity * a_Entity);
 	
-	/// Returns true if the entity with specified ID is present in the chunks
+	/** Returns true if the entity with specified ID is present in the chunks */
 	bool HasEntity(int a_EntityID);
 	
-	/// Removes the entity from its appropriate chunk
+	/** Removes the entity from its appropriate chunk */
 	void RemoveEntity(cEntity * a_Entity);
 	
-	/// Calls the callback for each entity in the entire world; returns true if all entities processed, false if the callback aborted by returning true
+	/** Calls the callback for each entity in the entire world; returns true if all entities processed, false if the callback aborted by returning true */
 	bool ForEachEntity(cEntityCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for each entity in the specified chunk; returns true if all entities processed, false if the callback aborted by returning true
+	/** Calls the callback for each entity in the specified chunk; returns true if all entities processed, false if the callback aborted by returning true */
 	bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback & a_Callback);  // Lua-accessible
 
-	/// Destroys and returns a list of blocks destroyed in the explosion at the specified coordinates
+	/** Destroys and returns a list of blocks destroyed in the explosion at the specified coordinates */
 	void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, cVector3iArray & a_BlockAffected);
 	
-	/// Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found and callback returned false.
+	/** Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found and callback returned false. */
 	bool DoWithEntityByID(int a_UniqueID, cEntityCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for each block entity in the specified chunk; returns true if all block entities processed, false if the callback aborted by returning true
+	/** Calls the callback for each block entity in the specified chunk; returns true if all block entities processed, false if the callback aborted by returning true */
 	bool ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for each chest in the specified chunk; returns true if all chests processed, false if the callback aborted by returning true
+	/** Calls the callback for each chest in the specified chunk; returns true if all chests processed, false if the callback aborted by returning true */
 	bool ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for each dispenser in the specified chunk; returns true if all dispensers processed, false if the callback aborted by returning true
+	/** Calls the callback for each dispenser in the specified chunk; returns true if all dispensers processed, false if the callback aborted by returning true */
 	bool ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCallback & a_Callback);
 
-	/// Calls the callback for each dropper in the specified chunk; returns true if all droppers processed, false if the callback aborted by returning true
+	/** Calls the callback for each dropper in the specified chunk; returns true if all droppers processed, false if the callback aborted by returning true */
 	bool ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallback & a_Callback);
 
-	/// Calls the callback for each dropspenser in the specified chunk; returns true if all dropspensers processed, false if the callback aborted by returning true
+	/** Calls the callback for each dropspenser in the specified chunk; returns true if all dropspensers processed, false if the callback aborted by returning true */
 	bool ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpenserCallback & a_Callback);
 
-	/// Calls the callback for each furnace in the specified chunk; returns true if all furnaces processed, false if the callback aborted by returning true
+	/** Calls the callback for each furnace in the specified chunk; returns true if all furnaces processed, false if the callback aborted by returning true */
 	bool ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallback & a_Callback);  // Lua-accessible
 	
-	/// Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found
+	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
 	bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback & a_Callback);  // Lua-acessible
 
-	/// Calls the callback for the chest at the specified coords; returns false if there's no chest at those coords, true if found
+	/** Calls the callback for the chest at the specified coords; returns false if there's no chest at those coords, true if found */
 	bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback & a_Callback);  // Lua-acessible
 
-	/// Calls the callback for the dispenser at the specified coords; returns false if there's no dispenser at those coords or callback returns true, returns true if found
+	/** Calls the callback for the dispenser at the specified coords; returns false if there's no dispenser at those coords or callback returns true, returns true if found */
 	bool DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for the dropper at the specified coords; returns false if there's no dropper at those coords or callback returns true, returns true if found
+	/** Calls the callback for the dropper at the specified coords; returns false if there's no dropper at those coords or callback returns true, returns true if found */
 	bool DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for the dropspenser at the specified coords; returns false if there's no dropspenser at those coords or callback returns true, returns true if found
+	/** Calls the callback for the dropspenser at the specified coords; returns false if there's no dropspenser at those coords or callback returns true, returns true if found */
 	bool DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for the furnace at the specified coords; returns false if there's no furnace at those coords or callback returns true, returns true if found
+	/** Calls the callback for the furnace at the specified coords; returns false if there's no furnace at those coords or callback returns true, returns true if found */
 	bool DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for the noteblock at the specified coords; returns false if there's no noteblock at those coords or callback returns true, returns true if found
+	/** Calls the callback for the noteblock at the specified coords; returns false if there's no noteblock at those coords or callback returns true, returns true if found */
 	bool DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback & a_Callback);  // Lua-accessible
 
-	/// Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found
+	/** Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found */
 	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback & a_Callback);  // Lua-accessible
 
-	/// Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found
+	/** Calls the callback for the mob head block at the specified coords; returns false if there's no mob head block at those coords or callback returns true, returns true if found */
+	bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback & a_Callback);  // Lua-accessible
+
+	/** Calls the callback for the flower pot at the specified coords; returns false if there's no flower pot at those coords or callback returns true, returns true if found */
+	bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback & a_Callback);  // Lua-accessible
+
+	/** Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found */
 	bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Lua-accessible
 
-	/// Touches the chunk, causing it to be loaded or generated
+	/** Touches the chunk, causing it to be loaded or generated */
 	void TouchChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);
 	
-	/// Loads the chunk, if not already loaded. Doesn't generate. Returns true if chunk valid (even if already loaded before)
+	/** Loads the chunk, if not already loaded. Doesn't generate. Returns true if chunk valid (even if already loaded before) */
 	bool LoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);
 	
-	/// Loads the chunks specified. Doesn't report failure, other than chunks being !IsValid()
+	/** Loads the chunks specified. Doesn't report failure, other than chunks being !IsValid() */
 	void LoadChunks(const cChunkCoordsList & a_Chunks);
 
-	/// Marks the chunk as failed-to-load
+	/** Marks the chunk as failed-to-load */
 	void ChunkLoadFailed(int a_ChunkX, int a_ChunkY, int a_ChunkZ);
 	
-	/// Sets the sign text. Returns true if sign text changed.
+	/** Sets the sign text. Returns true if sign text changed. */
 	bool SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
 	
-	/// Marks (a_Stay == true) or unmarks (a_Stay == false) chunks as non-unloadable; to be used only by cChunkStay!
-	void ChunksStay(const cChunkCoordsList & a_Chunks, bool a_Stay = true);
-	
-	/// Marks the chunk as being regenerated - all its clients want that chunk again (used by cWorld::RegenerateChunk() )
+	/** Marks the chunk as being regenerated - all its clients want that chunk again (used by cWorld::RegenerateChunk() ) */
 	void MarkChunkRegenerating(int a_ChunkX, int a_ChunkZ);
 	
 	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 	
-	/// Calls the callback for each chunk in the coords specified (all cords are inclusive). Returns true if all chunks have been processed successfully
+	/** Calls the callback for each chunk in the coords specified (all cords are inclusive). Returns true if all chunks have been processed successfully */
 	bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback);
 	
-	/// Writes the block area into the specified coords. Returns true if all chunks have been processed. Prefer cBlockArea::Write() instead.
+	/** Writes the block area into the specified coords. Returns true if all chunks have been processed. Prefer cBlockArea::Write() instead. */
 	bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);
 
-	/// Returns the number of valid chunks and the number of dirty chunks
+	/** Returns the number of valid chunks and the number of dirty chunks */
 	void GetChunkStats(int & a_NumChunksValid, int & a_NumChunksDirty);
 	
-	/// Grows a melon or a pumpkin next to the block specified (assumed to be the stem)
+	/** Grows a melon or a pumpkin next to the block specified (assumed to be the stem) */
 	void GrowMelonPumpkin(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, MTRand & a_Rand);
 	
-	/// Grows a sugarcane present at the block specified by the amount of blocks specified, up to the max height specified in the config
+	/** Grows a sugarcane present at the block specified by the amount of blocks specified, up to the max height specified in the config */
 	void GrowSugarcane(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBlocksToGrow);
 	
-	/// Grows a cactus present at the block specified by the amount of blocks specified, up to the max height specified in the config
+	/** Grows a cactus present at the block specified by the amount of blocks specified, up to the max height specified in the config */
 	void GrowCactus(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBlocksToGrow);
 	
-	/// Sets the blockticking to start at the specified block. Only one blocktick per chunk may be set, second call overwrites the first call
+	/** Sets the blockticking to start at the specified block. Only one blocktick per chunk may be set, second call overwrites the first call */
 	void SetNextBlockTick(int a_BlockX, int a_BlockY, int a_BlockZ);
 
-	/// Make a Mob census, of all mobs, their family, their chunk and theyr distance to closest player
+	/** Make a Mob census, of all mobs, their family, their chunk and theyr distance to closest player */
 	void CollectMobCensus(cMobCensus& a_ToFill);
 
-	/// Try to Spawn Monsters inside all Chunks
+	/** Try to Spawn Monsters inside all Chunks */
 	void SpawnMobs(cMobSpawner& a_MobSpawner);
 
 	void Tick(float a_Dt);
 	
-	/// Ticks a single block. Used by cWorld::TickQueuedBlocks() to tick the queued blocks
+	/** Ticks a single block. Used by cWorld::TickQueuedBlocks() to tick the queued blocks */
 	void TickBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
 
 	void UnloadUnusedChunks(void);
@@ -308,15 +328,20 @@ public:
 	
 	void ChunkValidated(void);  // Called by chunks that have become valid
 	
-	/// Queues the specified block for ticking (block update)
+	/** Queues the specified block for ticking (block update) */
 	void QueueTickBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
 	
-	/// Returns the CS for locking the chunkmap; only cWorld::cLock may use this function!
+	/** Returns the CS for locking the chunkmap; only cWorld::cLock may use this function! */
 	cCriticalSection & GetCS(void) { return m_CSLayers; }
 
 private:
 
-	friend class cChunk;  // The chunks can manipulate neighbors while in their Tick() method, using LockedGetBlock() and LockedSetBlock()
+	// The chunks can manipulate neighbors while in their Tick() method, using LockedGetBlock() and LockedSetBlock()
+	friend class cChunk;
+	
+	// The chunkstay can (de-)register itself using AddChunkStay() and DelChunkStay()
+	friend class cChunkStay;
+	
 
 	class cChunkLayer
 	{
@@ -324,10 +349,10 @@ private:
 		cChunkLayer(int a_LayerX, int a_LayerZ, cChunkMap * a_Parent);
 		~cChunkLayer();
 
-		/// Always returns an assigned chunkptr, but the chunk needn't be valid (loaded / generated) - callers must check
+		/** Always returns an assigned chunkptr, but the chunk needn't be valid (loaded / generated) - callers must check */
 		cChunkPtr GetChunk( int a_ChunkX, int a_ChunkY, int a_ChunkZ );
 		
-		/// Returns the specified chunk, or NULL if not created yet
+		/** Returns the specified chunk, or NULL if not created yet */
 		cChunk * FindChunk(int a_ChunkX, int a_ChunkZ);
 		
 		int GetX(void) const {return m_LayerX; }
@@ -340,22 +365,22 @@ private:
 		void Save(void);
 		void UnloadUnusedChunks(void);
 		
-		/// Collect a mob census, of all mobs, their megatype, their chunk and their distance o closest player
+		/** Collect a mob census, of all mobs, their megatype, their chunk and their distance o closest player */
 		void CollectMobCensus(cMobCensus& a_ToFill);		
-		/// Try to Spawn Monsters inside all Chunks
+		/** Try to Spawn Monsters inside all Chunks */
 		void SpawnMobs(cMobSpawner& a_MobSpawner);
 
 		void Tick(float a_Dt);
 		
 		void RemoveClient(cClientHandle * a_Client);
 		
-		/// Calls the callback for each entity in the entire world; returns true if all entities processed, false if the callback aborted by returning true
+		/** Calls the callback for each entity in the entire world; returns true if all entities processed, false if the callback aborted by returning true */
 		bool ForEachEntity(cEntityCallback & a_Callback);  // Lua-accessible
 
-		/// Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found.
+		/** Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found. */
 		bool DoWithEntityByID(int a_EntityID, cEntityCallback & a_Callback, bool & a_CallbackReturn);  // Lua-accessible
 
-		/// Returns true if there is an entity with the specified ID within this layer's chunks
+		/** Returns true if there is an entity with the specified ID within this layer's chunks */
 		bool HasEntity(int a_EntityID);
 		
 	protected:
@@ -368,17 +393,19 @@ private:
 	};
 	
 	typedef std::list<cChunkLayer *> cChunkLayerList;
+	
+	typedef std::list<cChunkStay *> cChunkStays;
 
-	/// Finds the cChunkLayer object responsible for the specified chunk; returns NULL if not found. Assumes m_CSLayers is locked.
+	/** Finds the cChunkLayer object responsible for the specified chunk; returns NULL if not found. Assumes m_CSLayers is locked. */
 	cChunkLayer * FindLayerForChunk(int a_ChunkX, int a_ChunkZ);
 	
-	/// Returns the specified cChunkLayer object; returns NULL if not found. Assumes m_CSLayers is locked.
+	/** Returns the specified cChunkLayer object; returns NULL if not found. Assumes m_CSLayers is locked. */
 	cChunkLayer * FindLayer(int a_LayerX, int a_LayerZ);
 	
-	/// Returns the cChunkLayer object responsible for the specified chunk; creates it if not found.
+	/** Returns the cChunkLayer object responsible for the specified chunk; creates it if not found. */
 	cChunkLayer * GetLayerForChunk (int a_ChunkX, int a_ChunkZ);
 	
-	/// Returns the specified cChunkLayer object; creates it if not found.
+	/** Returns the specified cChunkLayer object; creates it if not found. */
 	cChunkLayer * GetLayer(int a_LayerX, int a_LayerZ);
 	
 	void RemoveLayer(cChunkLayer * a_Layer);
@@ -388,67 +415,45 @@ private:
 	cEvent           m_evtChunkValid;  // Set whenever any chunk becomes valid, via ChunkValidated()
 
 	cWorld * m_World;
+	
+	cCriticalSection m_CSFastSetBlock;
+	sSetBlockList    m_FastSetBlockQueue;
+	
+	/** The cChunkStay descendants that are currently enabled in this chunkmap */
+	cChunkStays m_ChunkStays;
 
 	cChunkPtr GetChunk      (int a_ChunkX, int a_ChunkY, int a_ChunkZ);  // Also queues the chunk for loading / generating if not valid
 	cChunkPtr GetChunkNoGen (int a_ChunkX, int a_ChunkY, int a_ChunkZ);  // Also queues the chunk for loading if not valid; doesn't generate
 	cChunkPtr GetChunkNoLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ);  // Doesn't load, doesn't generate
 	
-	/// Gets a block in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load)
+	/** Gets a block in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load) */
 	bool LockedGetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
 	
-	/// Gets a block type in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load)
+	/** Gets a block type in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load) */
 	bool LockedGetBlockType(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType);
 	
-	/// Gets a block meta in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load)
+	/** Gets a block meta in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load) */
 	bool LockedGetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE & a_BlockMeta);
 	
-	/// Sets a block in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load)
+	/** Sets a block in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load) */
 	bool LockedSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
-	/// Fast-sets a block in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load)
+	/** Fast-sets a block in any chunk while in the cChunk's Tick() method; returns true if successful, false if chunk not loaded (doesn't queue load) */
 	bool LockedFastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
-	/// Locates a chunk ptr in the chunkmap; doesn't create it when not found; assumes m_CSLayers is locked. To be called only from cChunkMap.
+	/** Locates a chunk ptr in the chunkmap; doesn't create it when not found; assumes m_CSLayers is locked. To be called only from cChunkMap. */
 	cChunk * FindChunk(int a_ChunkX, int a_ChunkZ);
-};
-
 
-
-
-
-/** Makes chunks stay loaded until this object is cleared or destroyed
-Works by setting internal flags in the cChunk that it should not be unloaded.
-To optimize for speed, cChunkStay has an Enabled flag, it will "stay" the chunks only when enabled and it will refuse manipulations when enabled
-The object itself is not made thread-safe, it's supposed to be used from a single thread only.
-*/
-class cChunkStay
-{
-public:
-	cChunkStay(cWorld * a_World);
-	~cChunkStay();
-	
-	void Clear(void);
-	
-	void Add(int a_ChunkX, int a_ChunkY, int a_ChunkZ);
-	void Remove(int a_ChunkX, int a_ChunkY, int a_ChunkZ);
+	/** Adds a new cChunkStay descendant to the internal list of ChunkStays; loads its chunks.
+	To be used only by cChunkStay; others should use cChunkStay::Enable() instead */
+	void AddChunkStay(cChunkStay & a_ChunkStay);
 	
-	void Enable(void);
-	void Disable(void);
+	/** Removes the specified cChunkStay descendant from the internal list of ChunkStays.
+	To be used only by cChunkStay; others should use cChunkStay::Disable() instead */
+	void DelChunkStay(cChunkStay & a_ChunkStay);
 	
-	/// Queues each chunk in m_Chunks[] for loading / generating
-	void Load(void);
-	
-	// Allow cChunkStay be passed to functions expecting a const cChunkCoordsList &
-	operator const cChunkCoordsList(void) const {return m_Chunks; }
-	
-protected:
+};
 
-	cWorld * m_World;
-	
-	bool m_IsEnabled;
-	
-	cChunkCoordsList m_Chunks;
-} ;
 
 
 
diff --git a/src/ChunkStay.cpp b/src/ChunkStay.cpp
new file mode 100644
index 000000000..6b1d5ee34
--- /dev/null
+++ b/src/ChunkStay.cpp
@@ -0,0 +1,137 @@
+
+// ChunkStay.cpp
+
+// Implements the cChunkStay class representing a base for classes that keep chunks loaded
+
+#include "Globals.h"
+#include "ChunkStay.h"
+#include "ChunkMap.h"
+
+
+
+
+
+cChunkStay::cChunkStay(void) :
+	m_ChunkMap(NULL)
+{
+}
+
+
+
+
+
+cChunkStay::~cChunkStay()
+{
+	Clear();
+}
+
+
+
+
+
+void cChunkStay::Clear(void)
+{
+	if (m_ChunkMap != NULL)
+	{
+		Disable();
+	}
+	m_Chunks.clear();
+}
+
+
+
+
+
+void cChunkStay::Add(int a_ChunkX, int a_ChunkZ)
+{
+	ASSERT(m_ChunkMap == NULL);
+
+	for (cChunkCoordsVector::const_iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
+	{
+		if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))
+		{
+			// Already present
+			return;
+		}
+	}  // for itr - Chunks[]
+	m_Chunks.push_back(cChunkCoords(a_ChunkX, ZERO_CHUNK_Y, a_ChunkZ));
+}
+
+
+
+
+
+void cChunkStay::Remove(int a_ChunkX, int a_ChunkZ)
+{
+	ASSERT(m_ChunkMap == NULL);
+
+	for (cChunkCoordsVector::iterator itr = m_Chunks.begin(); itr != m_Chunks.end(); ++itr)
+	{
+		if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))
+		{
+			// Found, un-"stay"
+			m_Chunks.erase(itr);
+			return;
+		}
+	}  // for itr - m_Chunks[]
+}
+
+
+
+
+
+void cChunkStay::Enable(cChunkMap & a_ChunkMap)
+{
+	ASSERT(m_ChunkMap == NULL);
+	
+	m_OutstandingChunks = m_Chunks;
+	m_ChunkMap = &a_ChunkMap;
+	a_ChunkMap.AddChunkStay(*this);
+}
+
+
+
+
+
+void cChunkStay::Disable(void)
+{
+	ASSERT(m_ChunkMap != NULL);
+	
+	m_ChunkMap->DelChunkStay(*this);
+	m_ChunkMap = NULL;
+}
+
+
+
+
+
+bool cChunkStay::ChunkAvailable(int a_ChunkX, int a_ChunkZ)
+{
+	// Check if this is a chunk that we want:
+	bool IsMine = false;
+	for (cChunkCoordsVector::iterator itr = m_OutstandingChunks.begin(), end = m_OutstandingChunks.end(); itr != end; ++itr)
+	{
+		if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))
+		{
+			m_OutstandingChunks.erase(itr);
+			IsMine = true;
+			break;
+		}
+	}  // for itr - m_OutstandingChunks[]
+	if (!IsMine)
+	{
+		return false;
+	}
+	
+	// Call the appropriate callbacks:
+	OnChunkAvailable(a_ChunkX, a_ChunkZ);
+	if (m_OutstandingChunks.empty())
+	{
+		return OnAllChunksAvailable();
+	}
+	return false;
+}
+
+
+
+
diff --git a/src/ChunkStay.h b/src/ChunkStay.h
new file mode 100644
index 000000000..2510cb490
--- /dev/null
+++ b/src/ChunkStay.h
@@ -0,0 +1,97 @@
+
+// ChunkStay.h
+
+/* Declares the cChunkStay class representing a base for classes that want to wait for certain chunks to load,
+then do some action on them. While the object is enabled, the chunks contained within are locked and will
+not unload
+*/
+
+
+
+
+
+#pragma once
+
+
+
+
+
+// fwd
+class cChunkMap;
+
+
+
+
+
+/** Makes chunks stay loaded until this object is cleared or destroyed
+Works by setting internal flags in the cChunk that it should not be unloaded.
+To optimize for speed, cChunkStay has an Enabled flag, it will "stay" the chunks only when enabled
+and it will refuse chunk-list manipulations when enabled.
+The object itself is not made thread-safe, it's supposed to be used from a single thread only.
+This class is abstract, the descendants are expected to provide the OnChunkAvailable() and
+the OnAllChunksAvailable() callback implementations. Note that those are called from the contexts of
+different threads' - the caller, the Loader or the Generator thread.
+*/
+class cChunkStay
+{
+public:
+	cChunkStay(void);
+	virtual ~cChunkStay();
+	
+	void Clear(void);
+	
+	/** Adds a chunk to be locked from unloading.
+	To be used only while the ChunkStay object is not enabled. */
+	void Add(int a_ChunkX, int a_ChunkZ);
+	
+	/** Releases the chunk so that it's no longer locked from unloading.
+	To be used only while the ChunkStay object is not enabled. */
+	void Remove(int a_ChunkX, int a_ChunkZ);
+	
+	/** Enables the ChunkStay on the specified chunkmap, causing it to load and generate chunks.
+	All the contained chunks are queued for loading / generating. */
+	void Enable (cChunkMap & a_ChunkMap);
+	
+	/** Disables the ChunkStay, the chunks are released and the ChunkStay
+	object can be edited with Add() and Remove() again*/
+	virtual void Disable(void);
+	
+	/** Returns all the chunks that should be kept */
+	const cChunkCoordsVector & GetChunks(void) const { return m_Chunks; }
+	
+	/** Called when a specific chunk become available. */
+	virtual void OnChunkAvailable(int a_ChunkX, int a_ChunkZ) = 0;
+	
+	/** Caled once all of the contained chunks are available.
+	If returns true, the ChunkStay is automatically disabled by the ChunkMap; if it returns false, the ChunkStay is kept. */
+	virtual bool OnAllChunksAvailable(void) = 0;
+	
+	/** Called by the ChunkMap when the ChunkStay is disabled. The object may choose to delete itself. */
+	virtual void OnDisabled(void) = 0;
+	
+protected:
+
+	friend class cChunkMap;
+
+
+	/** The chunkmap where the object is enabled.
+	Valid only after call to Enable() and before Disable(). */
+	cChunkMap * m_ChunkMap;
+	
+	/** The list of chunks to lock from unloading. */
+	cChunkCoordsVector m_Chunks;
+	
+	/** The chunks that still need loading */
+	cChunkCoordsVector m_OutstandingChunks;
+	
+	
+	/** Called by cChunkMap when a chunk is available, checks m_NumLoaded and triggers the appropriate callbacks.
+	May be called for chunks outside this ChunkStay.
+	Returns true if the ChunkStay is to be automatically disabled by the ChunkMap; returns false to keep the ChunkStay. */
+	bool ChunkAvailable(int a_ChunkX, int a_ChunkZ);
+} ;
+
+
+
+
+
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 979298c59..73a275ab1 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -20,9 +20,7 @@
 #include "Items/ItemHandler.h"
 #include "Blocks/BlockHandler.h"
 #include "Blocks/BlockSlab.h"
-
-#include "Vector3f.h"
-#include "Vector3d.h"
+#include "Blocks/ChunkInterface.h"
 
 #include "Root.h"
 
@@ -30,29 +28,18 @@
 #include "MersenneTwister.h"
 
 #include "Protocol/ProtocolRecognizer.h"
+#include "CompositeChat.h"
+#include "Items/ItemSword.h"
 
 
 
+/** Maximum number of explosions to send this tick, server will start dropping if exceeded */
+#define MAX_EXPLOSIONS_PER_TICK 20
 
+/** Maximum number of block change interactions a player can perform per tick - exceeding this causes a kick */
+#define MAX_BLOCK_CHANGE_INTERACTIONS 20
 
-#define AddPistonDir(x, y, z, dir, amount) switch (dir) { case 0: (y)-=(amount); break; case 1: (y)+=(amount); break;\
-													 case 2: (z)-=(amount); break; case 3: (z)+=(amount); break;\
-													 case 4: (x)-=(amount); break; case 5: (x)+=(amount); break; }
-
-
-
-
-
-/// If the number of queued outgoing packets reaches this, the client will be kicked
-#define MAX_OUTGOING_PACKETS 2000
-
-/// How many explosions per single game tick are allowed
-static const int MAX_EXPLOSIONS_PER_TICK = 100;
-
-/// How many explosions in the recent history are allowed
-static const int MAX_RUNNING_SUM_EXPLOSIONS = cClientHandle::NUM_CHECK_EXPLOSIONS_TICKS * MAX_EXPLOSIONS_PER_TICK / 8;
-
-/// How many ticks before the socket is closed after the client is destroyed (#31)
+/** How many ticks before the socket is closed after the client is destroyed (#31) */
 static const int TICKS_BEFORE_CLOSE = 20;
 
 
@@ -94,10 +81,10 @@ cClientHandle::cClientHandle(const cSocket * a_Socket, int a_ViewDistance) :
 	m_TicksSinceDestruction(0),
 	m_State(csConnected),
 	m_ShouldCheckDownloaded(false),
-	m_CurrentExplosionTick(0),
-	m_RunningSumExplosions(0),
+	m_NumExplosionsThisTick(0),
 	m_UniqueID(0),
-	m_HasSentPlayerChunk(false)
+	m_HasSentPlayerChunk(false),
+	m_Locale("en_GB")
 {
 	m_Protocol = new cProtocolRecognizer(this);
 	
@@ -148,15 +135,6 @@ cClientHandle::~cClientHandle()
 		SendDisconnect("Server shut down? Kthnxbai");
 	}
 	
-	// Queue all remaining outgoing packets to cSocketThreads:
-	{
-		cCSLock Lock(m_CSOutgoingData);
-		AString Data;
-		m_OutgoingData.ReadAll(Data);
-		m_OutgoingData.CommitRead();
-		cRoot::Get()->GetServer()->WriteToClient(this, Data);
-	}
-	
 	// Close the socket as soon as it sends all outgoing data:
 	cRoot::Get()->GetServer()->RemoveClient(this);
 	
@@ -235,7 +213,11 @@ void cClientHandle::Authenticate(void)
 
 	m_Player->SetIP (m_IPString);
 
-	cRoot::Get()->GetPluginManager()->CallHookPlayerJoined(*m_Player);
+	if (!cRoot::Get()->GetPluginManager()->CallHookPlayerJoined(*m_Player))
+	{
+		cRoot::Get()->BroadcastChatJoin(Printf("%s has joined the game", GetUsername().c_str()));
+		LOGINFO("Player %s has joined the game.", m_Username.c_str());
+	}
 	
 	m_ConfirmPosition = m_Player->GetPosition();
 
@@ -263,6 +245,12 @@ void cClientHandle::Authenticate(void)
 	m_Player->Initialize(World);
 	m_State = csAuthenticated;
 
+	// Query player team
+	m_Player->UpdateTeam();
+
+	// Send scoreboard data
+	World->GetScoreBoard().SendTo(*this);
+
 	cRoot::Get()->GetPluginManager()->CallHookPlayerSpawned(*m_Player);
 }
 
@@ -542,18 +530,35 @@ void cClientHandle::HandlePlayerPos(double a_PosX, double a_PosY, double a_PosZ,
 
 void cClientHandle::HandlePluginMessage(const AString & a_Channel, const AString & a_Message)
 {
-	if (a_Channel == "MC|AdvCdm") // Command block, set text, Client -> Server
+	if (a_Channel == "MC|AdvCdm")
 	{
-		const char* Data = a_Message.c_str();
-		HandleCommandBlockMessage(Data, a_Message.size());
-		return;
+		// Command block, set text, Client -> Server
+		HandleCommandBlockMessage(a_Message.c_str(), a_Message.size());
 	}
-	else if (a_Channel == "MC|Brand") // Client <-> Server branding exchange
+	else if (a_Channel == "MC|Brand")
 	{
-		// We are custom,
-		// We are awesome,
-		// We are MCServer.
+		// Client <-> Server branding exchange
 		SendPluginMessage("MC|Brand", "MCServer");
+	}
+	else if (a_Channel == "REGISTER")
+	{
+		if (HasPluginChannel(a_Channel))
+		{
+			SendPluginMessage("UNREGISTER", a_Channel);
+			return; // Can't register again if already taken - kinda defeats the point of plugin messaging!
+		}
+
+		RegisterPluginChannels(BreakApartPluginChannels(a_Message));
+	}
+	else if (a_Channel == "UNREGISTER")
+	{
+		UnregisterPluginChannels(BreakApartPluginChannels(a_Message));
+	}
+	else if (!HasPluginChannel(a_Channel))
+	{
+		// Ignore if client sent something but didn't register the channel first
+		LOGD("Player %s sent a plugin message on channel \"%s\", but didn't REGISTER it first", GetUsername().c_str(), a_Channel.c_str());
+		SendPluginMessage("UNREGISTER", a_Channel);
 		return;
 	}
 
@@ -564,11 +569,65 @@ void cClientHandle::HandlePluginMessage(const AString & a_Channel, const AString
 
 
 
-void cClientHandle::HandleCommandBlockMessage(const char* a_Data, unsigned int a_Length)
+AStringVector cClientHandle::BreakApartPluginChannels(const AString & a_PluginChannels)
+{
+	// Break the string on each NUL character.
+	// Note that StringSplit() doesn't work on this because NUL is a special char - string terminator
+	size_t len = a_PluginChannels.size();
+	size_t first = 0;
+	AStringVector res;
+	for (size_t i = 0; i < len; i++)
+	{
+		if (a_PluginChannels[i] != 0)
+		{
+			continue;
+		}
+		if (i > first)
+		{
+			res.push_back(a_PluginChannels.substr(first, i - first));
+		}
+		first = i + 1;
+	}  // for i - a_PluginChannels[]
+	if (first < len)
+	{
+		res.push_back(a_PluginChannels.substr(first, len - first));
+	}
+	return res;
+}
+
+
+
+
+
+void cClientHandle::RegisterPluginChannels(const AStringVector & a_ChannelList)
+{
+	for (AStringVector::const_iterator itr = a_ChannelList.begin(), end = a_ChannelList.end(); itr != end; ++itr)
+	{
+		m_PluginChannels.insert(*itr);
+	}  // for itr - a_ChannelList[]
+}
+
+
+
+
+
+void cClientHandle::UnregisterPluginChannels(const AStringVector & a_ChannelList)
+{
+	for (AStringVector::const_iterator itr = a_ChannelList.begin(), end = a_ChannelList.end(); itr != end; ++itr)
+	{
+		m_PluginChannels.erase(*itr);
+	}  // for itr - a_ChannelList[]
+}
+
+
+
+
+
+void cClientHandle::HandleCommandBlockMessage(const char * a_Data, unsigned int a_Length)
 {
 	if (a_Length < 14)
 	{
-		SendChat(Printf("%s[INFO]%s Failure setting command block command; bad request", cChatColor::Red.c_str(), cChatColor::White.c_str()));
+		SendChat("Failure setting command block command; bad request", mtFailure);
 		LOGD("Malformed MC|AdvCdm packet.");
 		return;
 	}
@@ -598,43 +657,44 @@ void cClientHandle::HandleCommandBlockMessage(const char* a_Data, unsigned int a
 
 		default:
 		{
-			SendChat(Printf("%s[INFO]%s Failure setting command block command; unhandled mode", cChatColor::Red.c_str(), cChatColor::White.c_str()));
+			SendChat("Failure setting command block command; unhandled mode", mtFailure);
 			LOGD("Unhandled MC|AdvCdm packet mode.");
 			return;
 		}
 	}
 
-	class cUpdateCommandBlock :
-		public cCommandBlockCallback
-	{
-		AString m_Command;
-	public:
-		cUpdateCommandBlock(const AString & a_Command) : m_Command(a_Command) {}
-			
-		virtual bool Item(cCommandBlockEntity * a_CommandBlock) override
-		{
-			a_CommandBlock->SetCommand(m_Command);
-			return false;
-		}
-	} CmdBlockCB (Command);
-
 	cWorld * World = m_Player->GetWorld();
 
-	World->DoWithCommandBlockAt(BlockX, BlockY, BlockZ, CmdBlockCB);
-
-	SendChat(Printf("%s[INFO]%s Successfully set command block command", cChatColor::Green.c_str(), cChatColor::White.c_str()));
+	if (World->AreCommandBlocksEnabled())
+	{
+		World->SetCommandBlockCommand(BlockX, BlockY, BlockZ, Command);
+		
+		SendChat("Successfully set command block command", mtSuccess);
+	}
+	else
+	{
+		SendChat("Command blocks are not enabled on this server", mtFailure);
+	}
 }
 
 
 
 
 
-void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status)
+void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, char a_Status)
 {
 	LOGD("HandleLeftClick: {%i, %i, %i}; Face: %i; Stat: %i",
 		a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status
 	);
 
+	m_NumBlockChangeInteractionsThisTick++;
+
+	if (!CheckBlockInteractionsRate())
+	{
+		Kick("Too many blocks were destroyed per unit time - hacked client?");
+		return;
+	}
+
 	cPluginManager * PlgMgr = cRoot::Get()->GetPluginManager();
 	if (PlgMgr->CallHookPlayerLeftClick(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status))
 	{
@@ -642,12 +702,6 @@ void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, ch
 		m_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
 		return;
 	}
-	
-	if (!CheckBlockInteractionsRate())
-	{
-		// Too many interactions per second, simply ignore. Probably a hacked client, so don't even send bak the block
-		return;
-	}
 
 	switch (a_Status)
 	{
@@ -658,7 +712,8 @@ void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, ch
 				// A plugin doesn't agree with the tossing. The plugin itself is responsible for handling the consequences (possible inventory mismatch)
 				return;
 			}
-			m_Player->TossItem(false);
+
+			m_Player->TossEquippedItem();
 			return;
 		}
 
@@ -713,7 +768,7 @@ void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, ch
 				// A plugin doesn't agree with the tossing. The plugin itself is responsible for handling the consequences (possible inventory mismatch)
 				return;
 			}
-			m_Player->TossItem(false, 64); // Toss entire slot - if there aren't enough items, the maximum will be ejected
+			m_Player->TossEquippedItem(64); // Toss entire slot - if there aren't enough items, the maximum will be ejected
 			return;
 		}
 
@@ -729,7 +784,7 @@ void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, ch
 
 
 
-void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
+void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
 {
 	if (
 		m_HasStartedDigging &&
@@ -742,6 +797,15 @@ void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_Bloc
 		return;
 	}
 	
+	if (
+		m_Player->IsGameModeCreative() &&
+		ItemCategory::IsSword(m_Player->GetInventory().GetEquippedItem().m_ItemType)
+	)
+	{
+		// Players can't destroy blocks with a Sword in the hand.
+		return;
+	}
+	
 	if (cRoot::Get()->GetPluginManager()->CallHookPlayerBreakingBlock(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_OldBlock, a_OldMeta))
 	{
 		// A plugin doesn't agree with the breaking. Bail out. Send the block back to the client, so that it knows:
@@ -757,7 +821,7 @@ void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_Bloc
 
 	if (
 		(m_Player->IsGameModeCreative()) ||  // In creative mode, digging is done immediately
-		g_BlockOneHitDig[a_OldBlock]                        // One-hit blocks get destroyed immediately, too
+		cBlockInfo::IsOneHitDig(a_OldBlock)  // One-hit blocks get destroyed immediately, too
 	)
 	{
 		HandleBlockDigFinished(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_OldBlock, a_OldMeta);
@@ -775,9 +839,9 @@ void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_Bloc
 	m_Player->GetWorld()->BroadcastBlockBreakAnimation(m_UniqueID, m_BlockDigAnimX, m_BlockDigAnimY, m_BlockDigAnimZ, 0, this);
 
 	cWorld * World = m_Player->GetWorld();
-	
-	cBlockHandler * Handler = cBlockHandler::GetBlockHandler(a_OldBlock);
-	Handler->OnDigging(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
+	cChunkInterface ChunkInterface(World->GetChunkMap());
+	cBlockHandler * Handler = cBlockInfo::GetHandler(a_OldBlock);
+	Handler->OnDigging(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
 
 	cItemHandler * ItemHandler = cItemHandler::GetItemHandler(m_Player->GetEquippedItem());
 	ItemHandler->OnDiggingBlock(World, m_Player, m_Player->GetEquippedItem(), a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
@@ -790,11 +854,11 @@ void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_Bloc
 		int pZ = a_BlockZ;
 
 		AddFaceDirection(pX, pY, pZ, a_BlockFace); // Get the block in front of the clicked coordinates (m_bInverse defaulted to false)
-		Handler = cBlockHandler::GetBlockHandler(World->GetBlock(pX, pY, pZ));
+		Handler = cBlockInfo::GetHandler(World->GetBlock(pX, pY, pZ));
 
 		if (Handler->IsClickedThrough())
 		{
-			Handler->OnDigging(World, m_Player, pX, pY, pZ);
+			Handler->OnDigging(ChunkInterface, *World, m_Player, pX, pY, pZ);
 		}
 	}
 }
@@ -803,7 +867,7 @@ void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_Bloc
 
 
 
-void cClientHandle::HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
+void cClientHandle::HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
 {
 	if (
 		!m_HasStartedDigging ||           // Hasn't received the DIG_STARTED packet
@@ -815,7 +879,7 @@ void cClientHandle::HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_Blo
 		LOGD("Prevented a dig/aim bug in the client (finish {%d, %d, %d} vs start {%d, %d, %d}, HSD: %s)",
 			a_BlockX, a_BlockY, a_BlockZ,
 			m_LastDigBlockX, m_LastDigBlockY, m_LastDigBlockZ,
-			m_HasStartedDigging
+			(m_HasStartedDigging ? "True" : "False")
 		);
 		return;
 	}
@@ -840,8 +904,8 @@ void cClientHandle::HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_Blo
 	cWorld * World = m_Player->GetWorld();
 	ItemHandler->OnBlockDestroyed(World, m_Player, m_Player->GetEquippedItem(), a_BlockX, a_BlockY, a_BlockZ);
 	// The ItemHandler is also responsible for spawning the pickups
-	
-	BlockHandler(a_OldBlock)->OnDestroyedByPlayer(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
+	cChunkInterface ChunkInterface(World->GetChunkMap());
+	BlockHandler(a_OldBlock)->OnDestroyedByPlayer(ChunkInterface,*World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
 	World->BroadcastSoundParticleEffect(2001, a_BlockX, a_BlockY, a_BlockZ, a_OldBlock, this);
 	World->DigBlock(a_BlockX, a_BlockY, a_BlockZ);
 
@@ -852,27 +916,37 @@ void cClientHandle::HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_Blo
 
 
 
-void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, const cItem & a_HeldItem)
+void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, const cItem & a_HeldItem)
 {
 	LOGD("HandleRightClick: {%d, %d, %d}, face %d, HeldItem: %s",
 		a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, ItemToFullString(a_HeldItem).c_str()
 	);
 	
+	cWorld * World = m_Player->GetWorld();
+	
 	cPluginManager * PlgMgr = cRoot::Get()->GetPluginManager();
 	if (PlgMgr->CallHookPlayerRightClick(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ))
 	{
 		// A plugin doesn't agree with the action, replace the block on the client and quit:
-		if (a_BlockFace > -1)
+		cChunkInterface ChunkInterface(World->GetChunkMap());
+		BLOCKTYPE BlockType = World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+		cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
+		BlockHandler->OnCancelRightClick(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
+		
+		if (a_BlockFace != BLOCK_FACE_NONE)
 		{
 			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
-			m_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
+			World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
+			World->SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, m_Player); //2 block high things
 		}
 		return;
 	}
+
+	m_NumBlockChangeInteractionsThisTick++;
 	
 	if (!CheckBlockInteractionsRate())
 	{
-		LOGD("Too many block interactions, aborting placement");
+		Kick("Too many blocks were placed/interacted with per unit time - hacked client?");
 		return;
 	}
 	
@@ -888,20 +962,18 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, c
 		);
 		
 		// Let's send the current world block to the client, so that it can immediately "let the user know" that they haven't placed the block
-		if (a_BlockFace > -1)
+		if (a_BlockFace != BLOCK_FACE_NONE)
 		{
 			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
-			m_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
+			World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
 		}
 		return;
 	}
-	
-	cWorld * World = m_Player->GetWorld();
 
 	BLOCKTYPE BlockType;
 	NIBBLETYPE BlockMeta;
 	World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
-	cBlockHandler * BlockHandler = cBlockHandler::GetBlockHandler(BlockType);
+	cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
 	
 	if (BlockHandler->IsUseable() && !m_Player->IsCrouched())
 	{
@@ -910,14 +982,15 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, c
 			// A plugin doesn't agree with using the block, abort
 			return;
 		}
-		BlockHandler->OnUse(World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ);
+		cChunkInterface ChunkInterface(World->GetChunkMap());
+		BlockHandler->OnUse(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ);
 		PlgMgr->CallHookPlayerUsedBlock(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta);
 		return;
 	}
 	
 	cItemHandler * ItemHandler = cItemHandler::GetItemHandler(Equipped.m_ItemType);
 	
-	if (ItemHandler->IsPlaceable())
+	if (ItemHandler->IsPlaceable() && (a_BlockFace != BLOCK_FACE_NONE))
 	{
 		HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
 	}
@@ -953,8 +1026,9 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, c
 
 
 
-void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, cItemHandler & a_ItemHandler)
+void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, cItemHandler & a_ItemHandler)
 {
+	BLOCKTYPE EquippedBlock = (BLOCKTYPE)(m_Player->GetEquippedItem().m_ItemType);
 	if (a_BlockFace < 0)
 	{
 		// Clicked in air
@@ -965,7 +1039,6 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, c
 
 	BLOCKTYPE ClickedBlock;
 	NIBBLETYPE ClickedBlockMeta;
-	BLOCKTYPE EquippedBlock = (BLOCKTYPE)(m_Player->GetEquippedItem().m_ItemType);
 	NIBBLETYPE EquippedBlockDamage = (NIBBLETYPE)(m_Player->GetEquippedItem().m_ItemDamage);
 
 	if ((a_BlockY < 0) || (a_BlockY >= cChunkDef::Height))
@@ -980,10 +1053,10 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	if (
 		cBlockSlabHandler::IsAnySlabType(ClickedBlock) &&               // Is there a slab already?
 		cBlockSlabHandler::IsAnySlabType(EquippedBlock) &&              // Is the player placing another slab?
-		((ClickedBlockMeta & 0x07) == (EquippedBlockDamage & 0x07)) &&  // Is it the same slab type?
+		((ClickedBlockMeta & 0x07) == EquippedBlockDamage) &&           // Is it the same slab type?
 		(
-			(a_BlockFace == BLOCK_FACE_TOP) ||                            // Clicking the top of a bottom slab
-			(a_BlockFace == BLOCK_FACE_BOTTOM)                            // Clicking the bottom of a top slab
+			(a_BlockFace == BLOCK_FACE_TOP) ||                          // Clicking the top of a bottom slab
+			(a_BlockFace == BLOCK_FACE_BOTTOM)                          // Clicking the bottom of a top slab
 		)
 	)
 	{
@@ -991,7 +1064,7 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, c
 		// If clicked top face and slab occupies the top voxel, we want a slab to be placed above it (therefore increment Y)
 		// Else if clicked bottom face and slab occupies the bottom voxel, decrement Y for the same reason
 		// Don't touch coordinates if anything else because a dblslab opportunity is present
-		if((ClickedBlockMeta & 0x08) && (a_BlockFace == BLOCK_FACE_TOP))
+		if ((ClickedBlockMeta & 0x08) && (a_BlockFace == BLOCK_FACE_TOP))
 		{
 			++a_BlockY;
 		}
@@ -1009,7 +1082,8 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, c
 			BlockHandler(ClickedBlock)->DoesIgnoreBuildCollision(m_Player, ClickedBlockMeta)
 			)
 		{
-			BlockHandler(ClickedBlock)->OnDestroyedByPlayer(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
+			cChunkInterface ChunkInterface(World->GetChunkMap());
+			BlockHandler(ClickedBlock)->OnDestroyedByPlayer(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
 		}
 		else
 		{
@@ -1066,11 +1140,12 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	
 	// The actual block placement:
 	World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
-	if (m_Player->GetGameMode() != gmCreative)
+	if (!m_Player->IsGameModeCreative())
 	{
 		m_Player->GetInventory().RemoveOneEquippedItem();
 	}
-	NewBlock->OnPlacedByPlayer(World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta);
+	cChunkInterface ChunkInterface(World->GetChunkMap());
+	NewBlock->OnPlacedByPlayer(ChunkInterface,*World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta);
 	
 	// Step sound with 0.8f pitch is used as block placement sound
 	World->BroadcastSoundEffect(NewBlock->GetStepSound(), a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 1.0f, 0.8f);
@@ -1092,14 +1167,20 @@ void cClientHandle::HandleChat(const AString & a_Message)
 		return;
 	}
 	
-	// Not a command, broadcast as a simple message:
-	AString Msg;
-	Printf(Msg, "%s<%s>%s %s",
-		m_Player->GetColor().c_str(),
-		m_Player->GetName().c_str(),
-		cChatColor::White.c_str(),
-		Message.c_str()
-	);
+	// Not a command, broadcast as a message:
+	cCompositeChat Msg;
+	AString Color = m_Player->GetColor();
+	if (Color.length() == 3)
+	{
+		Color = AString("@") + Color[2];
+	}
+	else
+	{
+		Color.empty();
+	}
+	Msg.AddTextPart(AString("<") + m_Player->GetName() + "> ", Color);
+	Msg.ParseText(a_Message);
+	Msg.UnderlineUrls();
 	m_Player->GetWorld()->BroadcastChat(Msg);
 }
 
@@ -1335,13 +1416,9 @@ void cClientHandle::HandleRespawn(void)
 void cClientHandle::HandleDisconnect(const AString & a_Reason)
 {
 	LOGD("Received d/c packet from %s with reason \"%s\"", m_Username.c_str(), a_Reason.c_str());
-	if (!cRoot::Get()->GetPluginManager()->CallHookDisconnect(m_Player, a_Reason))
-	{
-		AString DisconnectMessage;
-		Printf(DisconnectMessage, "%s[LEAVE] %s%s has left the game", cChatColor::Yellow.c_str(), cChatColor::White.c_str(), m_Username.c_str());
-		cRoot::Get()->BroadcastChat(DisconnectMessage);
-		LOGINFO("Player %s has left the game.", m_Username.c_str());
-	}
+
+	cRoot::Get()->GetPluginManager()->CallHookDisconnect(m_Player, a_Reason);
+
 	m_HasSentDC = true;
 	Destroy();
 }
@@ -1380,7 +1457,7 @@ bool cClientHandle::HandleHandshake(const AString & a_Username)
 
 
 
-void cClientHandle::HandleEntityAction(int a_EntityID, char a_ActionID)
+void cClientHandle::HandleEntityCrouch(int a_EntityID, bool a_IsCrouching)
 {
 	if (a_EntityID != m_Player->GetUniqueID())
 	{
@@ -1388,35 +1465,37 @@ void cClientHandle::HandleEntityAction(int a_EntityID, char a_ActionID)
 		return;
 	}
 
-	switch (a_ActionID)
+	m_Player->SetCrouch(a_IsCrouching);
+}
+
+
+
+
+
+void cClientHandle::HandleEntityLeaveBed(int a_EntityID)
+{
+	if (a_EntityID != m_Player->GetUniqueID())
 	{
-		case 1:  // Crouch
-		{
-			m_Player->SetCrouch(true);
-			break;
-		}
-		case 2:  // Uncrouch
-		{
-			m_Player->SetCrouch(false);
-			break;
-		}
-		case 3:  // Leave bed
-		{
-			m_Player->GetWorld()->BroadcastEntityAnimation(*m_Player, 2);
-			break;
-		}
-		case 4:  // Start sprinting
-		{
-			m_Player->SetSprint(true);
-			break;
-		}
-		case 5:  // Stop sprinting
-		{
-			m_Player->SetSprint(false);
-			SendPlayerMaxSpeed();
-			break;
-		}
+		// We should only receive entity actions from the entity that is performing the action
+		return;
+	}
+
+	m_Player->GetWorld()->BroadcastEntityAnimation(*m_Player, 2);
+}
+
+
+
+
+
+void cClientHandle::HandleEntitySprinting(int a_EntityID, bool a_IsSprinting)
+{
+	if (a_EntityID != m_Player->GetUniqueID())
+	{
+		// We should only receive entity actions from the entity that is performing the action
+		return;
 	}
+
+	m_Player->SetSprint(a_IsSprinting);
 }
 
 
@@ -1453,7 +1532,7 @@ void cClientHandle::HandleTabCompletion(const AString & a_Text)
 
 
 
-void cClientHandle::SendData(const char * a_Data, int a_Size)
+void cClientHandle::SendData(const char * a_Data, size_t a_Size)
 {
 	if (m_HasSentDC)
 	{
@@ -1468,7 +1547,7 @@ void cClientHandle::SendData(const char * a_Data, int a_Size)
 		if (m_OutgoingDataOverflow.empty())
 		{
 			// No queued overflow data; if this packet fits into the ringbuffer, put it in, otherwise put it in the overflow buffer:
-			int CanFit = m_OutgoingData.GetFreeSpace();
+			size_t CanFit = m_OutgoingData.GetFreeSpace();
 			if (CanFit > a_Size)
 			{
 				CanFit = a_Size;
@@ -1529,10 +1608,8 @@ void cClientHandle::MoveToWorld(cWorld & a_World, bool a_SendRespawnPacket)
 		m_Protocol->SendUnloadChunk(itr->m_ChunkX, itr->m_ChunkZ);
 	}  // for itr - Chunks[]
 	
-	// Do NOT stream new chunks, the new world runs its own tick thread and may deadlock
-	// Instead, the chunks will be streamed when the client is moved to the new world's Tick list,
-	// by setting state to csAuthenticated
-	m_State = csAuthenticated;
+	// StreamChunks() called in cPlayer::MoveToWorld() after new world has been set
+	// Meanwhile here, we set last streamed values to bogus ones so everything is resent
 	m_LastStreamedChunkX = 0x7fffffff;
 	m_LastStreamedChunkZ = 0x7fffffff;
 	m_HasSentPlayerChunk = false;
@@ -1546,28 +1623,12 @@ bool cClientHandle::CheckBlockInteractionsRate(void)
 {
 	ASSERT(m_Player != NULL);
 	ASSERT(m_Player->GetWorld() != NULL);
-	/*
-	// TODO: _X 2012_11_01: This needs a total re-thinking and rewriting
-	int LastActionCnt = m_Player->GetLastBlockActionCnt();
-	if ((m_Player->GetWorld()->GetTime() - m_Player->GetLastBlockActionTime()) < 0.1)
-	{
-		// Limit the number of block interactions per tick
-		m_Player->SetLastBlockActionTime(); //Player tried to interact with a block. Reset last block interation time.
-		m_Player->SetLastBlockActionCnt(LastActionCnt + 1);
-		if (m_Player->GetLastBlockActionCnt() > MAXBLOCKCHANGEINTERACTIONS)
-		{
-			// Kick if more than MAXBLOCKCHANGEINTERACTIONS per tick
-			LOGWARN("Player %s tried to interact with a block too quickly! (could indicate bot) Was Kicked.", m_Username.c_str());
-			Kick("You're a baaaaaad boy!");
-			return false;
-		}
-	}
-	else
+
+	if (m_NumBlockChangeInteractionsThisTick > MAX_BLOCK_CHANGE_INTERACTIONS)
 	{
-		m_Player->SetLastBlockActionCnt(0);  // Reset count 
-		m_Player->SetLastBlockActionTime();  // Player tried to interact with a block. Reset last block interation time.
+		return false;
 	}
-	*/
+
 	return true;
 }
 
@@ -1640,10 +1701,9 @@ void cClientHandle::Tick(float a_Dt)
 		}
 	}
 	
-	// Update the explosion statistics:
-	m_CurrentExplosionTick = (m_CurrentExplosionTick + 1) % ARRAYCOUNT(m_NumExplosionsPerTick);
-	m_RunningSumExplosions -= m_NumExplosionsPerTick[m_CurrentExplosionTick];
-	m_NumExplosionsPerTick[m_CurrentExplosionTick] = 0;
+	// Reset explosion & block change counters:
+	m_NumExplosionsThisTick = 0;
+	m_NumBlockChangeInteractionsThisTick = 0;
 }
 
 
@@ -1740,7 +1800,118 @@ void cClientHandle::SendBlockChanges(int a_ChunkX, int a_ChunkZ, const sSetBlock
 
 
 
-void cClientHandle::SendChat(const AString & a_Message)
+void cClientHandle::SendChat(const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData)
+{
+	bool ShouldAppendChatPrefixes = true;
+
+	if (GetPlayer()->GetWorld() == NULL)
+	{
+		cWorld * World = cRoot::Get()->GetWorld(GetPlayer()->GetLoadedWorldName());
+		if (World == NULL)
+		{
+			World = cRoot::Get()->GetDefaultWorld();
+		}
+
+		if (!World->ShouldUseChatPrefixes())
+		{
+			ShouldAppendChatPrefixes = false;
+		}
+	}
+	else if (!GetPlayer()->GetWorld()->ShouldUseChatPrefixes())
+	{
+		ShouldAppendChatPrefixes = false;
+	}
+
+	AString Message;
+
+	switch (a_ChatPrefix)
+	{
+		case mtCustom: break;
+		case mtFailure:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[INFO] %s", cChatColor::Rose.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Rose.c_str());
+			break;
+		}
+		case mtInformation:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[INFO] %s", cChatColor::Yellow.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Yellow.c_str());
+			break;
+		}
+		case mtSuccess:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[INFO] %s", cChatColor::Green.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Green.c_str());
+			break;
+		}
+		case mtWarning:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[WARN] %s", cChatColor::Rose.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Rose.c_str());
+			break;
+		}
+		case mtFatal:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[FATAL] %s", cChatColor::Red.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Red.c_str());
+			break;
+		}
+		case mtDeath:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[DEATH] %s", cChatColor::Gray.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Gray.c_str());
+			break;
+		}
+		case mtPrivateMessage:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[MSG: %s] %s%s", cChatColor::LightBlue.c_str(), a_AdditionalData.c_str(), cChatColor::White.c_str(), cChatColor::Italic.c_str());
+			else
+				Message = Printf("%s: %s", a_AdditionalData.c_str(), cChatColor::LightBlue.c_str());
+			break;
+		}
+		case mtJoin:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[JOIN] %s", cChatColor::Yellow.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Yellow.c_str());
+			break;
+		}
+		case mtLeave:
+		{
+			if (ShouldAppendChatPrefixes)
+				Message = Printf("%s[LEAVE] %s", cChatColor::Yellow.c_str(), cChatColor::White.c_str());
+			else
+				Message = Printf("%s", cChatColor::Yellow.c_str());
+			break;
+		}
+		default: ASSERT(!"Unhandled chat prefix type!"); return;
+	}
+
+	Message.append(a_Message);
+
+	m_Protocol->SendChat(Message);
+}
+
+
+
+
+
+void cClientHandle::SendChat(const cCompositeChat & a_Message)
 {
 	m_Protocol->SendChat(a_Message);
 }
@@ -1923,18 +2094,14 @@ void cClientHandle::SendEntityVelocity(const cEntity & a_Entity)
 
 void cClientHandle::SendExplosion(double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion)
 {
-	if (
-		(m_NumExplosionsPerTick[m_CurrentExplosionTick] > MAX_EXPLOSIONS_PER_TICK) ||  // Too many explosions in this tick
-		(m_RunningSumExplosions > MAX_RUNNING_SUM_EXPLOSIONS)  // Too many explosions in the recent history
-	)
+	if (m_NumExplosionsThisTick > MAX_EXPLOSIONS_PER_TICK)
 	{
-		LOGD("Dropped %u explosions", a_BlocksAffected.size());
+		LOGD("Dropped an explosion!");
 		return;
 	}
 	
 	// Update the statistics:
-	m_NumExplosionsPerTick[m_CurrentExplosionTick] += a_BlocksAffected.size();
-	m_RunningSumExplosions += a_BlocksAffected.size();
+	m_NumExplosionsThisTick += 1;
 	
 	m_Protocol->SendExplosion(a_BlockX, a_BlockY, a_BlockZ, a_Radius, a_BlocksAffected, a_PlayerMotion);
 }
@@ -1970,6 +2137,33 @@ void cClientHandle::SendInventorySlot(char a_WindowID, short a_SlotNum, const cI
 
 
 
+void cClientHandle::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+{
+	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length);
+}
+
+
+
+
+
+void cClientHandle::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+{
+	m_Protocol->SendMapDecorators(a_ID, a_Decorators);
+}
+
+
+
+
+
+void cClientHandle::SendMapInfo(int a_ID, unsigned int a_Scale)
+{
+	m_Protocol->SendMapInfo(a_ID, a_Scale);
+}
+
+
+
+
+
 void cClientHandle::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
 {
 	m_Protocol->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmmount);
@@ -1987,6 +2181,14 @@ void cClientHandle::SendPickupSpawn(const cPickup & a_Pickup)
 
 
 
+void cClientHandle::SendPaintingSpawn(const cPainting & a_Painting)
+{
+	m_Protocol->SendPaintingSpawn(a_Painting);
+}
+
+
+
+
 
 void cClientHandle::SendEntityAnimation(const cEntity & a_Entity, char a_Animation)
 {
@@ -2111,6 +2313,33 @@ void cClientHandle::SendExperienceOrb(const cExpOrb & a_ExpOrb)
 
 
 
+void cClientHandle::SendScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
+{
+	m_Protocol->SendScoreboardObjective(a_Name, a_DisplayName, a_Mode);
+}
+
+
+
+
+
+void cClientHandle::SendScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
+{
+	m_Protocol->SendScoreUpdate(a_Objective, a_Player, a_Score, a_Mode);
+}
+
+
+
+
+
+void cClientHandle::SendDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
+{
+	m_Protocol->SendDisplayObjective(a_Objective, a_Display);
+}
+
+
+
+
+
 void cClientHandle::SendSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch)
 {
 	m_Protocol->SendSoundEffect(a_SoundName, a_SrcX, a_SrcY, a_SrcZ, a_Volume, a_Pitch);
@@ -2324,6 +2553,15 @@ void cClientHandle::SetViewDistance(int a_ViewDistance)
 
 
 
+bool cClientHandle::HasPluginChannel(const AString & a_PluginChannel)
+{
+	return (m_PluginChannels.find(a_PluginChannel) != m_PluginChannels.end());
+}
+
+
+
+
+
 bool cClientHandle::WantsSendChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
 {
 	if (m_State >= csDestroying)
@@ -2395,7 +2633,7 @@ void cClientHandle::PacketError(unsigned char a_PacketType)
 
 
 
-void cClientHandle::DataReceived(const char * a_Data, int a_Size)
+void cClientHandle::DataReceived(const char * a_Data, size_t a_Size)
 {
 	// Data is received from the client, store it in the buffer to be processed by the Tick thread:
 	m_TimeSinceLastPacket = 0;
@@ -2437,13 +2675,7 @@ void cClientHandle::SocketClosed(void)
 
 	if (m_Username != "") // Ignore client pings
 	{
-		if (!cRoot::Get()->GetPluginManager()->CallHookDisconnect(m_Player, "Player disconnected"))
-		{
-			AString DisconnectMessage;
-			Printf(DisconnectMessage, "%s[LEAVE] %s%s has left the game", cChatColor::Yellow.c_str(), cChatColor::White.c_str(), m_Username.c_str());
-			cRoot::Get()->BroadcastChat(DisconnectMessage);
-			LOGINFO("Player %s has left the game.", m_Username.c_str());
-		}
+		cRoot::Get()->GetPluginManager()->CallHookDisconnect(m_Player, "Player disconnected");
 	}
 
 	Destroy();
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index 4add022a6..0c367ec7d 100644
--- a/src/ClientHandle.h
+++ b/src/ClientHandle.h
@@ -12,10 +12,12 @@
 #define CCLIENTHANDLE_H_INCLUDED
 
 #include "Defines.h"
-#include "Vector3d.h"
+#include "Vector3.h"
 #include "OSSupport/SocketThreads.h"
 #include "ChunkDef.h"
 #include "ByteBuffer.h"
+#include "Scoreboard.h"
+#include "Map.h"
 
 
 
@@ -26,6 +28,7 @@ class cInventory;
 class cMonster;
 class cPawn;
 class cExpOrb;
+class cPainting;
 class cPickup;
 class cPlayer;
 class cProtocol;
@@ -33,6 +36,7 @@ class cWindow;
 class cFallingBlock;
 class cItemHandler;
 class cWorld;
+class cCompositeChat;
 
 
 
@@ -42,7 +46,6 @@ class cClientHandle :  // tolua_export
 	public cSocketThreads::cCallback
 {											// tolua_export
 public:
-	static const int MAXBLOCKCHANGEINTERACTIONS = 20; // 5 didn't help, 10 still doesn't work in Creative, 20 seems to have done the trick
 	
 #if defined(ANDROID_NDK)
 	static const int DEFAULT_VIEW_DISTANCE = 4;  // The default ViewDistance (used when no value is set in Settings.ini)
@@ -52,9 +55,6 @@ public:
 	static const int MAX_VIEW_DISTANCE = 15;
 	static const int MIN_VIEW_DISTANCE = 3;
 	
-	/// How many ticks should be checked for a running average of explosions, for limiting purposes
-	static const int NUM_CHECK_EXPLOSIONS_TICKS = 20;
-	
 	cClientHandle(const cSocket * a_Socket, int a_ViewDistance);
 	virtual ~cClientHandle();
 
@@ -72,10 +72,10 @@ public:
 	
 	inline bool IsLoggedIn(void) const { return (m_State >= csAuthenticating); }
 
-	/// Called while the client is being ticked from the world via its cPlayer object
+	/** Called while the client is being ticked from the world via its cPlayer object */
 	void Tick(float a_Dt);
 	
-	/// Called while the client is being ticked from the cServer object
+	/** Called while the client is being ticked from the cServer object */
 	void ServerTick(float a_Dt);
 
 	void Destroy(void);
@@ -91,7 +91,8 @@ public:
 	void SendBlockBreakAnim      (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage);
 	void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta); // tolua_export
 	void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes);
-	void SendChat                (const AString & a_Message);
+	void SendChat                (const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData = "");
+	void SendChat                (const cCompositeChat & a_Message);
 	void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer);
 	void SendCollectPickup       (const cPickup & a_Pickup, const cPlayer & a_Player);
 	void SendDestroyEntity       (const cEntity & a_Entity);
@@ -111,6 +112,10 @@ public:
 	void SendGameMode            (eGameMode a_GameMode);
 	void SendHealth              (void);
 	void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item);
+	void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length);
+	void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators);
+	void SendMapInfo             (int a_ID, unsigned int a_Scale);
+	void SendPaintingSpawn       (const cPainting & a_Painting);
 	void SendPickupSpawn         (const cPickup & a_Pickup);
 	void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation);
 	void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount);
@@ -125,6 +130,9 @@ public:
 	void SendRespawn             (void);
 	void SendExperience          (void);
 	void SendExperienceOrb       (const cExpOrb & a_ExpOrb);
+	void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
+	void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
+	void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
 	void SendSoundEffect         (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch);  // a_Src coords are Block * 8
 	void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data);
 	void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock);
@@ -145,20 +153,28 @@ public:
 	void SendWindowOpen          (const cWindow & a_Window);
 	void SendWindowProperty      (const cWindow & a_Window, int a_Property, int a_Value);
 
-	const AString & GetUsername(void) const;		// tolua_export
-	void SetUsername( const AString & a_Username );	// tolua_export
+	// tolua_begin
+	const AString & GetUsername(void) const;
+	void SetUsername( const AString & a_Username );
+	
+	inline short GetPing(void) const { return m_Ping; }
 	
-	inline short GetPing(void) const { return m_Ping; }	// tolua_export
+	void SetViewDistance(int a_ViewDistance);
+	int  GetViewDistance(void) const { return m_ViewDistance; }
 	
-	void SetViewDistance(int a_ViewDistance);		// tolua_export
-	int  GetViewDistance(void) const { return m_ViewDistance; }  // tolua_export
+	void SetLocale(AString & a_Locale) { m_Locale = a_Locale; }
+	AString GetLocale(void) const { return m_Locale; }
 
-	int GetUniqueID() const { return m_UniqueID; }	// tolua_export
+	int GetUniqueID(void) const { return m_UniqueID; }
+	
+	bool HasPluginChannel(const AString & a_PluginChannel);
+	
+	// tolua_end
 	
-	/// Returns true if the client wants the chunk specified to be sent (in m_ChunksToSend)
+	/** Returns true if the client wants the chunk specified to be sent (in m_ChunksToSend) */
 	bool WantsSendChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);
 	
-	/// Adds the chunk specified to the list of chunks wanted for sending (m_ChunksToSend)
+	/** Adds the chunk specified to the list of chunks wanted for sending (m_ChunksToSend) */
 	void AddWantedChunk(int a_ChunkX, int a_ChunkZ);
 	
 	// Calls that cProtocol descendants use to report state:
@@ -171,7 +187,9 @@ public:
 	void HandleChat             (const AString & a_Message);
 	void HandleCreativeInventory(short a_SlotNum, const cItem & a_HeldItem);
 	void HandleDisconnect       (const AString & a_Reason);
-	void HandleEntityAction     (int a_EntityID, char a_ActionID);
+	void HandleEntityCrouch     (int a_EntityID, bool a_IsCrouching);
+	void HandleEntityLeaveBed   (int a_EntityID);
+	void HandleEntitySprinting  (int a_EntityID, bool a_IsSprinting);
 	
 	/** Called when the protocol handshake has been received (for protocol versions that support it;
 	otherwise the first instant when a username is received).
@@ -180,7 +198,7 @@ public:
 	bool HandleHandshake        (const AString & a_Username);
 	
 	void HandleKeepAlive        (int a_KeepAliveID);
-	void HandleLeftClick        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status);
+	void HandleLeftClick        (int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, char a_Status);
 	void HandlePing             (void);
 	void HandlePlayerAbilities  (bool a_CanFly, bool a_IsFlying, float FlyingSpeed, float WalkingSpeed);
 	void HandlePlayerLook       (float a_Rotation, float a_Pitch, bool a_IsOnGround);
@@ -188,7 +206,7 @@ public:
 	void HandlePlayerPos        (double a_PosX, double a_PosY, double a_PosZ, double a_Stance, bool a_IsOnGround);
 	void HandlePluginMessage    (const AString & a_Channel, const AString & a_Message);
 	void HandleRespawn          (void);
-	void HandleRightClick       (int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, const cItem & a_HeldItem);
+	void HandleRightClick       (int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, const cItem & a_HeldItem);
 	void HandleSlotSelected     (short a_SlotNum);
 	void HandleSteerVehicle     (float Forward, float Sideways);
 	void HandleTabCompletion    (const AString & a_Text);
@@ -207,16 +225,19 @@ public:
 	*/
 	bool HandleLogin(int a_ProtocolVersion, const AString & a_Username);
 	
-	void SendData(const char * a_Data, int a_Size);
+	void SendData(const char * a_Data, size_t a_Size);
 	
-	/// Called when the player moves into a different world; queues sreaming the new chunks
+	/** Called when the player moves into a different world; queues sreaming the new chunks */
 	void MoveToWorld(cWorld & a_World, bool a_SendRespawnPacket);
 	
-	/// Handles the block placing packet when it is a real block placement (not block-using, item-using or eating)
-	void HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, cItemHandler & a_ItemHandler);
-	
 private:
 
+	/** Handles the block placing packet when it is a real block placement (not block-using, item-using or eating) */
+	void HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, cItemHandler & a_ItemHandler);
+
+	/** The type used for storing the names of registered plugin channels. */
+	typedef std::set<AString> cChannels;
+
 	int m_ViewDistance;  // Number of chunks the player can see in each direction; 4 is the minimum ( http://wiki.vg/Protocol_FAQ#.E2.80.A6all_connecting_clients_spasm_and_jerk_uncontrollably.21 )
 	
 	static const int GENERATEDISTANCE = 2; // Server generates this many chunks AHEAD of player sight. 2 is the minimum, since foliage is generated 1 step behind chunk terrain generation
@@ -249,7 +270,7 @@ private:
 	int m_LastStreamedChunkX;
 	int m_LastStreamedChunkZ;
 
-	/// Seconds since the last packet data was received (updated in Tick(), reset in DataReceived())
+	/** Seconds since the last packet data was received (updated in Tick(), reset in DataReceived()) */
 	float m_TimeSinceLastPacket;
 	
 	short m_Ping;
@@ -271,7 +292,7 @@ private:
 	int m_LastDigBlockY;
 	int m_LastDigBlockZ;
 	
-	/// Used while csDestroyedWaiting for counting the ticks until the connection is closed
+	/** Used while csDestroyedWaiting for counting the ticks until the connection is closed */
 	int m_TicksSinceDestruction;
 
 	enum eState
@@ -291,46 +312,57 @@ private:
 	
 	eState m_State;
 	
-	/// m_State needs to be locked in the Destroy() function so that the destruction code doesn't run twice on two different threads
+	/** m_State needs to be locked in the Destroy() function so that the destruction code doesn't run twice on two different threads */
 	cCriticalSection m_CSDestroyingState;
 
-	/// If set to true during csDownloadingWorld, the tick thread calls CheckIfWorldDownloaded()
+	/** If set to true during csDownloadingWorld, the tick thread calls CheckIfWorldDownloaded() */
 	bool m_ShouldCheckDownloaded;
 
-	/// Stores the recent history of the number of explosions per tick
-	int m_NumExplosionsPerTick[NUM_CHECK_EXPLOSIONS_TICKS];
-	
-	/// Points to the current tick in the m_NumExplosionsPerTick[] array
-	int m_CurrentExplosionTick;
-	
-	/// Running sum of m_NumExplosionsPerTick[]
-	int m_RunningSumExplosions;
+	/** Number of explosions sent this tick */
+	int m_NumExplosionsThisTick;
+
+	/** Number of place or break interactions this tick */
+	int m_NumBlockChangeInteractionsThisTick;
 	
 	static int s_ClientCount;
 	int m_UniqueID;
 	
-	/// Set to true when the chunk where the player is is sent to the client. Used for spawning the player
+	/** Set to true when the chunk where the player is is sent to the client. Used for spawning the player */
 	bool m_HasSentPlayerChunk;
+
+	/** Client Settings */
+	AString m_Locale;
 	
+	/** The plugin channels that the client has registered. */
+	cChannels m_PluginChannels;
 
 
-	/// Returns true if the rate block interactions is within a reasonable limit (bot protection)
+	/** Returns true if the rate block interactions is within a reasonable limit (bot protection) */
 	bool CheckBlockInteractionsRate(void);
 	
-	/// Adds a single chunk to be streamed to the client; used by StreamChunks()
+	/** Adds a single chunk to be streamed to the client; used by StreamChunks() */
 	void StreamChunk(int a_ChunkX, int a_ChunkZ);
 	
-	/// Handles the DIG_STARTED dig packet:
-	void HandleBlockDigStarted (int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta);
+	/** Handles the DIG_STARTED dig packet: */
+	void HandleBlockDigStarted (int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta);
 	
-	/// Handles the DIG_FINISHED dig packet:
-	void HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta);
+	/** Handles the DIG_FINISHED dig packet: */
+	void HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta);
 
-	/// Handles the "MC|AdvCdm" plugin message
-	void HandleCommandBlockMessage(const char* a_Data, unsigned int a_Length);
+	/** Converts the protocol-formatted channel list (NUL-separated) into a proper string vector. */
+	AStringVector BreakApartPluginChannels(const AString & a_PluginChannels);
+	
+	/** Adds all of the channels to the list of current plugin channels. Handles duplicates gracefully. */
+	void RegisterPluginChannels(const AStringVector & a_ChannelList);
+	
+	/** Removes all of the channels from the list of current plugin channels. Ignores channels that are not found. */
+	void UnregisterPluginChannels(const AStringVector & a_ChannelList);
+	
+	/** Handles the "MC|AdvCdm" plugin message */
+	void HandleCommandBlockMessage(const char * a_Data, unsigned int a_Length);
 	
 	// cSocketThreads::cCallback overrides:
-	virtual void DataReceived   (const char * a_Data, int a_Size) override;  // Data is received from the client
+	virtual void DataReceived   (const char * a_Data, size_t a_Size) override;  // Data is received from the client
 	virtual void GetOutgoingData(AString & a_Data) override;  // Data can be sent to client
 	virtual void SocketClosed   (void) override;  // The socket has been closed for any reason
 };										// tolua_export
diff --git a/src/CommandOutput.cpp b/src/CommandOutput.cpp
index c221682a1..2c116b3d6 100644
--- a/src/CommandOutput.cpp
+++ b/src/CommandOutput.cpp
@@ -51,7 +51,7 @@ void cLogCommandOutputCallback::Finished(void)
 		{
 			case '\n':
 			{
-				LOG(m_Buffer.substr(last, i - last).c_str());
+				LOG("%s", m_Buffer.substr(last, i - last).c_str());
 				last = i + 1;
 				break;
 			}
@@ -59,7 +59,7 @@ void cLogCommandOutputCallback::Finished(void)
 	}  // for i - m_Buffer[]
 	if (last < len)
 	{
-		LOG(m_Buffer.substr(last).c_str());
+		LOG("%s", m_Buffer.substr(last).c_str());
 	}
 	
 	// Clear the buffer for the next command output:
diff --git a/src/CommandOutput.h b/src/CommandOutput.h
index 3763d625f..5682b4fd8 100644
--- a/src/CommandOutput.h
+++ b/src/CommandOutput.h
@@ -17,7 +17,7 @@ public:
 	virtual ~cCommandOutputCallback() {};  // Force a virtual destructor in subclasses
 	
 	/// Syntax sugar function, calls Out() with Printf()-ed parameters; appends a "\n"
-	void Out(const char * a_Fmt, ...);
+	void Out(const char * a_Fmt, ...) FORMATSTRING(2, 3);
 	
 	/// Called when the command wants to output anything; may be called multiple times
 	virtual void Out(const AString & a_Text) = 0;
diff --git a/src/CompositeChat.cpp b/src/CompositeChat.cpp
new file mode 100644
index 000000000..c70ef1070
--- /dev/null
+++ b/src/CompositeChat.cpp
@@ -0,0 +1,478 @@
+
+// CompositeChat.cpp
+
+// Implements the cCompositeChat class used to wrap a chat message with multiple parts (text, url, cmd)
+
+#include "Globals.h"
+#include "CompositeChat.h"
+
+
+
+
+
+#ifdef SELF_TEST
+
+/** A simple self-test that verifies that the composite chat parser is working properly. */
+class SelfTest_CompositeChat
+{
+public:
+	SelfTest_CompositeChat(void)
+	{
+		fprintf(stderr, "cCompositeChat self test...\n");
+		TestParser1();
+		TestParser2();
+		TestParser3();
+		TestParser4();
+		TestParser5();
+		fprintf(stderr, "cCompositeChat self test finished.\n");
+	}
+	
+	void TestParser1(void)
+	{
+		cCompositeChat Msg;
+		Msg.ParseText("Testing @2color codes and http://links parser");
+		const cCompositeChat::cParts & Parts = Msg.GetParts();
+		assert_test(Parts.size() == 4);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[2]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[3]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[0]->m_Style == "");
+		assert_test(Parts[1]->m_Style == "@2");
+		assert_test(Parts[2]->m_Style == "@2");
+		assert_test(Parts[3]->m_Style == "@2");
+	}
+	
+	void TestParser2(void)
+	{
+		cCompositeChat Msg;
+		Msg.ParseText("@3Advanced stuff: @5overriding color codes and http://links.with/@4color-in-them handling");
+		const cCompositeChat::cParts & Parts = Msg.GetParts();
+		assert_test(Parts.size() == 4);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[2]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[3]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[0]->m_Style == "@3");
+		assert_test(Parts[1]->m_Style == "@5");
+		assert_test(Parts[2]->m_Style == "@5");
+		assert_test(Parts[3]->m_Style == "@5");
+	}
+	
+	void TestParser3(void)
+	{
+		cCompositeChat Msg;
+		Msg.ParseText("http://links.starting the text");
+		const cCompositeChat::cParts & Parts = Msg.GetParts();
+		assert_test(Parts.size() == 2);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[0]->m_Style == "");
+		assert_test(Parts[1]->m_Style == "");
+	}
+	
+	void TestParser4(void)
+	{
+		cCompositeChat Msg;
+		Msg.ParseText("links finishing the text: http://some.server");
+		const cCompositeChat::cParts & Parts = Msg.GetParts();
+		assert_test(Parts.size() == 2);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[0]->m_Style == "");
+		assert_test(Parts[1]->m_Style == "");
+	}
+	
+	void TestParser5(void)
+	{
+		cCompositeChat Msg;
+		Msg.ParseText("http://only.links");
+		const cCompositeChat::cParts & Parts = Msg.GetParts();
+		assert_test(Parts.size() == 1);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[0]->m_Style == "");
+	}
+	
+} gTest;
+#endif  // SELF_TEST
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat:
+
+cCompositeChat::cCompositeChat(void) :
+	m_MessageType(mtCustom)
+{
+}
+
+
+
+
+
+cCompositeChat::cCompositeChat(const AString & a_ParseText, eMessageType a_MessageType) :
+	m_MessageType(a_MessageType)
+{
+	ParseText(a_ParseText);
+}
+
+
+
+
+
+cCompositeChat::~cCompositeChat()
+{
+	Clear();
+}
+
+
+
+
+
+void cCompositeChat::Clear(void)
+{
+	for (cParts::iterator itr = m_Parts.begin(), end = m_Parts.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - m_Parts[]
+	m_Parts.clear();
+}
+
+
+
+
+
+void cCompositeChat::AddTextPart(const AString & a_Message, const AString & a_Style)
+{
+	m_Parts.push_back(new cTextPart(a_Message, a_Style));
+}
+
+
+
+
+
+void cCompositeChat::AddClientTranslatedPart(const AString & a_TranslationID, const AStringVector & a_Parameters, const AString & a_Style)
+{
+	m_Parts.push_back(new cClientTranslatedPart(a_TranslationID, a_Parameters, a_Style));
+}
+
+
+
+
+
+void cCompositeChat::AddUrlPart(const AString & a_Text, const AString & a_Url, const AString & a_Style)
+{
+	m_Parts.push_back(new cUrlPart(a_Text, a_Url, a_Style));
+}
+
+
+
+
+
+void cCompositeChat::AddRunCommandPart(const AString & a_Text, const AString & a_Command, const AString & a_Style)
+{
+	m_Parts.push_back(new cRunCommandPart(a_Text, a_Command, a_Style));
+}
+
+
+
+
+
+void cCompositeChat::AddSuggestCommandPart(const AString & a_Text, const AString & a_SuggestedCommand, const AString & a_Style)
+{
+	m_Parts.push_back(new cSuggestCommandPart(a_Text, a_SuggestedCommand, a_Style));
+}
+
+
+
+
+
+void cCompositeChat::ParseText(const AString & a_ParseText)
+{
+	size_t len = a_ParseText.length();
+	size_t first = 0;  // First character of the currently parsed block
+	AString CurrentStyle;
+	AString CurrentText;
+	for (size_t i = 0; i < len; i++)
+	{
+		switch (a_ParseText[i])
+		{
+			case '@':
+			{
+				// Color code
+				i++;
+				if (i >= len)
+				{
+					// Not enough following text
+					break;
+				}
+				if (a_ParseText[i] == '@')
+				{
+					// "@@" escape, just put a "@" into the current text and keep parsing as text
+					if (i > first + 1)
+					{
+						CurrentText.append(a_ParseText.c_str() + first, i - first - 1);
+					}
+					first = i + 1;
+					continue;
+				}
+				else
+				{
+					// True color code. Create a part for the CurrentText and start parsing anew:
+					if (i >= first)
+					{
+						CurrentText.append(a_ParseText.c_str() + first, i - first - 1);
+						first = i + 1;
+					}
+					if (!CurrentText.empty())
+					{
+						m_Parts.push_back(new cTextPart(CurrentText, CurrentStyle));
+						CurrentText.clear();
+					}
+					AddStyle(CurrentStyle, a_ParseText.substr(i - 1, 2));
+				}
+				break;
+			}
+			
+			case ':':
+			{
+				const char * LinkPrefixes[] =
+				{
+					"http",
+					"https"
+				};
+				for (size_t Prefix = 0; Prefix < ARRAYCOUNT(LinkPrefixes); Prefix++)
+				{
+					size_t PrefixLen = strlen(LinkPrefixes[Prefix]);
+					if (
+						(i >= first + PrefixLen) &&  // There is enough space in front of the colon for the prefix
+						(strncmp(a_ParseText.c_str() + i - PrefixLen, LinkPrefixes[Prefix], PrefixLen) == 0)  // the prefix matches
+					)
+					{
+						// Add everything before this as a text part:
+						if (i > first + PrefixLen)
+						{
+							CurrentText.append(a_ParseText.c_str() + first, i - first - PrefixLen);
+							first = i - PrefixLen;
+						}
+						if (!CurrentText.empty())
+						{
+							AddTextPart(CurrentText, CurrentStyle);
+							CurrentText.clear();
+						}
+						
+						// Go till the last non-whitespace char in the text:
+						for (; i < len; i++)
+						{
+							if (isspace(a_ParseText[i]))
+							{
+								break;
+							}
+						}
+						AddUrlPart(a_ParseText.substr(first, i - first), a_ParseText.substr(first, i - first), CurrentStyle);
+						first = i;
+						break;
+					}
+				}  // for Prefix - LinkPrefix[]
+				break;
+			}  // case ':'
+		}  // switch (a_ParseText[i])
+	}  // for i - a_ParseText[]
+	if (first < len)
+	{
+		AddTextPart(a_ParseText.substr(first, len - first), CurrentStyle);
+	}
+}
+
+
+
+
+
+void cCompositeChat::SetMessageType(eMessageType a_MessageType)
+{
+	m_MessageType = a_MessageType;
+}
+
+
+
+
+
+void cCompositeChat::UnderlineUrls(void)
+{
+	for (cParts::iterator itr = m_Parts.begin(), end = m_Parts.end(); itr != end; ++itr)
+	{
+		if ((*itr)->m_PartType == ptUrl)
+		{
+			(*itr)->m_Style.append("u");
+		}
+	}  // for itr - m_Parts[]
+}
+
+
+
+
+
+AString cCompositeChat::ExtractText(void) const
+{
+	AString Msg;
+	for (cParts::const_iterator itr = m_Parts.begin(), end = m_Parts.end(); itr != end; ++itr)
+	{
+		switch ((*itr)->m_PartType)
+		{
+			case ptText:
+			case ptClientTranslated:
+			case ptRunCommand:
+			case ptSuggestCommand:
+			{
+				Msg.append((*itr)->m_Text);
+				break;
+			}
+			case ptUrl:
+			{
+				Msg.append(((cUrlPart *)(*itr))->m_Url);
+				break;
+			}
+		}  // switch (PartType)
+	}  // for itr - m_Parts[]
+	return Msg;
+}
+
+
+
+
+
+cMCLogger::eLogLevel cCompositeChat::MessageTypeToLogLevel(eMessageType a_MessageType)
+{
+	switch (a_MessageType)
+	{
+		case mtCustom:         return cMCLogger::llRegular;
+		case mtFailure:        return cMCLogger::llWarning;
+		case mtInformation:    return cMCLogger::llInfo;
+		case mtSuccess:        return cMCLogger::llRegular;
+		case mtWarning:        return cMCLogger::llWarning;
+		case mtFatal:          return cMCLogger::llError;
+		case mtDeath:          return cMCLogger::llRegular;
+		case mtPrivateMessage: return cMCLogger::llRegular;
+		case mtJoin:           return cMCLogger::llRegular;
+		case mtLeave:          return cMCLogger::llRegular;
+	}
+	ASSERT(!"Unhandled MessageType");
+	return cMCLogger::llError;
+}
+
+
+
+
+
+void cCompositeChat::AddStyle(AString & a_Style, const AString & a_AddStyle)
+{
+	if (a_AddStyle.empty())
+	{
+		return;
+	}
+	if (a_AddStyle[0] == '@')
+	{
+		size_t idx = a_Style.find('@');
+		if ((idx != AString::npos) && (idx != a_Style.length()))
+		{
+			a_Style.erase(idx, 2);
+		}
+		a_Style.append(a_AddStyle);
+		return;
+	}
+	a_Style.append(a_AddStyle);
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cBasePart:
+
+cCompositeChat::cBasePart::cBasePart(cCompositeChat::ePartType a_PartType, const AString & a_Text, const AString & a_Style) :
+	m_PartType(a_PartType),
+	m_Text(a_Text),
+	m_Style(a_Style)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cTextPart:
+
+cCompositeChat::cTextPart::cTextPart(const AString & a_Text, const AString &a_Style) :
+	super(ptText, a_Text, a_Style)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cClientTranslatedPart:
+
+cCompositeChat::cClientTranslatedPart::cClientTranslatedPart(const AString & a_TranslationID, const AStringVector & a_Parameters, const AString & a_Style) :
+	super(ptClientTranslated, a_TranslationID, a_Style),
+	m_Parameters(a_Parameters)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cUrlPart:
+
+cCompositeChat::cUrlPart::cUrlPart(const AString & a_Text, const AString & a_Url, const AString & a_Style) :
+	super(ptUrl, a_Text, a_Style),
+	m_Url(a_Url)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cCommandPart:
+
+cCompositeChat::cCommandPart::cCommandPart(ePartType a_PartType, const AString & a_Text, const AString & a_Command, const AString & a_Style) :
+	super(a_PartType, a_Text, a_Style),
+	m_Command(a_Command)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cRunCommandPart:
+
+cCompositeChat::cRunCommandPart::cRunCommandPart(const AString & a_Text, const AString & a_Command, const AString & a_Style) :
+	super(ptRunCommand, a_Text, a_Command, a_Style)
+{
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCompositeChat::cSuggestCommandPart:
+
+cCompositeChat::cSuggestCommandPart::cSuggestCommandPart(const AString & a_Text, const AString & a_Command, const AString & a_Style) :
+	super(ptSuggestCommand, a_Text, a_Command, a_Style)
+{
+}
+
+
+
+
diff --git a/src/CompositeChat.h b/src/CompositeChat.h
new file mode 100644
index 000000000..5b9c5f612
--- /dev/null
+++ b/src/CompositeChat.h
@@ -0,0 +1,195 @@
+
+// CompositeChat.h
+
+// Declares the cCompositeChat class used to wrap a chat message with multiple parts (text, url, cmd)
+
+#include "Defines.h"
+
+
+
+
+
+// tolua_begin
+/** Container for a single chat message composed of multiple functional parts.
+Each part corresponds roughly to the behavior supported by the client messaging:
+	- plain text, optionaly colorized / styled
+	- clickable URLs
+	- clickable commands (run)
+	- clickable commands (suggest)
+Each part has a text assigned to it that can be styled. The style is specified using a string,
+each character / character combination in the string specifies the style to use:
+	- b = bold
+	- i = italic
+	- u = underlined
+	- s = strikethrough
+	- o = obfuscated
+	- @X = color X (X is 0 - 9 or a - f, same as dye meta
+If the protocol version doesn't support all the features, it degrades gracefully.
+*/
+class cCompositeChat
+{
+public:
+	// tolua_end
+	
+	enum ePartType
+	{
+		ptText,
+		ptClientTranslated,
+		ptUrl,
+		ptRunCommand,
+		ptSuggestCommand,
+	} ;
+	
+	class cBasePart
+	{
+	public:
+		ePartType m_PartType;
+		AString m_Text;
+		AString m_Style;
+		
+		cBasePart(ePartType a_PartType, const AString & a_Text, const AString & a_Style = "");
+		
+		// Force a virtual destructor in descendants
+		virtual ~cBasePart() {}
+	} ;
+	
+	class cTextPart :
+		public cBasePart
+	{
+		typedef cBasePart super;
+	public:
+		cTextPart(const AString & a_Text, const AString & a_Style = "");
+	} ;
+	
+	class cClientTranslatedPart :
+		public cBasePart
+	{
+		typedef cBasePart super;
+	public:
+		AStringVector m_Parameters;
+		
+		cClientTranslatedPart(const AString & a_TranslationID, const AStringVector & a_Parameters, const AString & a_Style = "");
+	} ;
+	
+	class cUrlPart :
+		public cBasePart
+	{
+		typedef cBasePart super;
+	public:
+		AString m_Url;
+		
+		cUrlPart(const AString & a_Text, const AString & a_Url, const AString & a_Style = "");
+	} ;
+	
+	class cCommandPart :
+		public cBasePart
+	{
+		typedef cBasePart super;
+	public:
+		AString m_Command;
+		
+		cCommandPart(ePartType a_PartType, const AString & a_Text, const AString & a_Command, const AString & a_Style = "");
+	} ;
+	
+	class cRunCommandPart :
+		public cCommandPart
+	{
+		typedef cCommandPart super;
+	public:
+		cRunCommandPart(const AString & a_Text, const AString & a_Command, const AString & a_Style = "");
+	} ;
+	
+	class cSuggestCommandPart :
+		public cCommandPart
+	{
+		typedef cCommandPart super;
+	public:
+		cSuggestCommandPart(const AString & a_Text, const AString & a_Command, const AString & a_Style = "");
+	} ;
+	
+	typedef std::vector<cBasePart *> cParts;
+	
+	// tolua_begin
+	
+	/** Creates a new empty chat message */
+	cCompositeChat(void);
+	
+	/** Creates a new chat message and parses the text into parts.
+	Recognizes "http:" and "https:" links and @color-codes.
+	Uses ParseText() for the actual parsing. */
+	cCompositeChat(const AString & a_ParseText, eMessageType a_MessageType = mtCustom);
+	
+	~cCompositeChat();
+	
+	/** Removes all parts from the object. */
+	void Clear(void);
+	
+	// tolua_end
+
+	// The following are exported in ManualBindings in order to support chaining - they return *this in Lua (#755)
+	
+	/** Adds a plain text part, with optional style.
+	The default style is plain white text. */
+	void AddTextPart(const AString & a_Message, const AString & a_Style = "");
+	
+	/** Adds a part that is translated client-side, with the formatting parameters and optional style. */
+	void AddClientTranslatedPart(const AString & a_TranslationID, const AStringVector & a_Parameters, const AString & a_Style = "");
+	
+	// tolua_begin
+	
+	/** Adds a part that opens an URL when clicked.
+	The default style is underlined light blue text. */
+	void AddUrlPart(const AString & a_Text, const AString & a_Url, const AString & a_Style = "u@c");
+	
+	/** Adds a part that runs a command when clicked.
+	The default style is underlined light green text. */
+	void AddRunCommandPart(const AString & a_Text, const AString & a_Command, const AString & a_Style = "u@a");
+	
+	/** Adds a part that suggests a command (enters it into the chat message area, but doesn't send) when clicked.
+	The default style is underlined yellow text. */
+	void AddSuggestCommandPart(const AString & a_Text, const AString & a_SuggestedCommand, const AString & a_Style = "u@b");
+	
+	/** Parses text into various parts, adds those.
+	Recognizes "http:" and "https:" URLs and @color-codes. */
+	void ParseText(const AString & a_ParseText);
+	
+	/** Sets the message type, which is indicated by prefixes added to the message when serializing. */
+	void SetMessageType(eMessageType a_MessageType);
+	
+	/** Adds the "underline" style to each part that is an URL. */
+	void UnderlineUrls(void);
+	
+	// tolua_begin
+
+	/** Returns the message type set previously by SetMessageType(). */
+	eMessageType GetMessageType(void) const { return m_MessageType; }
+	
+	/** Returns the text from the parts that comprises the human-readable data.
+	Used for older protocols that don't support composite chat
+	and for console-logging. */
+	AString ExtractText(void) const;
+	
+	// tolua_end
+	
+	const cParts & GetParts(void) const { return m_Parts; }
+	
+	/** Converts the MessageType to a LogLevel value.
+	Used by the logging bindings when logging a cCompositeChat object. */
+	static cMCLogger::eLogLevel MessageTypeToLogLevel(eMessageType a_MessageType);
+	
+protected:
+	/** All the parts that */
+	cParts m_Parts;
+	
+	/** The message type, as indicated by prefixes. */
+	eMessageType m_MessageType;
+	
+	
+	/** Adds a_AddStyle to a_Style; overwrites the existing style if appropriate.
+	If the style already contains something that a_AddStyle overrides, it is erased first. */
+	void AddStyle(AString & a_Style, const AString & a_AddStyle);
+} ;  // tolua_export
+
+
+
+
diff --git a/src/CraftingRecipes.cpp b/src/CraftingRecipes.cpp
index fb1a10cca..30e7a8733 100644
--- a/src/CraftingRecipes.cpp
+++ b/src/CraftingRecipes.cpp
@@ -1,4 +1,4 @@
-
+
 // CraftingRecipes.cpp
 
 // Interfaces to the cCraftingRecipes class representing the storage of crafting recipes
@@ -192,7 +192,9 @@ void cCraftingGrid::Dump(void)
 {
 	for (int y = 0; y < m_Height; y++) for (int x = 0; x < m_Width; x++)
 	{
+		#ifdef _DEBUG
 		int idx = x + m_Width * y;
+		#endif
 		LOGD("Slot (%d, %d): Type %d, health %d, count %d", 
 			x, y, m_Items[idx].m_ItemType, m_Items[idx].m_ItemDamage, m_Items[idx].m_ItemCount
 		);
@@ -338,7 +340,7 @@ void cCraftingRecipes::LoadRecipes(void)
 		}
 		AddRecipeLine(LineNum, Recipe);
 	}  // for itr - Split[]
-	LOG("Loaded %d crafting recipes", m_Recipes.size());
+	LOG("Loaded " SIZE_T_FMT " crafting recipes", m_Recipes.size());
 }
 
 
@@ -762,9 +764,94 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::MatchRecipe(const cItem * a_Crafti
 		Recipe->m_Ingredients.push_back(*itrS);
 	}
 	Recipe->m_Ingredients.insert(Recipe->m_Ingredients.end(), MatchedSlots.begin(), MatchedSlots.end());
+
+	// We use Recipe instead of a_Recipe because we want the wildcard ingredients' slot numbers as well, which was just added previously
+	HandleFireworks(a_CraftingGrid, Recipe.get(), a_GridStride, a_OffsetX, a_OffsetY);
+
 	return Recipe.release();
 }
 
 
 
 
+
+void cCraftingRecipes::HandleFireworks(const cItem * a_CraftingGrid, cCraftingRecipes::cRecipe * a_Recipe, int a_GridStride, int a_OffsetX, int a_OffsetY)
+{
+	// TODO: add support for more than one dye in the recipe
+	// A manual and temporary solution (listing everything) is in crafting.txt for fade colours, but a programmatic solutions needs to be done for everything else
+
+	if (a_Recipe->m_Result.m_ItemType == E_ITEM_FIREWORK_ROCKET)
+	{
+		for (cRecipeSlots::const_iterator itr = a_Recipe->m_Ingredients.begin(); itr != a_Recipe->m_Ingredients.end(); ++itr)
+		{
+			switch (itr->m_Item.m_ItemType)
+			{
+				case E_ITEM_FIREWORK_STAR:
+				{
+					// Result was a rocket, found a star - copy star data to rocket data
+					int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
+					a_Recipe->m_Result.m_FireworkItem.CopyFrom(a_CraftingGrid[GridID].m_FireworkItem);
+					break;
+				}
+				case E_ITEM_GUNPOWDER:
+				{
+					// Gunpowder - increase flight time
+					a_Recipe->m_Result.m_FireworkItem.m_FlightTimeInTicks += 20;
+					break;
+				}
+				case E_ITEM_PAPER: break;
+				default: LOG("Unexpected item in firework rocket a_Recipe, was the crafting file fireworks section changed?"); break;
+			}
+		}
+	}
+	else if (a_Recipe->m_Result.m_ItemType == E_ITEM_FIREWORK_STAR)
+	{
+		std::vector<int> DyeColours;
+		bool FoundStar = false;
+
+		for (cRecipeSlots::const_iterator itr = a_Recipe->m_Ingredients.begin(); itr != a_Recipe->m_Ingredients.end(); ++itr)
+		{
+			switch (itr->m_Item.m_ItemType)
+			{
+				case E_ITEM_FIREWORK_STAR:
+				{
+					// Result was star, found another star - probably adding fade colours, but copy data over anyhow
+					FoundStar = true;
+					int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
+					a_Recipe->m_Result.m_FireworkItem.CopyFrom(a_CraftingGrid[GridID].m_FireworkItem);
+					break;
+				}
+				case E_ITEM_DYE:
+				{
+					int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
+					DyeColours.push_back(cFireworkItem::GetVanillaColourCodeFromDye(a_CraftingGrid[GridID].m_ItemDamage));
+					break;
+				}
+				case E_ITEM_GUNPOWDER: break;
+				case E_ITEM_DIAMOND: a_Recipe->m_Result.m_FireworkItem.m_HasTrail = true; break;
+				case E_ITEM_GLOWSTONE_DUST: a_Recipe->m_Result.m_FireworkItem.m_HasFlicker = true; break;
+
+				case E_ITEM_FIRE_CHARGE: a_Recipe->m_Result.m_FireworkItem.m_Type = 1; break;
+				case E_ITEM_GOLD_NUGGET: a_Recipe->m_Result.m_FireworkItem.m_Type = 2; break;
+				case E_ITEM_FEATHER: a_Recipe->m_Result.m_FireworkItem.m_Type = 4; break;
+				case E_ITEM_HEAD: a_Recipe->m_Result.m_FireworkItem.m_Type = 3; break;
+				default: LOG("Unexpected item in firework star a_Recipe, was the crafting file fireworks section changed?"); break; // ermahgerd BARD ardmins
+			}
+		}
+
+		if (FoundStar && (!DyeColours.empty()))
+		{
+			// Found a star and a dye? Fade colours.
+			a_Recipe->m_Result.m_FireworkItem.m_FadeColours = DyeColours;
+		}
+		else if (!DyeColours.empty())
+		{
+			// Only dye? Normal colours.
+			a_Recipe->m_Result.m_FireworkItem.m_Colours = DyeColours;
+		}
+	}
+}
+
+
+
+
diff --git a/src/CraftingRecipes.h b/src/CraftingRecipes.h
index 9d92cbfab..90e41eddc 100644
--- a/src/CraftingRecipes.h
+++ b/src/CraftingRecipes.h
@@ -165,6 +165,9 @@ protected:
 	
 	/// Checks if the grid matches the specified recipe, offset by the specified offsets. Returns a matched cRecipe * if so, or NULL if not matching. Caller must delete the return value!
 	cRecipe * MatchRecipe(const cItem * a_CraftingGrid, int a_GridWidth, int a_GridHeight, int a_GridStride, const cRecipe * a_Recipe, int a_OffsetX, int a_OffsetY);
+
+	/** Searches for anything firework related, and does the data setting if appropriate */
+	void HandleFireworks(const cItem * a_CraftingGrid, cCraftingRecipes::cRecipe * a_Recipe, int a_GridStride, int a_OffsetX, int a_OffsetY);
 } ;
 
 
diff --git a/src/Crypto.cpp b/src/Crypto.cpp
new file mode 100644
index 000000000..26500f263
--- /dev/null
+++ b/src/Crypto.cpp
@@ -0,0 +1,509 @@
+
+// Crypto.cpp
+
+// Implements classes that wrap the cryptographic code library
+
+#include "Globals.h"
+#include "Crypto.h"
+
+#include "polarssl/pk.h"
+
+
+
+
+
+/*
+// Self-test the hash formatting for known values:
+// sha1(Notch) : 4ed1f46bbe04bc756bcb17c0c7ce3e4632f06a48
+// sha1(jeb_)  : -7c9d5b0044c130109a5d7b5fb5c317c02b4e28c1
+// sha1(simon) : 88e16a1019277b15d58faf0541e11910eb756f6
+
+class Test
+{
+public:
+	Test(void)
+	{
+		AString DigestNotch, DigestJeb, DigestSimon;
+		Byte Digest[20];
+		cSHA1Checksum Checksum;
+		Checksum.Update((const Byte *)"Notch", 5);
+		Checksum.Finalize(Digest);
+		cSHA1Checksum::DigestToJava(Digest, DigestNotch);
+		Checksum.Restart();
+		Checksum.Update((const Byte *)"jeb_", 4);
+		Checksum.Finalize(Digest);
+		cSHA1Checksum::DigestToJava(Digest, DigestJeb);
+		Checksum.Restart();
+		Checksum.Update((const Byte *)"simon", 5);
+		Checksum.Finalize(Digest);
+		cSHA1Checksum::DigestToJava(Digest, DigestSimon);
+		printf("Notch: \"%s\"\n", DigestNotch.c_str());
+		printf("jeb_:  \"%s\"\n",  DigestJeb.c_str());
+		printf("simon: \"%s\"\n", DigestSimon.c_str());
+		assert(DigestNotch == "4ed1f46bbe04bc756bcb17c0c7ce3e4632f06a48");
+		assert(DigestJeb   == "-7c9d5b0044c130109a5d7b5fb5c317c02b4e28c1");
+		assert(DigestSimon == "88e16a1019277b15d58faf0541e11910eb756f6");
+	}
+} test;
+*/
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cRSAPrivateKey:
+
+cRSAPrivateKey::cRSAPrivateKey(void)
+{
+	rsa_init(&m_Rsa, RSA_PKCS_V15, 0);
+	InitRnd();
+}
+
+
+
+
+
+cRSAPrivateKey::cRSAPrivateKey(const cRSAPrivateKey & a_Other)
+{
+	rsa_init(&m_Rsa, RSA_PKCS_V15, 0);
+	rsa_copy(&m_Rsa, &a_Other.m_Rsa);
+	InitRnd();
+}
+
+
+
+
+
+cRSAPrivateKey::~cRSAPrivateKey()
+{
+	entropy_free(&m_Entropy);
+	rsa_free(&m_Rsa);
+}
+
+
+
+
+
+void cRSAPrivateKey::InitRnd(void)
+{
+	entropy_init(&m_Entropy);
+	const unsigned char pers[] = "rsa_genkey";
+	ctr_drbg_init(&m_Ctr_drbg, entropy_func, &m_Entropy, pers, sizeof(pers) - 1);
+}
+
+
+
+
+
+bool cRSAPrivateKey::Generate(unsigned a_KeySizeBits)
+{
+	if (rsa_gen_key(&m_Rsa, ctr_drbg_random, &m_Ctr_drbg, a_KeySizeBits, 65537) != 0)
+	{
+		// Key generation failed
+		return false;
+	}
+
+	return true;
+}
+
+
+
+
+
+AString cRSAPrivateKey::GetPubKeyDER(void)
+{
+	class cPubKey
+	{
+	public:
+		cPubKey(rsa_context * a_Rsa) :
+			m_IsValid(false)
+		{
+			pk_init(&m_Key);
+			if (pk_init_ctx(&m_Key, pk_info_from_type(POLARSSL_PK_RSA)) != 0)
+			{
+				ASSERT(!"Cannot init PrivKey context");
+				return;
+			}
+			if (rsa_copy(pk_rsa(m_Key), a_Rsa) != 0)
+			{
+				ASSERT(!"Cannot copy PrivKey to PK context");
+				return;
+			}
+			m_IsValid = true;
+		}
+		
+		~cPubKey()
+		{
+			if (m_IsValid)
+			{
+				pk_free(&m_Key);
+			}
+		}
+		
+		operator pk_context * (void) { return &m_Key; }
+		
+	protected:
+		bool m_IsValid;
+		pk_context m_Key;
+	} PkCtx(&m_Rsa);
+	
+	unsigned char buf[3000];
+	int res = pk_write_pubkey_der(PkCtx, buf, sizeof(buf));
+	if (res < 0)
+	{
+		return AString();
+	}
+	return AString((const char *)(buf + sizeof(buf) - res), (size_t)res);
+}
+
+
+
+
+
+int cRSAPrivateKey::Decrypt(const Byte * a_EncryptedData, size_t a_EncryptedLength, Byte * a_DecryptedData, size_t a_DecryptedMaxLength)
+{
+	if (a_EncryptedLength < m_Rsa.len)
+	{
+		LOGD("%s: Invalid a_EncryptedLength: got %u, exp at least %u",
+			__FUNCTION__, (unsigned)a_EncryptedLength, (unsigned)(m_Rsa.len)
+		);
+		ASSERT(!"Invalid a_DecryptedMaxLength!");
+		return -1;
+	}
+	if (a_DecryptedMaxLength < m_Rsa.len)
+	{
+		LOGD("%s: Invalid a_DecryptedMaxLength: got %u, exp at least %u",
+			__FUNCTION__, (unsigned)a_EncryptedLength, (unsigned)(m_Rsa.len)
+		);
+		ASSERT(!"Invalid a_DecryptedMaxLength!");
+		return -1;
+	}
+	size_t DecryptedLength;
+	int res = rsa_pkcs1_decrypt(
+		&m_Rsa, ctr_drbg_random, &m_Ctr_drbg, RSA_PRIVATE, &DecryptedLength,
+		a_EncryptedData, a_DecryptedData, a_DecryptedMaxLength
+	);
+	if (res != 0)
+	{
+		return -1;
+	}
+	return (int)DecryptedLength;
+}
+
+
+
+
+
+int cRSAPrivateKey::Encrypt(const Byte * a_PlainData, size_t a_PlainLength, Byte * a_EncryptedData, size_t a_EncryptedMaxLength)
+{
+	if (a_EncryptedMaxLength < m_Rsa.len)
+	{
+		LOGD("%s: Invalid a_EncryptedMaxLength: got %u, exp at least %u",
+			__FUNCTION__, (unsigned)a_EncryptedMaxLength, (unsigned)(m_Rsa.len)
+		);
+		ASSERT(!"Invalid a_DecryptedMaxLength!");
+		return -1;
+	}
+	if (a_EncryptedMaxLength < m_Rsa.len)
+	{
+		LOGD("%s: Invalid a_PlainLength: got %u, exp at least %u",
+			__FUNCTION__, (unsigned)a_PlainLength, (unsigned)(m_Rsa.len)
+		);
+		ASSERT(!"Invalid a_PlainLength!");
+		return -1;
+	}
+	int res = rsa_pkcs1_encrypt(
+		&m_Rsa, ctr_drbg_random, &m_Ctr_drbg, RSA_PRIVATE,
+		a_PlainLength, a_PlainData, a_EncryptedData
+	);
+	if (res != 0)
+	{
+		return -1;
+	}
+	return (int)m_Rsa.len;
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPublicKey:
+
+cPublicKey::cPublicKey(const AString & a_PublicKeyDER)
+{
+	pk_init(&m_Pk);
+	if (pk_parse_public_key(&m_Pk, (const Byte *)a_PublicKeyDER.data(), a_PublicKeyDER.size()) != 0)
+	{
+		ASSERT(!"Cannot parse PubKey");
+		return;
+	}
+	InitRnd();
+}
+
+
+
+
+
+cPublicKey::~cPublicKey()
+{
+	pk_free(&m_Pk);
+}
+
+
+
+
+
+int cPublicKey::Decrypt(const Byte * a_EncryptedData, size_t a_EncryptedLength, Byte * a_DecryptedData, size_t a_DecryptedMaxLength)
+{
+	size_t DecryptedLen = a_DecryptedMaxLength;
+	int res = pk_decrypt(&m_Pk,
+		a_EncryptedData, a_EncryptedLength,
+		a_DecryptedData, &DecryptedLen, a_DecryptedMaxLength,
+		ctr_drbg_random, &m_Ctr_drbg
+	);
+	if (res != 0)
+	{
+		return res;
+	}
+	return (int)DecryptedLen;
+}
+
+
+
+
+
+int cPublicKey::Encrypt(const Byte * a_PlainData, size_t a_PlainLength, Byte * a_EncryptedData, size_t a_EncryptedMaxLength)
+{
+	size_t EncryptedLength = a_EncryptedMaxLength;
+	int res = pk_encrypt(&m_Pk,
+		a_PlainData, a_PlainLength, a_EncryptedData, &EncryptedLength, a_EncryptedMaxLength,
+		ctr_drbg_random, &m_Ctr_drbg
+	);
+	if (res != 0)
+	{
+		return res;
+	}
+	return (int)EncryptedLength;
+}
+
+
+
+
+
+void cPublicKey::InitRnd(void)
+{
+	entropy_init(&m_Entropy);
+	const unsigned char pers[] = "rsa_genkey";
+	ctr_drbg_init(&m_Ctr_drbg, entropy_func, &m_Entropy, pers, sizeof(pers) - 1);
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cAESCFBDecryptor:
+
+cAESCFBDecryptor::cAESCFBDecryptor(void) :
+	m_IVOffset(0),
+	m_IsValid(false)
+{
+}
+
+
+
+
+
+cAESCFBDecryptor::~cAESCFBDecryptor()
+{
+	// Clear the leftover in-memory data, so that they can't be accessed by a backdoor
+	memset(&m_Aes, 0, sizeof(m_Aes));
+}
+
+
+
+
+
+void cAESCFBDecryptor::Init(const Byte a_Key[16], const Byte a_IV[16])
+{
+	ASSERT(!IsValid());  // Cannot Init twice
+	
+	memcpy(m_IV, a_IV, 16);
+	aes_setkey_enc(&m_Aes, a_Key, 128);
+	m_IsValid = true;
+}
+
+
+
+
+
+void cAESCFBDecryptor::ProcessData(Byte * a_DecryptedOut, const Byte * a_EncryptedIn, size_t a_Length)
+{
+	ASSERT(IsValid());  // Must Init() first
+	
+	// PolarSSL doesn't support AES-CFB8, need to implement it manually:
+	for (size_t i = 0; i < a_Length; i++)
+	{
+		Byte Buffer[sizeof(m_IV)];
+		aes_crypt_ecb(&m_Aes, AES_ENCRYPT, m_IV, Buffer);
+		for (size_t idx = 0; idx < sizeof(m_IV) - 1; idx++)
+		{
+			m_IV[idx] = m_IV[idx + 1];
+		}
+		m_IV[sizeof(m_IV) - 1] = a_EncryptedIn[i];
+		a_DecryptedOut[i] = a_EncryptedIn[i] ^ Buffer[0];
+	}
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cAESCFBEncryptor:
+
+cAESCFBEncryptor::cAESCFBEncryptor(void) :
+	m_IVOffset(0),
+	m_IsValid(false)
+{
+}
+
+
+
+
+
+cAESCFBEncryptor::~cAESCFBEncryptor()
+{
+	// Clear the leftover in-memory data, so that they can't be accessed by a backdoor
+	memset(&m_Aes, 0, sizeof(m_Aes));
+}
+
+
+
+
+
+void cAESCFBEncryptor::Init(const Byte a_Key[16], const Byte a_IV[16])
+{
+	ASSERT(!IsValid());  // Cannot Init twice
+	ASSERT(m_IVOffset == 0);
+	
+	memcpy(m_IV, a_IV, 16);
+	aes_setkey_enc(&m_Aes, a_Key, 128);
+	m_IsValid = true;
+}
+
+
+
+
+
+void cAESCFBEncryptor::ProcessData(Byte * a_EncryptedOut, const Byte * a_PlainIn, size_t a_Length)
+{
+	ASSERT(IsValid());  // Must Init() first
+	
+	// PolarSSL doesn't do AES-CFB8, so we need to implement it ourselves:
+	for (size_t i = 0; i < a_Length; i++)
+	{
+		Byte Buffer[sizeof(m_IV)];
+		aes_crypt_ecb(&m_Aes, AES_ENCRYPT, m_IV, Buffer);
+		for (size_t idx = 0; idx < sizeof(m_IV) - 1; idx++)
+		{
+			m_IV[idx] = m_IV[idx + 1];
+		}
+		a_EncryptedOut[i] = a_PlainIn[i] ^ Buffer[0];
+		m_IV[sizeof(m_IV) - 1] = a_EncryptedOut[i];
+	}
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cSHA1Checksum:
+
+cSHA1Checksum::cSHA1Checksum(void) :
+	m_DoesAcceptInput(true)
+{
+	sha1_starts(&m_Sha1);
+}
+
+
+
+
+
+void cSHA1Checksum::Update(const Byte * a_Data, size_t a_Length)
+{
+	ASSERT(m_DoesAcceptInput);  // Not Finalize()-d yet, or Restart()-ed
+	
+	sha1_update(&m_Sha1, a_Data, a_Length);
+}
+
+
+
+
+
+void cSHA1Checksum::Finalize(cSHA1Checksum::Checksum & a_Output)
+{
+	ASSERT(m_DoesAcceptInput);  // Not Finalize()-d yet, or Restart()-ed
+	
+	sha1_finish(&m_Sha1, a_Output);
+	m_DoesAcceptInput = false;
+}
+
+
+
+
+
+void cSHA1Checksum::DigestToJava(const Checksum & a_Digest, AString & a_Out)
+{
+	Checksum Digest;
+	memcpy(Digest, a_Digest, sizeof(Digest));
+	
+	bool IsNegative = (Digest[0] >= 0x80);
+	if (IsNegative)
+	{
+		// Two's complement:
+		bool carry = true;  // Add one to the whole number
+		for (int i = 19; i >= 0; i--)
+		{
+			Digest[i] = ~Digest[i];
+			if (carry)
+			{
+				carry = (Digest[i] == 0xff);
+				Digest[i]++;
+			}
+		}
+	}
+	a_Out.clear();
+	a_Out.reserve(40);
+	for (int i = 0; i < 20; i++)
+	{
+		AppendPrintf(a_Out, "%02x", Digest[i]);
+	}
+	while ((a_Out.length() > 0) && (a_Out[0] == '0'))
+	{
+		a_Out.erase(0, 1);
+	}
+	if (IsNegative)
+	{
+		a_Out.insert(0, "-");
+	}
+}
+
+
+
+
+
+
+void cSHA1Checksum::Restart(void)
+{
+	sha1_starts(&m_Sha1);
+	m_DoesAcceptInput = true;
+}
+
+
+
+
diff --git a/src/Crypto.h b/src/Crypto.h
new file mode 100644
index 000000000..a9ec2c6d4
--- /dev/null
+++ b/src/Crypto.h
@@ -0,0 +1,198 @@
+
+// Crypto.h
+
+// Declares classes that wrap the cryptographic code library
+
+
+
+
+
+#pragma once
+
+#include "polarssl/rsa.h"
+#include "polarssl/aes.h"
+#include "polarssl/entropy.h"
+#include "polarssl/ctr_drbg.h"
+#include "polarssl/sha1.h"
+#include "polarssl/pk.h"
+
+
+
+
+
+/** Encapsulates an RSA private key used in PKI cryptography */
+class cRSAPrivateKey
+{
+public:
+	/** Creates a new empty object, the key is not assigned */
+	cRSAPrivateKey(void);
+	
+	/** Deep-copies the key from a_Other */
+	cRSAPrivateKey(const cRSAPrivateKey & a_Other);
+	
+	~cRSAPrivateKey();
+	
+	/** Generates a new key within this object, with the specified size in bits.
+	Returns true on success, false on failure. */
+	bool Generate(unsigned a_KeySizeBits = 1024);
+	
+	/** Returns the public key part encoded in ASN1 DER encoding */
+	AString GetPubKeyDER(void);
+	
+	/** Decrypts the data using RSAES-PKCS#1 algorithm.
+	Both a_EncryptedData and a_DecryptedData must be at least <KeySizeBytes> bytes large.
+	Returns the number of bytes decrypted, or negative number for error. */
+	int Decrypt(const Byte * a_EncryptedData, size_t a_EncryptedLength, Byte * a_DecryptedData, size_t a_DecryptedMaxLength);
+	
+	/** Encrypts the data using RSAES-PKCS#1 algorithm.
+	Both a_EncryptedData and a_DecryptedData must be at least <KeySizeBytes> bytes large.
+	Returns the number of bytes decrypted, or negative number for error. */
+	int Encrypt(const Byte * a_PlainData, size_t a_PlainLength, Byte * a_EncryptedData, size_t a_EncryptedMaxLength);
+	
+protected:
+	rsa_context m_Rsa;
+	entropy_context m_Entropy;
+	ctr_drbg_context m_Ctr_drbg;
+	
+	/** Initializes the m_Entropy and m_Ctr_drbg contexts
+	Common part of this object's construction, called from all constructors. */
+	void InitRnd(void);
+} ;
+
+
+
+
+
+class cPublicKey
+{
+public:
+	cPublicKey(const AString & a_PublicKeyDER);
+	~cPublicKey();
+	
+	/** Decrypts the data using the stored public key
+	Both a_EncryptedData and a_DecryptedData must be at least <KeySizeBytes> bytes large.
+	Returns the number of bytes decrypted, or negative number for error. */
+	int Decrypt(const Byte * a_EncryptedData, size_t a_EncryptedLength, Byte * a_DecryptedData, size_t a_DecryptedMaxLength);
+	
+	/** Encrypts the data using the stored public key
+	Both a_EncryptedData and a_DecryptedData must be at least <KeySizeBytes> bytes large.
+	Returns the number of bytes decrypted, or negative number for error. */
+	int Encrypt(const Byte * a_PlainData, size_t a_PlainLength, Byte * a_EncryptedData, size_t a_EncryptedMaxLength);
+
+protected:
+	pk_context m_Pk;
+	entropy_context m_Entropy;
+	ctr_drbg_context m_Ctr_drbg;
+	
+	/** Initializes the m_Entropy and m_Ctr_drbg contexts
+	Common part of this object's construction, called from all constructors. */
+	void InitRnd(void);
+} ;
+
+
+
+
+
+/** Decrypts data using the AES / CFB (128) algorithm */
+class cAESCFBDecryptor
+{
+public:
+	Byte test;
+	
+	cAESCFBDecryptor(void);
+	~cAESCFBDecryptor();
+	
+	/** Initializes the decryptor with the specified Key / IV */
+	void Init(const Byte a_Key[16], const Byte a_IV[16]);
+	
+	/** Decrypts a_Length bytes of the encrypted data; produces a_Length output bytes */
+	void ProcessData(Byte * a_DecryptedOut, const Byte * a_EncryptedIn, size_t a_Length);
+	
+	/** Returns true if the object has been initialized with the Key / IV */
+	bool IsValid(void) const { return m_IsValid; }
+	
+protected:
+	aes_context m_Aes;
+	
+	/** The InitialVector, used by the CFB mode decryption */
+	Byte m_IV[16];
+	
+	/** Current offset in the m_IV, used by the CFB mode decryption */
+	size_t m_IVOffset;
+	
+	/** Indicates whether the object has been initialized with the Key / IV */
+	bool m_IsValid;
+} ;
+
+
+
+
+
+/** Encrypts data using the AES / CFB (128) algorithm */
+class cAESCFBEncryptor
+{
+public:
+	cAESCFBEncryptor(void);
+	~cAESCFBEncryptor();
+	
+	/** Initializes the decryptor with the specified Key / IV */
+	void Init(const Byte a_Key[16], const Byte a_IV[16]);
+	
+	/** Encrypts a_Length bytes of the plain data; produces a_Length output bytes */
+	void ProcessData(Byte * a_EncryptedOut, const Byte * a_PlainIn, size_t a_Length);
+	
+	/** Returns true if the object has been initialized with the Key / IV */
+	bool IsValid(void) const { return m_IsValid; }
+	
+protected:
+	aes_context m_Aes;
+	
+	/** The InitialVector, used by the CFB mode encryption */
+	Byte m_IV[16];
+	
+	/** Current offset in the m_IV, used by the CFB mode encryption */
+	size_t m_IVOffset;
+	
+	/** Indicates whether the object has been initialized with the Key / IV */
+	bool m_IsValid;
+} ;
+
+
+
+
+
+/** Calculates a SHA1 checksum for data stream */
+class cSHA1Checksum
+{
+public:
+	typedef Byte Checksum[20];  // The type used for storing the checksum
+	
+	cSHA1Checksum(void);
+	
+	/** Adds the specified data to the checksum */
+	void Update(const Byte * a_Data, size_t a_Length);
+	
+	/** Calculates and returns the final checksum */
+	void Finalize(Checksum & a_Output);
+	
+	/** Returns true if the object is accepts more input data, false if Finalize()-d (need to Restart()) */
+	bool DoesAcceptInput(void) const { return m_DoesAcceptInput; }
+	
+	/** Converts a raw 160-bit SHA1 digest into a Java Hex representation
+	According to http://wiki.vg/wiki/index.php?title=Protocol_Encryption&oldid=2802
+	*/
+	static void DigestToJava(const Checksum & a_Digest, AString & a_JavaOut);
+	
+	/** Clears the current context and start a new checksum calculation */
+	void Restart(void);
+	
+protected:
+	/** True if the object is accepts more input data, false if Finalize()-d (need to Restart()) */
+	bool m_DoesAcceptInput;
+	
+	sha1_context m_Sha1;
+} ;
+
+
+
+
diff --git a/src/Cuboid.cpp b/src/Cuboid.cpp
index ea6f7c453..3e5240248 100644
--- a/src/Cuboid.cpp
+++ b/src/Cuboid.cpp
@@ -38,6 +38,20 @@ void cCuboid::Assign(int a_X1, int a_Y1, int a_Z1, int a_X2, int a_Y2, int a_Z2)
 
 
 
+void cCuboid::Assign(const cCuboid & a_SrcCuboid)
+{
+	p1.x = a_SrcCuboid.p1.x;
+	p1.y = a_SrcCuboid.p1.y;
+	p1.z = a_SrcCuboid.p1.z;
+	p2.x = a_SrcCuboid.p2.x;
+	p2.y = a_SrcCuboid.p2.y;
+	p2.z = a_SrcCuboid.p2.z;
+}
+
+
+
+
+
 void cCuboid::Sort(void)
 {
 	if (p1.x > p2.x)
@@ -58,8 +72,23 @@ void cCuboid::Sort(void)
 
 
 
+int cCuboid::GetVolume(void) const
+{
+	int DifX = abs(p2.x - p1.x) + 1;
+	int DifY = abs(p2.y - p1.y) + 1;
+	int DifZ = abs(p2.z - p1.z) + 1;
+	return DifX * DifY * DifZ;
+}
+
+
+
+
+
 bool cCuboid::DoesIntersect(const cCuboid & a_Other) const
 {
+	ASSERT(IsSorted());
+	ASSERT(a_Other.IsSorted());
+	
 	// In order for cuboids to intersect, each of their coord intervals need to intersect
 	return (
 		DoIntervalsIntersect(p1.x, p2.x, a_Other.p1.x, a_Other.p2.x) &&
@@ -74,6 +103,9 @@ bool cCuboid::DoesIntersect(const cCuboid & a_Other) const
 
 bool cCuboid::IsCompletelyInside(const cCuboid & a_Outer) const
 {
+	ASSERT(IsSorted());
+	ASSERT(a_Outer.IsSorted());
+	
 	return (
 		(p1.x >= a_Outer.p1.x) &&
 		(p2.x <= a_Outer.p2.x) &&
@@ -103,6 +135,76 @@ void cCuboid::Move(int a_OfsX, int a_OfsY, int a_OfsZ)
 
 
 
+void cCuboid::Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ)
+{
+	if (p1.x < p2.x)
+	{
+		p1.x -= a_SubMinX;
+		p2.x += a_AddMaxX;
+	}
+	else
+	{
+		p2.x -= a_SubMinX;
+		p1.x += a_AddMaxX;
+	}
+	
+	if (p1.y < p2.y)
+	{
+		p1.y -= a_SubMinY;
+		p2.y += a_AddMaxY;
+	}
+	else
+	{
+		p2.y -= a_SubMinY;
+		p1.y += a_AddMaxY;
+	}
+	
+	if (p1.z < p2.z)
+	{
+		p1.z -= a_SubMinZ;
+		p2.z += a_AddMaxZ;
+	}
+	else
+	{
+		p2.z -= a_SubMinZ;
+		p1.z += a_AddMaxZ;
+	}
+}
+
+
+
+
+
+void cCuboid::ClampX(int a_MinX, int a_MaxX)
+{
+	p1.x = Clamp(p1.x, a_MinX, a_MaxX);
+	p2.x = Clamp(p2.x, a_MinX, a_MaxX);
+}
+
+
+
+
+
+void cCuboid::ClampY(int a_MinY, int a_MaxY)
+{
+	p1.y = Clamp(p1.y, a_MinY, a_MaxY);
+	p2.y = Clamp(p2.y, a_MinY, a_MaxY);
+}
+
+
+
+
+
+void cCuboid::ClampZ(int a_MinZ, int a_MaxZ)
+{
+	p1.z = Clamp(p1.z, a_MinZ, a_MaxZ);
+	p2.z = Clamp(p2.z, a_MinZ, a_MaxZ);
+}
+
+
+
+
+
 bool cCuboid::IsSorted(void) const
 {
 	return (
@@ -115,3 +217,37 @@ bool cCuboid::IsSorted(void) const
 
 
 
+
+void cCuboid::Engulf(const Vector3i & a_Point)
+{
+	if (a_Point.x < p1.x)
+	{
+		p1.x = a_Point.x;
+	}
+	else if (a_Point.x > p2.x)
+	{
+		p2.x = a_Point.x;
+	}
+
+	if (a_Point.y < p1.y)
+	{
+		p1.y = a_Point.y;
+	}
+	else if (a_Point.y > p2.y)
+	{
+		p2.y = a_Point.y;
+	}
+
+	if (a_Point.z < p1.z)
+	{
+		p1.z = a_Point.z;
+	}
+	else if (a_Point.z > p2.z)
+	{
+		p2.z = a_Point.z;
+	}
+}
+
+
+
+
diff --git a/src/Cuboid.h b/src/Cuboid.h
index 44db7b98e..3239c54fc 100644
--- a/src/Cuboid.h
+++ b/src/Cuboid.h
@@ -1,8 +1,7 @@
 
 #pragma once
 
-#include "Vector3i.h"
-#include "Vector3d.h"
+#include "Vector3.h"
 
 
 
@@ -22,6 +21,7 @@ public:
 	cCuboid(int a_X1, int a_Y1, int a_Z1, int a_X2, int a_Y2, int a_Z2) : p1(a_X1, a_Y1, a_Z1), p2(a_X2, a_Y2, a_Z2) {}
 
 	void Assign(int a_X1, int a_Y1, int a_Z1, int a_X2, int a_Y2, int a_Z2);
+	void Assign(const cCuboid & a_SrcCuboid);
 
 	void Sort(void);
 	
@@ -29,7 +29,13 @@ public:
 	int DifY(void) const { return p2.y - p1.y; }
 	int DifZ(void) const { return p2.z - p1.z; }
 	
-	/// Returns true if the cuboids have at least one voxel in common. Both coords are considered inclusive.
+	/** Returns the volume of the cuboid, in blocks.
+	Note that the volume considers both coords inclusive.
+	Works on unsorted cuboids, too. */
+	int GetVolume(void) const;
+	
+	/** Returns true if the cuboids have at least one voxel in common. Both coords are considered inclusive.
+	Assumes both cuboids are sorted. */
 	bool DoesIntersect(const cCuboid & a_Other) const;
 
 	bool IsInside(const Vector3i & v)	const
@@ -59,14 +65,32 @@ public:
 		);
 	}
 	
-	/// Returns true if this cuboid is completely inside the specifie cuboid (in all 6 coords)
+	/** Returns true if this cuboid is completely inside the specifie cuboid (in all 6 coords).
+	Assumes both cuboids are sorted. */
 	bool IsCompletelyInside(const cCuboid & a_Outer) const;
 	
-	/// Moves the cuboid by the specified offsets in each direction
+	/** Moves the cuboid by the specified offsets in each direction */
 	void Move(int a_OfsX, int a_OfsY, int a_OfsZ);
+	
+	/** Expands the cuboid by the specified amount in each direction.
+	Works on unsorted cuboids as well.
+	Note that this function doesn't check for underflows when using negative amounts. */
+	void Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
+	
+	/** Clamps both X coords to the specified range. Works on unsorted cuboids, too. */
+	void ClampX(int a_MinX, int a_MaxX);
 
-	/// Returns true if the coords are properly sorted (lesser in p1, greater in p2)
+	/** Clamps both Y coords to the specified range. Works on unsorted cuboids, too. */
+	void ClampY(int a_MinY, int a_MaxY);
+
+	/** Clamps both Z coords to the specified range. Works on unsorted cuboids, too. */
+	void ClampZ(int a_MinZ, int a_MaxZ);
+
+	/** Returns true if the coords are properly sorted (lesser in p1, greater in p2) */
 	bool IsSorted(void) const;
+	
+	/** If needed, expands the cuboid so that it contains the specified point. Assumes sorted. Doesn't contract. */
+	void Engulf(const Vector3i & a_Point);
 } ;
 // tolua_end
 
diff --git a/src/DeadlockDetect.cpp b/src/DeadlockDetect.cpp
index c42d09b89..322084dc4 100644
--- a/src/DeadlockDetect.cpp
+++ b/src/DeadlockDetect.cpp
@@ -7,7 +7,7 @@
 #include "DeadlockDetect.h"
 #include "Root.h"
 #include "World.h"
-# include <cstdlib>
+#include <cstdlib>
 
 
 
@@ -16,9 +16,6 @@
 /// Number of milliseconds per cycle
 const int CYCLE_MILLISECONDS = 100;
 
-/// When the number of cycles for the same world age hits this value, it is considered a deadlock
-const int NUM_CYCLES_LIMIT = 200;  // 200 = twenty seconds
-
 
 
 
@@ -121,7 +118,6 @@ void cDeadlockDetect::CheckWorldAge(const AString & a_WorldName, Int64 a_Age)
 		if (itr->second.m_NumCyclesSame > (1000 * m_IntervalSec) / CYCLE_MILLISECONDS)
 		{
 			DeadlockDetected();
-			return;
 		}
 	}
 	else
diff --git a/src/DeadlockDetect.h b/src/DeadlockDetect.h
index cb2309169..6aa98acbb 100644
--- a/src/DeadlockDetect.h
+++ b/src/DeadlockDetect.h
@@ -60,7 +60,7 @@ protected:
 	void CheckWorldAge(const AString & a_WorldName, Int64 a_Age);
 	
 	/// Called when a deadlock is detected. Aborts the server.
-	void DeadlockDetected(void);
+	NORETURN void DeadlockDetected(void);
 } ;
 
 
diff --git a/src/Defines.h b/src/Defines.h
index 7a86f499e..1a8b3fa4a 100644
--- a/src/Defines.h
+++ b/src/Defines.h
@@ -1,11 +1,12 @@
 
 #pragma once
 
+#include "ChatColor.h"
+#include <limits>
 
 
 
 
-typedef unsigned char Byte;
 
 /// List of slot numbers, used for inventory-painting
 typedef std::vector<int> cSlotNums;
@@ -17,33 +18,6 @@ typedef std::vector<int> cSlotNums;
 
 // tolua_begin
 
-/// How much light do the blocks emit on their own?
-extern unsigned char g_BlockLightValue[];
-
-/// How much light do the block consume?
-extern unsigned char g_BlockSpreadLightFalloff[];
-
-/// Is a block completely transparent? (light doesn't get decreased(?))
-extern bool g_BlockTransparent[];
-
-/// Is a block destroyed after a single hit?
-extern bool g_BlockOneHitDig[];
-
-/// Can a piston break this block?
-extern bool g_BlockPistonBreakable[256];
-
-/// Can this block hold snow atop?
-extern bool g_BlockIsSnowable[256];
-
-/// Does this block require a tool to drop?
-extern bool g_BlockRequiresSpecialTool[256];
-
-/// Is this block solid (player cannot walk through)?
-extern bool g_BlockIsSolid[256];
-
-/// Does this block fully occupy it's voxel - is it a 'full' block?
-extern bool g_BlockFullyOccupiesVoxel[256];
-
 /// Experience Orb setup
 enum
 {
@@ -174,6 +148,43 @@ enum eWeather
 
 
 
+enum eMobHeadType
+{
+	SKULL_TYPE_SKELETON    = 0,
+	SKULL_TYPE_WITHER      = 1,
+	SKULL_TYPE_ZOMBIE      = 2,
+	SKULL_TYPE_PLAYER      = 3,
+	SKULL_TYPE_CREEPER     = 4,
+} ;
+
+
+
+
+
+enum eMobHeadRotation
+{
+	SKULL_ROTATION_NORTH = 0,
+	SKULL_ROTATION_NORTH_NORTH_EAST = 1,
+	SKULL_ROTATION_NORTH_EAST = 2,
+	SKULL_ROTATION_EAST_NORTH_EAST = 3,
+	SKULL_ROTATION_EAST = 4,
+	SKULL_ROTATION_EAST_SOUTH_EAST = 5,
+	SKULL_ROTATION_SOUTH_EAST = 6,
+	SKULL_ROTATION_SOUTH_SOUTH_EAST = 7,
+	SKULL_ROTATION_SOUTH = 8,
+	SKULL_ROTATION_SOUTH_SOUTH_WEST = 9,
+	SKULL_ROTATION_SOUTH_WEST = 10,
+	SKULL_ROTATION_WEST_SOUTH_WEST = 11,
+	SKULL_ROTATION_WEST = 12,
+	SKULL_ROTATION_WEST_NORTH_WEST = 13,
+	SKULL_ROTATION_NORTH_WEST = 14,
+	SKULL_ROTATION_NORTH_NORTH_WEST = 15,
+} ;
+
+
+
+
+
 inline const char * ClickActionToString(eClickAction a_ClickAction)
 {
 	switch (a_ClickAction)
@@ -216,6 +227,79 @@ inline const char * ClickActionToString(eClickAction a_ClickAction)
 
 
 
+/** Returns a blockface mirrored around the Y axis (doesn't change up/down). */
+inline eBlockFace MirrorBlockFaceY(eBlockFace a_BlockFace)
+{
+	switch (a_BlockFace)
+	{
+		case BLOCK_FACE_XM: return BLOCK_FACE_XP;
+		case BLOCK_FACE_XP: return BLOCK_FACE_XM;
+		case BLOCK_FACE_ZM: return BLOCK_FACE_ZP;
+		case BLOCK_FACE_ZP: return BLOCK_FACE_ZM;
+		default: return a_BlockFace;
+	}
+}
+
+
+
+
+
+/** Returns a blockface rotated around the Y axis counter-clockwise. */
+inline eBlockFace RotateBlockFaceCCW(eBlockFace a_BlockFace)
+{
+	switch (a_BlockFace)
+	{
+		case BLOCK_FACE_XM: return BLOCK_FACE_ZP;
+		case BLOCK_FACE_XP: return BLOCK_FACE_ZM;
+		case BLOCK_FACE_ZM: return BLOCK_FACE_XM;
+		case BLOCK_FACE_ZP: return BLOCK_FACE_XP;
+		default: return a_BlockFace;
+	}
+}
+
+
+
+
+
+inline eBlockFace RotateBlockFaceCW(eBlockFace a_BlockFace)
+{
+	switch (a_BlockFace)
+	{
+		case BLOCK_FACE_XM: return BLOCK_FACE_ZM;
+		case BLOCK_FACE_XP: return BLOCK_FACE_ZP;
+		case BLOCK_FACE_ZM: return BLOCK_FACE_XP;
+		case BLOCK_FACE_ZP: return BLOCK_FACE_XM;
+		default: return a_BlockFace;
+	}
+}
+
+
+
+
+
+/** Returns the textual representation of the BlockFace constant. */
+inline AString BlockFaceToString(eBlockFace a_BlockFace)
+{
+	switch (a_BlockFace)
+	{
+		case BLOCK_FACE_XM: return "BLOCK_FACE_XM";
+		case BLOCK_FACE_XP: return "BLOCK_FACE_XP";
+		case BLOCK_FACE_YM: return "BLOCK_FACE_YM";
+		case BLOCK_FACE_YP: return "BLOCK_FACE_YP";
+		case BLOCK_FACE_ZM: return "BLOCK_FACE_ZM";
+		case BLOCK_FACE_ZP: return "BLOCK_FACE_ZP";
+		case BLOCK_FACE_NONE: return "BLOCK_FACE_NONE";
+	}
+	// clang optimisises this line away then warns that it has done so.
+	#if !defined(__clang__)
+	return Printf("Unknown BLOCK_FACE: %d", a_BlockFace);
+	#endif
+}
+
+
+
+
+
 inline bool IsValidBlock(int a_BlockType)
 {
 	if (
@@ -265,6 +349,15 @@ inline bool IsBlockWater(BLOCKTYPE a_BlockType)
 
 
 
+inline bool IsBlockWaterOrIce(BLOCKTYPE a_BlockType)
+{
+	return (IsBlockWater(a_BlockType) || (a_BlockType == E_BLOCK_ICE));
+}
+
+
+
+
+
 inline bool IsBlockLava(BLOCKTYPE a_BlockType)
 {
 	return ((a_BlockType == E_BLOCK_LAVA) || (a_BlockType == E_BLOCK_STATIONARY_LAVA));
@@ -282,6 +375,24 @@ inline bool IsBlockLiquid(BLOCKTYPE a_BlockType)
 
 
 
+inline bool IsBlockRail(BLOCKTYPE a_BlockType)
+{
+	switch (a_BlockType)
+	{
+		case E_BLOCK_RAIL:
+		case E_BLOCK_ACTIVATOR_RAIL:
+		case E_BLOCK_DETECTOR_RAIL:
+		case E_BLOCK_POWERED_RAIL:
+		{
+			return true;
+		}
+		default: return false;
+	}
+}
+
+
+
+
 
 inline bool IsBlockTypeOfDirt(BLOCKTYPE a_BlockType)
 {
@@ -300,7 +411,7 @@ inline bool IsBlockTypeOfDirt(BLOCKTYPE a_BlockType)
 
 
 
-inline void AddFaceDirection(int & a_BlockX, int & a_BlockY, int & a_BlockZ, char a_BlockFace, bool a_bInverse = false)  // tolua_export
+inline void AddFaceDirection(int & a_BlockX, int & a_BlockY, int & a_BlockZ, eBlockFace a_BlockFace, bool a_bInverse = false)  // tolua_export
 {  // tolua_export
 	if (!a_bInverse)
 	{
@@ -344,7 +455,7 @@ inline void AddFaceDirection(int & a_BlockX, int & a_BlockY, int & a_BlockZ, cha
 
 
 
-inline void AddFaceDirection(int & a_BlockX, unsigned char & a_BlockY, int & a_BlockZ, char a_BlockFace, bool a_bInverse = false)
+inline void AddFaceDirection(int & a_BlockX, unsigned char & a_BlockY, int & a_BlockZ, eBlockFace a_BlockFace, bool a_bInverse = false)
 {
 	int Y = a_BlockY;
 	AddFaceDirection(a_BlockX, Y, a_BlockZ, a_BlockFace, a_bInverse);
@@ -364,8 +475,6 @@ inline void AddFaceDirection(int & a_BlockX, unsigned char & a_BlockY, int & a_B
 
 
 
-
-
 #define PI 3.14159265358979323846264338327950288419716939937510582097494459072381640628620899862803482534211706798f
 
 inline void EulerToVector(double a_Pan, double a_Pitch, double & a_X, double & a_Y, double & a_Z)
@@ -384,7 +493,7 @@ inline void EulerToVector(double a_Pan, double a_Pitch, double & a_X, double & a
 
 inline void VectorToEuler(double a_X, double a_Y, double a_Z, double & a_Pan, double & a_Pitch)
 {
-	if (a_X != 0)
+	if (fabs(a_X) < std::numeric_limits<double>::epsilon())
 	{
 		a_Pan = atan2(a_Z, a_X) * 180 / PI - 90;
 	}
@@ -416,9 +525,37 @@ inline float GetSpecialSignf( float a_Val )
 
 
 
+
 // tolua_begin
 
-/// Normalizes an angle in degrees to the [-180, +180) range:
+enum eMessageType
+{
+	// http://forum.mc-server.org/showthread.php?tid=1212
+	// MessageType...
+
+	mtCustom,          // Send raw data without any processing
+	mtFailure,         // Something could not be done (i.e. command not executed due to insufficient privilege)
+	mtInformation,     // Informational message (i.e. command usage)
+	mtSuccess,         // Something executed successfully
+	mtWarning,         // Something concerning (i.e. reload) is about to happen
+	mtFatal,           // Something catastrophic occured (i.e. plugin crash)
+	mtDeath,           // Denotes death of player
+	mtPrivateMessage,  // Player to player messaging identifier
+	mtJoin,            // A player has joined the server
+	mtLeave,           // A player has left the server
+	
+	// Common aliases:
+	mtFail  = mtFailure,
+	mtError = mtFailure,
+	mtInfo  = mtInformation,
+	mtPM    = mtPrivateMessage,
+};
+
+
+
+
+
+/** Normalizes an angle in degrees to the [-180, +180) range: */
 inline double NormalizeAngleDegrees(const double a_Degrees)
 {
 	double Norm = fmod(a_Degrees + 180, 360);
@@ -570,7 +707,7 @@ namespace ItemCategory
 inline bool BlockRequiresSpecialTool(BLOCKTYPE a_BlockType)
 {
 	if(!IsValidBlock(a_BlockType)) return false;
-	return g_BlockRequiresSpecialTool[a_BlockType];
+	return cBlockInfo::RequiresSpecialTool(a_BlockType);
 }
 
 
diff --git a/src/Enchantments.h b/src/Enchantments.h
index e0861aa1e..2af772928 100644
--- a/src/Enchantments.h
+++ b/src/Enchantments.h
@@ -21,7 +21,6 @@ class cParsedNBT;
 
 
 
-
 /** Class that stores item enchantments or stored-enchantments
 The enchantments may be serialized to a stringspec and read back from such stringspec.
 The format for the stringspec is "id=lvl;id=lvl;id=lvl...", with an optional semicolon at the end,
diff --git a/src/Endianness.h b/src/Endianness.h
index 86eb369f5..78f9a5d99 100644
--- a/src/Endianness.h
+++ b/src/Endianness.h
@@ -1,12 +1,14 @@
 
 #pragma once
 
+#define ntohll(x) ((((UInt64)ntohl((u_long)x)) << 32) + ntohl(x >> 32))
+
 
 
 
 
 // Changes endianness
-inline unsigned long long HostToNetwork8(const void* a_Value )
+inline UInt64 HostToNetwork8(const void * a_Value)
 {
 	unsigned long long __HostToNetwork8;
 	memcpy( &__HostToNetwork8, a_Value, sizeof( __HostToNetwork8 ) );
@@ -18,7 +20,7 @@ inline unsigned long long HostToNetwork8(const void* a_Value )
 
 
 
-inline unsigned int HostToNetwork4(const void* a_Value )
+inline UInt32 HostToNetwork4(const void* a_Value )
 {
 	unsigned int __HostToNetwork4;
 	memcpy( &__HostToNetwork4, a_Value, sizeof( __HostToNetwork4 ) );
@@ -30,11 +32,10 @@ inline unsigned int HostToNetwork4(const void* a_Value )
 
 
 
-inline double NetworkToHostDouble8(const void* a_Value )
+inline double NetworkToHostDouble8(const void * a_Value)
 {
-#define ntohll(x)   ((((unsigned long long)ntohl((u_long)x)) << 32) + ntohl(x >> 32))
-	unsigned long long buf = 0;//(*(unsigned long long*)a_Value);
-	memcpy( &buf, a_Value, 8 );
+	UInt64 buf = 0;
+	memcpy(&buf, a_Value, 8);
 	buf = ntohll(buf);
 	double x;
 	memcpy(&x, &buf, sizeof(double));
@@ -45,23 +46,25 @@ inline double NetworkToHostDouble8(const void* a_Value )
 
 
 
-inline long long NetworkToHostLong8(const void * a_Value )
+inline Int64 NetworkToHostLong8(const void * a_Value)
 {
-	unsigned long long buf = *(unsigned long long*)a_Value;
+	UInt64 buf;
+	memcpy(&buf, a_Value, 8);
 	buf = ntohll(buf);
-	return *reinterpret_cast<long long *>(&buf);
+	return *reinterpret_cast<Int64 *>(&buf);
 }
 
 
 
 
 
-inline float NetworkToHostFloat4(const void* a_Value )
+inline float NetworkToHostFloat4(const void * a_Value)
 {
-	u_long buf = *(u_long*)a_Value;
-	buf = ntohl( buf );
-	float x = 0;
-	memcpy( &x, &buf, sizeof(float) );
+	UInt32 buf;
+	float x;
+	memcpy(&buf, a_Value, 4);
+	buf = ntohl(buf);
+	memcpy(&x, &buf, sizeof(float));
 	return x;
 }
 
diff --git a/src/Entities/Boat.cpp b/src/Entities/Boat.cpp
index 184aeeeeb..921252253 100644
--- a/src/Entities/Boat.cpp
+++ b/src/Entities/Boat.cpp
@@ -89,10 +89,20 @@ void cBoat::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	super::Tick(a_Dt, a_Chunk);
 	BroadcastMovementUpdate();
-	SetSpeed(GetSpeed() * 0.97); // Slowly decrease the speed.
-	if (IsBlockWater(m_World->GetBlock((int) GetPosX(), (int) GetPosY(), (int) GetPosZ())))
+
+	SetSpeed(GetSpeed() * 0.97); // Slowly decrease the speed
+
+	if ((POSY_TOINT < 0) || (POSY_TOINT > cChunkDef::Height))
+	{
+		return;
+	}
+
+	if (IsBlockWater(m_World->GetBlock(POSX_TOINT, POSY_TOINT, POSZ_TOINT)))
 	{
-		SetSpeedY(1);
+		if (GetSpeedY() < 2)
+		{	
+			AddSpeedY(0.2);
+		}
 	}
 }
 
@@ -102,15 +112,13 @@ void cBoat::Tick(float a_Dt, cChunk & a_Chunk)
 
 void cBoat::HandleSpeedFromAttachee(float a_Forward, float a_Sideways)
 {
-	if (GetSpeed().Length() > 7)
+	if (GetSpeed().Length() > 7.5)
 	{
 		return;
 	}
 	
-	Vector3d ToAddSpeed(m_Attachee->GetLookVector() * (a_Sideways * 1.5));
+	Vector3d ToAddSpeed = m_Attachee->GetLookVector() * (a_Sideways * 0.4) ;
 	ToAddSpeed.y = 0;
 
 	AddSpeed(ToAddSpeed);
 }
-
-	
\ No newline at end of file
diff --git a/src/Entities/Effects.h b/src/Entities/Effects.h
index e7611847d..baf3302fb 100644
--- a/src/Entities/Effects.h
+++ b/src/Entities/Effects.h
@@ -27,4 +27,4 @@ enum ENUM_ENTITY_EFFECT
 	E_EFFECT_ABSORPTION = 22,
 	E_EFFECT_SATURATION = 23,
 } ; 
-// tolua_end
\ No newline at end of file
+// tolua_end
diff --git a/src/Entities/EnderCrystal.cpp b/src/Entities/EnderCrystal.cpp
new file mode 100644
index 000000000..a640b236c
--- /dev/null
+++ b/src/Entities/EnderCrystal.cpp
@@ -0,0 +1,56 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "EnderCrystal.h"
+#include "ClientHandle.h"
+#include "Player.h"
+#include "../Chunk.h"
+
+
+
+
+
+cEnderCrystal::cEnderCrystal(double a_X, double a_Y, double a_Z)
+	: cEntity(etEnderCrystal, a_X, a_Y, a_Z, 1.0, 1.0)
+{
+	SetMaxHealth(5);
+}
+
+
+
+
+
+void cEnderCrystal::SpawnOn(cClientHandle & a_ClientHandle)
+{
+	a_ClientHandle.SendSpawnObject(*this, 51, 0, (Byte)GetYaw(), (Byte)GetPitch());
+}
+
+
+
+
+
+void cEnderCrystal::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	UNUSED(a_Dt);
+
+	a_Chunk.SetBlock(POSX_TOINT, POSY_TOINT, POSZ_TOINT, E_BLOCK_FIRE, 0);
+
+	// No further processing (physics e.t.c.) is needed
+}
+
+
+
+
+
+void cEnderCrystal::KilledBy(cEntity * a_Killer)
+{
+	super::KilledBy(a_Killer);
+
+	m_World->DoExplosionAt(6.0, GetPosX(), GetPosY(), GetPosZ(), true, esEnderCrystal, this);
+
+	Destroy();
+}
+
+
+
+
diff --git a/src/Entities/EnderCrystal.h b/src/Entities/EnderCrystal.h
new file mode 100644
index 000000000..5b86df987
--- /dev/null
+++ b/src/Entities/EnderCrystal.h
@@ -0,0 +1,33 @@
+
+#pragma once
+
+#include "Entity.h"
+
+
+
+
+
+// tolua_begin
+class cEnderCrystal :
+	public cEntity
+{
+	// tolua_end
+	typedef cEntity super;
+
+public:
+	CLASS_PROTODEF(cEnderCrystal);
+
+	cEnderCrystal(double a_X, double a_Y, double a_Z);
+
+private:
+
+	// cEntity overrides:
+	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+	virtual void KilledBy(cEntity * a_Killer) override;
+
+};  // tolua_export
+
+
+
+
diff --git a/src/Entities/Entity.cpp b/src/Entities/Entity.cpp
index 565c78dfd..8ef45f1a5 100644
--- a/src/Entities/Entity.cpp
+++ b/src/Entities/Entity.cpp
@@ -4,9 +4,7 @@
 #include "../World.h"
 #include "../Server.h"
 #include "../Root.h"
-#include "../Vector3d.h"
-#include "../Matrix4f.h"
-#include "../ReferenceManager.h"
+#include "../Matrix4.h"
 #include "../ClientHandle.h"
 #include "../Chunk.h"
 #include "../Simulator/FluidSimulator.h"
@@ -32,8 +30,6 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
 	, m_MaxHealth(1)
 	, m_AttachedTo(NULL)
 	, m_Attachee(NULL)
-	, m_Referencers(new cReferenceManager(cReferenceManager::RFMNGR_REFERENCERS))
-	, m_References(new cReferenceManager(cReferenceManager::RFMNGR_REFERENCES))
 	, m_bDirtyHead(true)
 	, m_bDirtyOrientation(true)
 	, m_bDirtyPosition(true)
@@ -54,6 +50,8 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
 	, m_TicksSinceLastFireDamage(0)
 	, m_TicksLeftBurning(0)
 	, m_TicksSinceLastVoidDamage(0)
+	, m_IsSwimming(false)
+	, m_IsSubmerged(false)
 	, m_HeadYaw( 0.0 )
 	, m_Rot(0.0, 0.0, 0.0)
 	, m_Pos(a_X, a_Y, a_Z)
@@ -73,7 +71,8 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
 
 cEntity::~cEntity()
 {
-	ASSERT(!m_World->HasEntity(m_UniqueID));  // Before deleting, the entity needs to have been removed from the world
+	// Before deleting, the entity needs to have been removed from the world, if ever added
+	ASSERT((m_World == NULL) || !m_World->HasEntity(m_UniqueID));
 	
 	/*
 	// DEBUG:
@@ -99,8 +98,6 @@ cEntity::~cEntity()
 		LOGWARNING("ERROR: Entity deallocated without being destroyed");
 		ASSERT(!"Entity deallocated without being destroyed or unlinked");
 	}
-	delete m_Referencers;
-	delete m_References;
 }
 
 
@@ -400,6 +397,7 @@ int cEntity::GetArmorCoverAgainst(const cEntity * a_Attacker, eDamageType a_Dama
 		case dtPotionOfHarming:
 		case dtFalling:
 		case dtLightning:
+		case dtPlugin:
 		{
 			return 0;
 		}
@@ -476,7 +474,7 @@ void cEntity::KilledBy(cEntity * a_Killer)
 		return;
 	}
 
-	// Drop loot:	
+	// Drop loot:
 	cItems Drops;
 	GetDrops(Drops, a_Killer);
 	m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ());
@@ -523,18 +521,36 @@ void cEntity::Tick(float a_Dt, cChunk & a_Chunk)
 	{
 		if (a_Chunk.IsValid())
 		{
-			HandlePhysics(a_Dt, a_Chunk);
+			cChunk * NextChunk = a_Chunk.GetNeighborChunk(POSX_TOINT, POSZ_TOINT);
+
+			if ((NextChunk == NULL) || !NextChunk->IsValid())
+			{
+				return;
+			}
+
+			TickBurning(*NextChunk);
+
+			if (GetPosY() < VOID_BOUNDARY)
+			{
+				TickInVoid(*NextChunk);
+			}
+			else
+			{
+				m_TicksSinceLastVoidDamage = 0;
+			}
+
+			if (IsMob() || IsPlayer())
+			{
+				// Set swimming state
+				SetSwimState(*NextChunk);
+
+				// Handle drowning
+				HandleAir();
+			}
+
+			HandlePhysics(a_Dt, *NextChunk);
 		}
 	}
-	if (a_Chunk.IsValid())
-	{
-		TickBurning(a_Chunk);
-	}
-	if ((a_Chunk.IsValid())  && (GetPosY() < -46))
-	{
-		TickInVoid(a_Chunk);
-	}
-	else { m_TicksSinceLastVoidDamage = 0; }
 }
 
 
@@ -554,7 +570,7 @@ void cEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 	if ((BlockY >= cChunkDef::Height) || (BlockY < 0))
 	{
 		// Outside of the world
-
+		
 		cChunk * NextChunk = a_Chunk.GetNeighborChunk(BlockX, BlockZ);
 		// See if we can commit our changes. If not, we will discard them.
 		if (NextChunk != NULL)
@@ -563,210 +579,205 @@ void cEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 			NextPos += (NextSpeed * a_Dt);
 			SetPosition(NextPos);
 		}
+
 		return;
 	}
 	
-	// Make sure we got the correct chunk and a valid one. No one ever knows...
-	cChunk * NextChunk = a_Chunk.GetNeighborChunk(BlockX, BlockZ);
-	if (NextChunk != NULL)
+	int RelBlockX = BlockX - (a_Chunk.GetPosX() * cChunkDef::Width);
+	int RelBlockZ = BlockZ - (a_Chunk.GetPosZ() * cChunkDef::Width);
+	BLOCKTYPE BlockIn = a_Chunk.GetBlock( RelBlockX, BlockY, RelBlockZ );
+	BLOCKTYPE BlockBelow = (BlockY > 0) ? a_Chunk.GetBlock(RelBlockX, BlockY - 1, RelBlockZ) : E_BLOCK_AIR;
+	if (!cBlockInfo::IsSolid(BlockIn))  // Making sure we are not inside a solid block
 	{
-		int RelBlockX = BlockX - (NextChunk->GetPosX() * cChunkDef::Width);
-		int RelBlockZ = BlockZ - (NextChunk->GetPosZ() * cChunkDef::Width);
-		BLOCKTYPE BlockIn = NextChunk->GetBlock( RelBlockX, BlockY, RelBlockZ );
-		BLOCKTYPE BlockBelow = (BlockY > 0) ? NextChunk->GetBlock(RelBlockX, BlockY - 1, RelBlockZ) : E_BLOCK_AIR;
-		if (!g_BlockIsSolid[BlockIn])  // Making sure we are not inside a solid block
+		if (m_bOnGround)  // check if it's still on the ground
 		{
-			if (m_bOnGround)  // check if it's still on the ground
+			if (!cBlockInfo::IsSolid(BlockBelow))  // Check if block below is air or water.
 			{
-				if (!g_BlockIsSolid[BlockBelow])  // Check if block below is air or water.
-				{
-					m_bOnGround = false;
-				}
+				m_bOnGround = false;
 			}
 		}
-		else
-		{
-			// Push out entity.
-			BLOCKTYPE GotBlock;
+	}
+	else
+	{
+		// Push out entity.
+		BLOCKTYPE GotBlock;
 
-			static const struct
-			{
-				int x, y, z;
-			} gCrossCoords[] =
-			{
-				{ 1, 0,  0},
-				{-1, 0,  0},
-				{ 0, 0,  1},
-				{ 0, 0, -1},
-			} ;
-
-			bool IsNoAirSurrounding = true;
-			for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
+		static const struct
+		{
+			int x, y, z;
+		} gCrossCoords[] =
+		{
+			{ 1, 0,  0},
+			{-1, 0,  0},
+			{ 0, 0,  1},
+			{ 0, 0, -1},
+		} ;
+
+		bool IsNoAirSurrounding = true;
+		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
+		{
+			if (!a_Chunk.UnboundedRelGetBlockType(RelBlockX + gCrossCoords[i].x, BlockY, RelBlockZ + gCrossCoords[i].z, GotBlock))
 			{
-				if (!NextChunk->UnboundedRelGetBlockType(RelBlockX + gCrossCoords[i].x, BlockY, RelBlockZ + gCrossCoords[i].z, GotBlock))
-				{
-					// The pickup is too close to an unloaded chunk, bail out of any physics handling
-					return;
-				}
-				if (!g_BlockIsSolid[GotBlock])
-				{
-					NextPos.x += gCrossCoords[i].x;
-					NextPos.z += gCrossCoords[i].z;
-					IsNoAirSurrounding = false;
-					break;
-				}
-			}  // for i - gCrossCoords[]
-			
-			if (IsNoAirSurrounding)
+				// The pickup is too close to an unloaded chunk, bail out of any physics handling
+				return;
+			}
+			if (!cBlockInfo::IsSolid(GotBlock))
 			{
-				NextPos.y += 0.5;
+				NextPos.x += gCrossCoords[i].x;
+				NextPos.z += gCrossCoords[i].z;
+				IsNoAirSurrounding = false;
+				break;
 			}
+		}  // for i - gCrossCoords[]
+			
+		if (IsNoAirSurrounding)
+		{
+			NextPos.y += 0.5;
+		}
 
-			m_bOnGround = true;
+		m_bOnGround = true;
 
-			/*
-			// DEBUG:
-			LOGD("Entity #%d (%s) is inside a block at {%d, %d, %d}",
-				m_UniqueID, GetClass(), BlockX, BlockY, BlockZ
-			);
-			*/
-		}
+		/*
+		// DEBUG:
+		LOGD("Entity #%d (%s) is inside a block at {%d, %d, %d}",
+			m_UniqueID, GetClass(), BlockX, BlockY, BlockZ
+		);
+		*/
+	}
 
-		if (!m_bOnGround)
+	if (!m_bOnGround)
+	{
+		float fallspeed;
+		if (IsBlockWater(BlockIn))
 		{
-			float fallspeed;
-			if (IsBlockWater(BlockIn))
-			{
-				fallspeed = m_Gravity * a_Dt / 3;  // Fall 3x slower in water.
-			}
-			else if (BlockIn == E_BLOCK_COBWEB)
-			{
-				NextSpeed.y *= 0.05;  // Reduce overall falling speed
-				fallspeed = 0;  // No falling.
-			}
-			else
-			{
-				// Normal gravity
-				fallspeed = m_Gravity * a_Dt;
-			}
-			NextSpeed.y += fallspeed;
+			fallspeed = m_Gravity * a_Dt / 3;  // Fall 3x slower in water.
+		}
+		else if (BlockIn == E_BLOCK_COBWEB)
+		{
+			NextSpeed.y *= 0.05;  // Reduce overall falling speed
+			fallspeed = 0;  // No falling.
 		}
 		else
 		{
-			// Friction
-			if (NextSpeed.SqrLength() > 0.0004f)
+			// Normal gravity
+			fallspeed = m_Gravity * a_Dt;
+		}
+		NextSpeed.y += fallspeed;
+	}
+	else
+	{
+		// Friction
+		if (NextSpeed.SqrLength() > 0.0004f)
+		{
+			NextSpeed.x *= 0.7f / (1 + a_Dt);
+			if (fabs(NextSpeed.x) < 0.05)
 			{
-				NextSpeed.x *= 0.7f / (1 + a_Dt);
-				if (fabs(NextSpeed.x) < 0.05)
-				{
-					NextSpeed.x = 0;
-				}
-				NextSpeed.z *= 0.7f / (1 + a_Dt);
-				if (fabs(NextSpeed.z) < 0.05)
-				{
-					NextSpeed.z = 0;
-				}
+				NextSpeed.x = 0;
+			}
+			NextSpeed.z *= 0.7f / (1 + a_Dt);
+			if (fabs(NextSpeed.z) < 0.05)
+			{
+				NextSpeed.z = 0;
 			}
 		}
+	}
 
-		// Adjust X and Z speed for COBWEB temporary. This speed modification should be handled inside block handlers since we
-		// might have different speed modifiers according to terrain.
-		if (BlockIn == E_BLOCK_COBWEB)
-		{
-			NextSpeed.x *= 0.25;
-			NextSpeed.z *= 0.25;
-		}
+	// Adjust X and Z speed for COBWEB temporary. This speed modification should be handled inside block handlers since we
+	// might have different speed modifiers according to terrain.
+	if (BlockIn == E_BLOCK_COBWEB)
+	{
+		NextSpeed.x *= 0.25;
+		NextSpeed.z *= 0.25;
+	}
 					
-		//Get water direction
-		Direction WaterDir = m_World->GetWaterSimulator()->GetFlowingDirection(BlockX, BlockY, BlockZ);
+	//Get water direction
+	Direction WaterDir = m_World->GetWaterSimulator()->GetFlowingDirection(BlockX, BlockY, BlockZ);
 
-		m_WaterSpeed *= 0.9f;		//Reduce speed each tick
+	m_WaterSpeed *= 0.9f;		//Reduce speed each tick
 
-		switch(WaterDir)
-		{
-			case X_PLUS:
-				m_WaterSpeed.x = 0.2f;
-				m_bOnGround = false;
-				break;
-			case X_MINUS:
-				m_WaterSpeed.x = -0.2f;
-				m_bOnGround = false;
-				break;
-			case Z_PLUS:
-				m_WaterSpeed.z = 0.2f;
-				m_bOnGround = false;
-				break;
-			case Z_MINUS:
-				m_WaterSpeed.z = -0.2f;
-				m_bOnGround = false;
-				break;
-			
-		default:
+	switch(WaterDir)
+	{
+		case X_PLUS:
+			m_WaterSpeed.x = 0.2f;
+			m_bOnGround = false;
 			break;
-		}
+		case X_MINUS:
+			m_WaterSpeed.x = -0.2f;
+			m_bOnGround = false;
+			break;
+		case Z_PLUS:
+			m_WaterSpeed.z = 0.2f;
+			m_bOnGround = false;
+			break;
+		case Z_MINUS:
+			m_WaterSpeed.z = -0.2f;
+			m_bOnGround = false;
+			break;
+			
+	default:
+		break;
+	}
 
-		if (fabs(m_WaterSpeed.x) < 0.05)
-		{
-			m_WaterSpeed.x = 0;
-		}
+	if (fabs(m_WaterSpeed.x) < 0.05)
+	{
+		m_WaterSpeed.x = 0;
+	}
 
-		if (fabs(m_WaterSpeed.z) < 0.05)
-		{
-			m_WaterSpeed.z = 0;
-		}
+	if (fabs(m_WaterSpeed.z) < 0.05)
+	{
+		m_WaterSpeed.z = 0;
+	}
 
-		NextSpeed += m_WaterSpeed;
+	NextSpeed += m_WaterSpeed;
 
-		if( NextSpeed.SqrLength() > 0.f )
+	if( NextSpeed.SqrLength() > 0.f )
+	{
+		cTracer Tracer( GetWorld() );
+		bool HasHit = Tracer.Trace( NextPos, NextSpeed, 2 );
+		if (HasHit) // Oh noez! we hit something
 		{
-			cTracer Tracer( GetWorld() );
-			int Ret = Tracer.Trace( NextPos, NextSpeed, 2 );
-			if( Ret ) // Oh noez! we hit something
+			// Set to hit position
+			if ((Tracer.RealHit - NextPos).SqrLength() <= (NextSpeed * a_Dt).SqrLength())
 			{
-				// Set to hit position
-				if( (Tracer.RealHit - NextPos).SqrLength() <= ( NextSpeed * a_Dt ).SqrLength() )
-				{
-					if( Ret == 1 )
-					{
-						if( Tracer.HitNormal.x != 0.f ) NextSpeed.x = 0.f;
-						if( Tracer.HitNormal.y != 0.f ) NextSpeed.y = 0.f;
-						if( Tracer.HitNormal.z != 0.f ) NextSpeed.z = 0.f;
-
-						if( Tracer.HitNormal.y > 0 ) // means on ground
-						{
-							m_bOnGround = true;
-						}
-					}
-					NextPos.Set(Tracer.RealHit.x,Tracer.RealHit.y,Tracer.RealHit.z);
-					NextPos.x += Tracer.HitNormal.x * 0.3f;
-					NextPos.y += Tracer.HitNormal.y * 0.05f; // Any larger produces entity vibration-upon-the-spot
-					NextPos.z += Tracer.HitNormal.z * 0.3f;
-				}
-				else
+				if (Tracer.HitNormal.x != 0.f) NextSpeed.x = 0.f;
+				if (Tracer.HitNormal.y != 0.f) NextSpeed.y = 0.f;
+				if (Tracer.HitNormal.z != 0.f) NextSpeed.z = 0.f;
+
+				if (Tracer.HitNormal.y > 0) // means on ground
 				{
-					NextPos += (NextSpeed * a_Dt);
+					m_bOnGround = true;
 				}
+				NextPos.Set(Tracer.RealHit.x,Tracer.RealHit.y,Tracer.RealHit.z);
+				NextPos.x += Tracer.HitNormal.x * 0.3f;
+				NextPos.y += Tracer.HitNormal.y * 0.05f; // Any larger produces entity vibration-upon-the-spot
+				NextPos.z += Tracer.HitNormal.z * 0.3f;
 			}
 			else
 			{
-				// We didn't hit anything, so move =]
 				NextPos += (NextSpeed * a_Dt);
 			}
 		}
-		BlockX = (int) floor(NextPos.x);
-		BlockZ = (int) floor(NextPos.z);
-		NextChunk = NextChunk->GetNeighborChunk(BlockX,BlockZ);
-		// See if we can commit our changes. If not, we will discard them.
-		if (NextChunk != NULL)
+		else
 		{
-			if (NextPos.x != GetPosX()) SetPosX(NextPos.x);
-			if (NextPos.y != GetPosY()) SetPosY(NextPos.y);
-			if (NextPos.z != GetPosZ()) SetPosZ(NextPos.z);
-			if (NextSpeed.x != GetSpeedX()) SetSpeedX(NextSpeed.x);
-			if (NextSpeed.y != GetSpeedY()) SetSpeedY(NextSpeed.y);
-			if (NextSpeed.z != GetSpeedZ()) SetSpeedZ(NextSpeed.z);
+			// We didn't hit anything, so move =]
+			NextPos += (NextSpeed * a_Dt);
 		}
 	}
+
+	BlockX = (int) floor(NextPos.x);
+	BlockZ = (int) floor(NextPos.z);
+
+	cChunk * NextChunk = a_Chunk.GetNeighborChunk(BlockX, BlockZ);
+	// See if we can commit our changes. If not, we will discard them.
+	if (NextChunk != NULL)
+	{
+		if (NextPos.x != GetPosX()) SetPosX(NextPos.x);
+		if (NextPos.y != GetPosY()) SetPosY(NextPos.y);
+		if (NextPos.z != GetPosZ()) SetPosZ(NextPos.z);
+		if (NextSpeed.x != GetSpeedX()) SetSpeedX(NextSpeed.x);
+		if (NextSpeed.y != GetSpeedY()) SetSpeedY(NextSpeed.y);
+		if (NextSpeed.z != GetSpeedZ()) SetSpeedZ(NextSpeed.z);
+	}
 }
 
 
@@ -807,14 +818,13 @@ void cEntity::TickBurning(cChunk & a_Chunk)
 		{
 			int RelX = x;
 			int RelZ = z;
-			cChunk * CurChunk = a_Chunk.GetRelNeighborChunkAdjustCoords(RelX, RelZ);
-			if (CurChunk == NULL)
-			{
-				continue;
-			}
+
 			for (int y = MinY; y <= MaxY; y++)
 			{
-				switch (CurChunk->GetBlock(RelX, y, RelZ))
+				BLOCKTYPE Block;
+				a_Chunk.UnboundedRelGetBlockType(RelX, y, RelZ, Block);
+				
+				switch (Block)
 				{
 					case E_BLOCK_FIRE:
 					{
@@ -912,6 +922,86 @@ void cEntity::TickInVoid(cChunk & a_Chunk)
 
 
 
+void cEntity::SetSwimState(cChunk & a_Chunk)
+{
+	int RelY = (int)floor(GetPosY() + 0.1);
+	if ((RelY < 0) || (RelY >= cChunkDef::Height - 1))
+	{
+		m_IsSwimming = false;
+		m_IsSubmerged = false;
+		return;
+	}
+
+	BLOCKTYPE BlockIn;
+	int RelX = POSX_TOINT - a_Chunk.GetPosX() * cChunkDef::Width;
+	int RelZ = POSZ_TOINT - a_Chunk.GetPosZ() * cChunkDef::Width;
+
+	// Check if the player is swimming:
+	if (!a_Chunk.UnboundedRelGetBlockType(RelX, RelY, RelZ, BlockIn))
+	{
+		// This sometimes happens on Linux machines
+		// Ref.: http://forum.mc-server.org/showthread.php?tid=1244
+		LOGD("SetSwimState failure: RelX = %d, RelZ = %d, LastPos = {%.02f, %.02f}, Pos = %.02f, %.02f}",
+			RelX, RelY, m_LastPosX, m_LastPosZ, GetPosX(), GetPosZ()
+			);
+		m_IsSwimming = false;
+		m_IsSubmerged = false;
+		return;
+	}
+	m_IsSwimming = IsBlockWater(BlockIn);
+
+	// Check if the player is submerged:
+	VERIFY(a_Chunk.UnboundedRelGetBlockType(RelX, RelY + 1, RelZ, BlockIn));
+	m_IsSubmerged = IsBlockWater(BlockIn);
+}
+
+
+
+
+
+void cEntity::HandleAir(void)
+{
+	// Ref.: http://www.minecraftwiki.net/wiki/Chunk_format
+	// See if the entity is /submerged/ water (block above is water)
+	// Get the type of block the entity is standing in:
+
+	if (IsSubmerged())
+	{
+		SetSpeedY(1); // Float in the water
+
+		// Either reduce air level or damage player
+		if (m_AirLevel < 1)
+		{
+			if (m_AirTickTimer < 1)
+			{
+				// Damage player 
+				TakeDamage(dtDrowning, NULL, 1, 1, 0);
+				// Reset timer
+				m_AirTickTimer = DROWNING_TICKS;
+			}
+			else
+			{
+				m_AirTickTimer -= 1;
+			}
+		}
+		else
+		{
+			// Reduce air supply
+			m_AirLevel -= 1;
+		}
+	}
+	else
+	{
+		// Set the air back to maximum
+		m_AirLevel = MAX_AIR_LEVEL;
+		m_AirTickTimer = DROWNING_TICKS;
+	}
+}
+
+
+
+
+
 /// Called when the entity starts burning
 void cEntity::OnStartedBurning(void)
 {
@@ -1379,7 +1469,7 @@ void cEntity::SteerVehicle(float a_Forward, float a_Sideways)
 Vector3d cEntity::GetLookVector(void) const
 {
 	Matrix4d m;
-	m.Init(Vector3f(), 0, m_Rot.x, -m_Rot.y);
+	m.Init(Vector3d(), 0, m_Rot.x, -m_Rot.y);
 	Vector3d Look = m.Transform(Vector3d(0, 0, 1));
 	return Look;
 }
@@ -1429,33 +1519,3 @@ void cEntity::SetPosZ(double a_PosZ)
 
 
 
-
-//////////////////////////////////////////////////////////////////////////
-// Reference stuffs
-void cEntity::AddReference(cEntity * & a_EntityPtr)
-{
-	m_References->AddReference(a_EntityPtr);
-	a_EntityPtr->ReferencedBy(a_EntityPtr);
-}
-
-
-
-
-
-void cEntity::ReferencedBy(cEntity * & a_EntityPtr)
-{
-	m_Referencers->AddReference(a_EntityPtr);
-}
-
-
-
-
-
-void cEntity::Dereference(cEntity * & a_EntityPtr)
-{
-	m_Referencers->Dereference(a_EntityPtr);
-}
-
-
-
-
diff --git a/src/Entities/Entity.h b/src/Entities/Entity.h
index 91463bfd6..6e3f8292b 100644
--- a/src/Entities/Entity.h
+++ b/src/Entities/Entity.h
@@ -2,8 +2,7 @@
 #pragma once
 
 #include "../Item.h"
-#include "../Vector3d.h"
-#include "../Vector3f.h"
+#include "../Vector3.h"
 
 
 
@@ -28,12 +27,16 @@
 		return super::GetClass(); \
 	}
 
+#define POSX_TOINT (int)floor(GetPosX())
+#define POSY_TOINT (int)floor(GetPosY())
+#define POSZ_TOINT (int)floor(GetPosZ())
+#define POS_TOINT  Vector3i(POSXTOINT, POSYTOINT, POSZTOINT)
+
 
 
 
 
 class cWorld;
-class cReferenceManager;
 class cClientHandle;
 class cPlayer;
 class cChunk;
@@ -66,6 +69,7 @@ public:
 	enum eEntityType
 	{
 		etEntity,  // For all other types
+		etEnderCrystal,
 		etPlayer,
 		etPickup,
 		etMonster,
@@ -76,6 +80,8 @@ public:
 		etProjectile,
 		etExpOrb,
 		etFloater,
+		etItemFrame,
+		etPainting,
 		
 		// Common variations
 		etMob = etMonster,  // DEPRECATED, use etMonster instead!
@@ -110,6 +116,9 @@ public:
 		BURN_TICKS_PER_DAMAGE = 20,  ///< How many ticks to wait between damaging an entity when it is burning
 		BURN_DAMAGE = 1,             ///< How much damage to deal when the entity is burning
 		BURN_TICKS = 200,            ///< How long to keep an entity burning after it has stood in lava / fire
+		MAX_AIR_LEVEL = 300,         ///< Maximum air an entity can have
+		DROWNING_TICKS = 20,         ///< Number of ticks per heart of damage
+		VOID_BOUNDARY = -46          ///< At what position Y to begin applying void damage
 	} ;
 	
 	cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, double a_Width, double a_Height);
@@ -122,16 +131,19 @@ public:
 	
 	eEntityType GetEntityType(void) const { return m_EntityType; }
 	
-	bool IsPlayer      (void) const { return (m_EntityType == etPlayer); }
-	bool IsPickup      (void) const { return (m_EntityType == etPickup); }
-	bool IsMob         (void) const { return (m_EntityType == etMonster); }
+	bool IsEnderCrystal(void) const { return (m_EntityType == etEnderCrystal); }
+	bool IsPlayer      (void) const { return (m_EntityType == etPlayer);       }
+	bool IsPickup      (void) const { return (m_EntityType == etPickup);       }
+	bool IsMob         (void) const { return (m_EntityType == etMonster);      }
 	bool IsFallingBlock(void) const { return (m_EntityType == etFallingBlock); }
-	bool IsMinecart    (void) const { return (m_EntityType == etMinecart); }
-	bool IsBoat        (void) const { return (m_EntityType == etBoat); }
-	bool IsTNT         (void) const { return (m_EntityType == etTNT); }
-	bool IsProjectile  (void) const { return (m_EntityType == etProjectile); }
-	bool IsExpOrb      (void) const { return (m_EntityType == etExpOrb); }
-	bool IsFloater     (void) const { return (m_EntityType == etFloater); }
+	bool IsMinecart    (void) const { return (m_EntityType == etMinecart);     }
+	bool IsBoat        (void) const { return (m_EntityType == etBoat);         }
+	bool IsTNT         (void) const { return (m_EntityType == etTNT);          }
+	bool IsProjectile  (void) const { return (m_EntityType == etProjectile);   }
+	bool IsExpOrb      (void) const { return (m_EntityType == etExpOrb);       }
+	bool IsFloater     (void) const { return (m_EntityType == etFloater);      }
+	bool IsItemFrame   (void) const { return (m_EntityType == etItemFrame);    }
+	bool IsPainting    (void) const { return (m_EntityType == etPainting);     }
 	
 	/// Returns true if the entity is of the specified class or a subclass (cPawn's IsA("cEntity") returns true)
 	virtual bool IsA(const char * a_ClassName) const;
@@ -147,7 +159,7 @@ public:
 
 	cWorld * GetWorld(void) const { return m_World; }
 
-	double           GetHeadYaw   (void) const { return m_HeadYaw; }
+	double           GetHeadYaw   (void) const { return m_HeadYaw; }  // In degrees
 	double           GetHeight    (void) const { return m_Height;  }
 	double           GetMass      (void) const { return m_Mass;    }
 	const Vector3d & GetPosition  (void) const { return m_Pos;     }
@@ -155,9 +167,9 @@ public:
 	double           GetPosY      (void) const { return m_Pos.y;   }
 	double           GetPosZ      (void) const { return m_Pos.z;   }
 	const Vector3d & GetRot       (void) const { return m_Rot;     }  // OBSOLETE, use individual GetYaw(), GetPitch, GetRoll() components
-	double           GetYaw       (void) const { return m_Rot.x;   }
-	double           GetPitch     (void) const { return m_Rot.y;   }
-	double           GetRoll      (void) const { return m_Rot.z;   }
+	double           GetYaw       (void) const { return m_Rot.x;   }  // In degrees, [-180, +180)
+	double           GetPitch     (void) const { return m_Rot.y;   }  // In degrees, [-180, +180), but normal client clips to [-90, +90]
+	double           GetRoll      (void) const { return m_Rot.z;   }  // In degrees, unused in current client
 	Vector3d         GetLookVector(void) const;
 	const Vector3d & GetSpeed     (void) const { return m_Speed;   }
 	double           GetSpeedX    (void) const { return m_Speed.x; }
@@ -177,9 +189,9 @@ public:
 	void SetPosition(double a_PosX, double a_PosY, double a_PosZ);
 	void SetPosition(const Vector3d & a_Pos) { SetPosition(a_Pos.x, a_Pos.y, a_Pos.z); }
 	void SetRot     (const Vector3f & a_Rot);  // OBSOLETE, use individual SetYaw(), SetPitch(), SetRoll() components
-	void SetYaw     (double a_Yaw);
-	void SetPitch   (double a_Pitch);
-	void SetRoll    (double a_Roll);
+	void SetYaw     (double a_Yaw);    // In degrees, normalizes to [-180, +180)
+	void SetPitch   (double a_Pitch);  // In degrees, normalizes to [-180, +180)
+	void SetRoll    (double a_Roll);   // In degrees, normalizes to [-180, +180)
 	void SetSpeed   (double a_SpeedX, double a_SpeedY, double a_SpeedZ);
 	void SetSpeed   (const Vector3d & a_Speed) { SetSpeed(a_Speed.x, a_Speed.y, a_Speed.z); }
 	void SetSpeedX  (double a_SpeedX);
@@ -344,7 +356,14 @@ public:
 	virtual bool IsRiding   (void) const {return false; }
 	virtual bool IsSprinting(void) const {return false; }
 	virtual bool IsRclking  (void) const {return false; }
-	virtual bool IsInvisible(void) const {return false; }
+	virtual bool IsInvisible(void) const { return false; }
+
+	/** Returns whether the player is swimming or not */
+	virtual bool IsSwimming(void) const{ return m_IsSwimming; }
+	/** Return whether the player is under water or not */
+	virtual bool IsSubmerged(void) const{ return m_IsSubmerged; }
+	/** Gets remaining air of a monster */
+	int GetAirLevel(void) const { return m_AirLevel; }
 	
 	// tolua_end
 	
@@ -373,9 +392,6 @@ protected:
 	/// The entity which is attached to this entity (rider), NULL if none
 	cEntity * m_Attachee;
 
-	cReferenceManager* m_Referencers;
-	cReferenceManager* m_References;
-
 	// Flags that signal that we haven't updated the clients with the latest.
 	bool     m_bDirtyHead;
 	bool     m_bDirtyOrientation;
@@ -415,11 +431,18 @@ protected:
 	virtual void Destroyed(void) {} // Called after the entity has been destroyed
 
 	void SetWorld(cWorld * a_World) { m_World = a_World; }
-	
-	friend class cReferenceManager;
-	void AddReference( cEntity*& a_EntityPtr );
-	void ReferencedBy( cEntity*& a_EntityPtr );
-	void Dereference( cEntity*& a_EntityPtr );
+
+	/** Called in each tick to handle air-related processing i.e. drowning */
+	virtual void HandleAir();
+	/** Called once per tick to set IsSwimming and IsSubmerged */
+	virtual void SetSwimState(cChunk & a_Chunk);
+
+	/** If an entity is currently swimming in or submerged under water */
+	bool m_IsSwimming, m_IsSubmerged;
+
+	/** Air level of a mobile */
+	int m_AirLevel;
+	int m_AirTickTimer;
 	
 private:
 	// Measured in degrees, [-180, +180)
diff --git a/src/Entities/ExpOrb.cpp b/src/Entities/ExpOrb.cpp
index 04ee85823..3623c869a 100644
--- a/src/Entities/ExpOrb.cpp
+++ b/src/Entities/ExpOrb.cpp
@@ -5,20 +5,26 @@
 #include "../ClientHandle.h"
 
 
-cExpOrb::cExpOrb(double a_X, double a_Y, double a_Z, int a_Reward) :
-	cEntity(etExpOrb, a_X, a_Y, a_Z, 0.98, 0.98),
-	m_Reward(a_Reward)
+cExpOrb::cExpOrb(double a_X, double a_Y, double a_Z, int a_Reward)
+	:	cEntity(etExpOrb, a_X, a_Y, a_Z, 0.98, 0.98)
+	, m_Reward(a_Reward)
+	, m_Timer(0.f)
 {
+	SetMaxHealth(5);
+	SetHealth(5);
 }
 
 
 
 
 
-cExpOrb::cExpOrb(const Vector3d & a_Pos, int a_Reward) :
-	cEntity(etExpOrb, a_Pos.x, a_Pos.y, a_Pos.z, 0.98, 0.98),
-	m_Reward(a_Reward)
+cExpOrb::cExpOrb(const Vector3d & a_Pos, int a_Reward)
+	:	cEntity(etExpOrb, a_Pos.x, a_Pos.y, a_Pos.z, 0.98, 0.98)
+	, m_Reward(a_Reward)
+	, m_Timer(0.f)
 {
+	SetMaxHealth(5);
+	SetHealth(5);
 }
 
 
@@ -51,7 +57,10 @@ void cExpOrb::Tick(float a_Dt, cChunk & a_Chunk)
 		{
 			LOGD("Player %s picked up an ExpOrb. His reward is %i", a_ClosestPlayer->GetName().c_str(), m_Reward);
 			a_ClosestPlayer->DeltaExperience(m_Reward);
-			Destroy(true);
+			
+			m_World->BroadcastSoundEffect("random.orb", (int)(GetPosX() * 8), (int)(GetPosY() * 8), (int)(GetPosZ() * 8), 0.5f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
+			
+			Destroy();
 		}
 		a_Distance.Normalize();
 		a_Distance *= ((float) (5.5 - Distance));
@@ -61,4 +70,10 @@ void cExpOrb::Tick(float a_Dt, cChunk & a_Chunk)
 		BroadcastMovementUpdate();
 	}
 	HandlePhysics(a_Dt, a_Chunk);
-}
\ No newline at end of file
+	
+	m_Timer += a_Dt;
+	if (m_Timer >= 1000 * 60 * 5)  // 5 minutes
+	{
+		Destroy(true);
+	}
+}
diff --git a/src/Entities/ExpOrb.h b/src/Entities/ExpOrb.h
index a062eedd3..e76274ac9 100644
--- a/src/Entities/ExpOrb.h
+++ b/src/Entities/ExpOrb.h
@@ -7,13 +7,17 @@
 
 
 
+// tolua_begin
 class cExpOrb :
 	public cEntity
 {
 	typedef cExpOrb super;
 	
 public:
-	
+	// tolua_end
+
+	CLASS_PROTODEF(cExpOrb);
+
 	cExpOrb(double a_X, double a_Y, double a_Z, int a_Reward);
 	cExpOrb(const Vector3d & a_Pos, int a_Reward);
 
@@ -21,9 +25,21 @@ public:
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void SpawnOn(cClientHandle & a_Client) override;
 
-	// cExpOrb functions
-	int GetReward(void) const { return m_Reward; }
+	/** Returns the number of ticks that this entity has existed */
+	int GetAge(void) const { return (int)(m_Timer / 50); }     // tolua_export
+
+	/** Set the number of ticks that this entity has existed */
+	void SetAge(int a_Age) { m_Timer = (float)(a_Age * 50); }  // tolua_export
+
+	/** Get the exp amount */
+	int GetReward(void) const { return m_Reward; }  // tolua_export
+
+	/** Set the exp amount */
+	void SetReward(int a_Reward) { m_Reward = a_Reward; }  // tolua_export
 
 protected:
 	int m_Reward;
-} ;
\ No newline at end of file
+	
+	/** The number of ticks that the entity has existed / timer between collect and destroy; in msec */
+	float m_Timer;
+} ;  // tolua_export
diff --git a/src/Entities/FallingBlock.cpp b/src/Entities/FallingBlock.cpp
index 9fcd9ac80..a66c7e4ae 100644
--- a/src/Entities/FallingBlock.cpp
+++ b/src/Entities/FallingBlock.cpp
@@ -33,20 +33,16 @@ void cFallingBlock::SpawnOn(cClientHandle & a_ClientHandle)
 
 void cFallingBlock::Tick(float a_Dt, cChunk & a_Chunk)
 {
-	float MilliDt = a_Dt * 0.001f;
-	AddSpeedY(MilliDt * -9.8f);
-	AddPosY(GetSpeedY() * MilliDt);
-
 	// GetWorld()->BroadcastTeleportEntity(*this);  // Test position
 	
-	int BlockX = m_OriginalPosition.x;
+	int BlockX = POSX_TOINT;
 	int BlockY = (int)(GetPosY() - 0.5);
-	int BlockZ = m_OriginalPosition.z;
+	int BlockZ = POSZ_TOINT;
 	
 	if (BlockY < 0)
 	{
 		// Fallen out of this world, just continue falling until out of sight, then destroy:
-		if (BlockY < 100)
+		if (BlockY < VOID_BOUNDARY)
 		{
 			Destroy(true);
 		}
@@ -86,6 +82,15 @@ void cFallingBlock::Tick(float a_Dt, cChunk & a_Chunk)
 		Destroy(true);
 		return;
 	}
+	
+	float MilliDt = a_Dt * 0.001f;
+	AddSpeedY(MilliDt * -9.8f);
+	AddPosition(GetSpeed() * MilliDt);
+
+	if ((GetSpeedX() != 0) || (GetSpeedZ() != 0))
+	{
+		BroadcastMovementUpdate();
+	}
 }
 
 
diff --git a/src/Entities/Floater.cpp b/src/Entities/Floater.cpp
index dfe77f059..b910c3769 100644
--- a/src/Entities/Floater.cpp
+++ b/src/Entities/Floater.cpp
@@ -35,7 +35,7 @@ public:
 		cBoundingBox EntBox(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
 
 		double LineCoeff;
-		char Face;
+		eBlockFace Face;
 		EntBox.Expand(m_Floater->GetWidth() / 2, m_Floater->GetHeight() / 2, m_Floater->GetWidth() / 2);
 		if (!EntBox.CalcLineIntersection(m_Pos, m_NextPos, LineCoeff, Face))
 		{
@@ -103,10 +103,10 @@ protected:
 
 cFloater::cFloater(double a_X, double a_Y, double a_Z, Vector3d a_Speed, int a_PlayerID, int a_CountDownTime) :
 	cEntity(etFloater, a_X, a_Y, a_Z, 0.2, 0.2),
-	m_PickupCountDown(0),
-	m_PlayerID(a_PlayerID),
 	m_CanPickupItem(false),
+	m_PickupCountDown(0),
 	m_CountDownTime(a_CountDownTime),
+	m_PlayerID(a_PlayerID),
 	m_AttachedMobID(-1)
 {
 	SetSpeed(a_Speed);
@@ -215,4 +215,4 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
 	SetSpeedZ(GetSpeedZ() * 0.95);
 
 	BroadcastMovementUpdate();
-}
\ No newline at end of file
+}
diff --git a/src/Entities/Floater.h b/src/Entities/Floater.h
index 162b74e75..547d503f1 100644
--- a/src/Entities/Floater.h
+++ b/src/Entities/Floater.h
@@ -11,11 +11,13 @@
 class cFloater :
 	public cEntity
 {
-	typedef cFloater super;
+	typedef cEntity super;
 	
 public:
-
 	//tolua_end
+
+	CLASS_PROTODEF(cFloater);
+
 	cFloater(double a_X, double a_Y, double a_Z, Vector3d a_Speed, int a_PlayerID, int a_CountDownTime);
 
 	virtual void SpawnOn(cClientHandle & a_Client) override;
@@ -41,4 +43,4 @@ protected:
 	// Entity IDs
 	int m_PlayerID;
 	int m_AttachedMobID;
-} ; // tolua_export
\ No newline at end of file
+} ; // tolua_export
diff --git a/src/Entities/HangingEntity.cpp b/src/Entities/HangingEntity.cpp
new file mode 100644
index 000000000..41ac86268
--- /dev/null
+++ b/src/Entities/HangingEntity.cpp
@@ -0,0 +1,53 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "HangingEntity.h"
+#include "ClientHandle.h"
+#include "Player.h"
+
+
+
+
+
+cHangingEntity::cHangingEntity(eEntityType a_EntityType, eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z)
+	:	cEntity(a_EntityType, a_X, a_Y, a_Z, 0.8, 0.8)
+	, m_BlockFace(a_BlockFace)
+{
+	SetMaxHealth(1);
+	SetHealth(1);
+}
+
+
+
+
+
+void cHangingEntity::SpawnOn(cClientHandle & a_ClientHandle)
+{
+	int Dir = 0;
+			
+	// The client uses different values for item frame directions and block faces. Our constants are for the block faces, so we convert them here to item frame faces
+	switch (m_BlockFace)
+	{
+		case BLOCK_FACE_ZP: break; // Initialised to zero
+		case BLOCK_FACE_ZM: Dir = 2; break;
+		case BLOCK_FACE_XM: Dir = 1; break;
+		case BLOCK_FACE_XP: Dir = 3; break;
+		default: ASSERT(!"Unhandled block face when trying to spawn item frame!"); return;
+	}
+
+	if ((Dir == 0) || (Dir == 2)) // Probably a client bug, but two directions are flipped and contrary to the norm, so we do -180
+	{
+		SetYaw((Dir * 90) - 180);
+	}
+	else
+	{
+		SetYaw(Dir * 90);
+	}
+
+	a_ClientHandle.SendSpawnObject(*this, 71, Dir, (Byte)GetYaw(), (Byte)GetPitch());
+	a_ClientHandle.SendEntityMetadata(*this);
+}
+
+
+
+
diff --git a/src/Entities/HangingEntity.h b/src/Entities/HangingEntity.h
new file mode 100644
index 000000000..6498e4b5b
--- /dev/null
+++ b/src/Entities/HangingEntity.h
@@ -0,0 +1,49 @@
+
+#pragma once
+
+#include "Entity.h"
+
+
+
+
+
+// tolua_begin
+class cHangingEntity :
+	public cEntity
+{
+	// tolua_end
+	typedef cEntity super;
+
+public:
+
+	CLASS_PROTODEF(cHangingEntity);
+
+	cHangingEntity(eEntityType a_EntityType, eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z);
+	
+	/** Returns the orientation from the hanging entity */
+	eBlockFace GetDirection() const { return m_BlockFace; }  // tolua_export
+	
+	/** Set the orientation from the hanging entity */
+	void SetDirection(eBlockFace a_BlockFace) { m_BlockFace = a_BlockFace; }  // tolua_export
+	
+	/** Returns the X coord. */
+	int GetTileX() const { return POSX_TOINT; }  // tolua_export
+	
+	/** Returns the Y coord. */
+	int GetTileY() const { return POSY_TOINT; }  // tolua_export
+	
+	/** Returns the Z coord. */
+	int GetTileZ() const { return POSZ_TOINT; }  // tolua_export
+
+private:
+
+	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override {};
+
+	eBlockFace m_BlockFace;
+
+};  // tolua_export
+
+
+
+
diff --git a/src/Entities/ItemFrame.cpp b/src/Entities/ItemFrame.cpp
new file mode 100644
index 000000000..9dd909880
--- /dev/null
+++ b/src/Entities/ItemFrame.cpp
@@ -0,0 +1,91 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "ItemFrame.h"
+#include "ClientHandle.h"
+#include "Player.h"
+
+
+
+
+
+cItemFrame::cItemFrame(eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z)
+	:	cHangingEntity(etItemFrame, a_BlockFace, a_X, a_Y, a_Z)
+	, m_Item(E_BLOCK_AIR)
+	, m_Rotation(0)
+{
+}
+
+
+
+
+
+void cItemFrame::OnRightClicked(cPlayer & a_Player)
+{
+	if (!m_Item.IsEmpty())
+	{
+		// Item not empty, rotate, clipping values to zero to three inclusive
+		m_Rotation++;
+		if (m_Rotation >= 4)
+		{
+			m_Rotation = 0;
+		}
+	}
+	else if (!a_Player.GetEquippedItem().IsEmpty())
+	{
+		// Item empty, and player held item not empty - add this item to self
+		m_Item = a_Player.GetEquippedItem();
+		m_Item.m_ItemCount = 1;
+
+		if (!a_Player.IsGameModeCreative())
+		{
+			a_Player.GetInventory().RemoveOneEquippedItem();
+		}
+	}
+
+	GetWorld()->BroadcastEntityMetadata(*this); // Update clients
+}
+
+
+
+
+
+
+void cItemFrame::KilledBy(cEntity * a_Killer)
+{
+	if (m_Item.IsEmpty())
+	{
+		super::KilledBy(a_Killer);
+		Destroy();
+		return;
+	}
+
+	if ((a_Killer != NULL) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
+	{
+		cItems Item;
+		Item.push_back(m_Item);
+
+		GetWorld()->SpawnItemPickups(Item, GetPosX(), GetPosY(), GetPosZ());
+	}
+
+	SetHealth(GetMaxHealth());
+	m_Item.Clear();
+	m_Rotation = 0;
+	GetWorld()->BroadcastEntityMetadata(*this);
+}
+
+
+
+
+
+void cItemFrame::GetDrops(cItems & a_Items, cEntity * a_Killer)
+{
+	if ((a_Killer != NULL) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
+	{
+		a_Items.push_back(cItem(E_ITEM_ITEM_FRAME));
+	}
+}
+
+
+
+
diff --git a/src/Entities/ItemFrame.h b/src/Entities/ItemFrame.h
new file mode 100644
index 000000000..6577e7d94
--- /dev/null
+++ b/src/Entities/ItemFrame.h
@@ -0,0 +1,48 @@
+
+#pragma once
+
+#include "HangingEntity.h"
+
+
+
+
+
+// tolua_begin
+class cItemFrame :
+	public cHangingEntity
+{
+	// tolua_end
+	typedef cHangingEntity super;
+
+public:
+
+	CLASS_PROTODEF(cItemFrame);
+
+	cItemFrame(eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z);
+
+	/** Returns the item in the frame */
+	const cItem & GetItem(void) { return m_Item; }                  // tolua_export
+
+	/** Set the item in the frame */
+	void SetItem(cItem & a_Item) { m_Item = a_Item; };              // tolua_export
+
+	/** Returns the rotation from the item in the frame */
+	Byte GetRotation(void) const { return m_Rotation; }             // tolua_export
+
+	/** Set the rotation from the item in the frame */
+	void SetRotation(Byte a_Rotation) { m_Rotation = a_Rotation; }  // tolua_export
+
+private:
+
+	virtual void OnRightClicked(cPlayer & a_Player) override;
+	virtual void KilledBy(cEntity * a_Killer) override;
+	virtual void GetDrops(cItems & a_Items, cEntity * a_Killer) override;
+
+	cItem m_Item;
+	Byte m_Rotation;
+
+};  // tolua_export
+
+
+
+
diff --git a/src/Entities/Minecart.cpp b/src/Entities/Minecart.cpp
index d0d384481..7f38aa35a 100644
--- a/src/Entities/Minecart.cpp
+++ b/src/Entities/Minecart.cpp
@@ -19,6 +19,70 @@
 
 
 
+class cMinecartCollisionCallback :
+	public cEntityCallback
+{
+public:
+	cMinecartCollisionCallback(Vector3d a_Pos, double a_Height, double a_Width, int a_UniqueID, int a_AttacheeUniqueID) :
+		m_DoesInteserct(false),
+		m_CollidedEntityPos(0, 0, 0),
+		m_Pos(a_Pos),
+		m_Height(a_Height),
+		m_Width(a_Width),
+		m_UniqueID(a_UniqueID),
+		m_AttacheeUniqueID(a_AttacheeUniqueID)
+	{
+	}
+
+	virtual bool Item(cEntity * a_Entity) override
+	{
+		ASSERT(a_Entity != NULL);
+
+		if (!a_Entity->IsPlayer() && !a_Entity->IsMob() && !a_Entity->IsMinecart() && !a_Entity->IsBoat())
+		{
+			return false;
+		}
+		else if ((a_Entity->GetUniqueID() == m_UniqueID) || (a_Entity->GetUniqueID() == m_AttacheeUniqueID))
+		{
+			return false;
+		}
+
+		cBoundingBox bbEntity(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
+		cBoundingBox bbMinecart(Vector3d(m_Pos.x, floor(m_Pos.y), m_Pos.z), m_Width / 2, m_Height);
+
+		if (bbEntity.DoesIntersect(bbMinecart))
+		{
+			m_CollidedEntityPos = a_Entity->GetPosition();
+			m_DoesInteserct = true;
+			return true;
+		}
+		return false;
+	}
+
+	bool FoundIntersection(void) const
+	{
+		return m_DoesInteserct;
+	}
+
+	Vector3d GetCollidedEntityPosition(void) const
+	{
+		return m_CollidedEntityPos;
+	}
+
+protected:
+	bool m_DoesInteserct;
+
+	Vector3d m_CollidedEntityPos;
+
+	Vector3d m_Pos;
+	double m_Height, m_Width;
+	int m_UniqueID;
+	int m_AttacheeUniqueID;
+};
+
+
+
+
 
 cMinecart::cMinecart(ePayload a_Payload, double a_X, double a_Y, double a_Z) :
 	super(etMinecart, a_X, a_Y, a_Z, 0.98, 0.7),
@@ -30,7 +94,7 @@ cMinecart::cMinecart(ePayload a_Payload, double a_X, double a_Y, double a_Z) :
 	SetMass(20.f);
 	SetMaxHealth(6);
 	SetHealth(6);
-	SetWidth(1.2);
+	SetWidth(1);
 	SetHeight(0.9);
 }
 
@@ -96,10 +160,17 @@ void cMinecart::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 		if (IsBlockRail(InsideType)) AddPosY(1); // Push cart upwards
 	}
 
+	bool WasDetectorRail = false;
 	if (IsBlockRail(InsideType))
 	{
-		bool WasDetectorRail = false;
-		SnapToRail(InsideMeta);
+		if (InsideType == E_BLOCK_RAIL)
+		{
+			SnapToRail(InsideMeta);
+		}
+		else
+		{
+			SnapToRail(InsideMeta & 0x07);
+		}
 
 		switch (InsideType)
 		{
@@ -116,12 +187,6 @@ void cMinecart::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 		}
 
 		AddPosition(GetSpeed() * (a_Dt / 1000)); // Commit changes; as we use our own engine when on rails, this needs to be done, whereas it is normally in Entity.cpp
-
-		if (m_bIsOnDetectorRail && !WasDetectorRail)
-		{
-			m_World->SetBlock(m_DetectorRailPosition.x, m_DetectorRailPosition.y, m_DetectorRailPosition.z, E_BLOCK_DETECTOR_RAIL, m_World->GetBlockMeta(m_DetectorRailPosition) & 0x07);
-			m_bIsOnDetectorRail = false;
-		}
 	}
 	else
 	{
@@ -129,6 +194,17 @@ void cMinecart::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 		SetPosY(floor(GetPosY()) + 0.35); // HandlePhysics overrides this if minecart can fall, else, it is to stop ground clipping minecart bottom when off-rail
 		super::HandlePhysics(a_Dt, *Chunk);
 	}
+
+	if (m_bIsOnDetectorRail && !Vector3i((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ())).Equals(m_DetectorRailPosition))
+	{
+		m_World->SetBlock(m_DetectorRailPosition.x, m_DetectorRailPosition.y, m_DetectorRailPosition.z, E_BLOCK_DETECTOR_RAIL, m_World->GetBlockMeta(m_DetectorRailPosition) & 0x07);
+		m_bIsOnDetectorRail = false;
+	}
+	else if (WasDetectorRail)
+	{
+		m_bIsOnDetectorRail = true;
+		m_DetectorRailPosition = Vector3i((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()));
+	}
 	
 	// Broadcast positioning changes to client
 	BroadcastMovementUpdate();
@@ -154,7 +230,9 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 			SetSpeedY(0); // Don't move vertically as on ground
 			SetSpeedX(0); // Correct diagonal movement from curved rails
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			// Execute both the entity and block collision checks
+			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
+			if (EntCol || BlckCol) return;
 			
 			if (GetSpeedZ() != 0) // Don't do anything if cart is stationary
 			{
@@ -178,7 +256,8 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 			SetSpeedY(0);
 			SetSpeedZ(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
+			if (EntCol || BlckCol) return;
 
 			if (GetSpeedX() != 0)
 			{
@@ -281,94 +360,46 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 		{
 			SetYaw(315); // Set correct rotation server side
 			SetPosY(floor(GetPosY()) + 0.55); // Levitate dat cart
+			SetSpeedY(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			TestBlockCollision(a_RailMeta);
+			TestEntityCollision(a_RailMeta);
+
+			// SnapToRail handles turning
 
-			if (GetSpeedZ() > 0) // Cart moving south
-			{
-				int OldX = (int)floor(GetPosX());
-				AddSpeedX(-GetSpeedZ() + 0.5); // See below
-				AddPosX(-GetSpeedZ() * (a_Dt / 1000)); // Diagonally move southwest (which will make cart hit a southwest rail)
-				// If we are already at southwest rail, set Z speed to zero as we can be moving so fast, MCS doesn't tick fast enough to active the handle for the rail...
-				// ...and so we derail unexpectedly.
-				if (GetPosX() <= OldX - 1) SetSpeedZ(0);
-			}
-			else if (GetSpeedX() > 0) // Cart moving east
-			{
-				int OldZ = (int)floor(GetPosZ());
-				AddSpeedZ(-GetSpeedX() + 0.5);
-				AddPosZ(-GetSpeedX() * (a_Dt / 1000)); // Diagonally move northeast
-				if (GetPosZ() <= OldZ - 1) SetSpeedX(0);
-			}
 			break;
 		}
 		case E_META_RAIL_CURVED_ZM_XP: // Curved NORTH EAST
 		{
 			SetYaw(225);
 			SetPosY(floor(GetPosY()) + 0.55);
+			SetSpeedY(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			TestBlockCollision(a_RailMeta);
+			TestEntityCollision(a_RailMeta);
 
-			if (GetSpeedZ() > 0)
-			{
-				int OldX = (int)floor(GetPosX());
-				AddSpeedX(GetSpeedZ() - 0.5);
-				AddPosX(GetSpeedZ() * (a_Dt / 1000));
-				if (GetPosX() >= OldX + 1) SetSpeedZ(0);
-			}
-			else if (GetSpeedX() < 0)
-			{
-				int OldZ = (int)floor(GetPosZ());
-				AddSpeedZ(GetSpeedX() + 0.5);
-				AddPosZ(GetSpeedX() * (a_Dt / 1000));
-				if (GetPosZ() <= OldZ - 1) SetSpeedX(0);
-			}
 			break;
 		}
 		case E_META_RAIL_CURVED_ZP_XM: // Curved SOUTH WEST
 		{
 			SetYaw(135);
 			SetPosY(floor(GetPosY()) + 0.55);
+			SetSpeedY(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			TestBlockCollision(a_RailMeta);
+			TestEntityCollision(a_RailMeta);
 
-			if (GetSpeedZ() < 0)
-			{
-				int OldX = (int)floor(GetPosX());
-				AddSpeedX(GetSpeedZ() + 0.5);
-				AddPosX(GetSpeedZ() * (a_Dt / 1000));
-				if (GetPosX() <= OldX - 1) SetSpeedZ(0);
-			}
-			else if (GetSpeedX() > 0)
-			{
-				int OldZ = (int)floor(GetPosZ());
-				AddSpeedZ(GetSpeedX() - 0.5);
-				AddPosZ(GetSpeedX() * (a_Dt / 1000));
-				if (GetPosZ() >= OldZ + 1) SetSpeedX(0);
-			}
 			break;
 		}
 		case E_META_RAIL_CURVED_ZP_XP: // Curved SOUTH EAST
 		{
 			SetYaw(45);
 			SetPosY(floor(GetPosY()) + 0.55);
+			SetSpeedY(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			TestBlockCollision(a_RailMeta);
+			TestEntityCollision(a_RailMeta);
 
-			if (GetSpeedZ() < 0)
-			{
-				int OldX = (int)floor(GetPosX());
-				AddSpeedX(-GetSpeedZ() - 0.5);
-				AddPosX(-GetSpeedZ() * (a_Dt / 1000));
-				if (GetPosX() >= OldX + 1) SetSpeedZ(0);
-			}
-			else if (GetSpeedX() < 0)
-			{
-				int OldZ = (int)floor(GetPosZ());
-				AddSpeedZ(-GetSpeedX() - 0.5);
-				AddPosZ(-GetSpeedX() * (a_Dt / 1000));
-				if (GetPosZ() >= OldZ + 1) SetSpeedX(0);
-			}
 			break;
 		}
 		default:
@@ -385,8 +416,8 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 {
 	// Initialise to 'slow down' values
-	int AccelDecelSpeed = -1;
-	int AccelDecelNegSpeed = 1;
+	int AccelDecelSpeed = -2;
+	int AccelDecelNegSpeed = 2;
 
 	if ((a_RailMeta & 0x8) == 0x8)
 	{
@@ -404,17 +435,18 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 			SetSpeedY(0);
 			SetSpeedX(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
+			if (EntCol || BlckCol) return;
 			
 			if (GetSpeedZ() != 0)
 			{
 				if (GetSpeedZ() > 0)
 				{
-					AddSpeedZ(AccelDecelNegSpeed);
+					AddSpeedZ(AccelDecelSpeed);
 				}
 				else
 				{
-					AddSpeedZ(AccelDecelSpeed);
+					AddSpeedZ(AccelDecelNegSpeed);
 				}
 			}
 			break;
@@ -426,7 +458,8 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 			SetSpeedY(0);
 			SetSpeedZ(0);
 
-			if (TestBlockCollision(a_RailMeta)) return;
+			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
+			if (EntCol || BlckCol) return;
 
 			if (GetSpeedX() != 0)
 			{
@@ -441,6 +474,87 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 			}
 			break;
 		}
+		case E_META_RAIL_ASCEND_XM: // ASCEND EAST
+		{
+			SetYaw(180);
+			SetSpeedZ(0);
+
+			if (GetSpeedX() >= 0)
+			{
+				if (GetSpeedX() <= MAX_SPEED)
+				{
+					AddSpeedX(AccelDecelSpeed);
+					SetSpeedY(-GetSpeedX());
+				}
+			}
+			else
+			{
+				AddSpeedX(AccelDecelNegSpeed);
+				SetSpeedY(-GetSpeedX());
+			}
+			break;
+		}		
+		case E_META_RAIL_ASCEND_XP: // ASCEND WEST
+		{
+			SetYaw(180);
+			SetSpeedZ(0);
+
+			if (GetSpeedX() > 0)
+			{
+				AddSpeedX(AccelDecelSpeed);
+				SetSpeedY(GetSpeedX());
+			}
+			else
+			{
+				if (GetSpeedX() >= MAX_SPEED_NEGATIVE)
+				{
+					AddSpeedX(AccelDecelNegSpeed);
+					SetSpeedY(GetSpeedX());
+				}
+			}
+			break;
+		}			
+		case E_META_RAIL_ASCEND_ZM: // ASCEND NORTH
+		{
+			SetYaw(270);
+			SetSpeedX(0);
+
+			if (GetSpeedZ() >= 0)
+			{
+				if (GetSpeedZ() <= MAX_SPEED)
+				{
+					AddSpeedZ(AccelDecelSpeed);
+					SetSpeedY(-GetSpeedZ());
+				}
+			}
+			else
+			{
+				AddSpeedZ(AccelDecelNegSpeed);
+				SetSpeedY(-GetSpeedZ());
+			}
+			break;
+		}
+		case E_META_RAIL_ASCEND_ZP: // ASCEND SOUTH
+		{
+			SetYaw(270);
+			SetSpeedX(0);
+
+			if (GetSpeedZ() > 0)
+			{
+				AddSpeedZ(AccelDecelSpeed);
+				SetSpeedY(GetSpeedZ());
+			}
+			else
+			{
+				if (GetSpeedZ() >= MAX_SPEED_NEGATIVE)
+				{
+					AddSpeedZ(AccelDecelNegSpeed);
+					SetSpeedY(GetSpeedZ());
+				}
+			}
+			break;
+		}
+		default: ASSERT(!"Unhandled powered rail metadata!"); break;
 	}
 }
 
@@ -450,11 +564,17 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 
 void cMinecart::HandleDetectorRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 {
-	m_bIsOnDetectorRail = true;
-	m_DetectorRailPosition = Vector3i((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()));
-
 	m_World->SetBlockMeta(m_DetectorRailPosition, a_RailMeta | 0x08);
 
+	// No special handling
+	HandleRailPhysics(a_RailMeta & 0x07, a_Dt);
+}
+
+
+
+
+void cMinecart::HandleActivatorRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
+{
 	HandleRailPhysics(a_RailMeta & 0x07, a_Dt);
 }
 
@@ -482,6 +602,107 @@ void cMinecart::SnapToRail(NIBBLETYPE a_RailMeta)
 			SetPosX(floor(GetPosX()) + 0.5);
 			break;
 		}
+		// Curved rail physics: once minecart has reached more than half of the block in the direction that it is travelling in, jerk it in the direction of curvature
+		case E_META_RAIL_CURVED_ZM_XM:
+		{
+			if (GetPosZ() > floor(GetPosZ()) + 0.5)
+			{
+				if (GetSpeedZ() > 0)
+				{
+					SetSpeedX(-GetSpeedZ() * 0.7);
+				}
+
+				SetSpeedZ(0);
+				SetPosZ(floor(GetPosZ()) + 0.5);
+			}
+			else if (GetPosX() > floor(GetPosX()) + 0.5)
+			{
+				if (GetSpeedX() > 0)
+				{
+					SetSpeedZ(-GetSpeedX() * 0.7);
+				}
+
+				SetSpeedX(0);
+				SetPosX(floor(GetPosX()) + 0.5);
+			}
+			SetSpeedY(0);
+			break;
+		}
+		case E_META_RAIL_CURVED_ZM_XP:
+		{
+			if (GetPosZ() > floor(GetPosZ()) + 0.5)
+			{
+				if (GetSpeedZ() > 0)
+				{
+					SetSpeedX(GetSpeedZ() * 0.7);
+				}
+
+				SetSpeedZ(0);
+				SetPosZ(floor(GetPosZ()) + 0.5);
+			}
+			else if (GetPosX() < floor(GetPosX()) + 0.5)
+			{
+				if (GetSpeedX() < 0)
+				{
+					SetSpeedZ(GetSpeedX() * 0.7);
+				}
+
+				SetSpeedX(0);
+				SetPosX(floor(GetPosX()) + 0.5);
+			}
+			SetSpeedY(0);
+			break;
+		}
+		case E_META_RAIL_CURVED_ZP_XM:
+		{
+			if (GetPosZ() < floor(GetPosZ()) + 0.5)
+			{
+				if (GetSpeedZ() < 0)
+				{
+					SetSpeedX(GetSpeedZ() * 0.7);
+				}
+
+				SetSpeedZ(0);
+				SetPosZ(floor(GetPosZ()) + 0.5);
+			}
+			else if (GetPosX() > floor(GetPosX()) + 0.5)
+			{
+				if (GetSpeedX() > 0)
+				{
+					SetSpeedZ(GetSpeedX() * 0.7);
+				}
+
+				SetSpeedX(0);
+				SetPosX(floor(GetPosX()) + 0.5);
+			}
+			SetSpeedY(0);
+			break;
+		}
+		case E_META_RAIL_CURVED_ZP_XP:
+		{
+			if (GetPosZ() < floor(GetPosZ()) + 0.5)
+			{
+				if (GetSpeedZ() < 0)
+				{
+					SetSpeedX(-GetSpeedZ() * 0.7);
+				}
+
+				SetSpeedZ(0);
+				SetPosZ(floor(GetPosZ()) + 0.5);
+			}
+			else if (GetPosX() < floor(GetPosX()) + 0.5)
+			{
+				if (GetSpeedX() < 0)
+				{
+					SetSpeedZ(-GetSpeedX() * 0.7);
+				}
+
+				SetSpeedX(0);
+				SetPosX(floor(GetPosX()) + 0.5);
+			}
+			SetSpeedY(0);
+			break;
+		}
 		default: break;
 	}
 }
@@ -499,7 +720,7 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 			if (GetSpeedZ() > 0)
 			{
 				BLOCKTYPE Block = m_World->GetBlock((int)floor(GetPosX()), (int)floor(GetPosY()), (int)ceil(GetPosZ()));
-				if (!IsBlockRail(Block) && g_BlockIsSolid[Block])
+				if (!IsBlockRail(Block) && cBlockInfo::IsSolid(Block))
 				{
 					// We could try to detect a block in front based purely on coordinates, but xoft made a bounding box system - why not use? :P
 					cBoundingBox bbBlock(Vector3d((int)floor(GetPosX()), (int)floor(GetPosY()), (int)ceil(GetPosZ())), 0.5, 1);
@@ -513,10 +734,10 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 					}
 				}
 			}
-			else
+			else if (GetSpeedZ() < 0)
 			{
 				BLOCKTYPE Block = m_World->GetBlock((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()) - 1);
-				if (!IsBlockRail(Block) && g_BlockIsSolid[Block])
+				if (!IsBlockRail(Block) && cBlockInfo::IsSolid(Block))
 				{
 					cBoundingBox bbBlock(Vector3d((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()) - 1), 0.5, 1);
 					cBoundingBox bbMinecart(Vector3d(GetPosX(), floor(GetPosY()), GetPosZ() - 1), GetWidth() / 2, GetHeight());
@@ -536,7 +757,7 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 			if (GetSpeedX() > 0)
 			{
 				BLOCKTYPE Block = m_World->GetBlock((int)ceil(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()));
-				if (!IsBlockRail(Block) && g_BlockIsSolid[Block])
+				if (!IsBlockRail(Block) && cBlockInfo::IsSolid(Block))
 				{
 					cBoundingBox bbBlock(Vector3d((int)ceil(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ())), 0.5, 1);
 					cBoundingBox bbMinecart(Vector3d(GetPosX(), floor(GetPosY()), GetPosZ()), GetWidth() / 2, GetHeight());
@@ -549,10 +770,10 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 					}
 				}
 			}
-			else
+			else if (GetSpeedX() < 0)
 			{
 				BLOCKTYPE Block = m_World->GetBlock((int)floor(GetPosX()) - 1, (int)floor(GetPosY()), (int)floor(GetPosZ()));
-				if (!IsBlockRail(Block) && g_BlockIsSolid[Block])
+				if (!IsBlockRail(Block) && cBlockInfo::IsSolid(Block))
 				{
 					cBoundingBox bbBlock(Vector3d((int)floor(GetPosX()) - 1, (int)floor(GetPosY()), (int)floor(GetPosZ())), 0.5, 1);
 					cBoundingBox bbMinecart(Vector3d(GetPosX() - 1, floor(GetPosY()), GetPosZ()), GetWidth() / 2, GetHeight());
@@ -577,10 +798,10 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 			BLOCKTYPE BlockZM = m_World->GetBlock((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()) + 1);
 			BLOCKTYPE BlockZP = m_World->GetBlock((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()) + 1);
 			if (
-				(!IsBlockRail(BlockXM) && g_BlockIsSolid[BlockXM]) ||
-				(!IsBlockRail(BlockXP) && g_BlockIsSolid[BlockXP]) ||
-				(!IsBlockRail(BlockZM) && g_BlockIsSolid[BlockZM]) ||
-				(!IsBlockRail(BlockZP) && g_BlockIsSolid[BlockZP])
+				(!IsBlockRail(BlockXM) && cBlockInfo::IsSolid(BlockXM)) ||
+				(!IsBlockRail(BlockXP) && cBlockInfo::IsSolid(BlockXP)) ||
+				(!IsBlockRail(BlockZM) && cBlockInfo::IsSolid(BlockZM)) ||
+				(!IsBlockRail(BlockZP) && cBlockInfo::IsSolid(BlockZP))
 				)
 			{
 				SetSpeed(0, 0, 0);
@@ -597,10 +818,93 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 
 
 
+bool cMinecart::TestEntityCollision(NIBBLETYPE a_RailMeta)
+{
+	cMinecartCollisionCallback MinecartCollisionCallback(GetPosition(), GetHeight(), GetWidth(), GetUniqueID(), ((m_Attachee == NULL) ? -1 : m_Attachee->GetUniqueID()));
+	int ChunkX, ChunkZ;
+	cChunkDef::BlockToChunk((int)floor(GetPosX()), (int)floor(GetPosZ()), ChunkX, ChunkZ);
+	m_World->ForEachEntityInChunk(ChunkX, ChunkZ, MinecartCollisionCallback);
+
+	if (!MinecartCollisionCallback.FoundIntersection())
+	{
+		return false;
+	}
+
+	switch (a_RailMeta)
+	{
+		case E_META_RAIL_ZM_ZP:
+		{
+			if (MinecartCollisionCallback.GetCollidedEntityPosition().z >= GetPosZ())
+			{
+				if ((-GetSpeedZ() * 0.4) < 0.01)
+				{
+					AddSpeedZ(-4);
+				}
+				else
+				{
+					SetSpeedZ(-GetSpeedZ() * 0.4);
+				}
+			}
+			else
+			{
+				if ((GetSpeedZ() * 0.4) < 0.01)
+				{
+					AddSpeedZ(4);
+				}
+				else
+				{
+					SetSpeedZ(GetSpeedZ() * 0.4);
+				}
+			}
+			return true;
+		}
+		case E_META_RAIL_XM_XP:
+		{
+			if (MinecartCollisionCallback.GetCollidedEntityPosition().x >= GetPosX())
+			{
+				if ((-GetSpeedX() * 0.4) < 0.01)
+				{
+					AddSpeedX(-4);
+				}
+				else
+				{
+					SetSpeedX(-GetSpeedX() * 0.4);
+				}
+			}
+			else
+			{
+				if ((GetSpeedX() * 0.4) < 0.01)
+				{
+					AddSpeedX(4);
+				}
+				else
+				{
+					SetSpeedX(GetSpeedX() * 0.4);
+				}
+			}
+			return true;
+		}			
+		case E_META_RAIL_CURVED_ZM_XM:
+		case E_META_RAIL_CURVED_ZM_XP:
+		case E_META_RAIL_CURVED_ZP_XM:
+		case E_META_RAIL_CURVED_ZP_XP:
+		{
+			// TODO - simply can't be bothered right now
+			break;
+		}
+		default: break;
+	}
+
+	return false;
+}
+
+
+
+
 
 void cMinecart::DoTakeDamage(TakeDamageInfo & TDI)
 {
-	if (TDI.Attacker->IsPlayer() && ((cPlayer *)TDI.Attacker)->IsGameModeCreative())
+	if ((TDI.Attacker != NULL) && TDI.Attacker->IsPlayer() && ((cPlayer *)TDI.Attacker)->IsGameModeCreative())
 	{
 		Destroy();
 		TDI.FinalDamage = GetMaxHealth(); // Instant hit for creative
@@ -727,9 +1031,9 @@ cMinecartWithChest::cMinecartWithChest(double a_X, double a_Y, double a_Z) :
 
 
 
-void cMinecartWithChest::SetSlot(int a_Idx, const cItem & a_Item)
+void cMinecartWithChest::SetSlot(size_t a_Idx, const cItem & a_Item)
 {
-	ASSERT((a_Idx >= 0) && (a_Idx < ARRAYCOUNT(m_Items)));
+	ASSERT(a_Idx < ARRAYCOUNT(m_Items));
 	
 	m_Items[a_Idx] = a_Item;
 }
@@ -753,8 +1057,8 @@ void cMinecartWithChest::OnRightClicked(cPlayer & a_Player)
 
 cMinecartWithFurnace::cMinecartWithFurnace(double a_X, double a_Y, double a_Z) :
 	super(mpFurnace, a_X, a_Y, a_Z),
-	m_IsFueled(false),
-	m_FueledTimeLeft(-1)
+	m_FueledTimeLeft(-1),
+	m_IsFueled(false)
 {
 }
 
@@ -833,4 +1137,4 @@ cMinecartWithHopper::cMinecartWithHopper(double a_X, double a_Y, double a_Z) :
 }
 
 // TODO: Make it suck up blocks and travel further than any other cart and physics and put and take blocks
-// AND AVARYTHING!!
\ No newline at end of file
+// AND AVARYTHING!!
diff --git a/src/Entities/Minecart.h b/src/Entities/Minecart.h
index 874d0204e..ebdb576e0 100644
--- a/src/Entities/Minecart.h
+++ b/src/Entities/Minecart.h
@@ -15,20 +15,6 @@
 
 
 
-inline bool IsBlockRail(BLOCKTYPE a_BlockType)
-	{
-		return (
-			(a_BlockType == E_BLOCK_RAIL) ||
-			(a_BlockType == E_BLOCK_ACTIVATOR_RAIL) ||
-			(a_BlockType == E_BLOCK_DETECTOR_RAIL) ||
-			(a_BlockType == E_BLOCK_POWERED_RAIL)
-			) ;
-	}
-
-
-
-
-
 class cMinecart :
 	public cEntity
 {
@@ -79,10 +65,16 @@ protected:
 	*/
 	void HandleDetectorRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt);
 
-	/** Snaps a minecart to a rail's axis, resetting its speed */
+	/** Handles activator rails - placeholder for future implementation */
+	void HandleActivatorRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt);
+
+	/** Snaps a mincecart to a rail's axis, resetting its speed
+		For curved rails, it changes the cart's direction as well as snapping it to axis */
 	void SnapToRail(NIBBLETYPE a_RailMeta);
-	/** Tests is a solid block is in front of a cart, and stops the cart (and returns true) if so; returns false if no obstruction*/
+	/** Tests if a solid block is in front of a cart, and stops the cart (and returns true) if so; returns false if no obstruction */
 	bool TestBlockCollision(NIBBLETYPE a_RailMeta);
+	/** Tests if this mincecart's bounding box is intersecting another entity's bounding box (collision) and pushes mincecart away */
+	bool TestEntityCollision(NIBBLETYPE a_RailMeta);
 
 } ;
 
@@ -130,7 +122,7 @@ public:
 	const cItem & GetSlot(int a_Idx) const { return m_Items[a_Idx]; }
 	cItem &       GetSlot(int a_Idx)       { return m_Items[a_Idx]; }
 	
-	void SetSlot(int a_Idx, const cItem & a_Item);
+	void SetSlot(size_t a_Idx, const cItem & a_Item);
 
 protected:
 
@@ -201,4 +193,4 @@ public:
 	CLASS_PROTODEF(cMinecartWithHopper);
 	
 	cMinecartWithHopper(double a_X, double a_Y, double a_Z);
-} ;
\ No newline at end of file
+} ;
diff --git a/src/Entities/Painting.cpp b/src/Entities/Painting.cpp
new file mode 100644
index 000000000..e217556c7
--- /dev/null
+++ b/src/Entities/Painting.cpp
@@ -0,0 +1,54 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "Painting.h"
+#include "ClientHandle.h"
+#include "Player.h"
+#include "../Chunk.h"
+
+
+
+
+
+cPainting::cPainting(const AString & a_Name, int a_Direction, double a_X, double a_Y, double a_Z)
+	: cEntity(etPainting, a_X, a_Y, a_Z, 1, 1),
+	m_Name(a_Name),
+	m_Direction(a_Direction)
+{
+}
+
+
+
+
+
+
+void cPainting::SpawnOn(cClientHandle & a_Client)
+{
+	a_Client.SendPaintingSpawn(*this);
+}
+
+
+
+
+
+void cPainting::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	UNUSED(a_Dt);
+	UNUSED(a_Chunk);
+}
+
+
+
+
+
+void cPainting::GetDrops(cItems & a_Items, cEntity * a_Killer)
+{
+	if ((a_Killer != NULL) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
+	{
+		a_Items.push_back(cItem(E_ITEM_PAINTING));
+	}
+}
+
+
+
+
diff --git a/src/Entities/Painting.h b/src/Entities/Painting.h
new file mode 100644
index 000000000..c1024bd1b
--- /dev/null
+++ b/src/Entities/Painting.h
@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include "Entity.h"
+
+
+
+
+
+// tolua_begin
+class cPainting :
+	public cEntity
+{
+	// tolua_end
+	typedef cEntity super;
+
+public:
+	CLASS_PROTODEF(cPainting);
+
+	cPainting(const AString & a_Name, int a_Direction, double a_X, double a_Y, double a_Z);
+	const AString & GetName(void) const { return m_Name; } // tolua_export
+	int GetDirection(void) const { return m_Direction; } // tolua_export
+
+private:
+
+	virtual void SpawnOn(cClientHandle & a_Client) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+	virtual void GetDrops(cItems & a_Items, cEntity * a_Killer) override;
+	virtual void KilledBy(cEntity * a_Killer) override
+	{
+		super::KilledBy(a_Killer);
+		Destroy();
+	}
+
+	AString m_Name;
+	int m_Direction;
+
+};  // tolua_export
+
+
+
+
diff --git a/src/Entities/Pickup.cpp b/src/Entities/Pickup.cpp
index 001e386a7..7fc89b62b 100644
--- a/src/Entities/Pickup.cpp
+++ b/src/Entities/Pickup.cpp
@@ -6,19 +6,58 @@
 #endif
 
 #include "Pickup.h"
+#include "Player.h"
 #include "../ClientHandle.h"
-#include "../Inventory.h"
 #include "../World.h"
-#include "../Simulator/FluidSimulator.h"
 #include "../Server.h"
-#include "Player.h"
 #include "../Bindings/PluginManager.h"
-#include "../Item.h"
 #include "../Root.h"
 #include "../Chunk.h"
 
-#include "../Vector3d.h"
-#include "../Vector3f.h"
+
+
+
+class cPickupCombiningCallback :
+	public cEntityCallback
+{
+public:
+	cPickupCombiningCallback(Vector3d a_Position, cPickup * a_Pickup) :
+		m_FoundMatchingPickup(false),
+		m_Position(a_Position),
+		m_Pickup(a_Pickup)
+	{
+	}
+
+	virtual bool Item(cEntity * a_Entity) override
+	{
+		if (!a_Entity->IsPickup() || (a_Entity->GetUniqueID() == m_Pickup->GetUniqueID()) || a_Entity->IsDestroyed())
+		{
+			return false;
+		}
+
+		Vector3d EntityPos = a_Entity->GetPosition();
+		double Distance = (EntityPos - m_Position).Length();
+
+		if ((Distance < 1.2) && ((cPickup *)a_Entity)->GetItem().IsEqual(m_Pickup->GetItem()))
+		{
+			m_Pickup->GetItem().AddCount(((cPickup *)a_Entity)->GetItem().m_ItemCount);
+			a_Entity->Destroy();
+			m_FoundMatchingPickup = true;
+		}
+		return false;
+	}
+
+	inline bool FoundMatchingPickup()
+	{
+		return m_FoundMatchingPickup;
+	}
+
+protected:
+	bool m_FoundMatchingPickup;
+
+	Vector3d m_Position;
+	cPickup * m_Pickup;
+};
 
 
 
@@ -26,10 +65,10 @@
 
 cPickup::cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */)
 	:	cEntity(etPickup, a_PosX, a_PosY, a_PosZ, 0.2, 0.2)
-	, m_Timer( 0.f )
+	, m_Timer(0.f)
 	, m_Item(a_Item)
-	, m_bCollected( false )
-	, m_bIsPlayerCreated( IsPlayerCreated )
+	, m_bCollected(false)
+	, m_bIsPlayerCreated(IsPlayerCreated)
 {
 	SetGravity(-10.5f);
 	SetMaxHealth(5);
@@ -43,7 +82,7 @@ cPickup::cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_It
 
 void cPickup::SpawnOn(cClientHandle & a_Client)
 {
-	a_Client.SendPickupSpawn(*this);	
+	a_Client.SendPickupSpawn(*this);
 }
 
 
@@ -89,6 +128,16 @@ void cPickup::Tick(float a_Dt, cChunk & a_Chunk)
 						return;
 					}
 				}
+
+				if (!IsDestroyed()) // Don't try to combine if someone has tried to combine me
+				{
+					cPickupCombiningCallback PickupCombiningCallback(GetPosition(), this);
+					m_World->ForEachEntity(PickupCombiningCallback); // Not ForEachEntityInChunk, otherwise pickups don't combine across chunk boundaries
+					if (PickupCombiningCallback.FoundMatchingPickup())
+					{
+						m_World->BroadcastEntityMetadata(*this);
+					}
+				}
 			}
 		}
 	}
diff --git a/src/Entities/Pickup.h b/src/Entities/Pickup.h
index d39eda298..74b917bce 100644
--- a/src/Entities/Pickup.h
+++ b/src/Entities/Pickup.h
@@ -18,38 +18,42 @@ class cPlayer;
 class cPickup :
 	public cEntity
 {
-	// tolua_end
 	typedef cEntity super;
 	
 public:
+	// tolua_end
+
 	CLASS_PROTODEF(cPickup);
 
-	cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f);	// tolua_export
-	
-	cItem &       GetItem(void)       {return m_Item; }								// tolua_export
+	cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f);
+
+	cItem &       GetItem(void)       {return m_Item; } // tolua_export
 	const cItem & GetItem(void) const {return m_Item; }
 
 	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
-	
+
 	bool CollectedBy(cPlayer * a_Dest);					// tolua_export
 
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
-	
-	/// Returns the number of ticks that this entity has existed
-	int GetAge(void) const { return (int)(m_Timer / 50); }  // tolua_export
-	
-	/// Returns true if the pickup has already been collected
+
+	/** Returns the number of ticks that this entity has existed */
+	int GetAge(void) const { return (int)(m_Timer / 50); }     // tolua_export
+
+	/** Set the number of ticks that this entity has existed */
+	void SetAge(int a_Age) { m_Timer = (float)(a_Age * 50); }  // tolua_export
+
+	/** Returns true if the pickup has already been collected */
 	bool IsCollected(void) const { return m_bCollected; }  // tolua_export
 
-	/// Returns true if created by player (i.e. vomiting), used for determining picking-up delay time
+	/** Returns true if created by player (i.e. vomiting), used for determining picking-up delay time */
 	bool IsPlayerCreated(void) const { return m_bIsPlayerCreated; } // tolua_export
-	
+
 private:
 	Vector3d   m_ResultingSpeed;	 //Can be used to modify the resulting speed for the current tick ;)
 
 	Vector3d   m_WaterSpeed;
 
-	/// The number of ticks that the entity has existed / timer between collect and destroy; in msec
+	/** The number of ticks that the entity has existed / timer between collect and destroy; in msec */
 	float m_Timer;
 
 	cItem m_Item;
diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp
index c1f2456eb..7f2e5b4c2 100644
--- a/src/Entities/Player.cpp
+++ b/src/Entities/Player.cpp
@@ -3,32 +3,22 @@
 
 #include "Player.h"
 #include "../Server.h"
-#include "../ClientHandle.h"
 #include "../UI/Window.h"
 #include "../UI/WindowOwner.h"
 #include "../World.h"
-#include "Pickup.h"
 #include "../Bindings/PluginManager.h"
 #include "../BlockEntities/BlockEntity.h"
 #include "../GroupManager.h"
 #include "../Group.h"
-#include "../ChatColor.h"
-#include "../Item.h"
-#include "../Tracer.h"
 #include "../Root.h"
 #include "../OSSupport/Timer.h"
-#include "../MersenneTwister.h"
 #include "../Chunk.h"
 #include "../Items/ItemHandler.h"
-
-#include "../Vector3d.h"
-#include "../Vector3f.h"
+#include "../Vector3.h"
 
 #include "inifile/iniFile.h"
 #include "json/json.h"
 
-#define float2int(x) ((x)<0 ? ((int)(x))-1 : (int)(x))
-
 
 
 
@@ -36,8 +26,6 @@
 
 cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
 	: super(etPlayer, 0.6, 1.8)
-	, m_AirLevel( MAX_AIR_LEVEL )
-	, m_AirTickTimer(DROWNING_TICKS)
 	, m_bVisible(true)
 	, m_FoodLevel(MAX_FOOD_LEVEL)
 	, m_FoodSaturationLevel(5)
@@ -51,15 +39,13 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
 	, m_Inventory(*this)
 	, m_CurrentWindow(NULL)
 	, m_InventoryWindow(NULL)
-	, m_TimeLastPickupCheck(0.f)
 	, m_Color('-')
-	, m_LastBlockActionTime(0)
-	, m_LastBlockActionCnt(0)
 	, m_GameMode(eGameMode_NotSet)
 	, m_IP("")
 	, m_ClientHandle(a_Client)
-	, m_NormalMaxSpeed(0.1)
-	, m_SprintingMaxSpeed(0.13)
+	, m_NormalMaxSpeed(1.0)
+	, m_SprintingMaxSpeed(1.3)
+	, m_FlyingMaxSpeed(1.0)
 	, m_IsCrouched(false)
 	, m_IsSprinting(false)
 	, m_IsFlying(false)
@@ -74,6 +60,7 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
 	, m_IsChargingBow(false)
 	, m_BowCharge(0)
 	, m_FloaterID(-1)
+	, m_Team(NULL)
 {
 	LOGD("Created a player object for \"%s\" @ \"%s\" at %p, ID %d", 
 		a_PlayerName.c_str(), a_Client->GetIPString().c_str(),
@@ -91,7 +78,6 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
 	m_LastPlayerListTime = t1.GetNowTime();
 
 	m_TimeLastTeleportPacket = 0;
-	m_TimeLastPickupCheck = 0;
 	
 	m_PlayerName = a_PlayerName;
 	m_bDirtyPosition = true; // So chunks are streamed to player at spawn
@@ -107,9 +93,23 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
 			a_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ()
 		);
 	}
+
 	m_LastJumpHeight = (float)(GetPosY());
 	m_LastGroundHeight = (float)(GetPosY());
 	m_Stance = GetPosY() + 1.62;
+
+	if (m_GameMode == gmNotSet)
+	{
+		cWorld * World = cRoot::Get()->GetWorld(GetLoadedWorldName());
+		if (World == NULL)
+		{
+			World = cRoot::Get()->GetDefaultWorld();
+		}
+		if (World->IsGameModeCreative())
+		{
+			m_CanFly = true;
+		}
+	}
 	
 	cRoot::Get()->GetServer()->PlayerCreated(this);
 }
@@ -120,7 +120,13 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
 
 cPlayer::~cPlayer(void)
 {
-	LOGD("Deleting cPlayer \"%s\" at %p, ID %d", m_PlayerName.c_str(), this, GetUniqueID());
+	if (!cRoot::Get()->GetPluginManager()->CallHookPlayerDestroyed(*this))
+	{
+		cRoot::Get()->BroadcastChatLeave(Printf("%s has left the game", GetName().c_str()));
+		LOGINFO("Player %s has left the game.", GetName().c_str());
+	}
+
+	LOGD("Deleting cPlayer \"%s\" at %p, ID %d", GetName().c_str(), this, GetUniqueID());
 	
 	// Notify the server that the player is being destroyed
 	cRoot::Get()->GetServer()->PlayerDestroying(this);
@@ -196,12 +202,6 @@ void cPlayer::Tick(float a_Dt, cChunk & a_Chunk)
 	
 	super::Tick(a_Dt, a_Chunk);
 	
-	// Set player swimming state
-	SetSwimState(a_Chunk);
-
-	// Handle air drowning stuff
-	HandleAir();
-	
 	// Handle charging the bow:
 	if (m_IsChargingBow)
 	{
@@ -245,6 +245,9 @@ void cPlayer::Tick(float a_Dt, cChunk & a_Chunk)
 		HandleFloater();
 	}
 
+	// Update items (e.g. Maps)
+	m_Inventory.UpdateItems();
+
 	// Send Player List (Once per m_LastPlayerListTime/1000 ms)
 	cTimer t1;
 	if (m_LastPlayerListTime + cPlayer::PLAYER_LIST_TIME_MS <= t1.GetNowTime())
@@ -434,7 +437,7 @@ void cPlayer::SetTouchGround(bool a_bTouchGround)
 		cWorld * World = GetWorld();
 		if ((GetPosY() >= 0) && (GetPosY() < cChunkDef::Height))
 		{
-			BLOCKTYPE BlockType = World->GetBlock(float2int(GetPosX()), float2int(GetPosY()), float2int(GetPosZ()));
+			BLOCKTYPE BlockType = World->GetBlock((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()));
 			if (BlockType != E_BLOCK_AIR)
 			{
 				m_bTouchGround = true;
@@ -459,12 +462,10 @@ void cPlayer::SetTouchGround(bool a_bTouchGround)
 
 		if (Damage > 0)
 		{
-			if (!IsGameModeCreative())
-			{
-				TakeDamage(dtFalling, NULL, Damage, Damage, 0);
-			}
+			// cPlayer makes sure damage isn't applied in creative, no need to check here
+			TakeDamage(dtFalling, NULL, Damage, Damage, 0);
 			
-			// Mojang uses floor() to get X and Z positions, instead of just casting it to an (int)
+			// Fall particles
 			GetWorld()->BroadcastSoundParticleEffect(2006, (int)floor(GetPosX()), (int)GetPosY() - 1, (int)floor(GetPosZ()), Damage /* Used as particle effect speed modifier */);
 		}		
 
@@ -684,7 +685,21 @@ const cSlotNums & cPlayer::GetInventoryPaintSlots(void) const
 
 double cPlayer::GetMaxSpeed(void) const
 {
-	return m_IsSprinting ? m_SprintingMaxSpeed : m_NormalMaxSpeed;
+	if (m_IsFlying)
+	{
+		return m_FlyingMaxSpeed;
+	}
+	else
+	{
+		if (m_IsSprinting)
+		{
+			return m_SprintingMaxSpeed;
+		}
+		else
+		{
+			return m_NormalMaxSpeed;
+		}
+	}
 }
 
 
@@ -694,7 +709,7 @@ double cPlayer::GetMaxSpeed(void) const
 void cPlayer::SetNormalMaxSpeed(double a_Speed)
 {
 	m_NormalMaxSpeed = a_Speed;
-	if (!m_IsSprinting)
+	if (!m_IsSprinting && !m_IsFlying)
 	{
 		m_ClientHandle->SendPlayerMaxSpeed();
 	}
@@ -707,7 +722,7 @@ void cPlayer::SetNormalMaxSpeed(double a_Speed)
 void cPlayer::SetSprintingMaxSpeed(double a_Speed)
 {
 	m_SprintingMaxSpeed = a_Speed;
-	if (m_IsSprinting)
+	if (m_IsSprinting && !m_IsFlying)
 	{
 		m_ClientHandle->SendPlayerMaxSpeed();
 	}
@@ -717,6 +732,18 @@ void cPlayer::SetSprintingMaxSpeed(double a_Speed)
 
 
 
+void cPlayer::SetFlyingMaxSpeed(double a_Speed)
+{
+	m_FlyingMaxSpeed = a_Speed;
+	
+	// Update the flying speed, always:
+	m_ClientHandle->SendPlayerAbilities();
+}
+
+
+
+
+
 void cPlayer::SetCrouch(bool a_IsCrouched)
 {
 	// Set the crouch status, broadcast to all visible players
@@ -782,14 +809,28 @@ void cPlayer::SetFlying(bool a_IsFlying)
 
 void cPlayer::DoTakeDamage(TakeDamageInfo & a_TDI)
 {
-	if (a_TDI.DamageType != dtInVoid)
+	if ((a_TDI.DamageType != dtInVoid) && (a_TDI.DamageType != dtPlugin))
 	{
 		if (IsGameModeCreative())
 		{
-			// No damage / health in creative mode
+			// No damage / health in creative mode if not void or plugin damage
 			return;
 		}
 	}
+
+	if ((a_TDI.Attacker != NULL) && (a_TDI.Attacker->IsPlayer()))
+	{
+		cPlayer* Attacker = (cPlayer*) a_TDI.Attacker;
+
+		if ((m_Team != NULL) && (m_Team == Attacker->m_Team))
+		{
+			if (!m_Team->AllowsFriendlyFire())
+			{
+				// Friendly fire is disabled
+				return;
+			}
+		}
+	}
 	
 	super::DoTakeDamage(a_TDI);
 	
@@ -818,24 +859,34 @@ void cPlayer::KilledBy(cEntity * a_Killer)
 	cItems Pickups;
 	m_Inventory.CopyToItems(Pickups);
 	m_Inventory.Clear();
+
+	if (GetName() == "Notch")
+	{
+		Pickups.Add(cItem(E_ITEM_RED_APPLE));
+	}
+
 	m_World->SpawnItemPickups(Pickups, GetPosX(), GetPosY(), GetPosZ(), 10);
 	SaveToDisk();  // Save it, yeah the world is a tough place !
 
 	if (a_Killer == NULL)
 	{
-		GetWorld()->BroadcastChat(Printf("%s[DEATH] %s%s was killed by environmental damage", cChatColor::Red.c_str(), cChatColor::White.c_str(), GetName().c_str()));
+		GetWorld()->BroadcastChatDeath(Printf("%s was killed by environmental damage", GetName().c_str()));
 	}
 	else if (a_Killer->IsPlayer())
 	{
-		GetWorld()->BroadcastChat(Printf("%s[DEATH] %s%s was killed by %s", cChatColor::Red.c_str(), cChatColor::White.c_str(), GetName().c_str(), ((cPlayer *)a_Killer)->GetName().c_str()));
+		GetWorld()->BroadcastChatDeath(Printf("%s was killed by %s", GetName().c_str(), ((cPlayer *)a_Killer)->GetName().c_str()));
+
+		m_World->GetScoreBoard().AddPlayerScore(((cPlayer *)a_Killer)->GetName(), cObjective::otPlayerKillCount, 1);
 	}
 	else
 	{
 		AString KillerClass = a_Killer->GetClass();
 		KillerClass.erase(KillerClass.begin()); // Erase the 'c' of the class (e.g. "cWitch" -> "Witch")
 
-		GetWorld()->BroadcastChat(Printf("%s[DEATH] %s%s was killed by a %s", cChatColor::Red.c_str(), cChatColor::White.c_str(), GetName().c_str(), KillerClass.c_str()));
+		GetWorld()->BroadcastChatDeath(Printf("%s was killed by a %s", GetName().c_str(), KillerClass.c_str()));
 	}
+
+	m_World->GetScoreBoard().AddPlayerScore(GetName(), cObjective::otDeathCount, 1);
 }
 
 
@@ -916,6 +967,50 @@ bool cPlayer::IsGameModeAdventure(void) const
 
 
 
+void cPlayer::SetTeam(cTeam * a_Team)
+{
+	if (m_Team == a_Team)
+	{
+		return;
+	}
+
+	if (m_Team)
+	{
+		m_Team->RemovePlayer(GetName());
+	}
+
+	m_Team = a_Team;
+
+	if (m_Team)
+	{
+		m_Team->AddPlayer(GetName());
+	}
+}
+
+
+
+
+
+cTeam * cPlayer::UpdateTeam(void)
+{
+	if (m_World == NULL)
+	{
+		SetTeam(NULL);
+	}
+	else
+	{
+		cScoreboard & Scoreboard = m_World->GetScoreBoard();
+
+		SetTeam(Scoreboard.QueryPlayerTeam(GetName()));
+	}
+
+	return m_Team;
+}
+
+
+
+
+
 void cPlayer::OpenWindow(cWindow * a_Window)
 {
 	if (a_Window != m_CurrentWindow)
@@ -969,27 +1064,6 @@ void cPlayer::CloseWindowIfID(char a_WindowID, bool a_CanRefuse)
 
 
 
-void cPlayer::SetLastBlockActionTime()
-{
-	if (m_World != NULL)
-	{
-		m_LastBlockActionTime = m_World->GetWorldAge() / 20.0f;
-	}
-}
-
-
-
-
-
-void cPlayer::SetLastBlockActionCnt( int a_LastBlockActionCnt )
-{
-	m_LastBlockActionCnt = a_LastBlockActionCnt;
-}
-
-
-
-
-
 void cPlayer::SetGameMode(eGameMode a_GameMode)
 {
 	if ((a_GameMode < gmMin) || (a_GameMode >= gmMax))
@@ -1036,21 +1110,24 @@ void cPlayer::SetIP(const AString & a_IP)
 
 
 
-void cPlayer::SendMessage(const AString & a_Message)
+void cPlayer::TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ)
 {
-	m_ClientHandle->SendChat(a_Message);
+	SetPosition(a_PosX, a_PosY, a_PosZ);
+	m_LastGroundHeight = (float)a_PosY;
+	m_LastJumpHeight = (float)a_PosY;
+
+	m_World->BroadcastTeleportEntity(*this, GetClientHandle());
+	m_ClientHandle->SendPlayerMoveLook();
 }
 
 
 
 
 
-void cPlayer::TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ)
+void cPlayer::SendRotation(double a_YawDegrees, double a_PitchDegrees)
 {
-	SetPosition( a_PosX, a_PosY, a_PosZ );
-	m_LastGroundHeight = (float)a_PosY;
-
-	m_World->BroadcastTeleportEntity(*this, GetClientHandle());
+	SetYaw(a_YawDegrees);
+	SetPitch(a_PitchDegrees);
 	m_ClientHandle->SendPlayerMoveLook();
 }
 
@@ -1186,19 +1263,6 @@ void cPlayer::RemoveFromGroup( const AString & a_GroupName )
 
 
 
-bool cPlayer::CanUseCommand( const AString & a_Command )
-{
-	for( GroupList::iterator itr = m_Groups.begin(); itr != m_Groups.end(); ++itr )
-	{
-		if( (*itr)->HasCommand( a_Command ) ) return true;
-	}
-	return false;
-}
-
-
-
-
-
 bool cPlayer::HasPermission(const AString & a_Permission)
 {
 	if (a_Permission.empty())
@@ -1342,59 +1406,68 @@ AString cPlayer::GetColor(void) const
 
 
 
-void cPlayer::TossItem(
-	bool a_bDraggingItem,
-	char a_Amount /* = 1 */,
-	short a_CreateType /* = 0 */,
-	short a_CreateHealth /* = 0 */ 
-)
+void cPlayer::TossEquippedItem(char a_Amount)
 {
 	cItems Drops;
-	if (a_CreateType != 0)
+	cItem DroppedItem(GetInventory().GetEquippedItem());
+	if (!DroppedItem.IsEmpty())
 	{
-		// Just create item without touching the inventory (used in creative mode)
-		Drops.push_back(cItem(a_CreateType, a_Amount, a_CreateHealth));
+		char NewAmount = a_Amount;
+		if (NewAmount > GetInventory().GetEquippedItem().m_ItemCount)
+		{
+			NewAmount = GetInventory().GetEquippedItem().m_ItemCount; // Drop only what's there
+		}
+
+		GetInventory().GetHotbarGrid().ChangeSlotCount(GetInventory().GetEquippedSlotNum() /* Returns hotbar subslot, which HotbarGrid takes */, -a_Amount);
+
+		DroppedItem.m_ItemCount = NewAmount;
+		Drops.push_back(DroppedItem);
 	}
-	else
+
+	double vX = 0, vY = 0, vZ = 0;
+	EulerToVector(-GetYaw(), GetPitch(), vZ, vX, vY);
+	vY = -vY * 2 + 1.f;
+	m_World->SpawnItemPickups(Drops, GetPosX(), GetEyeHeight(), GetPosZ(), vX * 3, vY * 3, vZ * 3, true); // 'true' because created by player
+}
+
+
+
+
+
+void cPlayer::TossHeldItem(char a_Amount)
+{
+	cItems Drops;
+	cItem & Item = GetDraggingItem();
+	if (!Item.IsEmpty())
 	{
-		// Drop an item from the inventory:
-		if (a_bDraggingItem)
+		char OriginalItemAmount = Item.m_ItemCount;
+		Item.m_ItemCount = std::min(OriginalItemAmount, a_Amount);
+		Drops.push_back(Item);
+		if (OriginalItemAmount > a_Amount)
 		{
-			cItem & Item = GetDraggingItem();
-			if (!Item.IsEmpty())
-			{
-				char OriginalItemAmount = Item.m_ItemCount;
-				Item.m_ItemCount = std::min(OriginalItemAmount, a_Amount);
-				Drops.push_back(Item);
-				if (OriginalItemAmount > a_Amount)
-				{
-					Item.m_ItemCount = OriginalItemAmount - (char)a_Amount;
-				}
-				else
-				{
-					Item.Empty();
-				}
-			}
+			Item.m_ItemCount = OriginalItemAmount - a_Amount;
 		}
 		else
 		{
-			// Else drop equipped item
-			cItem DroppedItem(GetInventory().GetEquippedItem());
-			if (!DroppedItem.IsEmpty())
-			{
-				char NewAmount = a_Amount;
-				if (NewAmount > GetInventory().GetEquippedItem().m_ItemCount)
-				{
-					NewAmount = GetInventory().GetEquippedItem().m_ItemCount; // Drop only what's there
-				}
-
-				GetInventory().GetHotbarGrid().ChangeSlotCount(GetInventory().GetEquippedSlotNum() /* Returns hotbar subslot, which HotbarGrid takes */, -a_Amount);
-
-				DroppedItem.m_ItemCount = NewAmount;
-				Drops.push_back(DroppedItem);
-			}
+			Item.Empty();
 		}
 	}
+
+	double vX = 0, vY = 0, vZ = 0;
+	EulerToVector(-GetYaw(), GetPitch(), vZ, vX, vY);
+	vY = -vY * 2 + 1.f;
+	m_World->SpawnItemPickups(Drops, GetPosX(), GetEyeHeight(), GetPosZ(), vX * 3, vY * 3, vZ * 3, true); // 'true' because created by player
+}
+
+
+
+
+
+void cPlayer::TossPickup(const cItem & a_Item)
+{
+	cItems Drops;
+	Drops.push_back(a_Item);
+
 	double vX = 0, vY = 0, vZ = 0;
 	EulerToVector(-GetYaw(), GetPitch(), vZ, vX, vY);
 	vY = -vY * 2 + 1.f;
@@ -1427,6 +1500,7 @@ bool cPlayer::MoveToWorld(const char * a_WorldName)
 
 	// Add player to all the necessary parts of the new world
 	SetWorld(World);
+	m_ClientHandle->StreamChunks();
 	World->AddEntity(this);
 	World->AddPlayer(this);
 
@@ -1448,10 +1522,14 @@ void cPlayer::LoadPermissionsFromDisk()
 		std::string Groups = IniFile.GetValue(m_PlayerName, "Groups", "");
 		if (!Groups.empty())
 		{
-			AStringVector Split = StringSplit( Groups, "," );
-			for( unsigned int i = 0; i < Split.size(); i++ )
+			AStringVector Split = StringSplitAndTrim(Groups, ",");
+			for (AStringVector::const_iterator itr = Split.begin(), end = Split.end(); itr != end; ++itr)
 			{
-				AddToGroup( Split[i].c_str() );
+				if (!cRoot::Get()->GetGroupManager()->ExistsGroup(*itr))
+				{
+					LOGWARNING("The group %s for player %s was not found!", itr->c_str(), m_PlayerName.c_str());
+				}
+				AddToGroup(*itr);
 			}
 		}
 		else
@@ -1459,16 +1537,15 @@ void cPlayer::LoadPermissionsFromDisk()
 			AddToGroup("Default");
 		}
 
-		m_Color = IniFile.GetValue(m_PlayerName, "Color", "-")[0];
+		AString Color = IniFile.GetValue(m_PlayerName, "Color", "-");
+		if (!Color.empty())
+		{
+			m_Color = Color[0];
+		}
 	}
 	else
 	{
-		LOGWARN("Regenerating users.ini, player %s will be added to the \"Default\" group", m_PlayerName.c_str());
-		IniFile.AddHeaderComment(" This is the file in which the group the player belongs to is stored");
-		IniFile.AddHeaderComment(" The format is: [PlayerName] | Groups=GroupName");
-
-		IniFile.SetValue(m_PlayerName, "Groups", "Default");
-		IniFile.WriteFile("users.ini");
+		cGroupManager::GenerateDefaultUsersIni(IniFile);
 		AddToGroup("Default");
 	}
 	ResolvePermissions();
@@ -1543,27 +1620,12 @@ bool cPlayer::LoadFromDisk()
 	m_CurrentXp           = (short) root.get("xpCurrent", 0).asInt();
 	m_IsFlying            = root.get("isflying", 0).asBool();
 
-	//SetExperience(root.get("experience", 0).asInt());
-
 	m_GameMode = (eGameMode) root.get("gamemode", eGameMode_NotSet).asInt();
 
 	if (m_GameMode == eGameMode_Creative)
 	{
 		m_CanFly = true;
 	}
-	else if (m_GameMode == eGameMode_NotSet)
-	{
-		cWorld * World = cRoot::Get()->GetWorld(GetLoadedWorldName());
-		if (World == NULL)
-		{
-			World = cRoot::Get()->GetDefaultWorld();
-		}
-
-		if (World->GetGameMode() == eGameMode_Creative)
-		{
-			m_CanFly = true;
-		}
-	}
 	
 	m_Inventory.LoadFromJson(root["inventory"]);
 
@@ -1679,79 +1741,17 @@ void cPlayer::UseEquippedItem(void)
 
 
 
-
-void cPlayer::SetSwimState(cChunk & a_Chunk)
-{
-	int RelY = (int)floor(m_LastPosY + 0.1);
-	if ((RelY < 0) || (RelY >= cChunkDef::Height - 1))
-	{
-		m_IsSwimming = false;
-		m_IsSubmerged = false;
-		return;
-	}
-	
-	BLOCKTYPE BlockIn;
-	int RelX = (int)floor(m_LastPosX) - a_Chunk.GetPosX() * cChunkDef::Width;
-	int RelZ = (int)floor(m_LastPosZ) - a_Chunk.GetPosZ() * cChunkDef::Width;
-	
-	// Check if the player is swimming:
-	// Use Unbounded, because we're being called *after* processing super::Tick(), which could have changed our chunk
-	if (!a_Chunk.UnboundedRelGetBlockType(RelX, RelY, RelZ, BlockIn))
-	{
-		// This sometimes happens on Linux machines
-		// Ref.: http://forum.mc-server.org/showthread.php?tid=1244
-		LOGD("SetSwimState failure: RelX = %d, RelZ = %d, LastPos = {%.02f, %.02f}, Pos = %.02f, %.02f}",
-			RelX, RelY, m_LastPosX, m_LastPosZ, GetPosX(), GetPosZ()
-		);
-		m_IsSwimming = false;
-		m_IsSubmerged = false;
-		return;
-	}
-	m_IsSwimming = IsBlockWater(BlockIn);
-
-	// Check if the player is submerged:
-	VERIFY(a_Chunk.UnboundedRelGetBlockType(RelX, RelY + 1, RelZ, BlockIn));
-	m_IsSubmerged = IsBlockWater(BlockIn);
-}
-
-
-
-
-
-void cPlayer::HandleAir(void)
+void cPlayer::TickBurning(cChunk & a_Chunk)
 {
-	// Ref.: http://www.minecraftwiki.net/wiki/Chunk_format
-	// see if the player is /submerged/ water (block above is water)
-	// Get the type of block the player's standing in:
-
-	if (IsSubmerged())
+	// Don't burn in creative and stop burning in creative if necessary
+	if (!IsGameModeCreative())
 	{
-		// either reduce air level or damage player
-		if (m_AirLevel < 1)
-		{
-			if (m_AirTickTimer < 1)
-			{
-				// damage player 
-				TakeDamage(dtDrowning, NULL, 1, 1, 0);
-				// reset timer
-				m_AirTickTimer = DROWNING_TICKS;
-			}
-			else
-			{
-				m_AirTickTimer -= 1;
-			}
-		}
-		else
-		{
-			// reduce air supply
-			m_AirLevel -= 1;
-		}
+		super::TickBurning(a_Chunk);
 	}
-	else
+	else if (IsOnFire())
 	{
-		// set the air back to maximum
-		m_AirLevel = MAX_AIR_LEVEL;
-		m_AirTickTimer = DROWNING_TICKS;
+		m_TicksLeftBurning = 0;
+		OnFinishedBurning();
 	}
 }
 
@@ -1763,6 +1763,12 @@ void cPlayer::HandleFood(void)
 {
 	// Ref.: http://www.minecraftwiki.net/wiki/Hunger
 	
+	if (IsGameModeCreative())
+	{
+		// Hunger is disabled for Creative
+		return;
+	}
+	
 	// Remember the food level before processing, for later comparison
 	int LastFoodLevel = m_FoodLevel;
 	
@@ -1780,7 +1786,7 @@ void cPlayer::HandleFood(void)
 				Heal(1);
 				m_FoodExhaustionLevel += 3;
 			}
-			else if (m_FoodLevel <= 0)
+			else if ((m_FoodLevel <= 0) && (m_Health > 1))
 			{
 				// Damage from starving
 				TakeDamage(dtStarving, NULL, 1, 1, 0);
@@ -1906,7 +1912,7 @@ void cPlayer::Detach()
 		{
 			for (int z = PosZ - 2; z <= (PosZ + 2); ++z)
 			{
-				if (!g_BlockIsSolid[m_World->GetBlock(x, y, z)] && g_BlockIsSolid[m_World->GetBlock(x, y - 1, z)])
+				if (!cBlockInfo::IsSolid(m_World->GetBlock(x, y, z)) && cBlockInfo::IsSolid(m_World->GetBlock(x, y - 1, z)))
 				{
 					TeleportToCoords(x, y, z);
 					return;
diff --git a/src/Entities/Player.h b/src/Entities/Player.h
index bf3ca08e8..05377a117 100644
--- a/src/Entities/Player.h
+++ b/src/Entities/Player.h
@@ -5,6 +5,7 @@
 #include "../Inventory.h"
 #include "../Defines.h"
 #include "../World.h"
+#include "../ClientHandle.h"
 
 
 
@@ -13,6 +14,7 @@
 class cGroup;
 class cWindow;
 class cClientHandle;
+class cTeam;
 
 
 
@@ -30,8 +32,6 @@ public:
 		MAX_HEALTH = 20,
 		MAX_FOOD_LEVEL = 20,
 		EATING_TICKS = 30,  ///< Number of ticks it takes to eat an item
-		MAX_AIR_LEVEL = 300,
-		DROWNING_TICKS = 10, //number of ticks per heart of damage
 	} ;
 	// tolua_end
 	
@@ -47,19 +47,19 @@ public:
 
 	virtual void HandlePhysics(float a_Dt, cChunk &) override { UNUSED(a_Dt); };
 
-	/// Returns the curently equipped weapon; empty item if none
+	/** Returns the curently equipped weapon; empty item if none */
 	virtual cItem GetEquippedWeapon(void) const override { return m_Inventory.GetEquippedItem(); }
 	
-	/// Returns the currently equipped helmet; empty item if nonte
+	/** Returns the currently equipped helmet; empty item if none */
 	virtual cItem GetEquippedHelmet(void) const override { return m_Inventory.GetEquippedHelmet(); }
 	
-	/// Returns the currently equipped chestplate; empty item if none
+	/** Returns the currently equipped chestplate; empty item if none */
 	virtual cItem GetEquippedChestplate(void) const override { return m_Inventory.GetEquippedChestplate(); }
 
-	/// Returns the currently equipped leggings; empty item if none
+	/** Returns the currently equipped leggings; empty item if none */
 	virtual cItem GetEquippedLeggings(void) const override { return m_Inventory.GetEquippedLeggings(); }
 	
-	/// Returns the currently equipped boots; empty item if none
+	/** Returns the currently equipped boots; empty item if none */
 	virtual cItem GetEquippedBoots(void) const override { return m_Inventory.GetEquippedBoots(); }
 
 
@@ -77,36 +77,41 @@ public:
 	*/
 	short DeltaExperience(short a_Xp_delta);
 
-	/// Gets the experience total - XpTotal for score on death
+	/** Gets the experience total - XpTotal for score on death */
 	inline short GetXpLifetimeTotal(void) { return m_LifetimeTotalXp; }
 
-	/// Gets the currrent experience
+	/** Gets the currrent experience */
 	inline short GetCurrentXp(void) { return m_CurrentXp; }
 
-	/// Gets the current level - XpLevel
+	/** Gets the current level - XpLevel */
 	short GetXpLevel(void);
 
-	/// Gets the experience bar percentage - XpP
+	/** Gets the experience bar percentage - XpP */
 	float GetXpPercentage(void);
 
-	/// Caculates the amount of XP needed for a given level, ref: http://minecraft.gamepedia.com/XP
+	/** Caculates the amount of XP needed for a given level
+	Ref: http://minecraft.gamepedia.com/XP
+	*/
 	static short XpForLevel(short int a_Level);
 
-	/// inverse of XpForLevel, ref: http://minecraft.gamepedia.com/XP values are as per this with pre-calculations
+	/** Inverse of XpForLevel
+	Ref: http://minecraft.gamepedia.com/XP
+	values are as per this with pre-calculations
+	*/
 	static short CalcLevelFromXp(short int a_CurrentXp);
 
 	// tolua_end
 	
-	/// Starts charging the equipped bow
+	/** Starts charging the equipped bow */
 	void StartChargingBow(void);
 	
-	/// Finishes charging the current bow. Returns the number of ticks for which the bow has been charged
+	/** Finishes charging the current bow. Returns the number of ticks for which the bow has been charged */
 	int FinishChargingBow(void);
 	
-	/// Cancels the current bow charging
+	/** Cancels the current bow charging */
 	void CancelChargingBow(void);
 	
-	/// Returns true if the player is currently charging the bow
+	/** Returns true if the player is currently charging the bow */
 	bool IsChargingBow(void) const { return m_IsChargingBow; }
 
 	void SetTouchGround( bool a_bTouchGround );
@@ -124,16 +129,22 @@ public:
 
 	// tolua_begin
 	
-	/// Returns the position where projectiles thrown by this player should start, player eye position + adjustment
+	/** Sends the "look" packet to the player, forcing them to set their rotation to the specified values.
+	a_YawDegrees is clipped to range [-180, +180),
+	a_PitchDegrees is clipped to range [-180, +180) but the client only uses [-90, +90]
+	*/
+	void SendRotation(double a_YawDegrees, double a_PitchDegrees);
+	
+	/** Returns the position where projectiles thrown by this player should start, player eye position + adjustment */
 	Vector3d GetThrowStartPos(void) const;
 	
-	/// Returns the initial speed vector of a throw, with a 3D length of a_SpeedCoeff.
+	/** Returns the initial speed vector of a throw, with a 3D length of a_SpeedCoeff. */
 	Vector3d GetThrowSpeed(double a_SpeedCoeff) const;
 	
-	/// Returns the current gamemode. Partly OBSOLETE, you should use IsGameModeXXX() functions wherever applicable
+	/** Returns the current gamemode. Partly OBSOLETE, you should use IsGameModeXXX() functions wherever applicable */
 	eGameMode GetGameMode(void) const { return m_GameMode; }
 	
-	/// Returns the current effective gamemode (inherited gamemode is resolved before returning)
+	/** Returns the current effective gamemode (inherited gamemode is resolved before returning) */
 	eGameMode GetEffectiveGameMode(void) const { return (m_GameMode == gmNotSet) ? m_World->GetGameMode() : m_GameMode; }
 	
 	/** Sets the gamemode for the player.
@@ -142,52 +153,63 @@ public:
 	*/
 	void SetGameMode(eGameMode a_GameMode);
 
-	/// Returns true if the player is in Creative mode, either explicitly, or by inheriting from current world
+	/** Returns true if the player is in Creative mode, either explicitly, or by inheriting from current world */
 	bool IsGameModeCreative(void) const;
 	
-	/// Returns true if the player is in Survival mode, either explicitly, or by inheriting from current world
+	/** Returns true if the player is in Survival mode, either explicitly, or by inheriting from current world */
 	bool IsGameModeSurvival(void) const;
 	
-	/// Returns true if the player is in Adventure mode, either explicitly, or by inheriting from current world
+	/** Returns true if the player is in Adventure mode, either explicitly, or by inheriting from current world */
 	bool IsGameModeAdventure(void) const;
 	
 	AString GetIP(void) const { return m_IP; }  // tolua_export
 
+	/** Returns the associated team, NULL if none */
+	cTeam * GetTeam(void) { return m_Team; } // tolua_export
+
+	/** Sets the player team, NULL if none */
+	void SetTeam(cTeam * a_Team);
+
+	/** Forces the player to query the scoreboard for his team */
+	cTeam * UpdateTeam(void);
+
 	// tolua_end
 	
 	void SetIP(const AString & a_IP);
-
-	float GetLastBlockActionTime() { return m_LastBlockActionTime; }
-	int GetLastBlockActionCnt() { return m_LastBlockActionCnt; }
-	void SetLastBlockActionCnt( int );
-	void SetLastBlockActionTime();
 	
 	// Sets the current gamemode, doesn't check validity, doesn't send update packets to client
 	void LoginSetGameMode(eGameMode a_GameMode);
 
-	/// Forces the player to move in the given direction.
+	/** Forces the player to move in the given direction. */
 	void ForceSetSpeed(Vector3d a_Direction); // tolua_export
 
-	/// Tries to move to a new position, with attachment-related checks (y == -999)
+	/** Tries to move to a new position, with attachment-related checks (y == -999) */
 	void MoveTo(const Vector3d & a_NewPos);  // tolua_export
 
 	cWindow * GetWindow(void) { return m_CurrentWindow; }  // tolua_export
 	const cWindow * GetWindow(void) const { return m_CurrentWindow; }
 	
-	/// Opens the specified window; closes the current one first using CloseWindow()
+	/** Opens the specified window; closes the current one first using CloseWindow() */
 	void OpenWindow(cWindow * a_Window);  // Exported in ManualBindings.cpp
 	
 	// tolua_begin
 	
-	/// Closes the current window, resets current window to m_InventoryWindow. A plugin may refuse the closing if a_CanRefuse is true
+	/** Closes the current window, resets current window to m_InventoryWindow. A plugin may refuse the closing if a_CanRefuse is true */
 	void CloseWindow(bool a_CanRefuse = true);
 	
-	/// Closes the current window if it matches the specified ID, resets current window to m_InventoryWindow
+	/** Closes the current window if it matches the specified ID, resets current window to m_InventoryWindow */
 	void CloseWindowIfID(char a_WindowID, bool a_CanRefuse = true);
 
 	cClientHandle * GetClientHandle(void) const { return m_ClientHandle; }
 
-	void SendMessage(const AString & a_Message);
+	void SendMessage          (const AString & a_Message) { m_ClientHandle->SendChat(a_Message, mtCustom); }
+	void SendMessageInfo      (const AString & a_Message) { m_ClientHandle->SendChat(a_Message, mtInformation); }
+	void SendMessageFailure   (const AString & a_Message) { m_ClientHandle->SendChat(a_Message, mtFailure); }
+	void SendMessageSuccess   (const AString & a_Message) { m_ClientHandle->SendChat(a_Message, mtSuccess); }
+	void SendMessageWarning   (const AString & a_Message) { m_ClientHandle->SendChat(a_Message, mtWarning); }
+	void SendMessageFatal     (const AString & a_Message) { m_ClientHandle->SendChat(a_Message, mtFailure); }
+	void SendMessagePrivateMsg(const AString & a_Message, const AString & a_Sender) { m_ClientHandle->SendChat(a_Message, mtPrivateMessage, a_Sender); }
+	void SendMessage          (const cCompositeChat & a_Message) { m_ClientHandle->SendChat(a_Message); }
 
 	const AString & GetName(void) const { return m_PlayerName; }
 	void SetName(const AString & a_Name) { m_PlayerName = a_Name; }
@@ -197,13 +219,12 @@ public:
 	typedef std::list< cGroup* > GroupList;
 	typedef std::list< std::string > StringList;
 
-	/// Adds a player to existing group or creates a new group when it doesn't exist
+	/** Adds a player to existing group or creates a new group when it doesn't exist */
 	void AddToGroup( const AString & a_GroupName );							// tolua_export
 	
-	/// Removes a player from the group, resolves permissions and group inheritance (case sensitive)
+	/** Removes a player from the group, resolves permissions and group inheritance (case sensitive) */
 	void RemoveFromGroup( const AString & a_GroupName );					// tolua_export
 	
-	bool CanUseCommand( const AString & a_Command );						// tolua_export
 	bool HasPermission( const AString & a_Permission );						// tolua_export
 	const GroupList & GetGroups() { return m_Groups; }						// >> EXPORTED IN MANUALBINDINGS <<
 	StringList GetResolvedPermissions();									// >> EXPORTED IN MANUALBINDINGS <<
@@ -211,12 +232,20 @@ public:
 
 	// tolua_begin
 	
-	/// Returns the full color code to use for this player, based on their primary group or set in m_Color
+	/** Returns the full color code to use for this player, based on their primary group or set in m_Color.
+	The returned value includes the cChatColor::Delimiter. */
 	AString GetColor(void) const;
 
-	void TossItem(bool a_bDraggingItem, char a_Amount = 1, short a_CreateType = 0, short a_CreateHealth = 0);
+	/** tosses the item in the selected hotbar slot */
+	void TossEquippedItem(char a_Amount = 1);
+
+	/** tosses the item held in hand (when in UI windows) */
+	void TossHeldItem(char a_Amount = 1);
 
-	/// Heals the player by the specified amount of HPs (positive only); sends health update
+	/** tosses a pickup newly created from a_Item */
+	void TossPickup(const cItem & a_Item);
+
+	/** Heals the player by the specified amount of HPs (positive only); sends health update */
 	void Heal(int a_Health);
 	
 	int    GetFoodLevel                 (void) const { return m_FoodLevel; }
@@ -224,10 +253,8 @@ public:
 	int    GetFoodTickTimer             (void) const { return m_FoodTickTimer; }
 	double GetFoodExhaustionLevel       (void) const { return m_FoodExhaustionLevel; }
 	int    GetFoodPoisonedTicksRemaining(void) const { return m_FoodPoisonedTicksRemaining; }
-
-	int GetAirLevel                     (void) const { return m_AirLevel; }
 	
-	/// Returns true if the player is satiated, i. e. their foodlevel is at the max and they cannot eat anymore
+	/** Returns true if the player is satiated, i. e. their foodlevel is at the max and they cannot eat anymore */
 	bool IsSatiated(void) const { return (m_FoodLevel >= MAX_FOOD_LEVEL); }
 	
 	void SetFoodLevel                 (int a_FoodLevel);
@@ -236,25 +263,28 @@ public:
 	void SetFoodExhaustionLevel       (double a_FoodExhaustionLevel);
 	void SetFoodPoisonedTicksRemaining(int a_FoodPoisonedTicksRemaining);
 
-	/// Adds to FoodLevel and FoodSaturationLevel, returns true if any food has been consumed, false if player "full"
+	/** Adds to FoodLevel and FoodSaturationLevel, returns true if any food has been consumed, false if player "full" */
 	bool Feed(int a_Food, double a_Saturation);
 
-	/// Adds the specified exhaustion to m_FoodExhaustion. Expects only positive values.
+	/** Adds the specified exhaustion to m_FoodExhaustion. Expects only positive values. */
 	void AddFoodExhaustion(double a_Exhaustion)
 	{
 		m_FoodExhaustionLevel += a_Exhaustion;
 	}
 	
-	/// Starts the food poisoning for the specified amount of ticks; if already foodpoisoned, sets FoodPoisonedTicksRemaining to the larger of the two
+	/** Starts the food poisoning for the specified amount of ticks; if already foodpoisoned, sets FoodPoisonedTicksRemaining to the larger of the two */
 	void FoodPoison(int a_NumTicks);
 	
-	/// Returns true if the player is currently in the process of eating the currently equipped item
+	/** Returns true if the player is currently in the process of eating the currently equipped item */
 	bool IsEating(void) const { return (m_EatingFinishTick >= 0); }
 	
-	/// Returns true if the player is currently flying.
+	/** Returns true if the player is currently flying. */
 	bool IsFlying(void) const { return m_IsFlying; }
 
-	/// returns true if the player has thrown out a floater.
+	/** Returns if a player is sleeping in a bed */
+	bool IsInBed(void) const { return m_bIsInBed; }
+
+	/** returns true if the player has thrown out a floater. */
 	bool IsFishing(void) const { return m_IsFishing; }
 
 	void SetIsFishing(bool a_IsFishing, int a_FloaterID = -1) { m_IsFishing = a_IsFishing; m_FloaterID = a_FloaterID; }
@@ -262,14 +292,17 @@ public:
 	int GetFloaterID(void) const { return m_FloaterID; }
 
 	// tolua_end
+
+	/** Sets a player's in-bed state; we can't be sure plugins will keep this value updated, so no exporting */
+	void SetIsInBed(bool a_Flag) { m_bIsInBed = a_Flag; }
 	
-	/// Starts eating the currently equipped item. Resets the eating timer and sends the proper animation packet
+	/** Starts eating the currently equipped item. Resets the eating timer and sends the proper animation packet */
 	void StartEating(void);
 	
-	/// Finishes eating the currently equipped item. Consumes the item, updates health and broadcasts the packets
+	/** Finishes eating the currently equipped item. Consumes the item, updates health and broadcasts the packets */
 	void FinishEating(void);
 	
-	/// Aborts the current eating operation
+	/** Aborts the current eating operation */
 	void AbortEating(void);
 	
 	virtual void KilledBy(cEntity * a_Killer) override;
@@ -298,51 +331,51 @@ public:
 	cItem & GetDraggingItem(void) {return m_DraggingItem; }
 	
 	// In UI windows, when inventory-painting:
-	/// Clears the list of slots that are being inventory-painted. To be used by cWindow only
+	/** Clears the list of slots that are being inventory-painted. To be used by cWindow only */
 	void ClearInventoryPaintSlots(void);
 	
-	/// Adds a slot to the list for inventory painting. To be used by cWindow only
+	/** Adds a slot to the list for inventory painting. To be used by cWindow only */
 	void AddInventoryPaintSlot(int a_SlotNum);
 	
-	/// Returns the list of slots currently stored for inventory painting. To be used by cWindow only
+	/** Returns the list of slots currently stored for inventory painting. To be used by cWindow only */
 	const cSlotNums & GetInventoryPaintSlots(void) const;
 	
 	// tolua_begin
 	
-	/// Returns the current maximum speed, as reported in the 1.6.1+ protocol (takes current sprinting state into account)
+	/** Returns the current relative maximum speed (takes current sprinting / flying state into account) */
 	double GetMaxSpeed(void) const;
 	
-	/// Gets the normal maximum speed, as reported in the 1.6.1+ protocol, in the protocol units
+	/** Gets the normal relative maximum speed */
 	double GetNormalMaxSpeed(void) const { return m_NormalMaxSpeed; }
 	
-	/// Gets the sprinting maximum speed, as reported in the 1.6.1+ protocol, in the protocol units
+	/** Gets the sprinting relative maximum speed */
 	double GetSprintingMaxSpeed(void) const { return m_SprintingMaxSpeed; }
 	
-	/// Sets the normal maximum speed, as reported in the 1.6.1+ protocol. Sends the update to player, if needed.
+	/** Gets the flying relative maximum speed */
+	double GetFlyingMaxSpeed(void) const { return m_FlyingMaxSpeed; }
+	
+	/** Sets the normal relative maximum speed. Sends the update to player, if needed. */
 	void SetNormalMaxSpeed(double a_Speed);
 	
-	/// Sets the sprinting maximum speed, as reported in the 1.6.1+ protocol. Sends the update to player, if needed.
+	/** Sets the sprinting relative maximum speed. Sends the update to player, if needed. */
 	void SetSprintingMaxSpeed(double a_Speed);
 	
-	/// Sets the crouch status, broadcasts to all visible players
+	/** Sets the flying relative maximum speed. Sends the update to player, if needed. */
+	void SetFlyingMaxSpeed(double a_Speed);
+	
+	/** Sets the crouch status, broadcasts to all visible players */
 	void SetCrouch(bool a_IsCrouched);
 	
-	/// Starts or stops sprinting, sends the max speed update to the client, if needed
+	/** Starts or stops sprinting, sends the max speed update to the client, if needed */
 	void SetSprint(bool a_IsSprinting);
 	
-	/// Flags the player as flying
+	/** Flags the player as flying */
 	void SetFlying(bool a_IsFlying);
 
-	/// If true the player can fly even when he's not in creative.
+	/** If true the player can fly even when he's not in creative. */
 	void SetCanFly(bool a_CanFly);
 
-	/// Returns whether the player is swimming or not
-	virtual bool IsSwimming(void) const{ return m_IsSwimming; }
-
-	/// Return whether the player is under water or not
-	virtual bool IsSubmerged(void) const{ return m_IsSubmerged; }
-
-	/// Returns wheter the player can fly or not.
+	/** Returns wheter the player can fly or not. */
 	virtual bool CanFly(void) const { return m_CanFly; }
 	// tolua_end
 
@@ -361,10 +394,10 @@ protected:
 	GroupList m_ResolvedGroups;
 	GroupList m_Groups;
 
-	std::string m_PlayerName;
-	std::string m_LoadedWorldName;
+	AString m_PlayerName;
+	AString m_LoadedWorldName;
 
-	/// Xp Level stuff
+	/** Xp Level stuff */
 	enum 
 	{
 		XP_TO_LEVEL15 = 255,
@@ -372,31 +405,25 @@ protected:
 		XP_TO_LEVEL30 = 825
 	} ;
 
-	/// Player's air level (for swimming)
-	int m_AirLevel;
-
-	/// used to time ticks between damage taken via drowning/suffocation
-	int m_AirTickTimer;
-
 	bool m_bVisible;
 
 	// Food-related variables:
-	/// Represents the food bar, one point equals half a "drumstick"
+	/** Represents the food bar, one point equals half a "drumstick" */
 	int m_FoodLevel;
 	
-	/// "Overcharge" for the m_FoodLevel; is depleted before m_FoodLevel
+	/** "Overcharge" for the m_FoodLevel; is depleted before m_FoodLevel */
 	double m_FoodSaturationLevel;
 	
-	/// Count-up to the healing or damaging action, based on m_FoodLevel
+	/** Count-up to the healing or damaging action, based on m_FoodLevel */
 	int   m_FoodTickTimer;
 	
-	/// A "buffer" which adds up hunger before it is substracted from m_FoodSaturationLevel or m_FoodLevel. Each action adds a little
+	/** A "buffer" which adds up hunger before it is substracted from m_FoodSaturationLevel or m_FoodLevel. Each action adds a little */
 	double m_FoodExhaustionLevel;
 	
-	/// Number of ticks remaining for the foodpoisoning effect; zero if not foodpoisoned
+	/** Number of ticks remaining for the foodpoisoning effect; zero if not foodpoisoned */
 	int m_FoodPoisonedTicksRemaining;
 	
-	/// Last position that has been recorded for food-related processing:
+	/** Last position that has been recorded for food-related processing: */
 	Vector3d m_LastFoodPos;
 	
 	float m_LastJumpHeight;
@@ -407,16 +434,12 @@ protected:
 	cWindow * m_CurrentWindow;
 	cWindow * m_InventoryWindow;
 
-	float m_TimeLastPickupCheck;
-
 	char m_Color;
 
-	float m_LastBlockActionTime;
-	int m_LastBlockActionCnt;
 	eGameMode m_GameMode;
-	std::string m_IP;
+	AString m_IP;
 	
-	/// The item being dragged by the cursor while in a UI window
+	/** The item being dragged by the cursor while in a UI window */
 	cItem m_DraggingItem;
 
 	long long m_LastPlayerListTime;
@@ -426,12 +449,21 @@ protected:
 	
 	cSlotNums m_InventoryPaintSlots;
 	
-	/// Max speed, in ENTITY_PROPERTIES packet's units, when the player is walking. 0.1 by default
+	/** Max speed, relative to the game default.
+	1 means regular speed, 2 means twice as fast, 0.5 means half-speed.
+	Default value is 1. */
 	double m_NormalMaxSpeed;
 	
-	/// Max speed, in ENTITY_PROPERTIES packet's units, when the player is sprinting. 0.13 by default
+	/** Max speed, relative to the game default max speed, when sprinting.
+	1 means regular speed, 2 means twice as fast, 0.5 means half-speed.
+	Default value is 1.3. */
 	double m_SprintingMaxSpeed;
 	
+	/** Max speed, relative to the game default flying max speed, when flying.
+	1 means regular speed, 2 means twice as fast, 0.5 means half-speed.
+	Default value is 1. */
+	double m_FlyingMaxSpeed;
+	
 	bool m_IsCrouched;
 	bool m_IsSprinting;
 	bool m_IsFlying;
@@ -441,10 +473,10 @@ protected:
 
 	bool m_CanFly;  // If this is true the player can fly. Even if he is not in creative.
 
-	/// The world tick in which eating will be finished. -1 if not eating
+	/** The world tick in which eating will be finished. -1 if not eating */
 	Int64 m_EatingFinishTick;
 
-	/// Player Xp level
+	/** Player Xp level */
 	short int m_LifetimeTotalXp;
 	short int m_CurrentXp;
 
@@ -456,6 +488,8 @@ protected:
 
 	int m_FloaterID;
 
+	cTeam * m_Team;
+
 
 
 	void ResolvePermissions(void);
@@ -463,23 +497,25 @@ protected:
 
 	virtual void Destroyed(void);
 
-	/// Filters out damage for creative mode
+	/** Filters out damage for creative mode/friendly fire */
 	virtual void DoTakeDamage(TakeDamageInfo & TDI) override;
+
+	/** Stops players from burning in creative mode */
+	virtual void TickBurning(cChunk & a_Chunk) override;
 	
-	/// Called in each tick to handle food-related processing
+	/** Called in each tick to handle food-related processing */
 	void HandleFood(void);
 
-	/// Called in each tick if the player is fishing to make sure the floater dissapears when the player doesn't have a fishing rod as equipped item.
+	/** Called in each tick if the player is fishing to make sure the floater dissapears when the player doesn't have a fishing rod as equipped item. */
 	void HandleFloater(void);
-	
-	/// Called in each tick to handle air-related processing i.e. drowning
-	void HandleAir();
 
-	/// Called once per tick to set IsSwimming and IsSubmerged
-	void SetSwimState(cChunk & a_Chunk);
-
-	/// Adds food exhaustion based on the difference between Pos and LastPos, sprinting status and swimming (in water block)
+	/** Adds food exhaustion based on the difference between Pos and LastPos, sprinting status and swimming (in water block) */
 	void ApplyFoodExhaustionFromMovement();
+
+	/** Flag representing whether the player is currently in a bed
+	Set by a right click on unoccupied bed, unset by a time fast forward or teleport */
+	bool m_bIsInBed;
+
 } ; // tolua_export
 
 
diff --git a/src/Entities/ProjectileEntity.cpp b/src/Entities/ProjectileEntity.cpp
index 12ce9a303..e86bb48bd 100644
--- a/src/Entities/ProjectileEntity.cpp
+++ b/src/Entities/ProjectileEntity.cpp
@@ -4,6 +4,7 @@
 // Implements the cProjectileEntity class representing the common base class for projectiles, as well as individual projectile types
 
 #include "Globals.h"
+#include "../Bindings/PluginManager.h"
 #include "ProjectileEntity.h"
 #include "../ClientHandle.h"
 #include "Player.h"
@@ -50,12 +51,12 @@ protected:
 		LOGD("Hit block %d:%d at {%d, %d, %d} face %d, %s (%s)",
 			a_BlockType, a_BlockMeta,
 			a_BlockX, a_BlockY, a_BlockZ, a_EntryFace,
-			g_BlockIsSolid[a_BlockType] ? "solid" : "non-solid",
+			cBlockInfo::IsSolid(a_BlockType) ? "solid" : "non-solid",
 			ItemToString(cItem(a_BlockType, 1, a_BlockMeta)).c_str()
 		);
 		*/
 		
-		if (g_BlockIsSolid[a_BlockType])
+		if (cBlockInfo::IsSolid(a_BlockType))
 		{
 			// The projectile hit a solid block
 			// Calculate the exact hit coords:
@@ -63,9 +64,14 @@ protected:
 			Vector3d Line1 = m_Projectile->GetPosition();
 			Vector3d Line2 = Line1 + m_Projectile->GetSpeed();
 			double LineCoeff = 0;
-			char Face;
+			eBlockFace Face;
 			if (bb.CalcLineIntersection(Line1, Line2, LineCoeff, Face))
 			{
+				if (cPluginManager::Get()->CallHookProjectileHitBlock(*m_Projectile))
+				{
+					return false;
+				}
+
 				Vector3d Intersection = Line1 + m_Projectile->GetSpeed() * LineCoeff;
 				m_Projectile->OnHitSolidBlock(Intersection, Face);
 				return true;
@@ -138,7 +144,7 @@ public:
 		// Instead of colliding the bounding box with another bounding box in motion, we collide an enlarged bounding box with a hairline.
 		// The results should be good enough for our purposes
 		double LineCoeff;
-		char Face;
+		eBlockFace Face;
 		EntBox.Expand(m_Projectile->GetWidth() / 2, m_Projectile->GetHeight() / 2, m_Projectile->GetWidth() / 2);
 		if (!EntBox.CalcLineIntersection(m_Pos, m_NextPos, LineCoeff, Face))
 		{
@@ -147,7 +153,11 @@ public:
 		}
 
 		// TODO: Some entities don't interact with the projectiles (pickups, falling blocks)
-		// TODO: Allow plugins to interfere about which entities can be hit
+		if (cPluginManager::Get()->CallHookProjectileHitEntity(*m_Projectile, *a_Entity))
+		{
+			// A plugin disagreed.
+			return false;
+		}
 		
 		if (LineCoeff < m_MinCoeff)
 		{
@@ -214,7 +224,7 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Ve
 
 
 
-cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d * a_Speed)
+cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item, const Vector3d * a_Speed)
 {
 	Vector3d Speed;
 	if (a_Speed != NULL)
@@ -231,8 +241,15 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
 		case pkGhastFireball: return new cGhastFireballEntity   (a_Creator, a_X, a_Y, a_Z, Speed);
 		case pkFireCharge:    return new cFireChargeEntity      (a_Creator, a_X, a_Y, a_Z, Speed);
 		case pkExpBottle:     return new cExpBottleEntity       (a_Creator, a_X, a_Y, a_Z, Speed);
-		case pkFirework:      return new cFireworkEntity        (a_Creator, a_X, a_Y, a_Z       );
-		// TODO: the rest
+		case pkFirework:
+		{
+			if (a_Item.m_FireworkItem.m_Colours.empty())
+			{
+				return NULL;
+			}
+
+			return new cFireworkEntity(a_Creator, a_X, a_Y, a_Z, a_Item);
+		}
 	}
 	
 	LOGWARNING("%s: Unknown projectile kind: %d", __FUNCTION__, a_Kind);
@@ -243,7 +260,7 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
 
 
 
-void cProjectileEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cProjectileEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
 	// Set the position based on what face was hit:
 	SetPosition(a_HitPos);
@@ -276,6 +293,7 @@ AString cProjectileEntity::GetMCAClassName(void) const
 		case pkExpBottle:     return "ThrownExpBottle";
 		case pkSplashPotion:  return "ThrownPotion";
 		case pkWitherSkull:   return "WitherSkull";
+		case pkFirework:      return "Firework";
 		case pkFishingFloat:  return "";  // Unknown, perhaps MC doesn't save this?
 	}
 	ASSERT(!"Unhandled projectile entity kind!");
@@ -353,13 +371,14 @@ void cProjectileEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 	SetYawFromSpeed();
 	SetPitchFromSpeed();
 
-	// DEBUG:
+	/*
 	LOGD("Projectile %d: pos {%.02f, %.02f, %.02f}, speed {%.02f, %.02f, %.02f}, rot {%.02f, %.02f}",
 		m_UniqueID,
 		GetPosX(), GetPosY(), GetPosZ(),
 		GetSpeedX(), GetSpeedY(), GetSpeedZ(),
 		GetYaw(), GetPitch()
 	);
+	*/
 }
 
 
@@ -446,7 +465,7 @@ bool cArrowEntity::CanPickup(const cPlayer & a_Player) const
 
 
 
-void cArrowEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cArrowEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
 	if (a_HitFace == BLOCK_FACE_NONE) { return; }
 
@@ -590,7 +609,7 @@ cThrownEggEntity::cThrownEggEntity(cEntity * a_Creator, double a_X, double a_Y,
 
 
 
-void cThrownEggEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cThrownEggEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
 	if (m_World->GetTickRandomNumber(7) == 1)
 	{
@@ -623,7 +642,7 @@ cThrownEnderPearlEntity::cThrownEnderPearlEntity(cEntity * a_Creator, double a_X
 
 
 
-void cThrownEnderPearlEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cThrownEnderPearlEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
 	// Teleport the creator here, make them take 5 damage:
 	if (m_Creator != NULL)
@@ -653,10 +672,8 @@ cThrownSnowballEntity::cThrownSnowballEntity(cEntity * a_Creator, double a_X, do
 
 
 
-void cThrownSnowballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cThrownSnowballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
-	// TODO: Apply damage to certain mobs (blaze etc.) and anger all mobs
-	
 	Destroy();
 }
 
@@ -664,6 +681,30 @@ void cThrownSnowballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_Hi
 
 
 
+void cThrownSnowballEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
+{
+	int TotalDamage = 0;
+	if (a_EntityHit.IsMob())
+	{
+		cMonster::eType MobType = ((cMonster &) a_EntityHit).GetMobType();
+		if (MobType == cMonster::mtBlaze)
+		{
+			TotalDamage = 3;
+		}
+		else if (MobType == cMonster::mtEnderDragon)
+		{
+			TotalDamage = 1;
+		}
+	}
+	a_EntityHit.TakeDamage(dtRangedAttack, this, TotalDamage, 1);
+
+	Destroy(true);
+}
+
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cBottleOEnchantingEntity :
 
@@ -677,9 +718,11 @@ super(pkExpBottle, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
 
 
 
-void cExpBottleEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cExpBottleEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
-	// TODO: Spawn experience orbs
+	// Spawn an experience orb with a reward between 3 and 11.
+	m_World->BroadcastSoundParticleEffect(2002, POSX_TOINT, POSY_TOINT, POSZ_TOINT, 0);
+	m_World->SpawnExperienceOrb(GetPosX(), GetPosY(), GetPosZ(), 3 + m_World->GetTickRandomNumber(8));
 
 	Destroy();
 }
@@ -691,8 +734,10 @@ void cExpBottleEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFireworkEntity :
 
-cFireworkEntity::cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z) :
-super(pkFirework, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
+cFireworkEntity::cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item) :
+super(pkFirework, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25),
+	m_ExplodeTimer(0),
+	m_FireworkItem(a_Item)
 {
 }
 
@@ -700,32 +745,20 @@ super(pkFirework, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
 
 
 
-void cFireworkEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cFireworkEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 {
-	if ((a_HitFace != BLOCK_FACE_BOTTOM) && (a_HitFace != BLOCK_FACE_NONE))
+	int RelX = POSX_TOINT - a_Chunk.GetPosX() * cChunkDef::Width;
+	int RelZ = POSZ_TOINT - a_Chunk.GetPosZ() * cChunkDef::Width;
+	int PosY = POSY_TOINT;
+
+	if ((PosY < 0) || (PosY >= cChunkDef::Height))
 	{
-		return;
+		goto setspeed;
 	}
 
-	SetSpeed(0, 0, 0);
-	SetPosition(GetPosX(), GetPosY() - 0.5, GetPosZ());
-
-	std::cout << a_HitPos.x << " " << a_HitPos.y << " " << a_HitPos.z << std::endl;
-
-	m_IsInGround = true;
-
-	BroadcastMovementUpdate();
-}
-
-
-
-
-
-void cFireworkEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
-{
 	if (m_IsInGround)
 	{
-		if (a_Chunk.GetBlock((int)GetPosX(), (int)GetPosY() + 1, (int)GetPosZ()) == E_BLOCK_AIR)
+		if (a_Chunk.GetBlock(RelX, POSY_TOINT + 1, RelZ) == E_BLOCK_AIR)
 		{
 			m_IsInGround = false;
 		}
@@ -734,28 +767,35 @@ void cFireworkEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 			return;
 		}
 	}
+	else
+	{
+		if (a_Chunk.GetBlock(RelX, POSY_TOINT + 1, RelZ) != E_BLOCK_AIR)
+		{
+			OnHitSolidBlock(GetPosition(), BLOCK_FACE_YM);
+			return;
+		}
+	}
 
-	Vector3d PerTickSpeed = GetSpeed() / 20;
-	Vector3d Pos = GetPosition();
+setspeed:
+	AddSpeedY(1);
+	AddPosition(GetSpeed() * (a_Dt / 1000));
+}
 
-	// Trace the tick's worth of movement as a line:
-	Vector3d NextPos = Pos + PerTickSpeed;
-	cProjectileTracerCallback TracerCallback(this);
-	if (!cLineBlockTracer::Trace(*m_World, TracerCallback, Pos, NextPos))
+
+
+
+
+void cFireworkEntity::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	super::Tick(a_Dt, a_Chunk);
+
+	if (m_ExplodeTimer == m_FireworkItem.m_FireworkItem.m_FlightTimeInTicks)
 	{
-		// Something has been hit, abort all other processing
-		return;
+		m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_FIREWORK_EXPLODE);
+		Destroy();
 	}
-	// The tracer also checks the blocks for slowdown blocks - water and lava - and stores it for later in its SlowdownCoeff
-
-	// Update the position:
-	SetPosition(NextPos);
 
-	// Add slowdown and gravity effect to the speed:
-	Vector3d NewSpeed(GetSpeed());
-	NewSpeed.y += 2;
-	NewSpeed *= TracerCallback.GetSlowdownCoeff();
-	SetSpeed(NewSpeed);
+	m_ExplodeTimer++;
 }
 
 
@@ -785,7 +825,7 @@ void cGhastFireballEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 
 
-void cGhastFireballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cGhastFireballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
 	Destroy();
 	Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
@@ -831,7 +871,7 @@ void cFireChargeEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 
 
-void cFireChargeEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+void cFireChargeEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
 	Destroy();
 	Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
diff --git a/src/Entities/ProjectileEntity.h b/src/Entities/ProjectileEntity.h
index 4721409ee..efb7ae783 100644
--- a/src/Entities/ProjectileEntity.h
+++ b/src/Entities/ProjectileEntity.h
@@ -46,10 +46,10 @@ public:
 	cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, double a_Width, double a_Height);
 	cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Vector3d & a_Pos, const Vector3d & a_Speed, double a_Width, double a_Height);
 	
-	static cProjectileEntity * Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d * a_Speed = NULL);
+	static cProjectileEntity * Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item, const Vector3d * a_Speed = NULL);
 	
 	/// Called by the physics blocktracer when the entity hits a solid block, the hit position and the face hit (BLOCK_FACE_) is given
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace);
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace);
 	
 	/// Called by the physics blocktracer when the entity hits another entity
 	virtual void OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos) 
@@ -174,7 +174,7 @@ protected:
 	Vector3i m_HitBlockPos;
 	
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
 	virtual void OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos) override;
 	virtual void CollectedBy(cPlayer * a_Player) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
@@ -204,7 +204,7 @@ protected:
 	// tolua_end
 	
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
 
 	// tolua_begin
 	
@@ -232,7 +232,7 @@ protected:
 	// tolua_end
 	
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
 
 	// tolua_begin
 	
@@ -258,7 +258,8 @@ public:
 protected:
 	
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
+	virtual void OnHitEntity    (cEntity & a_EntityHit, const Vector3d & a_HitPos) override;
 
 	// tolua_begin
 	
@@ -284,7 +285,7 @@ public:
 protected:
 
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
 
 	// tolua_begin
 
@@ -305,13 +306,19 @@ public:
 
 	CLASS_PROTODEF(cFireworkEntity);
 
-	cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z);
+	cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item);
+	const cItem & GetItem(void) const { return m_FireworkItem; }
 
 protected:
 
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
 	virtual void HandlePhysics(float a_Dt, cChunk & a_Chunk) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+
+private:
+
+	int m_ExplodeTimer;
+	cItem m_FireworkItem;
 
 	// tolua_begin
 
@@ -339,7 +346,7 @@ protected:
 	void Explode(int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
 	virtual void OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos) override;
 
 	// TODO: Deflecting the fireballs by arrow- or sword- hits
@@ -370,7 +377,7 @@ protected:
 	void Explode(int a_BlockX, int a_BlockY, int a_BlockZ);
 
 	// cProjectileEntity overrides:
-	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace) override;
+	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
 	virtual void OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos) override;
 
 	// tolua_begin
diff --git a/src/Entities/TNTEntity.cpp b/src/Entities/TNTEntity.cpp
index 339107b2e..02f31f5bb 100644
--- a/src/Entities/TNTEntity.cpp
+++ b/src/Entities/TNTEntity.cpp
@@ -8,10 +8,9 @@
 
 
 
-cTNTEntity::cTNTEntity(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec) :
+cTNTEntity::cTNTEntity(double a_X, double a_Y, double a_Z, int a_FuseTicks) :
 	super(etTNT, a_X, a_Y, a_Z, 0.98, 0.98),
-	m_Counter(0),
-	m_MaxFuseTime(a_FuseTimeInSec)
+	m_FuseTicks(a_FuseTicks)
 {
 }
 
@@ -19,10 +18,9 @@ cTNTEntity::cTNTEntity(double a_X, double a_Y, double a_Z, double a_FuseTimeInSe
 
 
 
-cTNTEntity::cTNTEntity(const Vector3d & a_Pos, double a_FuseTimeInSec) :
+cTNTEntity::cTNTEntity(const Vector3d & a_Pos, int a_FuseTicks) :
 	super(etTNT, a_Pos.x, a_Pos.y, a_Pos.z, 0.98, 0.98),
-	m_Counter(0),
-	m_MaxFuseTime(a_FuseTimeInSec)
+	m_FuseTicks(a_FuseTicks)
 {
 }
 
@@ -42,18 +40,27 @@ void cTNTEntity::SpawnOn(cClientHandle & a_ClientHandle)
 
 
 
+void cTNTEntity::Explode(void)
+{
+	m_FuseTicks = 0;
+	Destroy(true);
+	LOGD("BOOM at {%f,%f,%f}", GetPosX(), GetPosY(), GetPosZ());
+	m_World->DoExplosionAt(4.0, GetPosX() + 0.49, GetPosY() + 0.49, GetPosZ() + 0.49, true, esPrimedTNT, this);
+}
+
+
+
+
+
 void cTNTEntity::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	super::Tick(a_Dt, a_Chunk);
 	BroadcastMovementUpdate();
-	float delta_time = a_Dt / 1000;  // Convert miliseconds to seconds
-	m_Counter += delta_time;
-	if (m_Counter > m_MaxFuseTime)  // Check if we go KABOOOM
+	
+	m_FuseTicks -= 1;
+	if (m_FuseTicks <= 0)
 	{
-		Destroy(true);
-		LOGD("BOOM at {%f,%f,%f}", GetPosX(), GetPosY(), GetPosZ());
-		m_World->DoExplosionAt(4.0, GetPosX() + 0.49, GetPosY() + 0.49, GetPosZ() + 0.49, true, esPrimedTNT, this);
-		return;
+		Explode();
 	}
 }
 
diff --git a/src/Entities/TNTEntity.h b/src/Entities/TNTEntity.h
index d1fcae766..116f5a8cb 100644
--- a/src/Entities/TNTEntity.h
+++ b/src/Entities/TNTEntity.h
@@ -16,19 +16,28 @@ public:
 	// tolua_end
 	CLASS_PROTODEF(cTNTEntity);
 
-	cTNTEntity(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec);
-	cTNTEntity(const Vector3d & a_Pos, double a_FuseTimeInSec);
+	cTNTEntity(double a_X, double a_Y, double a_Z, int a_FuseTicks = 80);
+	cTNTEntity(const Vector3d & a_Pos, int a_FuseTicks = 80);
 	
 	// cEntity overrides:
 	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
-
-	double GetCounterTime(void) const { return m_Counter; } // tolua_export
-	double GetMaxFuseTime(void) const { return m_MaxFuseTime; } // tolua_export
+	
+	// tolua_begin
+	
+	/** Explode the tnt */
+	void Explode(void);
+	
+	/** Returns the fuse ticks until the tnt will explode */
+	int GetFuseTicks(void) const { return m_FuseTicks; }
+	
+	/** Set the fuse ticks until the tnt will explode */
+	void SetFuseTicks(int a_FuseTicks) { m_FuseTicks = a_FuseTicks; }
+	
+	// tolua_end
 	
 protected:
-	double m_Counter;      ///< How much time has elapsed since the object was created, in seconds
-	double m_MaxFuseTime;  ///< How long the fuse is, in seconds
+	int m_FuseTicks;      ///< How much ticks is left, while the tnt will explode
 }; // tolua_export
 
 
diff --git a/src/ForEachChunkProvider.h b/src/ForEachChunkProvider.h
new file mode 100644
index 000000000..7a6e8c5c6
--- /dev/null
+++ b/src/ForEachChunkProvider.h
@@ -0,0 +1,41 @@
+
+// ForEachChunkProvider.h
+
+// Declares the cForEachChunkProvider class which acts as an interface for classes that provide a ForEachChunkInRect() function
+// Primarily serves as a decoupling between cBlockArea and cWorld
+
+
+
+
+
+#pragma once
+
+
+
+
+// fwd:
+class cChunkDataCallback;
+class cBlockArea;
+
+
+
+
+
+class cForEachChunkProvider
+{
+public:
+	virtual ~cForEachChunkProvider() {}
+	
+	/** Calls the callback for each chunk in the specified range. */
+	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) = 0;
+	
+	/** Writes the block area into the specified coords.
+	Returns true if all chunks have been processed.
+	a_DataTypes is a bitmask of cBlockArea::baXXX constants ORed together.
+	*/
+	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) = 0;
+};
+
+
+
+
diff --git a/src/FurnaceRecipe.cpp b/src/FurnaceRecipe.cpp
index 2e2276981..1810d7c49 100644
--- a/src/FurnaceRecipe.cpp
+++ b/src/FurnaceRecipe.cpp
@@ -175,7 +175,7 @@ void cFurnaceRecipe::ReloadRecipes(void)
 	{
 		LOGERROR("ERROR: FurnaceRecipe, syntax error" );
 	}
-	LOG("Loaded %u furnace recipes and %u fuels", m_pState->Recipes.size(), m_pState->Fuel.size());
+	LOG("Loaded " SIZE_T_FMT " furnace recipes and " SIZE_T_FMT " fuels", m_pState->Recipes.size(), m_pState->Fuel.size());
 }
 
 
diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index f89b1800d..32a687201 100644
--- a/src/Generating/BioGen.cpp
+++ b/src/Generating/BioGen.cpp
@@ -97,7 +97,7 @@ void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
 {
 	AString Biome = a_IniFile.GetValueSet("Generator", "ConstantBiome", "Plains");
 	m_Biome = StringToBiome(Biome);
-	if (m_Biome == -1)
+	if (m_Biome == biInvalidBiome)
 	{
 		LOGWARN("[Generator]::ConstantBiome value \"%s\" not recognized, using \"Plains\".", Biome.c_str());
 		m_Biome = biPlains;
@@ -233,7 +233,7 @@ void cBiomeGenList::InitializeBiomes(const AString & a_Biomes)
 			}
 		}
 		EMCSBiome Biome = StringToBiome(Split2[0]);
-		if (Biome != -1)
+		if (Biome != biInvalidBiome)
 		{
 			for (int i = 0; i < Count; i++)
 			{
@@ -371,8 +371,8 @@ void cBioGenDistortedVoronoi::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::B
 		Distort(BaseX + x * 4, BaseZ + z * 4, DistortX[4 * x][4 * z], DistortZ[4 * x][4 * z]);
 	}
 	
-	LinearUpscale2DArrayInPlace(&DistortX[0][0], cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4);
-	LinearUpscale2DArrayInPlace(&DistortZ[0][0], cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4);
+	LinearUpscale2DArrayInPlace<cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4>(&DistortX[0][0]);
+	LinearUpscale2DArrayInPlace<cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4>(&DistortZ[0][0]);
 	
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
@@ -477,8 +477,8 @@ void cBioGenMultiStepMap::DecideOceanLandMushroom(int a_ChunkX, int a_ChunkZ, cC
 	{
 		Distort(BaseX + x * 4, BaseZ + z * 4, DistortX[4 * x][4 * z], DistortZ[4 * x][4 * z], DistortSize);
 	}
-	LinearUpscale2DArrayInPlace(&DistortX[0][0], cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4);
-	LinearUpscale2DArrayInPlace(&DistortZ[0][0], cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4);
+	LinearUpscale2DArrayInPlace<cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4>(&DistortX[0][0]);
+	LinearUpscale2DArrayInPlace<cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4>(&DistortZ[0][0]);
 	
 	// Prepare a 9x9 area of neighboring cell seeds
 	// (assuming that 7x7 cell area is larger than a chunk being generated)
@@ -500,7 +500,7 @@ void cBioGenMultiStepMap::DecideOceanLandMushroom(int a_ChunkX, int a_ChunkZ, cC
 			int OffsetZ = (m_Noise4.IntNoise3DInt(RealCellX, 32 * RealCellX - 16 * RealCellZ, RealCellZ) / 8) % m_OceanCellSize;
 			SeedX[xc][zc] = CellBlockX + OffsetX;
 			SeedZ[xc][zc] = CellBlockZ + OffsetZ;
-			SeedV[xc][zc] = (((m_Noise6.IntNoise3DInt(RealCellX, RealCellX - RealCellZ + 1000, RealCellZ) / 11) % 256) > 90) ? biOcean : ((EMCSBiome)(-1));
+			SeedV[xc][zc] = (((m_Noise6.IntNoise3DInt(RealCellX, RealCellX - RealCellZ + 1000, RealCellZ) / 11) % 256) > 90) ? biOcean : (biInvalidBiome);
 		}  // for z
 	}  // for x
 	
@@ -573,7 +573,7 @@ void cBioGenMultiStepMap::AddRivers(int a_ChunkX, int a_ChunkZ, cChunkDef::Biome
 		float NoiseCoordZ = (float)(a_ChunkZ * cChunkDef::Width + z) / m_RiverCellSize;
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			if (cChunkDef::GetBiome(a_BiomeMap, x, z) != -1)
+			if (cChunkDef::GetBiome(a_BiomeMap, x, z) != biInvalidBiome)
 			{
 				// Biome already set, skip this column
 				continue;
@@ -651,8 +651,8 @@ void cBioGenMultiStepMap::BuildTemperatureHumidityMaps(int a_ChunkX, int a_Chunk
 			HumidityMap[x + 17 * z] = NoiseH;
 		}  // for x
 	}  // for z
-	LinearUpscale2DArrayInPlace(TemperatureMap, 17, 17, 8, 8);
-	LinearUpscale2DArrayInPlace(HumidityMap,    17, 17, 8, 8);
+	LinearUpscale2DArrayInPlace<17, 17, 8, 8>(TemperatureMap);
+	LinearUpscale2DArrayInPlace<17, 17, 8, 8>(HumidityMap);
 	
 	// Re-map into integral values in [0 .. 255] range:
 	for (size_t idx = 0; idx < ARRAYCOUNT(a_TemperatureMap); idx++)
@@ -693,7 +693,7 @@ void cBioGenMultiStepMap::DecideLandBiomes(cChunkDef::BiomeMap & a_BiomeMap, con
 		int idxZ = 17 * z;
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			if (cChunkDef::GetBiome(a_BiomeMap, x, z) != -1)
+			if (cChunkDef::GetBiome(a_BiomeMap, x, z) != biInvalidBiome)
 			{
 				// Already set before
 				continue;
@@ -778,8 +778,8 @@ void cBioGenTwoLevel::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap
 		DistortZ[4 * x][4 * z] = BlockZ + (int)(64 * NoiseZ);
 	}
 	
-	LinearUpscale2DArrayInPlace(&DistortX[0][0], cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4);
-	LinearUpscale2DArrayInPlace(&DistortZ[0][0], cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4);
+	LinearUpscale2DArrayInPlace<cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4>(&DistortX[0][0]);
+	LinearUpscale2DArrayInPlace<cChunkDef::Width + 1, cChunkDef::Width + 1, 4, 4>(&DistortZ[0][0]);
 	
 	// Apply distortion to each block coord, then query the voronoi maps for biome group and biome index and choose biome based on that:
 	for (int z = 0; z < cChunkDef::Width; z++)
diff --git a/src/Generating/CMakeLists.txt b/src/Generating/CMakeLists.txt
index e1ba299fc..1147744c0 100644
--- a/src/Generating/CMakeLists.txt
+++ b/src/Generating/CMakeLists.txt
@@ -9,3 +9,5 @@ file(GLOB SOURCE
 )
 
 add_library(Generating ${SOURCE})
+
+target_link_libraries(Generating OSSupport iniFile Blocks)
diff --git a/src/Generating/Caves.cpp b/src/Generating/Caves.cpp
index 2571e6b77..98b7c8681 100644
--- a/src/Generating/Caves.cpp
+++ b/src/Generating/Caves.cpp
@@ -762,7 +762,7 @@ void cStructGenWormNestCaves::ClearCache(void)
 
 
 
-void cStructGenWormNestCaves::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenWormNestCaves::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
@@ -902,7 +902,7 @@ static float GetMarbleNoise( float x, float y, float z, cNoise & a_Noise )
 
 
 
-void cStructGenMarbleCaves::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenMarbleCaves::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	cNoise Noise(m_Seed);
 	for (int z = 0; z < cChunkDef::Width; z++)
@@ -938,7 +938,7 @@ void cStructGenMarbleCaves::GenStructures(cChunkDesc & a_ChunkDesc)
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenDualRidgeCaves:
 
-void cStructGenDualRidgeCaves::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenDualRidgeCaves::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
diff --git a/src/Generating/Caves.h b/src/Generating/Caves.h
index ea7f10bf4..7c45c056b 100644
--- a/src/Generating/Caves.h
+++ b/src/Generating/Caves.h
@@ -20,7 +20,7 @@
 
 
 class cStructGenMarbleCaves :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenMarbleCaves(int a_Seed) : m_Seed(a_Seed) {}
@@ -29,8 +29,8 @@ protected:
 
 	int m_Seed;
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -38,7 +38,7 @@ protected:
 
 
 class cStructGenDualRidgeCaves :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenDualRidgeCaves(int a_Seed, float a_Threshold) :
@@ -55,8 +55,8 @@ protected:
 	int    m_Seed;
 	float  m_Threshold;
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -64,7 +64,7 @@ protected:
 
 
 class cStructGenWormNestCaves :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenWormNestCaves(int a_Seed, int a_Size = 64, int a_Grid = 96, int a_MaxOffset = 128) :
@@ -94,7 +94,7 @@ protected:
 	void GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cCaveSystems & a_Caves);
 	
 	// cStructGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
diff --git a/src/Generating/ChunkDesc.cpp b/src/Generating/ChunkDesc.cpp
index af1a8a6c7..7711723fc 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -118,9 +118,9 @@ void cChunkDesc::SetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_B
 
 
 
-void cChunkDesc::SetBiome(int a_RelX, int a_RelZ, int a_BiomeID)
+void cChunkDesc::SetBiome(int a_RelX, int a_RelZ, EMCSBiome a_BiomeID)
 {
-	cChunkDef::SetBiome(m_BiomeMap, a_RelX, a_RelZ, (EMCSBiome)a_BiomeID);
+	cChunkDef::SetBiome(m_BiomeMap, a_RelX, a_RelZ, a_BiomeID);
 }
 
 
@@ -209,6 +209,7 @@ bool cChunkDesc::IsUsingDefaultComposition(void) const
 
 void cChunkDesc::SetUseDefaultStructures(bool a_bUseDefaultStructures)
 {
+	LOGWARNING("%s: Structures are no longer accounted for, use Finishers instead", __FUNCTION__);
 	m_bUseDefaultStructures = a_bUseDefaultStructures;
 }
 
@@ -218,6 +219,7 @@ void cChunkDesc::SetUseDefaultStructures(bool a_bUseDefaultStructures)
 
 bool cChunkDesc::IsUsingDefaultStructures(void) const
 {
+	LOGWARNING("%s: Structures are no longer accounted for, use Finishers instead", __FUNCTION__);
 	return m_bUseDefaultStructures;
 }
 
@@ -341,9 +343,9 @@ void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX
 	int SizeY = a_MaxRelY - a_MinRelY;
 	int SizeZ = a_MaxRelZ - a_MinRelZ;
 	a_Dest.Clear();
-	a_Dest.m_OriginX = m_ChunkX * cChunkDef::Width + a_MinRelX;
-	a_Dest.m_OriginY = a_MinRelY;
-	a_Dest.m_OriginZ = m_ChunkZ * cChunkDef::Width + a_MinRelZ;
+	a_Dest.m_Origin.x = m_ChunkX * cChunkDef::Width + a_MinRelX;
+	a_Dest.m_Origin.y = a_MinRelY;
+	a_Dest.m_Origin.z = m_ChunkZ * cChunkDef::Width + a_MinRelZ;
 	a_Dest.SetSize(SizeX, SizeY, SizeZ, cBlockArea::baTypes | cBlockArea::baMetas);
 
 	for (int y = 0; y < SizeY; y++)
@@ -562,6 +564,31 @@ cBlockEntity * cChunkDesc::GetBlockEntity(int a_RelX, int a_RelY, int a_RelZ)
 
 
 
+void cChunkDesc::UpdateHeightmap(void)
+{
+	for (int x = 0; x < cChunkDef::Width; x++)
+	{
+		for (int z = 0; z < cChunkDef::Width; z++)
+		{
+			int Height = 0;
+			for (int y = cChunkDef::Height - 1; y > 0; y--)
+			{
+				BLOCKTYPE BlockType = GetBlockType(x, y, z);
+				if (BlockType != E_BLOCK_AIR)
+				{
+					Height = y;
+					break;
+				}
+			}  // for y
+			SetHeight(x, z, Height);
+		}  // for z
+	}  // for x
+}
+
+
+
+
+
 void cChunkDesc::CompressBlockMetas(cChunkDef::BlockNibbles & a_DestMetas)
 {
 	const NIBBLETYPE * AreaMetas = m_BlockArea.GetBlockMetas();
diff --git a/src/Generating/ChunkDesc.h b/src/Generating/ChunkDesc.h
index e130c463f..8edc2800b 100644
--- a/src/Generating/ChunkDesc.h
+++ b/src/Generating/ChunkDesc.h
@@ -30,7 +30,7 @@ class cChunkDesc
 public:
 	// tolua_end
 	
-	/// Uncompressed block metas, 1 meta per byte
+	/** Uncompressed block metas, 1 meta per byte */
 	typedef NIBBLETYPE BlockNibbleBytes[cChunkDef::NumBlocks];
 	
 	cChunkDesc(int a_ChunkX, int a_ChunkZ);
@@ -53,9 +53,11 @@ public:
 	void       SetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_BlockMeta);
 	NIBBLETYPE GetBlockMeta(int a_RelX, int a_RelY, int a_RelZ);
 
-	void       SetBiome(int a_RelX, int a_RelZ, int a_BiomeID);
+	void       SetBiome(int a_RelX, int a_RelZ, EMCSBiome a_BiomeID);
 	EMCSBiome  GetBiome(int a_RelX, int a_RelZ);
 
+	// These operate on the heightmap, so they could get out of sync with the data
+	// Use UpdateHeightmap() to re-sync
 	void       SetHeight(int a_RelX, int a_RelZ, int a_Height);
 	int        GetHeight(int a_RelX, int a_RelZ);
 
@@ -71,16 +73,16 @@ public:
 	void SetUseDefaultFinish(bool a_bUseDefaultFinish);
 	bool IsUsingDefaultFinish(void) const;
 
-	/// Writes the block area into the chunk, with its origin set at the specified relative coords. Area's data overwrite everything in the chunk.
+	/** Writes the block area into the chunk, with its origin set at the specified relative coords. Area's data overwrite everything in the chunk. */
 	void WriteBlockArea(const cBlockArea & a_BlockArea, int a_RelX, int a_RelY, int a_RelZ, cBlockArea::eMergeStrategy a_MergeStrategy = cBlockArea::msOverwrite);
 
-	/// Reads an area from the chunk into a cBlockArea, blocktypes and blockmetas
+	/** Reads an area from the chunk into a cBlockArea, blocktypes and blockmetas */
 	void ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ);
 
-	/// Returns the maximum height value in the heightmap
+	/** Returns the maximum height value in the heightmap */
 	HEIGHTTYPE GetMaxHeight(void) const;
 	
-	/// Fills the relative cuboid with specified block; allows cuboid out of range of this chunk
+	/** Fills the relative cuboid with specified block; allows cuboid out of range of this chunk */
 	void FillRelCuboid(
 		int a_MinX, int a_MaxX,
 		int a_MinY, int a_MaxY,
@@ -88,7 +90,7 @@ public:
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	);
 	
-	/// Fills the relative cuboid with specified block; allows cuboid out of range of this chunk
+	/** Fills the relative cuboid with specified block; allows cuboid out of range of this chunk */
 	void FillRelCuboid(const cCuboid & a_RelCuboid, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 	{
 		FillRelCuboid(
@@ -99,7 +101,7 @@ public:
 		);
 	}
 	
-	/// Replaces the specified src blocks in the cuboid by the dst blocks; allows cuboid out of range of this chunk
+	/** Replaces the specified src blocks in the cuboid by the dst blocks; allows cuboid out of range of this chunk */
 	void ReplaceRelCuboid(
 		int a_MinX, int a_MaxX,
 		int a_MinY, int a_MaxY,
@@ -108,7 +110,7 @@ public:
 		BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta
 	);
 	
-	/// Replaces the specified src blocks in the cuboid by the dst blocks; allows cuboid out of range of this chunk
+	/** Replaces the specified src blocks in the cuboid by the dst blocks; allows cuboid out of range of this chunk */
 	void ReplaceRelCuboid(
 		const cCuboid & a_RelCuboid,
 		BLOCKTYPE a_SrcType, NIBBLETYPE a_SrcMeta,
@@ -124,7 +126,7 @@ public:
 		);
 	}
 
-	/// Replaces the blocks in the cuboid by the dst blocks if they are considered non-floor (air, water); allows cuboid out of range of this chunk
+	/** Replaces the blocks in the cuboid by the dst blocks if they are considered non-floor (air, water); allows cuboid out of range of this chunk */
 	void FloorRelCuboid(
 		int a_MinX, int a_MaxX,
 		int a_MinY, int a_MaxY,
@@ -132,7 +134,7 @@ public:
 		BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta
 	);
 	
-	/// Replaces the blocks in the cuboid by the dst blocks if they are considered non-floor (air, water); allows cuboid out of range of this chunk
+	/** Replaces the blocks in the cuboid by the dst blocks if they are considered non-floor (air, water); allows cuboid out of range of this chunk */
 	void FloorRelCuboid(
 		const cCuboid & a_RelCuboid,
 		BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta
@@ -146,7 +148,7 @@ public:
 		);
 	}
 	
-	/// Fills the relative cuboid with specified block with a random chance; allows cuboid out of range of this chunk
+	/** Fills the relative cuboid with specified block with a random chance; allows cuboid out of range of this chunk */
 	void RandomFillRelCuboid(
 		int a_MinX, int a_MaxX,
 		int a_MinY, int a_MaxY,
@@ -155,7 +157,7 @@ public:
 		int a_RandomSeed, int a_ChanceOutOf10k
 	);
 	
-	/// Fills the relative cuboid with specified block with a random chance; allows cuboid out of range of this chunk
+	/** Fills the relative cuboid with specified block with a random chance; allows cuboid out of range of this chunk */
 	void RandomFillRelCuboid(
 		const cCuboid & a_RelCuboid, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
 		int a_RandomSeed, int a_ChanceOutOf10k
@@ -170,11 +172,15 @@ public:
 		);
 	}
 	
-	/// Returns the block entity at the specified coords.
-	/// If there is no block entity at those coords, tries to create one, based on the block type
-	/// If the blocktype doesn't support a block entity, returns NULL.
+	/** Returns the block entity at the specified coords.
+	If there is no block entity at those coords, tries to create one, based on the block type
+	If the blocktype doesn't support a block entity, returns NULL. */
 	cBlockEntity * GetBlockEntity(int a_RelX, int a_RelY, int a_RelZ);
 	
+	/** Updates the heightmap to match the current contents.
+	Useful for plugins when writing custom block areas into the chunk */
+	void UpdateHeightmap(void);
+	
 	// tolua_end
 	
 	// Accessors used by cChunkGenerator::Generator descendants:
@@ -187,11 +193,11 @@ public:
 	inline cEntityList &             GetEntities              (void) { return m_Entities; }
 	inline cBlockEntityList &        GetBlockEntities         (void) { return m_BlockEntities; }
 	
-	/// Compresses the metas from the BlockArea format (1 meta per byte) into regular format (2 metas per byte)
+	/** Compresses the metas from the BlockArea format (1 meta per byte) into regular format (2 metas per byte) */
 	void CompressBlockMetas(cChunkDef::BlockNibbles & a_DestMetas);
 	
 	#ifdef _DEBUG
-	/// Verifies that the heightmap corresponds to blocktype contents; if not, asserts on that column
+	/** Verifies that the heightmap corresponds to blocktype contents; if not, asserts on that column */
 	void VerifyHeightmap(void);
 	#endif  // _DEBUG
 	
diff --git a/src/Generating/ChunkGenerator.cpp b/src/Generating/ChunkGenerator.cpp
index baa5b76b8..73f0223e8 100644
--- a/src/Generating/ChunkGenerator.cpp
+++ b/src/Generating/ChunkGenerator.cpp
@@ -116,7 +116,7 @@ void cChunkGenerator::QueueGenerateChunk(int a_ChunkX, int a_ChunkY, int a_Chunk
 		// Add to queue, issue a warning if too many:
 		if (m_Queue.size() >= QUEUE_WARNING_LIMIT)
 		{
-			LOGWARN("WARNING: Adding chunk [%i, %i] to generation queue; Queue is too big! (%i)", a_ChunkX, a_ChunkZ, m_Queue.size());
+			LOGWARN("WARNING: Adding chunk [%i, %i] to generation queue; Queue is too big! (" SIZE_T_FMT ")", a_ChunkX, a_ChunkZ, m_Queue.size());
 		}
 		m_Queue.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));
 	}
@@ -180,7 +180,7 @@ BLOCKTYPE cChunkGenerator::GetIniBlock(cIniFile & a_IniFile, const AString & a_S
 	BLOCKTYPE Block = BlockStringToType(BlockType);
 	if (Block < 0)
 	{
-		LOGWARN("[&s].%s Could not parse block value \"%s\". Using default: \"%s\".", a_SectionName.c_str(), a_ValueName.c_str(), BlockType.c_str(),a_Default.c_str());
+		LOGWARN("[%s].%s Could not parse block value \"%s\". Using default: \"%s\".", a_SectionName.c_str(), a_ValueName.c_str(), BlockType.c_str(),a_Default.c_str());
 		return BlockStringToType(a_Default);
 	}
 	return Block;
@@ -201,7 +201,7 @@ void cChunkGenerator::Execute(void)
 	while (!m_ShouldTerminate)
 	{
 		cCSLock Lock(m_CS);
-		while (m_Queue.size() == 0)
+		while (m_Queue.empty())
 		{
 			if ((NumChunksGenerated > 16) && (clock() - LastReportTick > CLOCKS_PER_SEC))
 			{
@@ -221,6 +221,13 @@ void cChunkGenerator::Execute(void)
 			LastReportTick = clock();
 		}
 
+		if (m_Queue.empty())
+		{
+			// Sometimes the queue remains empty
+			// If so, we can't do any front() operations on it!
+			continue;
+		}
+
 		cChunkCoords coords = m_Queue.front();		// Get next coord from queue
 		m_Queue.erase( m_Queue.begin() );	// Remove coordinate from queue
 		bool SkipEnabled = (m_Queue.size() > QUEUE_SKIP_LIMIT);
diff --git a/src/Generating/CompoGen.cpp b/src/Generating/CompoGen.cpp
index 60356fe46..578bb2481 100644
--- a/src/Generating/CompoGen.cpp
+++ b/src/Generating/CompoGen.cpp
@@ -566,7 +566,7 @@ void cCompoGenNether::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 			m_Noise2.IntNoise3DInt(BaseX + INTERPOL_X * x, 0, BaseZ + INTERPOL_Z * z) /
 			256;
 	}  // for x, z - FloorLo[]
-	LinearUpscale2DArrayInPlace(FloorLo, 17, 17, INTERPOL_X, INTERPOL_Z);
+	LinearUpscale2DArrayInPlace<17, 17, INTERPOL_X, INTERPOL_Z>(FloorLo);
 	
 	// Interpolate segments:
 	for (int Segment = 0; Segment < MaxHeight; Segment += SEGMENT_HEIGHT)
@@ -579,7 +579,7 @@ void cCompoGenNether::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 				m_Noise2.IntNoise3DInt(BaseX + INTERPOL_Z * x, Segment + SEGMENT_HEIGHT, BaseZ + INTERPOL_Z * z) /
 				256;
 		}  // for x, z - FloorLo[]
-		LinearUpscale2DArrayInPlace(FloorHi, 17, 17, INTERPOL_X, INTERPOL_Z);
+		LinearUpscale2DArrayInPlace<17, 17, INTERPOL_X, INTERPOL_Z>(FloorHi);
 		
 		// Interpolate between FloorLo and FloorHi:
 		for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++)
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index cfa7e9c6f..2e886336f 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/src/Generating/ComposableGenerator.cpp
@@ -21,7 +21,9 @@
 #include "DistortedHeightmap.h"
 #include "EndGen.h"
 #include "MineShafts.h"
+#include "NetherFortGen.h"
 #include "Noise3DGenerator.h"
+#include "POCPieceGenerator.h"
 #include "Ravines.h"
 
 
@@ -133,11 +135,6 @@ cComposableGenerator::~cComposableGenerator()
 		delete *itr;
 	}
 	m_FinishGens.clear();
-	for (cStructureGenList::const_iterator itr = m_StructureGens.begin(); itr != m_StructureGens.end(); ++itr)
-	{
-		delete *itr;
-	}
-	m_StructureGens.clear();
 
 	delete m_CompositionGen;
 	m_CompositionGen = NULL;
@@ -164,7 +161,6 @@ void cComposableGenerator::Initialize(cIniFile & a_IniFile)
 	InitBiomeGen(a_IniFile);
 	InitHeightGen(a_IniFile);
 	InitCompositionGen(a_IniFile);
-	InitStructureGens(a_IniFile);
 	InitFinishGens(a_IniFile);
 }
 
@@ -196,25 +192,25 @@ void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a
 		m_HeightGen->GenHeightMap(a_ChunkX, a_ChunkZ, a_ChunkDesc.GetHeightMap());
 	}
 	
+	bool ShouldUpdateHeightmap = false;
 	if (a_ChunkDesc.IsUsingDefaultComposition())
 	{
 		m_CompositionGen->ComposeTerrain(a_ChunkDesc);
+		ShouldUpdateHeightmap = true;
 	}
 
-	if (a_ChunkDesc.IsUsingDefaultStructures())
-	{	
-		for (cStructureGenList::iterator itr = m_StructureGens.begin(); itr != m_StructureGens.end(); ++itr)
-		{
-			(*itr)->GenStructures(a_ChunkDesc);
-		}   // for itr - m_StructureGens[]
-	}
-	
 	if (a_ChunkDesc.IsUsingDefaultFinish())
 	{
 		for (cFinishGenList::iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)
 		{
 			(*itr)->GenFinish(a_ChunkDesc);
 		}  // for itr - m_FinishGens[]
+		ShouldUpdateHeightmap = true;
+	}
+	
+	if (ShouldUpdateHeightmap)
+	{
+		a_ChunkDesc.UpdateHeightmap();
 	}
 }
 
@@ -290,35 +286,69 @@ void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
 
 
 
-void cComposableGenerator::InitStructureGens(cIniFile & a_IniFile)
+void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 {
-	AString Structures = a_IniFile.GetValueSet("Generator", "Structures", "Ravines, WormNestCaves, WaterLakes, LavaLakes, OreNests, Trees");
-
 	int Seed = m_ChunkGenerator.GetSeed();
-	AStringVector Str = StringSplitAndTrim(Structures, ",");
+	eDimension Dimension = StringToDimension(a_IniFile.GetValue("General", "Dimension", "Overworld"));
+
+	// Older configuration used "Structures" in addition to "Finishers"; we don't distinguish between the two anymore (#398)
+	// Therefore, we load Structures from the ini file for compatibility, but move its contents over to Finishers:
+	AString Structures = a_IniFile.GetValue("Generator", "Structures", "");
+	AString Finishers = a_IniFile.GetValueSet("Generator", "Finishers", "Ravines, WormNestCaves, WaterLakes, LavaLakes, OreNests, Trees, SprinkleFoliage, Ice, Snow, Lilypads, BottomLava, DeadBushes, PreSimulator");
+	if (!Structures.empty())
+	{
+		LOGINFO("[Generator].Structures is deprecated, moving the contents to [Generator].Finishers.");
+		// Structures used to generate before Finishers, so place them first:
+		Structures.append(", ");
+		Finishers = Structures + Finishers;
+		a_IniFile.SetValue("Generator", "Finishers", Finishers);
+	}
+	a_IniFile.DeleteValue("Generator", "Structures");
+
+	// Create all requested finishers:
+	AStringVector Str = StringSplitAndTrim(Finishers, ",");
 	for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)
 	{
-		if (NoCaseCompare(*itr, "DualRidgeCaves") == 0)
+		// Finishers, alpha-sorted:
+		if (NoCaseCompare(*itr, "BottomLava") == 0)
 		{
-			float Threshold = (float)a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3);
-			m_StructureGens.push_back(new cStructGenDualRidgeCaves(Seed, Threshold));
+			int DefaultBottomLavaLevel = (Dimension == dimNether) ? 30 : 10;
+			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
+			m_FinishGens.push_back(new cFinishGenBottomLava(BottomLavaLevel));
+		}
+		else if (NoCaseCompare(*itr, "DeadBushes") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, biDesert, 2, E_BLOCK_SAND, E_BLOCK_SAND));
 		}
 		else if (NoCaseCompare(*itr, "DirectOverhangs") == 0)
 		{
-			m_StructureGens.push_back(new cStructGenDirectOverhangs(Seed));
+			m_FinishGens.push_back(new cStructGenDirectOverhangs(Seed));
 		}
 		else if (NoCaseCompare(*itr, "DistortedMembraneOverhangs") == 0)
 		{
-			m_StructureGens.push_back(new cStructGenDistortedMembraneOverhangs(Seed));
+			m_FinishGens.push_back(new cStructGenDistortedMembraneOverhangs(Seed));
+		}
+		else if (NoCaseCompare(*itr, "DualRidgeCaves") == 0)
+		{
+			float Threshold = (float)a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3);
+			m_FinishGens.push_back(new cStructGenDualRidgeCaves(Seed, Threshold));
+		}
+		else if (NoCaseCompare(*itr, "Ice") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenIce);
 		}
 		else if (NoCaseCompare(*itr, "LavaLakes") == 0)
 		{
 			int Probability = a_IniFile.GetValueSetI("Generator", "LavaLakesProbability", 10);
-			m_StructureGens.push_back(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, *m_HeightGen, Probability));
+			m_FinishGens.push_back(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, *m_HeightGen, Probability));
+		}
+		else if (NoCaseCompare(*itr, "LavaSprings") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, Dimension));
 		}
 		else if (NoCaseCompare(*itr, "MarbleCaves") == 0)
 		{
-			m_StructureGens.push_back(new cStructGenMarbleCaves(Seed));
+			m_FinishGens.push_back(new cStructGenMarbleCaves(Seed));
 		}
 		else if (NoCaseCompare(*itr, "MineShafts") == 0)
 		{
@@ -327,94 +357,69 @@ void cComposableGenerator::InitStructureGens(cIniFile & a_IniFile)
 			int ChanceCorridor  = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCorridor",  600);
 			int ChanceCrossing  = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCrossing",  200);
 			int ChanceStaircase = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceStaircase", 200);
-			m_StructureGens.push_back(new cStructGenMineShafts(
-				Seed, GridSize, MaxSystemSize, 
+			m_FinishGens.push_back(new cStructGenMineShafts(
+				Seed, GridSize, MaxSystemSize,
 				ChanceCorridor, ChanceCrossing, ChanceStaircase
 			));
 		}
-		else if (NoCaseCompare(*itr, "OreNests") == 0)
-		{
-			m_StructureGens.push_back(new cStructGenOreNests(Seed));
-		}
-		else if (NoCaseCompare(*itr, "Ravines") == 0)
-		{
-			m_StructureGens.push_back(new cStructGenRavines(Seed, 128));
-		}
-		else if (NoCaseCompare(*itr, "Trees") == 0)
+		else if (NoCaseCompare(*itr, "Lilypads") == 0)
 		{
-			m_StructureGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));
+			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_LILY_PAD, biSwampland, 4, E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER));
 		}
-		else if (NoCaseCompare(*itr, "WaterLakes") == 0)
+		else if (NoCaseCompare(*itr, "NetherClumpFoliage") == 0)
 		{
-			int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);
-			m_StructureGens.push_back(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, *m_HeightGen, Probability));
+			m_FinishGens.push_back(new cFinishGenNetherClumpFoliage(Seed));
 		}
-		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)
+		else if (NoCaseCompare(*itr, "NetherForts") == 0)
 		{
-			m_StructureGens.push_back(new cStructGenWormNestCaves(Seed));
+			int GridSize = a_IniFile.GetValueSetI("Generator", "NetherFortsGridSize", 512);
+			int MaxDepth = a_IniFile.GetValueSetI("Generator", "NetherFortsMaxDepth", 12);
+			m_FinishGens.push_back(new cNetherFortGen(Seed, GridSize, MaxDepth));
 		}
-		else
+		else if (NoCaseCompare(*itr, "OreNests") == 0)
 		{
-			LOGWARNING("Unknown structure generator: \"%s\". Ignoring.", itr->c_str());
+			m_FinishGens.push_back(new cStructGenOreNests(Seed));
 		}
-	}  // for itr - Str[]
-}
-
-
-
-
-
-void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
-{
-	int Seed = m_ChunkGenerator.GetSeed();
-	eDimension Dimension = StringToDimension(a_IniFile.GetValue("General", "Dimension", "Overworld"));
-
-	AString Finishers = a_IniFile.GetValueSet("Generator", "Finishers", "SprinkleFoliage,Ice,Snow,Lilypads,BottomLava,DeadBushes,PreSimulator");
-	AStringVector Str = StringSplitAndTrim(Finishers, ",");
-	for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)
-	{
-		// Finishers, alpha-sorted:
-		if (NoCaseCompare(*itr, "BottomLava") == 0)
+		else if (NoCaseCompare(*itr, "POCPieces") == 0)
 		{
-			int DefaultBottomLavaLevel = (Dimension == dimNether) ? 30 : 10;
-			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
-			m_FinishGens.push_back(new cFinishGenBottomLava(BottomLavaLevel));
+			m_FinishGens.push_back(new cPOCPieceGenerator(Seed));
 		}
-		else if (NoCaseCompare(*itr, "DeadBushes") == 0)
+		else if (NoCaseCompare(*itr, "PreSimulator") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, biDesert, 2, E_BLOCK_SAND, E_BLOCK_SAND));
+			m_FinishGens.push_back(new cFinishGenPreSimulator);
 		}
-		else if (NoCaseCompare(*itr, "Ice") == 0)
+		else if (NoCaseCompare(*itr, "Ravines") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenIce);
+			m_FinishGens.push_back(new cStructGenRavines(Seed, 128));
 		}
-		else if (NoCaseCompare(*itr, "LavaSprings") == 0)
+		else if (NoCaseCompare(*itr, "Snow") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, Dimension));
+			m_FinishGens.push_back(new cFinishGenSnow);
 		}
-		else if (NoCaseCompare(*itr, "Lilypads") == 0)
+		else if (NoCaseCompare(*itr, "SprinkleFoliage") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_LILY_PAD, biSwampland, 4, E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER));
+			m_FinishGens.push_back(new cFinishGenSprinkleFoliage(Seed));
 		}
-		else if (NoCaseCompare(*itr, "NetherClumpFoliage") == 0)
+		else if (NoCaseCompare(*itr, "Trees") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenNetherClumpFoliage(Seed));
+			m_FinishGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));
 		}
-		else if (NoCaseCompare(*itr, "PreSimulator") == 0)
+		else if (NoCaseCompare(*itr, "WaterLakes") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenPreSimulator);
+			int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);
+			m_FinishGens.push_back(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, *m_HeightGen, Probability));
 		}
-		else if (NoCaseCompare(*itr, "Snow") == 0)
+		else if (NoCaseCompare(*itr, "WaterSprings") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSnow);
+			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, Dimension));
 		}
-		else if (NoCaseCompare(*itr, "SprinkleFoliage") == 0)
+		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSprinkleFoliage(Seed));
+			m_FinishGens.push_back(new cStructGenWormNestCaves(Seed));
 		}
-		else if (NoCaseCompare(*itr, "WaterSprings") == 0)
+		else
 		{
-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, Dimension));
+			LOGWARNING("Unknown Finisher in the [Generator] section: \"%s\". Ignoring.", itr->c_str());
 		}
 	}  // for itr - Str[]
 }
diff --git a/src/Generating/ComposableGenerator.h b/src/Generating/ComposableGenerator.h
index 29add0636..6b7627d2e 100644
--- a/src/Generating/ComposableGenerator.h
+++ b/src/Generating/ComposableGenerator.h
@@ -43,16 +43,16 @@ class cBiomeGen
 public:
 	virtual ~cBiomeGen() {}  // Force a virtual destructor in descendants
 	
-	/// Generates biomes for the given chunk
+	/** Generates biomes for the given chunk */
 	virtual void GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) = 0;
 	
-	/// Reads parameters from the ini file, prepares generator for use.
+	/** Reads parameters from the ini file, prepares generator for use. */
 	virtual void InitializeBiomeGen(cIniFile & a_IniFile) {}
 
-	/// Creates the correct BiomeGen descendant based on the ini file settings and the seed provided.
-	/// a_CacheOffByDefault gets set to whether the cache should be disabled by default
-	/// Used in BiomeVisualiser, too.
-	/// Implemented in BioGen.cpp!
+	/** Creates the correct BiomeGen descendant based on the ini file settings and the seed provided.
+	a_CacheOffByDefault gets set to whether the cache should be disabled by default.
+	Used in BiomeVisualiser, too.
+	Implemented in BioGen.cpp! */
 	static cBiomeGen * CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault);
 
 } ;
@@ -72,10 +72,10 @@ class cTerrainHeightGen
 public:
 	virtual ~cTerrainHeightGen() {}  // Force a virtual destructor in descendants
 	
-	/// Generates heightmap for the given chunk
+	/** Generates heightmap for the given chunk */
 	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) = 0;
 	
-	/// Reads parameters from the ini file, prepares generator for use.
+	/** Reads parameters from the ini file, prepares generator for use. */
 	virtual void InitializeHeightGen(cIniFile & a_IniFile) {}
 	
 	/** Creates the correct TerrainHeightGen descendant based on the ini file settings and the seed provided.
@@ -102,7 +102,7 @@ public:
 	
 	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) = 0;
 	
-	/// Reads parameters from the ini file, prepares generator for use.
+	/** Reads parameters from the ini file, prepares generator for use. */
 	virtual void InitializeCompoGen(cIniFile & a_IniFile) {}
 	
 	/** Creates the correct TerrainCompositionGen descendant based on the ini file settings and the seed provided.
@@ -116,28 +116,12 @@ public:
 
 
 
-/** The interface that a structure generator must implement
-Structures are generated after the terrain composition took place. It should modify the blocktype data to account
-for whatever structures the generator is generating.
-Note that ores are considered structures too, at least from the interface point of view.
-Also note that a worldgenerator may contain multiple structure generators, one for each type of structure
-*/
-class cStructureGen
-{
-public:
-	virtual ~cStructureGen() {}  // Force a virtual destructor in descendants
-	
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) = 0;
-} ;
-
-typedef std::list<cStructureGen *> cStructureGenList;
-
-
-
-
-
 /** The interface that a finisher must implement
-Finisher implements small additions after all structures have been generated.
+Finisher implements changes to the chunk after the rough terrain has been generated.
+Examples of finishers are trees, snow, ore, lilypads and others.
+Note that a worldgenerator may contain multiple finishers.
+Also note that previously we used to distinguish between a structuregen and a finisher; this distinction is
+no longer relevant, all structure generators are considered finishers now (#398)
 */
 class cFinishGen
 {
@@ -171,7 +155,6 @@ protected:
 	cBiomeGen *              m_BiomeGen;
 	cTerrainHeightGen *      m_HeightGen;
 	cTerrainCompositionGen * m_CompositionGen;
-	cStructureGenList        m_StructureGens;
 	cFinishGenList           m_FinishGens;
 	
 	// Generators underlying the caches:
@@ -180,19 +163,16 @@ protected:
 	cTerrainCompositionGen * m_UnderlyingCompositionGen;
 	
 	
-	/// Reads the biome gen settings from the ini and initializes m_BiomeGen accordingly
+	/** Reads the biome gen settings from the ini and initializes m_BiomeGen accordingly */
 	void InitBiomeGen(cIniFile & a_IniFile);
 	
-	/// Reads the HeightGen settings from the ini and initializes m_HeightGen accordingly
+	/** Reads the HeightGen settings from the ini and initializes m_HeightGen accordingly */
 	void InitHeightGen(cIniFile & a_IniFile);
 	
-	/// Reads the CompositionGen settings from the ini and initializes m_CompositionGen accordingly
+	/** Reads the CompositionGen settings from the ini and initializes m_CompositionGen accordingly */
 	void InitCompositionGen(cIniFile & a_IniFile);
 	
-	/// Reads the structures to generate from the ini and initializes m_StructureGens accordingly
-	void InitStructureGens(cIniFile & a_IniFile);
-	
-	/// Reads the finishers from the ini and initializes m_FinishGens accordingly
+	/** Reads the finishers from the ini and initializes m_FinishGens accordingly */
 	void InitFinishGens(cIniFile & a_IniFile);
 } ;
 
diff --git a/src/Generating/FinishGen.cpp b/src/Generating/FinishGen.cpp
index 02045f76a..f2d66af70 100644
--- a/src/Generating/FinishGen.cpp
+++ b/src/Generating/FinishGen.cpp
@@ -88,7 +88,7 @@ void cFinishGenNetherClumpFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
 		{
 			continue;
 		}
-		if (!g_BlockIsSolid[a_ChunkDesc.GetBlockType(PosX, y - 1, PosZ)])  // Only place on solid blocks
+		if (!cBlockInfo::IsSolid(a_ChunkDesc.GetBlockType(PosX, y - 1, PosZ)))  // Only place on solid blocks
 		{
 			continue;
 		}
@@ -131,7 +131,7 @@ void cFinishGenNetherClumpFoliage::TryPlaceClump(cChunkDesc & a_ChunkDesc, int a
 				}
 
 				BLOCKTYPE BlockBelow = a_ChunkDesc.GetBlockType(x, y - 1, z);
-				if (!g_BlockIsSolid[BlockBelow])  // Only place on solid blocks
+				if (!cBlockInfo::IsSolid(BlockBelow))  // Only place on solid blocks
 				{
 					continue;
 				}
@@ -329,7 +329,7 @@ void cFinishGenSnow::GenFinish(cChunkDesc & a_ChunkDesc)
 				case biFrozenOcean:
 				{
 					int Height = a_ChunkDesc.GetHeight(x, z);
-					if (g_BlockIsSnowable[a_ChunkDesc.GetBlockType(x, Height, z)])
+					if (cBlockInfo::IsSnowable(a_ChunkDesc.GetBlockType(x, Height, z)))
 					{
 						a_ChunkDesc.SetBlockType(x, Height + 1, z, E_BLOCK_SNOW);
 						a_ChunkDesc.SetHeight(x, z, Height + 1);
diff --git a/src/Generating/HeiGen.cpp b/src/Generating/HeiGen.cpp
index 10710b4a1..3621421c2 100644
--- a/src/Generating/HeiGen.cpp
+++ b/src/Generating/HeiGen.cpp
@@ -428,7 +428,7 @@ void cHeiGenBiomal::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMa
 			Height[x + 17 * z] = GetHeightAt(x, z, a_ChunkX, a_ChunkZ, Biomes);
 		}
 	}
-	LinearUpscale2DArrayInPlace(Height, 17, 17, STEPX, STEPZ);
+	LinearUpscale2DArrayInPlace<17, 17, STEPX, STEPZ>(Height);
 	
 	// Copy into the heightmap
 	for (int z = 0; z < cChunkDef::Width; z++)
diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index cc39cef7b..231295c3f 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -69,6 +69,8 @@ public:
 		m_BoundingBox(a_BoundingBox)
 	{
 	}
+	
+	virtual ~cMineShaft() {}
 
 	/// Returns true if this mineshaft intersects the specified cuboid
 	bool DoesIntersect(const cCuboid & a_Other)
@@ -1338,7 +1340,7 @@ void cStructGenMineShafts::GetMineShaftSystemsForChunk(
 	BaseX -= NEIGHBORHOOD_SIZE / 2;
 	BaseZ -= NEIGHBORHOOD_SIZE / 2;
 
-	// Walk the cache, move each cave system that we want into a_Caves:
+	// Walk the cache, move each cave system that we want into a_Mineshafts:
 	int StartX = BaseX * m_GridSize;
 	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
 	int StartZ = BaseZ * m_GridSize;
@@ -1407,7 +1409,7 @@ void cStructGenMineShafts::GetMineShaftSystemsForChunk(
 
 
 
-void cStructGenMineShafts::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenMineShafts::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
diff --git a/src/Generating/MineShafts.h b/src/Generating/MineShafts.h
index c53d3bc53..ba32e75ad 100644
--- a/src/Generating/MineShafts.h
+++ b/src/Generating/MineShafts.h
@@ -17,7 +17,7 @@
 
 
 class cStructGenMineShafts :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenMineShafts(
@@ -52,8 +52,8 @@ protected:
 	*/
 	void GetMineShaftSystemsForChunk(int a_ChunkX, int a_ChunkZ, cMineShaftSystems & a_MineShaftSystems);
 
-	// cStructureGen overrides:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen overrides:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
diff --git a/src/Generating/NetherFortGen.cpp b/src/Generating/NetherFortGen.cpp
new file mode 100644
index 000000000..02779a8a3
--- /dev/null
+++ b/src/Generating/NetherFortGen.cpp
@@ -0,0 +1,275 @@
+
+// NetherFortGen.cpp
+
+// Implements the cNetherFortGen class representing the nether fortress generator
+
+#include "Globals.h"
+#include "NetherFortGen.h"
+#include "Prefabs/NetherFortPrefabs.h"
+
+
+
+
+
+static const int NEIGHBORHOOD_SIZE = 3;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cNetherFortGen::cNetherFort:
+
+class cNetherFortGen::cNetherFort
+{
+public:
+	cNetherFortGen & m_ParentGen;
+	int m_BlockX, m_BlockZ;
+	int m_GridSize;
+	int m_Seed;
+	cPlacedPieces m_Pieces;
+
+
+	cNetherFort(cNetherFortGen & a_ParentGen, int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxDepth, int a_Seed) :
+		m_ParentGen(a_ParentGen),
+		m_BlockX(a_BlockX),
+		m_BlockZ(a_BlockZ),
+		m_GridSize(a_GridSize),
+		m_Seed(a_Seed)
+	{
+		// TODO: Proper Y-coord placement
+		int BlockY = 64;
+		
+		// Generate pieces:
+		for (int i = 0; m_Pieces.size() < (size_t)(a_MaxDepth * a_MaxDepth / 8 + a_MaxDepth); i++)
+		{
+			cBFSPieceGenerator pg(m_ParentGen, a_Seed + i);
+			pg.PlacePieces(a_BlockX, BlockY, a_BlockZ, a_MaxDepth, m_Pieces);
+		}
+	}
+
+	
+	~cNetherFort()
+	{
+		cPieceGenerator::FreePieces(m_Pieces);
+	}
+	
+		
+	/** Carves the system into the chunk data */
+	void ProcessChunk(cChunkDesc & a_Chunk)
+	{
+		for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+		{
+			const cPrefab & Prefab = (const cPrefab &)((*itr)->GetPiece());
+			Prefab.Draw(a_Chunk, *itr);
+		}  // for itr - m_PlacedPieces[]
+	}
+};
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cNetherFortGen:
+
+cNetherFortGen::cNetherFortGen(int a_Seed, int a_GridSize, int a_MaxDepth) :
+	m_Seed(a_Seed),
+	m_Noise(a_Seed),
+	m_GridSize(a_GridSize),
+	m_MaxDepth(a_MaxDepth)
+{
+	// Initialize the prefabs:
+	for (size_t i = 0; i < g_NetherFortPrefabs1Count; i++)
+	{
+		cPrefab * Prefab = new cPrefab(g_NetherFortPrefabs1[i]);
+		m_AllPieces.push_back(Prefab);
+		if (Prefab->HasConnectorType(0))
+		{
+			m_OuterPieces.push_back(Prefab);
+		}
+		if (Prefab->HasConnectorType(1))
+		{
+			m_InnerPieces.push_back(Prefab);
+		}
+	}
+	
+	// Initialize the starting piece prefabs:
+	for (size_t i = 0; i < g_NetherFortStartingPrefabs1Count; i++)
+	{
+		m_StartingPieces.push_back(new cPrefab(g_NetherFortStartingPrefabs1[i]));
+	}
+
+	// DEBUG: Try one round of placement:
+	cPlacedPieces Pieces;
+	cBFSPieceGenerator pg(*this, a_Seed);
+	pg.PlacePieces(0, 64, 0, a_MaxDepth, Pieces);
+}
+
+
+
+
+
+cNetherFortGen::~cNetherFortGen()
+{
+	ClearCache();
+	for (cPieces::iterator itr = m_AllPieces.begin(), end = m_AllPieces.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - m_AllPieces[]
+	m_AllPieces.clear();
+}
+
+
+
+
+
+void cNetherFortGen::ClearCache(void)
+{
+	// TODO
+}
+
+
+
+
+
+void cNetherFortGen::GetFortsForChunk(int a_ChunkX, int a_ChunkZ, cNetherForts & a_Forts)
+{
+	int BaseX = a_ChunkX * cChunkDef::Width / m_GridSize;
+	int BaseZ = a_ChunkZ * cChunkDef::Width / m_GridSize;
+	if (BaseX < 0)
+	{
+		--BaseX;
+	}
+	if (BaseZ < 0)
+	{
+		--BaseZ;
+	}
+	BaseX -= NEIGHBORHOOD_SIZE / 2;
+	BaseZ -= NEIGHBORHOOD_SIZE / 2;
+
+	// Walk the cache, move each cave system that we want into a_Forts:
+	int StartX = BaseX * m_GridSize;
+	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
+	int StartZ = BaseZ * m_GridSize;
+	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
+	for (cNetherForts::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
+	{
+		if (
+			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
+			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
+		)
+		{
+			// want
+			a_Forts.push_back(*itr);
+			itr = m_Cache.erase(itr);
+		}
+		else
+		{
+			// don't want
+			++itr;
+		}
+	}  // for itr - m_Cache[]
+
+	// Create those forts that haven't been in the cache:
+	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
+	{
+		int RealX = (BaseX + x) * m_GridSize;
+		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
+		{
+			int RealZ = (BaseZ + z) * m_GridSize;
+			bool Found = false;
+			for (cNetherForts::const_iterator itr = a_Forts.begin(), end = a_Forts.end(); itr != end; ++itr)
+			{
+				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
+				{
+					Found = true;
+					break;
+				}
+			}  // for itr - a_Mineshafts
+			if (!Found)
+			{
+				a_Forts.push_back(new cNetherFort(*this, RealX, RealZ, m_GridSize, m_MaxDepth, m_Seed));
+			}
+		}  // for z
+	}  // for x
+
+	// Copy a_Forts into m_Cache to the beginning:
+	cNetherForts FortsCopy (a_Forts);
+	m_Cache.splice(m_Cache.begin(), FortsCopy, FortsCopy.begin(), FortsCopy.end());
+
+	// Trim the cache if it's too long:
+	if (m_Cache.size() > 100)
+	{
+		cNetherForts::iterator itr = m_Cache.begin();
+		std::advance(itr, 100);
+		for (cNetherForts::iterator end = m_Cache.end(); itr != end; ++itr)
+		{
+			delete *itr;
+		}
+		itr = m_Cache.begin();
+		std::advance(itr, 100);
+		m_Cache.erase(itr, m_Cache.end());
+	}
+}
+
+
+
+
+
+void cNetherFortGen::GenFinish(cChunkDesc & a_ChunkDesc)
+{
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cNetherForts Forts;
+	GetFortsForChunk(ChunkX, ChunkZ, Forts);
+	for (cNetherForts::const_iterator itr = Forts.begin(); itr != Forts.end(); ++itr)
+	{
+		(*itr)->ProcessChunk(a_ChunkDesc);
+	}  // for itr - Forts[]
+}
+
+
+
+
+
+cPieces cNetherFortGen::GetPiecesWithConnector(int a_ConnectorType)
+{
+	switch (a_ConnectorType)
+	{
+		case 0: return m_OuterPieces;
+		case 1: return m_InnerPieces;
+		default: return cPieces();
+	}
+}
+
+
+
+
+
+cPieces cNetherFortGen::GetStartingPieces(void)
+{
+	return m_StartingPieces;
+}
+
+
+
+
+
+void cNetherFortGen::PiecePlaced(const cPiece & a_Piece)
+{
+	UNUSED(a_Piece);
+}
+
+
+
+
+
+void cNetherFortGen::Reset(void)
+{
+	// Nothing needed
+}
+
+
+
+
diff --git a/src/Generating/NetherFortGen.h b/src/Generating/NetherFortGen.h
new file mode 100644
index 000000000..10ba01396
--- /dev/null
+++ b/src/Generating/NetherFortGen.h
@@ -0,0 +1,86 @@
+
+// NetherFortGen.h
+
+// Declares the cNetherFortGen class representing the nether fortress generator
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "PieceGenerator.h"
+
+
+
+
+
+class cNetherFortGen :
+	public cFinishGen,
+	public cPiecePool
+{
+public:
+	cNetherFortGen(int a_Seed, int a_GridSize, int a_MaxDepth);
+	
+	virtual ~cNetherFortGen();
+	
+protected:
+	class cNetherFort;  // fwd: NetherFortGen.cpp
+	typedef std::list<cNetherFort *> cNetherForts;
+	
+	
+	/** The seed used for generating*/
+	int m_Seed;
+	
+	/** The noise used for generating */
+	cNoise m_Noise;
+	
+	/** Average spacing between the fortresses*/
+	int m_GridSize;
+	
+	/** Maximum depth of the piece-generator tree */
+	int m_MaxDepth;
+
+	/** Cache of the most recently used systems. MoveToFront used. */
+	cNetherForts m_Cache;
+	
+	/** All the pieces that are allowed for building.
+	This is the list that's used for memory allocation and deallocation for the pieces. */
+	cPieces m_AllPieces;
+	
+	/** The pieces that are used as starting pieces.
+	This list is not shared and the pieces need deallocation. */
+	cPieces m_StartingPieces;
+	
+	/** The pieces that have an "outer" connector.
+	The pieces are copies out of m_AllPieces and shouldn't be ever delete-d. */
+	cPieces m_OuterPieces;
+
+	/** The pieces that have an "inner" connector.
+	The pieces are copies out of m_AllPieces and shouldn't be ever delete-d. */
+	cPieces m_InnerPieces;
+
+
+	/** Clears everything from the cache.
+	Also invalidates the forst returned by GetFortsForChunk(). */
+	void ClearCache(void);
+	
+	/** Returns all forts that *may* intersect the given chunk.
+	The returned forts live within m_Cache.They are valid until the next call
+	to this function (which may delete some of the pointers).	*/
+	void GetFortsForChunk(int a_ChunkX, int a_ChunkZ, cNetherForts & a_Forts);
+
+	// cFinishGen overrides:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+	
+	// cPiecePool overrides:
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;
+	virtual cPieces GetStartingPieces(void) override;
+	virtual void PiecePlaced(const cPiece & a_Piece) override;
+	virtual void Reset(void) override;
+} ;
+
+
+
+
diff --git a/src/Generating/Noise3DGenerator.cpp b/src/Generating/Noise3DGenerator.cpp
index afa40c647..15a588d45 100644
--- a/src/Generating/Noise3DGenerator.cpp
+++ b/src/Generating/Noise3DGenerator.cpp
@@ -420,7 +420,7 @@ void cNoise3DComposable::GenerateNoiseArrayIfNeeded(int a_ChunkX, int a_ChunkZ)
 			}
 		}
 		// Linear-interpolate this XZ floor:
-		LinearUpscale2DArrayInPlace(CurFloor, 17, 17, UPSCALE_X, UPSCALE_Z);
+		LinearUpscale2DArrayInPlace<17, 17, UPSCALE_X, UPSCALE_Z>(CurFloor);
 	}
 
 	// Finish the 3D linear interpolation by interpolating between each XZ-floors on the Y axis
diff --git a/src/Generating/POCPieceGenerator.cpp b/src/Generating/POCPieceGenerator.cpp
new file mode 100644
index 000000000..9ed4b565e
--- /dev/null
+++ b/src/Generating/POCPieceGenerator.cpp
@@ -0,0 +1,270 @@
+
+// POCPieceGenerator.cpp
+
+// Implements the cPOCPieceGenerator class representing a Proof-Of_Concept structure generator using the cPieceGenerator technique
+// The generator generates a maze of rooms at {0, 50, 0}
+
+#include "Globals.h"
+#include "POCPieceGenerator.h"
+#include "ChunkDesc.h"
+
+
+
+
+
+/** POC pieces are simple boxes that have connectors in the middle of their walls.
+Each wall has one connector, there are 3 connector types that get assigned semi-randomly.
+The piece also knows how to imprint itself in a cChunkDesc, each piece has a different color glass
+and each connector is uses a different color wool frame. */
+class cPOCPiece :
+	public cPiece
+{
+public:
+	cPOCPiece(int a_SizeXZ, int a_Height) :
+		m_SizeXZ(a_SizeXZ),
+		m_Height(a_Height)
+	{
+		m_Connectors.push_back(cConnector(m_SizeXZ / 2, a_Height / 2, 0,            0,            BLOCK_FACE_ZM));
+		m_Connectors.push_back(cConnector(m_SizeXZ / 2, a_Height / 2, m_SizeXZ - 1, 1,            BLOCK_FACE_ZP));
+		m_Connectors.push_back(cConnector(0,            a_Height / 2, m_SizeXZ / 2, 2,            BLOCK_FACE_XM));
+		m_Connectors.push_back(cConnector(m_SizeXZ - 1, a_Height - 1, m_SizeXZ / 2, m_SizeXZ % 3, BLOCK_FACE_XP));
+	}
+	
+	
+	/** Imprints the piece in the specified chunk. Assumes they intersect. */
+	void ImprintInChunk(cChunkDesc & a_ChunkDesc, const Vector3i & a_Pos, int a_NumCCWRotations)
+	{
+		int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+		int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+		Vector3i Min = a_Pos;
+		Min.Move(-BlockX, 0, -BlockZ);
+		Vector3i Max = Min;
+		Max.Move(m_SizeXZ - 1, m_Height - 1, m_SizeXZ - 1);
+		ASSERT(Min.x < cChunkDef::Width);
+		ASSERT(Min.z < cChunkDef::Width);
+		ASSERT(Max.x >= 0);
+		ASSERT(Max.z >= 0);
+		if (Min.x >= 0)
+		{
+			// Draw the XM wall:
+			a_ChunkDesc.FillRelCuboid(Min.x, Min.x, Min.y, Max.y, Min.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		if (Min.z >= 0)
+		{
+			// Draw the ZM wall:
+			a_ChunkDesc.FillRelCuboid(Min.x, Max.x, Min.y, Max.y, Min.z, Min.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		if (Max.x < cChunkDef::Width)
+		{
+			// Draw the XP wall:
+			a_ChunkDesc.FillRelCuboid(Max.x, Max.x, Min.y, Max.y, Min.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		if (Max.z < cChunkDef::Width)
+		{
+			// Draw the ZP wall:
+			a_ChunkDesc.FillRelCuboid(Min.x, Max.x, Min.y, Max.y, Max.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		
+		// Draw all the connectors:
+		for (cConnectors::const_iterator itr = m_Connectors.begin(), end = m_Connectors.end(); itr != end; ++itr)
+		{
+			cConnector Conn = cPiece::RotateMoveConnector(*itr, a_NumCCWRotations, a_Pos.x, a_Pos.y, a_Pos.z);
+			Conn.m_Pos.Move(-BlockX, 0, -BlockZ);
+			if (
+				(Conn.m_Pos.x >= 0) && (Conn.m_Pos.x < cChunkDef::Width) &&
+				(Conn.m_Pos.z >= 0) && (Conn.m_Pos.z < cChunkDef::Width)
+			)
+			{
+				a_ChunkDesc.SetBlockTypeMeta(Conn.m_Pos.x, Conn.m_Pos.y, Conn.m_Pos.z, E_BLOCK_WOOL, itr->m_Type % 16);
+			}
+			
+			/*
+			// TODO: Frame the connectors
+			switch (itr->m_Direction)
+			{
+				case BLOCK_FACE_XM:
+				case BLOCK_FACE_XP:
+				{
+					// TODO
+					break;
+				}
+				
+				case BLOCK_FACE_ZM:
+				case BLOCK_FACE_ZP:
+				{
+					// TODO
+					break;
+				}
+			}
+			*/
+		}  // for itr - m_Connectors[]
+	}
+	
+protected:
+	int m_SizeXZ;
+	int m_Height;
+	cConnectors m_Connectors;
+	
+	// cPiece overrides:
+	virtual cConnectors GetConnectors(void) const override
+	{
+		return m_Connectors;
+	}
+	
+	virtual Vector3i GetSize(void) const override
+	{
+		return Vector3i(m_SizeXZ, m_Height, m_SizeXZ);
+	}
+	
+	virtual cCuboid GetHitBox(void) const override
+	{
+		return cCuboid(0, 0, 0, m_SizeXZ - 1, m_Height - 1, m_SizeXZ - 1);
+	}
+	
+	virtual bool CanRotateCCW(int a_NumRotations) const override
+	{
+		return true;
+	}
+};
+
+
+
+
+
+/*
+static void DebugPieces(const cPlacedPieces & a_Pieces)
+{
+	size_t idx = 0;
+	for (cPlacedPieces::const_iterator itr = a_Pieces.begin(), end = a_Pieces.end(); itr != end; ++itr, ++idx)
+	{
+		const cCuboid & HitBox = (*itr)->GetHitBox();
+		printf("  %u: %d rotations, {%d - %d, %d - %d}\n",
+			idx, (*itr)->GetNumCCWRotations(),
+			HitBox.p1.x, HitBox.p2.x, HitBox.p1.z, HitBox.p2.z
+		);
+	}  // for itr - a_Pieces[]
+}
+//*/
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPOCPieceGenerator:
+
+cPOCPieceGenerator::cPOCPieceGenerator(int a_Seed) :
+	m_Seed(a_Seed)
+{
+	// Prepare a vector of available pieces:
+	m_AvailPieces.push_back(new cPOCPiece(5, 3));
+	m_AvailPieces.push_back(new cPOCPiece(7, 5));
+	m_AvailPieces.push_back(new cPOCPiece(9, 5));
+	m_AvailPieces.push_back(new cPOCPiece(5, 7));
+	
+	// Generate the structure:
+	cBFSPieceGenerator Gen(*this, a_Seed);
+	Gen.PlacePieces(0, 50, 0, 6, m_Pieces);
+	
+	// DebugPieces(m_Pieces);
+	
+	// Get the smallest cuboid encompassing the entire generated structure:
+	cCuboid Bounds(0, 50, 0, 0, 50, 0);
+	for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+	{
+		Vector3i MinCoords = (*itr)->GetCoords();
+		Bounds.Engulf(MinCoords);
+		Bounds.Engulf(MinCoords + (*itr)->GetPiece().GetSize());
+	}  // for itr - m_Pieces[]
+	m_Bounds = Bounds;
+}
+
+
+
+
+
+cPOCPieceGenerator::~cPOCPieceGenerator()
+{
+	cPieceGenerator::FreePieces(m_Pieces);
+}
+
+
+
+
+
+void cPOCPieceGenerator::GenFinish(cChunkDesc & a_ChunkDesc)
+{
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	if (
+		(BlockX + 16 < m_Bounds.p1.x) || (BlockX > m_Bounds.p2.x) ||  // X coords out of bounds of the generated structure
+		(BlockZ + 16 < m_Bounds.p1.z) || (BlockZ > m_Bounds.p2.z)     // Z coords out of bounds of the generated structure
+	)
+	{
+		return;
+	}
+	
+	// Imprint each piece in the chunk:
+	for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+	{
+		const Vector3i & Pos = (*itr)->GetCoords();
+		Vector3i Size = (*itr)->GetPiece().GetSize();
+		if (((*itr)->GetNumCCWRotations() % 2) == 1)
+		{
+			std::swap(Size.x, Size.z);
+		}
+		if (
+			(Pos.x >= BlockX + 16) || (Pos.x + Size.x - 1 < BlockX) ||
+			(Pos.z >= BlockZ + 16) || (Pos.z + Size.z - 1 < BlockZ)
+		)
+		{
+			// This piece doesn't intersect the chunk
+			continue;
+		}
+			
+		((cPOCPiece &)(*itr)->GetPiece()).ImprintInChunk(a_ChunkDesc, Pos, (*itr)->GetNumCCWRotations());
+	}  // for itr - m_Pieces[]
+	a_ChunkDesc.UpdateHeightmap();
+}
+
+
+
+
+
+cPieces cPOCPieceGenerator::GetPiecesWithConnector(int a_ConnectorType)
+{
+	// Each piece has each connector
+	return m_AvailPieces;
+}
+
+
+
+
+
+cPieces cPOCPieceGenerator::GetStartingPieces(void)
+{
+	// Any piece can be a starting piece
+	return m_AvailPieces;
+}
+
+
+
+
+
+void cPOCPieceGenerator::PiecePlaced(const cPiece & a_Piece)
+{
+	UNUSED(a_Piece);
+}
+
+
+
+
+
+void cPOCPieceGenerator::Reset(void)
+{
+	// Nothing needed
+}
+
+
+
+
diff --git a/src/Generating/POCPieceGenerator.h b/src/Generating/POCPieceGenerator.h
new file mode 100644
index 000000000..de3114ce0
--- /dev/null
+++ b/src/Generating/POCPieceGenerator.h
@@ -0,0 +1,54 @@
+
+// POCPieceGenerator.h
+
+// Declares the cPOCPieceGenerator class representing a Proof-Of_Concept structure generator using the cPieceGenerator technique
+// The generator generates a maze of rooms at {0, 100, 0}
+
+
+
+
+
+#pragma once
+
+#include "PieceGenerator.h"
+#include "ComposableGenerator.h"
+
+
+
+
+
+class cPOCPieceGenerator :
+	public cFinishGen,
+	protected cPiecePool
+{
+public:
+	cPOCPieceGenerator(int a_Seed);
+	~cPOCPieceGenerator();
+	
+protected:
+	int m_Seed;
+	
+	/** The pieces from which the generated structure is built. */
+	cPieces m_AvailPieces;
+	
+	/** The placed pieces of the generated structure. */
+	cPlacedPieces m_Pieces;
+	
+	/** Bounds of the complete structure, to save on processing outside chunks. */
+	cCuboid m_Bounds;
+
+
+	// cFinishGen overrides:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+	
+	// cPiecePool overrides:
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;
+	virtual cPieces GetStartingPieces(void) override;
+	virtual void PiecePlaced(const cPiece & a_Piece) override;
+	virtual void Reset(void) override;
+} ;
+
+
+
+
+
diff --git a/src/Generating/PieceGenerator.cpp b/src/Generating/PieceGenerator.cpp
new file mode 100644
index 000000000..8999a5ff7
--- /dev/null
+++ b/src/Generating/PieceGenerator.cpp
@@ -0,0 +1,625 @@
+
+// PieceGenerator.cpp
+
+// Implements the cBFSPieceGenerator class and cDFSPieceGenerator class 
+// representing base classes for generating structures composed of individual "pieces"
+
+#include "Globals.h"
+#include "PieceGenerator.h"
+
+
+
+
+
+#ifdef SELF_TEST
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Self-test:
+
+static class cPieceGeneratorSelfTest :
+	public cPiecePool
+{
+public:
+	cPieceGeneratorSelfTest(void)
+	{
+		// Prepare the internal state:
+		InitializePieces();
+		
+		// Generate:
+		cBFSPieceGenerator Gen(*this, 0);
+		cPlacedPieces OutPieces;
+		Gen.PlacePieces(500, 50, 500, 3, OutPieces);
+		
+		// Print out the pieces:
+		printf("OutPieces.size() = " SIZE_T_FMT "\n", OutPieces.size());
+		size_t idx = 0;
+		for (cPlacedPieces::const_iterator itr = OutPieces.begin(), end = OutPieces.end(); itr != end; ++itr, ++idx)
+		{
+			const Vector3i & Coords = (*itr)->GetCoords();
+			cCuboid Hitbox = (*itr)->GetHitBox();
+			Hitbox.Sort();
+			printf(SIZE_T_FMT ": {%d, %d, %d}, rot %d, hitbox {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n", idx,
+				Coords.x, Coords.y, Coords.z,
+				(*itr)->GetNumCCWRotations(),
+				Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
+				Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
+				Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
+			);
+		}  // itr - OutPieces[]
+		printf("Done.\n");
+		
+		// Free the placed pieces properly:
+		Gen.FreePieces(OutPieces);
+	}
+	
+	~cPieceGeneratorSelfTest()
+	{
+		// Dealloc all the pieces:
+		for (cPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+		{
+			delete *itr;
+		}
+		m_Pieces.clear();
+	}
+	
+protected:
+	class cTestPiece :
+		public cPiece
+	{
+		int m_Size;
+	public:
+		cTestPiece(int a_Size) :
+			m_Size(a_Size)
+		{
+		}
+		
+		virtual cConnectors GetConnectors(void) const override
+		{
+			// Each piece has 4 connectors, one of each type, plus one extra, at the center of its walls:
+			cConnectors res;
+			res.push_back(cConnector(m_Size / 2, 1, 0,          0, BLOCK_FACE_ZM));
+			res.push_back(cConnector(m_Size / 2, 1, m_Size - 1, 1, BLOCK_FACE_ZP));
+			res.push_back(cConnector(0,          1, m_Size / 2, 2, BLOCK_FACE_XM));
+			res.push_back(cConnector(m_Size - 1, 1, m_Size / 2, m_Size % 3, BLOCK_FACE_XP));
+			return res;
+		}
+		
+		virtual Vector3i GetSize(void) const override
+		{
+			return Vector3i(m_Size, 5, m_Size);
+		}
+		
+		virtual cCuboid GetHitBox(void) const override
+		{
+			return cCuboid(0, 0, 0, m_Size - 1, 4, m_Size - 1);
+		}
+		
+		virtual bool CanRotateCCW(int a_NumCCWRotations) const override
+		{
+			return true;
+		}
+	};
+	
+	cPieces m_Pieces;
+	
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override
+	{
+		// Each piece contains each connector
+		return m_Pieces;
+	}
+	
+	
+	virtual cPieces GetStartingPieces(void) override
+	{
+		return m_Pieces;
+	}
+	
+	
+	virtual void PiecePlaced(const cPiece & a_Piece) override
+	{
+		UNUSED(a_Piece);
+	}
+	
+	
+	virtual void Reset(void) override
+	{
+	}
+	
+	
+	void InitializePieces(void)
+	{
+		m_Pieces.push_back(new cTestPiece(5));
+		m_Pieces.push_back(new cTestPiece(7));
+		m_Pieces.push_back(new cTestPiece(9));
+	}
+} g_Test;
+
+#endif  // SELF_TEST
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPiece:
+
+	
+Vector3i cPiece::RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const
+{
+	Vector3i Size = GetSize();
+	switch (a_NumCCWRotations)
+	{
+		case 0:
+		{
+			// No rotation needed
+			return a_Pos;
+		}
+		case 1:
+		{
+			// 1 CCW rotation:
+			return Vector3i(a_Pos.z, a_Pos.y, Size.x - a_Pos.x - 1);
+		}
+		case 2:
+		{
+			// 2 rotations ( = axis flip):
+			return Vector3i(Size.x - a_Pos.x - 1, a_Pos.y, Size.z - a_Pos.z - 1);
+		}
+		case 3:
+		{
+			// 1 CW rotation:
+			return Vector3i(Size.z - a_Pos.z - 1, a_Pos.y, a_Pos.x);
+		}
+	}
+	ASSERT(!"Unhandled rotation");
+	return a_Pos;
+}
+
+
+
+
+
+cPiece::cConnector cPiece::RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const
+{
+	cPiece::cConnector res(a_Connector);
+	
+	// Rotate the res connector:
+	switch (a_NumCCWRotations)
+	{
+		case 0:
+		{
+			// No rotation needed
+			break;
+		}
+		case 1:
+		{
+			// 1 CCW rotation:
+			res.m_Direction = RotateBlockFaceCCW(res.m_Direction);
+			break;
+		}
+		case 2:
+		{
+			// 2 rotations ( = axis flip):
+			res.m_Direction = MirrorBlockFaceY(res.m_Direction);
+			break;
+		}
+		case 3:
+		{
+			// 1 CW rotation:
+			res.m_Direction = RotateBlockFaceCW(res.m_Direction);
+			break;
+		}
+	}
+	res.m_Pos = RotatePos(a_Connector.m_Pos, a_NumCCWRotations);
+	
+	// Move the res connector:
+	res.m_Pos.x += a_MoveX;
+	res.m_Pos.y += a_MoveY;
+	res.m_Pos.z += a_MoveZ;
+	
+	return res;
+}
+
+
+
+
+
+cCuboid cPiece::RotateHitBoxToConnector(
+	const cPiece::cConnector & a_MyConnector,
+	const Vector3i & a_ToConnectorPos,
+	int a_NumCCWRotations
+) const
+{
+	ASSERT(a_NumCCWRotations == (a_NumCCWRotations % 4));
+	Vector3i ConnPos = RotatePos(a_MyConnector.m_Pos, a_NumCCWRotations);
+	ConnPos = a_ToConnectorPos - ConnPos;
+	return RotateMoveHitBox(a_NumCCWRotations, ConnPos.x, ConnPos.y, ConnPos.z);
+}
+
+
+
+
+
+cCuboid cPiece::RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const
+{
+	ASSERT(a_NumCCWRotations == (a_NumCCWRotations % 4));
+	cCuboid res = GetHitBox();
+	res.p1 = RotatePos(res.p1, a_NumCCWRotations);
+	res.p2 = RotatePos(res.p2, a_NumCCWRotations);
+	res.p1.Move(a_MoveX, a_MoveY, a_MoveZ);
+	res.p2.Move(a_MoveX, a_MoveY, a_MoveZ);
+	return res;
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPiece::cConnector:
+
+cPiece::cConnector::cConnector(int a_X, int a_Y, int a_Z, int a_Type, eBlockFace a_Direction) :
+	m_Pos(a_X, a_Y, a_Z),
+	m_Type(a_Type),
+	m_Direction(a_Direction)
+{
+}
+
+
+
+
+
+cPiece::cConnector::cConnector(const Vector3i & a_Pos, int a_Type, eBlockFace a_Direction) :
+	m_Pos(a_Pos),
+	m_Type(a_Type),
+	m_Direction(a_Direction)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPlacedPiece:
+
+cPlacedPiece::cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations) :
+	m_Parent(a_Parent),
+	m_Piece(&a_Piece),
+	m_Coords(a_Coords),
+	m_NumCCWRotations(a_NumCCWRotations)
+{
+	m_Depth = (m_Parent == NULL) ? 0 : (m_Parent->GetDepth() + 1);
+	m_HitBox = a_Piece.RotateMoveHitBox(a_NumCCWRotations, a_Coords.x, a_Coords.y, a_Coords.z);
+	m_HitBox.Sort();
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPieceGenerator:
+
+cPieceGenerator::cPieceGenerator(cPiecePool & a_PiecePool, int a_Seed) :
+	m_PiecePool(a_PiecePool),
+	m_Noise(a_Seed),
+	m_Seed(a_Seed)
+{
+}
+
+
+
+
+
+void cPieceGenerator::FreePieces(cPlacedPieces & a_PlacedPieces)
+{
+	for (cPlacedPieces::iterator itr = a_PlacedPieces.begin(), end = a_PlacedPieces.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - a_PlacedPieces[]
+	a_PlacedPieces.clear();
+}
+
+
+
+
+
+cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, int a_BlockZ, cFreeConnectors & a_OutConnectors)
+{
+	m_PiecePool.Reset();
+	int rnd = m_Noise.IntNoise3DInt(a_BlockX, a_BlockY, a_BlockZ) / 7;
+	
+	// Choose a random one of the starting pieces:
+	cPieces StartingPieces = m_PiecePool.GetStartingPieces();
+	cPiece * StartingPiece = StartingPieces[rnd % StartingPieces.size()];
+	rnd = rnd >> 16;
+	
+	// Choose a random supported rotation:
+	int Rotations[4] = {0};
+	int NumRotations = 1;
+	for (size_t i = 1; i < ARRAYCOUNT(Rotations); i++)
+	{
+		if (StartingPiece->CanRotateCCW(i))
+		{
+			Rotations[NumRotations] = i;
+			NumRotations += 1;
+		}
+	}
+	int Rotation = Rotations[rnd % NumRotations];
+	
+	cPlacedPiece * res = new cPlacedPiece(NULL, *StartingPiece, Vector3i(a_BlockX, a_BlockY, a_BlockZ), Rotation);
+
+	// Place the piece's connectors into a_OutConnectors:
+	const cPiece::cConnectors & Conn = StartingPiece->GetConnectors();
+	for (cPiece::cConnectors::const_iterator itr = Conn.begin(), end = Conn.end(); itr != end; ++itr)
+	{
+		a_OutConnectors.push_back(
+			cFreeConnector(res, StartingPiece->RotateMoveConnector(*itr, Rotation, a_BlockX, a_BlockY, a_BlockZ))
+		);
+	}
+
+	return res;
+}
+
+
+
+
+
+bool cPieceGenerator::TryPlacePieceAtConnector(
+	const cPlacedPiece & a_ParentPiece,
+	const cPiece::cConnector & a_Connector,
+	cPlacedPieces & a_OutPieces,
+	cPieceGenerator::cFreeConnectors & a_OutConnectors
+)
+{
+	// Translation of direction - direction -> number of CCW rotations needed:
+	// You need DirectionRotationTable[rot1][rot2] CCW turns to connect rot1 to rot2 (they are opposite)
+	static const int DirectionRotationTable[6][6] =
+	{
+		/*         YM, YP, ZM, ZP, XM, XP */
+		/* YM */ { 0,  0,  0,  0,  0,  0},
+		/* YP */ { 0,  0,  0,  0,  0,  0},
+		/* ZM */ { 0,  0,  2,  0,  1,  3},
+		/* ZP */ { 0,  0,  0,  2,  3,  1},
+		/* XM */ { 0,  0,  3,  1,  2,  0},
+		/* XP */ { 0,  0,  1,  3,  0,  2},
+	};
+	
+	// Get a list of available connections:
+	const int * RotTable = DirectionRotationTable[a_Connector.m_Direction];
+	cConnections Connections;
+	cPieces AvailablePieces = m_PiecePool.GetPiecesWithConnector(a_Connector.m_Type);
+	Connections.reserve(AvailablePieces.size());
+	Vector3i ConnPos = a_Connector.m_Pos;  // The position at which the new connector should be placed - 1 block away from the connector
+	AddFaceDirection(ConnPos.x, ConnPos.y, ConnPos.z, a_Connector.m_Direction);
+	
+	/*
+	// DEBUG:
+	printf("Placing piece at connector pos {%d, %d, %d}, direction %s\n", ConnPos.x, ConnPos.y, ConnPos.z, BlockFaceToString(a_Connector.m_Direction).c_str());
+	//*/
+	
+	for (cPieces::iterator itrP = AvailablePieces.begin(), endP = AvailablePieces.end(); itrP != endP; ++itrP)
+	{
+		cPiece::cConnectors Connectors = (*itrP)->GetConnectors();
+		for (cPiece::cConnectors::iterator itrC = Connectors.begin(), endC = Connectors.end(); itrC != endC; ++itrC)
+		{
+			if (itrC->m_Type != a_Connector.m_Type)
+			{
+				continue;
+			}
+			// This is a same-type connector, find out how to rotate to it:
+			int NumCCWRotations = RotTable[itrC->m_Direction];
+			if (!(*itrP)->CanRotateCCW(NumCCWRotations))
+			{
+				// Doesn't support this rotation
+				continue;
+			}
+			if (!CheckConnection(a_Connector, ConnPos, **itrP, *itrC, NumCCWRotations, a_OutPieces))
+			{
+				// Doesn't fit in this rotation
+				continue;
+			}
+			Connections.push_back(cConnection(**itrP, *itrC, NumCCWRotations));
+		}  // for itrC - Connectors[]
+	}  // for itrP - AvailablePieces[]
+	if (Connections.empty())
+	{
+		// No available connections, bail out
+		return false;
+	}
+	
+	// Choose a random connection from the list:
+	int rnd = m_Noise.IntNoise3DInt(a_Connector.m_Pos.x, a_Connector.m_Pos.y, a_Connector.m_Pos.z) / 7;
+	cConnection & Conn = Connections[rnd % Connections.size()];
+	
+	// Place the piece:
+	/*
+	// DEBUG
+	printf("Chosen connector at {%d, %d, %d}, direction %s, needs %d rotations\n",
+		Conn.m_Connector.m_Pos.x, Conn.m_Connector.m_Pos.y, Conn.m_Connector.m_Pos.z,
+		BlockFaceToString(Conn.m_Connector.m_Direction).c_str(),
+		Conn.m_NumCCWRotations
+	);
+	//*/
+	
+	Vector3i NewPos = Conn.m_Piece->RotatePos(Conn.m_Connector.m_Pos, Conn.m_NumCCWRotations);
+	ConnPos -= NewPos;
+	cPlacedPiece * PlacedPiece = new cPlacedPiece(&a_ParentPiece, *(Conn.m_Piece), ConnPos, Conn.m_NumCCWRotations);
+	a_OutPieces.push_back(PlacedPiece);
+	
+	// Add the new piece's connectors to the list of free connectors:
+	cPiece::cConnectors Connectors = Conn.m_Piece->GetConnectors();
+	
+	/*
+	// DEBUG:
+	printf("Adding %u connectors to the pool\n", Connectors.size() - 1);
+	//*/
+	
+	for (cPiece::cConnectors::const_iterator itr = Connectors.begin(), end = Connectors.end(); itr != end; ++itr)
+	{
+		if (itr->m_Pos.Equals(Conn.m_Connector.m_Pos))
+		{
+			// This is the connector through which we have been connected to the parent, don't add
+			continue;
+		}
+		a_OutConnectors.push_back(cFreeConnector(PlacedPiece, Conn.m_Piece->RotateMoveConnector(*itr, Conn.m_NumCCWRotations, ConnPos.x, ConnPos.y, ConnPos.z)));
+	}
+	
+	return true;
+}
+
+
+
+
+
+bool cPieceGenerator::CheckConnection(
+	const cPiece::cConnector & a_ExistingConnector,
+	const Vector3i & a_ToPos,
+	const cPiece & a_Piece,
+	const cPiece::cConnector & a_NewConnector,
+	int a_NumCCWRotations,
+	const cPlacedPieces & a_OutPieces
+)
+{
+	// For each placed piece, test the hitbox against the new piece:
+	cCuboid RotatedHitBox = a_Piece.RotateHitBoxToConnector(a_NewConnector, a_ToPos, a_NumCCWRotations);
+	RotatedHitBox.Sort();
+	for (cPlacedPieces::const_iterator itr = a_OutPieces.begin(), end = a_OutPieces.end(); itr != end; ++itr)
+	{
+		if ((*itr)->GetHitBox().DoesIntersect(RotatedHitBox))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+
+
+
+//*
+// DEBUG:
+void cPieceGenerator::DebugConnectorPool(const cPieceGenerator::cFreeConnectors & a_ConnectorPool, size_t a_NumProcessed)
+{
+	printf("  Connector pool: " SIZE_T_FMT " items\n", a_ConnectorPool.size() - a_NumProcessed);
+	size_t idx = 0;
+	for (cPieceGenerator::cFreeConnectors::const_iterator itr = a_ConnectorPool.begin() + a_NumProcessed, end = a_ConnectorPool.end(); itr != end; ++itr, ++idx)
+	{
+		printf("    " SIZE_T_FMT ": {%d, %d, %d}, type %d, direction %s, depth %d\n",
+			idx,
+			itr->m_Connector.m_Pos.x, itr->m_Connector.m_Pos.y, itr->m_Connector.m_Pos.z,
+			itr->m_Connector.m_Type,
+			BlockFaceToString(itr->m_Connector.m_Direction).c_str(),
+			itr->m_Piece->GetDepth()
+		);
+	}  // for itr - a_ConnectorPool[]
+}
+//*/
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPieceGenerator::cConnection:
+
+cPieceGenerator::cConnection::cConnection(cPiece & a_Piece, cPiece::cConnector & a_Connector, int a_NumCCWRotations) :
+	m_Piece(&a_Piece),
+	m_Connector(a_Connector),
+	m_NumCCWRotations(a_NumCCWRotations)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPieceGenerator::cFreeConnector:
+
+cPieceGenerator::cFreeConnector::cFreeConnector(cPlacedPiece * a_Piece, const cPiece::cConnector & a_Connector) :
+	m_Piece(a_Piece),
+	m_Connector(a_Connector)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cBFSPieceGenerator:
+
+cBFSPieceGenerator::cBFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed) :
+	super(a_PiecePool, a_Seed)
+{
+}
+
+
+
+
+
+void cBFSPieceGenerator::PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MaxDepth, cPlacedPieces & a_OutPieces)
+{
+	a_OutPieces.clear();
+	cFreeConnectors ConnectorPool;
+	
+	// Place the starting piece:
+	a_OutPieces.push_back(PlaceStartingPiece(a_BlockX, a_BlockY, a_BlockZ, ConnectorPool));
+	
+	/*
+	// DEBUG:
+	printf("Placed the starting piece at {%d, %d, %d}\n", a_BlockX, a_BlockY, a_BlockZ);
+	cCuboid Hitbox = a_OutPieces[0]->GetHitBox();
+	Hitbox.Sort();
+	printf("  Hitbox: {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n",
+		Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
+		Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
+		Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
+	);
+	DebugConnectorPool(ConnectorPool, 0);
+	//*/
+	
+	// Place pieces at the available connectors:
+	/*
+	Instead of removing them one by one from the pool, we process them sequentially and take note of the last
+	processed one. To save on memory, once the number of processed connectors reaches a big number, a chunk
+	of the connectors is removed.
+	*/
+	size_t NumProcessed = 0;
+	while (ConnectorPool.size() > NumProcessed)
+	{
+		cFreeConnector & Conn = ConnectorPool[NumProcessed];
+		if (Conn.m_Piece->GetDepth() < a_MaxDepth)
+		{
+			if (TryPlacePieceAtConnector(*Conn.m_Piece, Conn.m_Connector, a_OutPieces, ConnectorPool))
+			{
+				/*
+				// DEBUG:
+				const cPlacedPiece * NewPiece = a_OutPieces.back();
+				const Vector3i & Coords = NewPiece->GetCoords();
+				printf("Placed a new piece at {%d, %d, %d}, rotation %d\n", Coords.x, Coords.y, Coords.z, NewPiece->GetNumCCWRotations());
+				cCuboid Hitbox = NewPiece->GetHitBox();
+				Hitbox.Sort();
+				printf("  Hitbox: {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n",
+					Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
+					Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
+					Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
+				);
+				DebugConnectorPool(ConnectorPool, NumProcessed + 1);
+				//*/
+			}
+		}
+		NumProcessed++;
+		if (NumProcessed > 1000)
+		{
+			ConnectorPool.erase(ConnectorPool.begin(), ConnectorPool.begin() + NumProcessed);
+			NumProcessed = 0;
+		}
+	}
+}
+
+
+
+
diff --git a/src/Generating/PieceGenerator.h b/src/Generating/PieceGenerator.h
new file mode 100644
index 000000000..bef9d3463
--- /dev/null
+++ b/src/Generating/PieceGenerator.h
@@ -0,0 +1,247 @@
+
+// PieceGenerator.h
+
+// Declares the cBFSPieceGenerator class and cDFSPieceGenerator class 
+// representing base classes for generating structures composed of individual "pieces"
+
+/*
+Each uses a slightly different approach to generating:
+	- DFS extends pieces one by one until it hits the configured depth (or can't connect another piece anymore),
+		then starts looking at adjacent connectors (like depth-first search).
+	- BFS keeps a pool of currently-open connectors, chooses one at random and tries to place a piece on it,
+		thus possibly extending the pool of open connectors (like breadth-first search).
+*/
+
+
+
+
+
+#pragma once
+
+#include "../Defines.h"
+#include "../Cuboid.h"
+#include "../Noise.h"
+
+
+
+
+
+/** Represents a single piece. Can have multiple connectors of different types where other pieces can connect. */
+class cPiece
+{
+public:
+	// Force a virtual destructor in all descendants
+	virtual ~cPiece() {}
+	
+	struct cConnector
+	{
+		/** Position relative to the piece */
+		Vector3i m_Pos;
+		
+		/** Type of the connector. Any arbitrary number; the generator connects only connectors of the same type. */
+		int m_Type;
+		
+		/** Direction in which the connector is facing.
+		Will be matched by the opposite direction for the connecting connector. */
+		eBlockFace m_Direction;
+		
+		cConnector(int a_X, int a_Y, int a_Z, int a_Type, eBlockFace a_Direction);
+		cConnector(const Vector3i & a_Pos, int a_Type, eBlockFace a_Direction);
+	};
+	
+	typedef std::vector<cConnector> cConnectors;
+	
+	/** Returns all of the available connectors that the piece has.
+	Each connector has a (relative) position in the piece, and a type associated with it. */
+	virtual cConnectors GetConnectors(void) const = 0;
+	
+	/** Returns the dimensions of this piece.
+	The dimensions cover the entire piece, there is no block that the piece generates outside of this size. */
+	virtual Vector3i GetSize(void) const = 0;
+	
+	/** Returns the "hitbox" of this piece.
+	A hitbox is what is compared and must not intersect other pieces' hitboxes when generating. */
+	virtual cCuboid GetHitBox(void) const = 0;
+	
+	/** Returns true if the piece can be rotated CCW the specific number of 90-degree turns. */
+	virtual bool CanRotateCCW(int a_NumRotations) const = 0;
+	
+	/** Returns a copy of the a_Pos after rotating the piece the specified number of CCW rotations. */
+	Vector3i RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const;
+
+	/** Returns a copy of the connector that is rotated and then moved by the specified amounts. */
+	cConnector RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
+	
+	/** Returns the hitbox after the specified number of rotations and moved so that a_MyConnector is placed at a_ToConnectorPos. */
+	cCuboid RotateHitBoxToConnector(const cConnector & a_MyConnector, const Vector3i & a_ToConnectorPos, int a_NumCCWRotations) const;
+	
+	/** Returns the hitbox after the specified number of CCW rotations and moved by the specified amounts. */
+	cCuboid RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
+};
+
+typedef std::vector<cPiece *> cPieces;
+
+
+
+
+
+/** This class is an interface that provides pieces for the generator. It can keep track of what pieces were
+placed and adjust the returned piece vectors. */
+class cPiecePool
+{
+public:
+	// Force a virtual destructor in all descendants:
+	virtual ~cPiecePool() {}
+	
+	/** Returns a list of pieces that contain the specified connector type.
+	The cPiece pointers returned are managed by the pool and the caller doesn't free them. */
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) = 0;
+	
+	/** Returns the pieces that should be used as the starting point.
+	Multiple starting points are supported, one of the returned piece will be chosen. */
+	virtual cPieces GetStartingPieces(void) = 0;
+	
+	/** Called after a piece is placed, to notify the pool that it has been used.
+	The pool may adjust the pieces it will return the next time. */
+	virtual void PiecePlaced(const cPiece & a_Piece) = 0;
+	
+	/** Called when the pool has finished the current structure and should reset any piece-counters it has
+	for a new structure. */
+	virtual void Reset(void) = 0;
+};
+
+
+
+
+
+/** Represents a single piece that has been placed to specific coords in the world. */
+class cPlacedPiece
+{
+public:
+	cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations);
+	
+	const cPiece &   GetPiece          (void) const { return *m_Piece; }
+	const Vector3i & GetCoords         (void) const { return m_Coords; }
+	int              GetNumCCWRotations(void) const { return m_NumCCWRotations; }
+	const cCuboid &  GetHitBox         (void) const { return m_HitBox; }
+	int              GetDepth          (void) const { return m_Depth; }
+	
+protected:
+	const cPlacedPiece * m_Parent;
+	const cPiece * m_Piece;
+	Vector3i m_Coords;
+	int m_NumCCWRotations;
+	cCuboid m_HitBox;
+	int m_Depth;
+};
+
+typedef std::vector<cPlacedPiece *> cPlacedPieces;
+
+
+
+
+
+class cPieceGenerator
+{
+public:
+	cPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
+	
+	/** Cleans up all the memory used by the placed pieces.
+	Call this utility function instead of freeing the items on your own. */
+	static void FreePieces(cPlacedPieces & a_PlacedPieces);
+	
+protected:
+	/** The type used for storing a connection from one piece to another, while building the piece tree. */
+	struct cConnection
+	{
+		cPiece * m_Piece;                  // The piece being connected
+		cPiece::cConnector m_Connector;    // The piece's connector being used (relative non-rotated coords)
+		int m_NumCCWRotations;             // Number of rotations necessary to match the two connectors
+		
+		cConnection(cPiece & a_Piece, cPiece::cConnector & a_Connector, int a_NumCCWRotations);
+	};
+	typedef std::vector<cConnection> cConnections;
+	
+	/** The type used for storing a pool of connectors that will be attempted to expand by another piece. */
+	struct cFreeConnector
+	{
+		cPlacedPiece * m_Piece;
+		cPiece::cConnector m_Connector;
+		
+		cFreeConnector(cPlacedPiece * a_Piece, const cPiece::cConnector & a_Connector);
+	};
+	typedef std::vector<cFreeConnector> cFreeConnectors;
+
+
+	cPiecePool & m_PiecePool;
+	cNoise m_Noise;
+	int m_Seed;
+
+	
+	/** Selects a starting piece and places it, including the rotations.
+	Also puts the piece's connectors in a_OutConnectors. */
+	cPlacedPiece * PlaceStartingPiece(int a_BlockX, int a_BlockY, int a_BlockZ, cFreeConnectors & a_OutConnectors);
+	
+	/** Tries to place a new piece at the specified (placed) connector. Returns true if successful. */
+	bool TryPlacePieceAtConnector(
+		const cPlacedPiece & a_ParentPiece,      // The existing piece to a new piece should be placed
+		const cPiece::cConnector & a_Connector,  // The existing connector (world-coords) to which a new piece should be placed
+		cPlacedPieces & a_OutPieces,             // Already placed pieces, to be checked for intersections
+		cFreeConnectors & a_OutConnectors        // List of free connectors to which the new connectors will be placed
+	);
+
+	/** Checks if the specified piece would fit with the already-placed pieces, using the specified connector
+	and number of CCW rotations.
+	a_ExistingConnector is in world-coords and is already rotated properly
+	a_ToPos is the world-coords position on which the new connector should be placed (1 block away from a_ExistingConnector, in its Direction)
+	a_NewConnector is in the original (non-rotated) coords.
+	Returns true if the piece fits, false if not. */
+	bool CheckConnection(
+		const cPiece::cConnector & a_ExistingConnector,  // The existing connector
+		const Vector3i & a_ToPos,                        // The position on which the new connector should be placed
+		const cPiece & a_Piece,                          // The new piece
+		const cPiece::cConnector & a_NewConnector,       // The connector of the new piece 
+		int a_NumCCWRotations,                           // Number of rotations for the new piece to align the connector
+		const cPlacedPieces & a_OutPieces                // All the already-placed pieces to check
+	);
+	
+	/** DEBUG: Outputs all the connectors in the pool into stdout.
+	a_NumProcessed signals the number of connectors from the pool that should be considered processed (not listed). */
+	void DebugConnectorPool(const cPieceGenerator::cFreeConnectors & a_ConnectorPool, size_t a_NumProcessed);
+} ;
+
+
+
+
+
+class cBFSPieceGenerator :
+	public cPieceGenerator
+{
+	typedef cPieceGenerator super;
+	
+public:
+	cBFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
+	
+	/** Generates a placement for pieces at the specified coords.
+	Caller must free each individual cPlacedPiece in a_OutPieces. */
+	void PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MaxDepth, cPlacedPieces & a_OutPieces);
+};
+
+
+
+
+
+class cDFSPieceGenerator :
+	public cPieceGenerator
+{
+public:
+	cDFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
+	
+	/** Generates a placement for pieces at the specified coords.
+	Caller must free each individual cPlacedPiece in a_OutPieces. */
+	void PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, cPlacedPieces & a_OutPieces);
+};
+
+
+
+
diff --git a/src/Generating/Prefab.cpp b/src/Generating/Prefab.cpp
new file mode 100644
index 000000000..131b6acb2
--- /dev/null
+++ b/src/Generating/Prefab.cpp
@@ -0,0 +1,316 @@
+
+// Prefab.cpp
+
+/*
+Implements the cPrefab class, representing a cPiece descendant for the cPieceGenerator that
+uses a prefabricate in a cBlockArea for drawing itself.
+*/
+
+#include "Globals.h"
+#include "Prefab.h"
+#include "../WorldStorage/SchematicFileSerializer.h"
+#include "ChunkDesc.h"
+
+
+
+
+
+#ifdef SELF_TEST
+
+// Create one static prefab to test the parser:
+static const cPrefab::sDef g_TestPrefabDef =
+{
+	// Size:
+	7, 6, 7,  // SizeX = 7, SizeY = 6, SizeZ = 7
+
+	// Block definitions:
+	".:  0: 0\n"  /* 0 */
+	"a:112: 0\n"  /* netherbrick */
+	"b:113: 0\n"  /* netherbrickfence */,
+
+	// Block data:
+	// Level 1
+	"aaaaaaa"
+	"aaaaaaa"
+	"aaaaaaa"
+	"aaaaaaa"
+	"aaaaaaa"
+	"aaaaaaa"
+	"aaaaaaa"
+
+	// Level 2
+	"aa...aa"
+	"a.....a"
+	"......."
+	"......."
+	"......."
+	"a.....a"
+	"aa...aa"
+
+	// Level 3
+	"aa...aa"
+	"a.....a"
+	"......."
+	"......."
+	"......."
+	"a.....a"
+	"aa...aa"
+
+	// Level 4
+	"aa...aa"
+	"a.....a"
+	"......."
+	"......."
+	"......."
+	"a.....a"
+	"aa...aa"
+
+	// Level 5
+	"aabbbaa"
+	"a.....a"
+	"b.....b"
+	"b.....b"
+	"b.....b"
+	"a.....a"
+	"aabbbaa"
+
+	// Level 6
+	"aaaaaaa"
+	"a.....a"
+	"a.....a"
+	"a.....a"
+	"a.....a"
+	"a.....a"
+	"aaaaaaa",
+	
+	// Connections:
+	"0: 0, 3, 2: 4\n"
+	"0: 2, 3, 0: 2\n",
+	
+	// AllowedRotations:
+	7,  /* 1, 2, 3 CCW rotations */
+	
+	// Merge strategy:
+	cBlockArea::msImprint
+};
+
+static cPrefab g_TestPrefab(g_TestPrefabDef);
+#endif
+
+
+
+
+
+cPrefab::cPrefab(const cPrefab::sDef & a_Def) :
+	m_Size(a_Def.m_SizeX, a_Def.m_SizeY, a_Def.m_SizeZ),
+	m_HitBox(0, 0, 0, a_Def.m_SizeX - 1, a_Def.m_SizeY - 1, a_Def.m_SizeZ - 1),
+	m_AllowedRotations(a_Def.m_AllowedRotations),
+	m_MergeStrategy(a_Def.m_MergeStrategy)
+{
+	m_BlockArea[0].Create(m_Size);
+	CharMap cm;
+	ParseCharMap(cm, a_Def.m_CharMap);
+	ParseBlockImage(cm, a_Def.m_Image);
+	ParseConnectors(a_Def.m_Connectors);
+	
+	// 1 CCW rotation:
+	if ((m_AllowedRotations & 0x01) != 0)
+	{
+		m_BlockArea[1].CopyFrom(m_BlockArea[0]);
+		m_BlockArea[1].RotateCCW();
+	}
+	
+	// 2 rotations are the same as mirroring twice; mirroring is faster because it has no reallocations
+	if ((m_AllowedRotations & 0x02) != 0)
+	{
+		m_BlockArea[2].CopyFrom(m_BlockArea[0]);
+		m_BlockArea[2].MirrorXY();
+		m_BlockArea[2].MirrorYZ();
+	}	
+	
+	// 3 CCW rotations = 1 CW rotation:
+	if ((m_AllowedRotations & 0x04) != 0)
+	{
+		m_BlockArea[3].CopyFrom(m_BlockArea[0]);
+		m_BlockArea[3].RotateCW();
+	}
+}
+
+
+
+
+
+void cPrefab::Draw(cChunkDesc & a_Dest, const cPlacedPiece * a_Placement) const
+{
+	Vector3i Placement = a_Placement->GetCoords();
+	int ChunkStartX = a_Dest.GetChunkX() * cChunkDef::Width;
+	int ChunkStartZ = a_Dest.GetChunkZ() * cChunkDef::Width;
+	Placement.Move(-ChunkStartX, 0, -ChunkStartZ);
+	a_Dest.WriteBlockArea(m_BlockArea[a_Placement->GetNumCCWRotations()], Placement.x, Placement.y, Placement.z, m_MergeStrategy);
+	
+}
+
+
+
+
+
+bool cPrefab::HasConnectorType(int a_ConnectorType) const
+{
+	for (cConnectors::const_iterator itr = m_Connectors.begin(), end = m_Connectors.end(); itr != end; ++itr)
+	{
+		if (itr->m_Type == a_ConnectorType)
+		{
+			return true;
+		}
+	}  // for itr - m_Connectors[]
+	return false;
+}
+
+
+
+
+
+void cPrefab::ParseCharMap(CharMap & a_CharMapOut, const char * a_CharMapDef)
+{
+	ASSERT(a_CharMapDef != NULL);
+	
+	// Initialize the charmap to all-invalid values:
+	for (size_t i = 0; i < ARRAYCOUNT(a_CharMapOut); i++)
+	{
+		a_CharMapOut[i].m_BlockType = 0;
+		a_CharMapOut[i].m_BlockMeta = 16;  // Mark unassigned entries with a meta that is impossible otherwise
+	}
+	
+	// Process the lines in the definition:
+	AStringVector Lines = StringSplitAndTrim(a_CharMapDef, "\n");
+	for (AStringVector::const_iterator itr = Lines.begin(), end = Lines.end(); itr != end; ++itr)
+	{
+		AStringVector CharDef = StringSplitAndTrim(*itr, ":");
+		size_t NumElements = CharDef.size();
+		if ((NumElements < 2) || CharDef[0].empty() || CharDef[1].empty())
+		{
+			LOGWARNING("Bad prefab CharMap definition line: \"%s\", skipping.", itr->c_str());
+			continue;
+		}
+		unsigned char Src = (unsigned char)CharDef[0][0];
+		ASSERT(a_CharMapOut[Src].m_BlockMeta == 16);  // This letter has not been assigned yet?
+		a_CharMapOut[Src].m_BlockType = (BLOCKTYPE)atoi(CharDef[1].c_str());
+		NIBBLETYPE BlockMeta = 0;
+		if ((NumElements >= 3) && !CharDef[2].empty())
+		{
+			BlockMeta = (NIBBLETYPE)atoi(CharDef[2].c_str());
+			ASSERT((BlockMeta >= 0) && (BlockMeta <= 15));
+		}
+		a_CharMapOut[Src].m_BlockMeta = BlockMeta;
+	}  // for itr - Lines[]
+}
+
+
+
+
+
+void cPrefab::ParseBlockImage(const CharMap & a_CharMap, const char * a_BlockImage)
+{
+	// Map each letter in the a_BlockImage (from the in-source definition) to real blocktype / blockmeta:
+	for (int y = 0; y < m_Size.y; y++)
+	{
+		for (int z = 0; z < m_Size.z; z++)
+		{
+			const unsigned char * BlockImage = (const unsigned char *)a_BlockImage + y * m_Size.x * m_Size.z + z * m_Size.x;
+			for (int x = 0; x < m_Size.x; x++)
+			{
+				const sBlockTypeDef & MappedValue = a_CharMap[BlockImage[x]];
+				ASSERT(MappedValue.m_BlockMeta != 16);  // Using a letter not defined in the CharMap?
+				m_BlockArea[0].SetRelBlockTypeMeta(x, y, z, MappedValue.m_BlockType, MappedValue.m_BlockMeta);
+			}
+		}
+	}
+}
+
+
+
+
+
+void cPrefab::ParseConnectors(const char * a_ConnectorsDef)
+{
+	ASSERT(a_ConnectorsDef != NULL);
+	
+	AStringVector Lines = StringSplitAndTrim(a_ConnectorsDef, "\n");
+	for (AStringVector::const_iterator itr = Lines.begin(), end = Lines.end(); itr != end; ++itr)
+	{
+		if (itr->empty())
+		{
+			continue;
+		}
+		// Split into components: "Type: X, Y, Z: Face":
+		AStringVector Defs = StringSplitAndTrim(*itr, ":");
+		if (Defs.size() != 3)
+		{
+			LOGWARNING("Bad prefab Connector definition line: \"%s\", skipping.", itr->c_str());
+			continue;
+		}
+		AStringVector Coords = StringSplitAndTrim(Defs[1], ",");
+		if (Coords.size() != 3)
+		{
+			LOGWARNING("Bad prefab Connector coords definition: \"%s\", skipping.", Defs[1].c_str());
+			continue;
+		}
+		
+		// Check that the BlockFace is within range:
+		int BlockFace = atoi(Defs[2].c_str());
+		if ((BlockFace < 0) || (BlockFace >= 6))
+		{
+			LOGWARNING("Bad prefab Connector Blockface: \"%s\", skipping.", Defs[2].c_str());
+			continue;
+		}
+
+		// Add the connector:
+		m_Connectors.push_back(cPiece::cConnector(
+			atoi(Coords[0].c_str()), atoi(Coords[1].c_str()), atoi(Coords[2].c_str()),  // Connector pos
+			atoi(Defs[0].c_str()),  // Connector type
+			(eBlockFace)BlockFace
+		));
+	}  // for itr - Lines[]
+}
+
+
+
+
+
+cPiece::cConnectors cPrefab::GetConnectors(void) const
+{
+	return m_Connectors;
+}
+
+
+
+
+
+Vector3i cPrefab::GetSize(void) const
+{
+	return m_Size;
+}
+
+
+
+
+
+cCuboid cPrefab::GetHitBox(void) const
+{
+	return m_HitBox;
+}
+
+
+
+
+
+bool cPrefab::CanRotateCCW(int a_NumRotations) const
+{
+	// Either zero rotations
+	// Or the proper bit in m_AllowedRotations is set
+	return (a_NumRotations == 0) || ((m_AllowedRotations & (1 << ((a_NumRotations + 3) % 4))) != 0);
+}
+
+
+
+
diff --git a/src/Generating/Prefab.h b/src/Generating/Prefab.h
new file mode 100644
index 000000000..04c4f09da
--- /dev/null
+++ b/src/Generating/Prefab.h
@@ -0,0 +1,105 @@
+
+// Prefab.h
+
+/*
+Declares the cPrefab class, representing a cPiece descendant for the cPieceGenerator that
+uses a prefabricate in a cBlockArea for drawing itself.
+The class can be constructed from data that is stored directly in the executable, in a sPrefabDef structure
+declared in this file as well; the Gallery server exports areas in this format.
+*/
+
+
+
+
+
+#pragma once
+
+#include "PieceGenerator.h"
+#include "../BlockArea.h"
+
+
+
+
+
+// fwd:
+class cChunkDesc;
+
+
+
+
+
+class cPrefab :
+	public cPiece
+{
+public:
+	struct sDef
+	{
+		int m_SizeX;
+		int m_SizeY;
+		int m_SizeZ;
+		const char * m_CharMap;
+		const char * m_Image;
+		const char * m_Connectors;
+		int m_AllowedRotations;
+		cBlockArea::eMergeStrategy m_MergeStrategy;
+	};
+	
+	cPrefab(const sDef & a_Def);
+	
+	/** Draws the prefab into the specified chunk, according to the placement stored in the PlacedPiece. */
+	void Draw(cChunkDesc & a_Dest, const cPlacedPiece * a_Placement) const;
+	
+	/** Returns true if the prefab has any connector of the specified type. */
+	bool HasConnectorType(int a_ConnectorType) const;
+
+protected:
+	/** Packs complete definition of a single block, for per-letter assignment. */
+	struct sBlockTypeDef
+	{
+		BLOCKTYPE  m_BlockType;
+		NIBBLETYPE m_BlockMeta;
+	};
+	
+	/** Maps letters in the sDef::m_Image onto a number, BlockType * 16 | BlockMeta */
+	typedef sBlockTypeDef CharMap[256];
+	
+	
+	/** The cBlockArea that contains the block definitions for the prefab.
+	The index identifies the number of CCW rotations applied (0 = no rotation, 1 = 1 CCW rotation, ...). */
+	cBlockArea m_BlockArea[4];
+	
+	/** The size of the prefab */
+	Vector3i m_Size;
+	
+	/** The hitbox of the prefab. In first version is the same as the m_BlockArea dimensions */
+	cCuboid m_HitBox;
+	
+	/** The connectors through which the piece connects to other pieces */
+	cConnectors m_Connectors;
+	
+	/** Bitmask, bit N set -> N rotations CCW supported */
+	int m_AllowedRotations;
+	
+	/** The merge strategy to use when drawing the prefab into a block area */
+	cBlockArea::eMergeStrategy m_MergeStrategy;
+	
+	
+	// cPiece overrides:	
+	virtual cConnectors GetConnectors(void) const override;
+	virtual Vector3i GetSize(void) const override;
+	virtual cCuboid GetHitBox(void) const override;
+	virtual bool CanRotateCCW(int a_NumRotations) const override;
+	
+	/** Parses the CharMap in the definition into a CharMap binary data used for translating the definition into BlockArea. */
+	void ParseCharMap(CharMap & a_CharMapOut, const char * a_CharMapDef);
+	
+	/** Parses the Image in the definition into m_BlockArea[0]'s block types and metas, using the specified CharMap. */
+	void ParseBlockImage(const CharMap & a_CharMap, const char * a_BlockImage);
+	
+	/** Parses the connectors definition text into m_Connectors member. */
+	void ParseConnectors(const char * a_ConnectorsDef);
+};
+
+
+
+
diff --git a/src/Generating/Prefabs/CMakeLists.txt b/src/Generating/Prefabs/CMakeLists.txt
new file mode 100644
index 000000000..1e60447e7
--- /dev/null
+++ b/src/Generating/Prefabs/CMakeLists.txt
@@ -0,0 +1,13 @@
+
+cmake_minimum_required (VERSION 2.6)
+project (MCServer)
+
+include_directories ("${PROJECT_SOURCE_DIR}/../../")
+
+file(GLOB SOURCE
+    "*.cpp"
+)
+
+add_library(Generating_Prefabs ${SOURCE})
+
+target_link_libraries(Generating_Prefabs OSSupport iniFile Blocks)
diff --git a/src/Generating/Prefabs/NetherFortPrefabs.cpp b/src/Generating/Prefabs/NetherFortPrefabs.cpp
new file mode 100644
index 000000000..5e8685e32
--- /dev/null
+++ b/src/Generating/Prefabs/NetherFortPrefabs.cpp
@@ -0,0 +1,2758 @@
+
+// NetherFortPrefabs.cpp
+
+// Defines all the prefabs for nether forts
+
+#include "Globals.h"
+#include "NetherFortPrefabs.h"
+
+
+
+
+
+/*
+The nether fortress has two types of connectors, Outer and Inner. Outer is Type 0, Inner is Type 1.
+*/
+
+
+
+
+
+const cPrefab::sDef g_NetherFortPrefabs1[] =
+{
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BalconyCorridor:
+	// The data has been exported from gallery Nether, area index 37, ID 288
+	{
+		// Size:
+		13, 7, 9,  // SizeX = 13, SizeY = 7, SizeZ = 9
+
+		// Block definitions:
+		"a:112: 0\n"  /* netherbrick */
+		"b: 19: 0\n"  /* sponge */
+		"c:114: 4\n"  /* netherbrickstairs */
+		"d:114: 7\n"  /* netherbrickstairs */
+		"e:114: 5\n"  /* netherbrickstairs */
+		"f: 44: 6\n"  /* step */
+		"g:113: 0\n"  /* netherbrickfence */
+		"h:114: 2\n"  /* netherbrickstairs */
+		"i:114: 3\n"  /* netherbrickstairs */
+		"j:114: 0\n"  /* netherbrickstairs */
+		"k:114: 1\n"  /* netherbrickstairs */
+		".:  0: 0\n"  /* air */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"bbbbaaaaabbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+
+		// Level 2
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaa.aaa.aaaa"
+		"bbcdaaaaadebb"
+		"bbbcdddddebbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+
+		// Level 3
+		"aaaaaaaaaaaaa"
+		"............."
+		"............."
+		"............."
+		"aaaa.fff.aaaa"
+		"bbaaaaaaaaabb"
+		"bbaaaaaaaaabb"
+		"bbaaaaaaaaabb"
+		"bbaaaaaaaaabb"
+
+		// Level 4
+		"agagagagagaga"
+		"............."
+		"............."
+		"............."
+		"agaa.....aaga"
+		"bbaaa...aaabb"
+		"bbg.......gbb"
+		"bbg.......gbb"
+		"bbgggggggggbb"
+
+		// Level 5
+		"agagagagagaga"
+		"............."
+		"............."
+		"............."
+		"agaa.....aaga"
+		"bbaaa...aaabb"
+		"bb.........bb"
+		"bb.........bb"
+		"bb.........bb"
+
+		// Level 6
+		"agagagagagaga"
+		"............."
+		"............."
+		"............."
+		"agaa.....aaga"
+		"bbaaa...aaabb"
+		"bb.........bb"
+		"bb.........bb"
+		"bb.........bb"
+
+		// Level 7
+		"hhhhhhhhhhhhh"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"iijaaaaaaaiii"
+		"bbjiiiiiiikbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb",
+		
+		// Connections:
+		"1:  0, 2, 2: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 12, 2, 2: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+		
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BalconyCorridor
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BalconyTee2:
+	// The data has been exported from gallery Nether, area index 38, ID 289
+	{
+		// Size:
+		13, 7, 11,  // SizeX = 13, SizeY = 7, SizeZ = 11
+
+		// Block definitions:
+		"a: 19: 0\n"  /* sponge */
+		"b:112: 0\n"  /* netherbrick */
+		"c:114: 4\n"  /* netherbrickstairs */
+		"d:114: 7\n"  /* netherbrickstairs */
+		"e:114: 5\n"  /* netherbrickstairs */
+		"f: 44: 6\n"  /* step */
+		"g:113: 0\n"  /* netherbrickfence */
+		"h:114: 0\n"  /* netherbrickstairs */
+		"i:114: 1\n"  /* netherbrickstairs */
+		"j:114: 2\n"  /* netherbrickstairs */
+		"k:114: 3\n"  /* netherbrickstairs */
+		".:  0: 0\n"  /* air */,
+
+		// Block data:
+		// Level 1
+		"aaaabbbbbaaaa"
+		"aaaabbbbbaaaa"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"aaaabbbbbaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 2
+		"aaaabbbbbaaaa"
+		"aaaabbbbbaaaa"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbb.bbb.bbbb"
+		"aacdbbbbbdeaa"
+		"aaacdddddeaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 3
+		"aaaab...baaaa"
+		"aaaab...baaaa"
+		"bbbbb...bbbbb"
+		"............."
+		"............."
+		"............."
+		"bbbb.fff.bbbb"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+
+		// Level 4
+		"aaaab...baaaa"
+		"aaaag...gaaaa"
+		"bgbgb...bgbgb"
+		"............."
+		"............."
+		"............."
+		"bgbb.....bbgb"
+		"aabbb...bbbaa"
+		"aag.......gaa"
+		"aag.......gaa"
+		"aagggggggggaa"
+
+		// Level 5
+		"aaaab...baaaa"
+		"aaaag...gaaaa"
+		"bgbgb...bgbgb"
+		"............."
+		"............."
+		"............."
+		"bgbb.....bbgb"
+		"aabbb...bbbaa"
+		"aa.........aa"
+		"aa.........aa"
+		"aa.........aa"
+
+		// Level 6
+		"aaaab...baaaa"
+		"aaaag...gaaaa"
+		"bgbgb...bgbgb"
+		"............."
+		"............."
+		"............."
+		"bgbb.....bbgb"
+		"aabbb...bbbaa"
+		"aa.........aa"
+		"aa.........aa"
+		"aa.........aa"
+
+		// Level 7
+		"aaaahbbbiaaaa"
+		"aaaahbbbiaaaa"
+		"jjjjjbbbjjjjj"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"bbbbbbbbbbbbb"
+		"kkhbbbbbbbkkk"
+		"aahkkkkkkkiaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa",
+		
+		// Connections:
+		"1:  0, 2, 4: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 12, 2, 4: 5\n"  /* Type 1, BLOCK_FACE_XP */
+		"1:  6, 2, 0: 2\n"  /* Type 1, BLOCK_FACE_ZM */,
+		
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BalconyTee2
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BlazePlatform
+	// The data has been exported from gallery Nether, area index 26, ID 276
+	{
+		// Size:
+		10, 7, 7,  // SizeX = 10, SizeY = 7, SizeZ = 7
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b: 52: 0\n"  /* mobspawner */
+		"c:113: 0\n"  /* netherbrickfence */,
+
+		// Block data:
+		// Level 1
+		".........."
+		"aaaaaaaaaa"
+		"aaaaaaaaaa"
+		"aaaaaaaaaa"
+		"aaaaaaaaaa"
+		"aaaaaaaaaa"
+		".........."
+
+		// Level 2
+		".........."
+		"aaaaaaaaaa"
+		"..aaaaaaaa"
+		"..aaaaaaaa"
+		"..aaaaaaaa"
+		"aaaaaaaaaa"
+		".........."
+
+		// Level 3
+		"....aaaaaa"
+		"aaaaaaaaaa"
+		"...aaaaaaa"
+		"...aaaaaaa"
+		"...aaaaaaa"
+		"aaaaaaaaaa"
+		"....aaaaaa"
+
+		// Level 4
+		"....aaaaaa"
+		"..aaa....a"
+		".........a"
+		"......b..a"
+		".........a"
+		"..aaa....a"
+		"....aaaaaa"
+
+		// Level 5
+		"....cccccc"
+		"...cc....c"
+		".........c"
+		".........c"
+		".........c"
+		"...cc....c"
+		"....cccccc"
+
+		// Level 6
+		".........."
+		".........c"
+		".........c"
+		".........c"
+		".........c"
+		".........c"
+		".........."
+
+		// Level 7
+		".........."
+		".........."
+		".........c"
+		".........c"
+		".........c"
+		".........."
+		"..........",
+
+		// Connections:
+		"0:  0, 1, 3: 4\n"  /* Type 0, BLOCK_FACE_XM */,
+		
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BlazePlatform
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BlazePlatformOverhang:
+	// The data has been exported from gallery Nether, area index 20, ID 162
+	{
+		// Size:
+		14, 9, 7,  // SizeX = 14, SizeY = 9, SizeZ = 7
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 5\n"  /* netherbrickstairs */
+		"c: 44:14\n"  /* step */
+		"d:114: 6\n"  /* netherbrickstairs */
+		"e:114: 7\n"  /* netherbrickstairs */
+		"f:114: 0\n"  /* netherbrickstairs */
+		"g:114: 4\n"  /* netherbrickstairs */
+		"h:113: 0\n"  /* netherbrickfence */
+		"i: 52: 0\n"  /* mobspawner */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"mmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+		"aammmmmmmmmmmm"
+		"aammmmmmmmmmmm"
+		"aammmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+
+		// Level 2
+		"mmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+		"aabcmmmmmmmmmm"
+		"aabcmmmmmmmmmm"
+		"aabcmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+
+		// Level 3
+		"mmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+		"aaaaabmmmmmmmm"
+		"aaaaabmmmmmmmm"
+		"aaaaabmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmm"
+
+		// Level 4
+		"mmmmmmmmmmmmmm"
+		"dddddddmmmmmmm"
+		"aaaaaabmmmmmmm"
+		"aaaaaabmmmmmmm"
+		"aaaaaabmmmmmmm"
+		"eeeeeeemmmmmmm"
+		"mmmmmmmmmmmmmm"
+
+		// Level 5
+		"mmmmmmmmmmmmmm"
+		"aaaaaaadmmmmmm"
+		"aaaaaaabmmmmmm"
+		"aaaaaaabmmmmmm"
+		"aaaaaaabmmmmmm"
+		"aaaaaaaemmmmmm"
+		"mmmmmmmmmmmmmm"
+
+		// Level 6
+		"mmmmmmmmmmmmmm"
+		"aaaaaaaabddddm"
+		"......faaaaabm"
+		"......faaaaabm"
+		"......faaaaabm"
+		"aaaaaaaaabeebm"
+		"mmmmmmmmmmmmmm"
+
+		// Level 7
+		"mmmmmmmmgdddbm"
+		"......aaaaaaad"
+		".......faaaaab"
+		".......faaaaab"
+		".......faaaaab"
+		"......aaaaaaae"
+		"mmmmmmmmgeeebm"
+
+		// Level 8
+		"mmmmmmmmaaaaam"
+		"......haa...aa"
+		".............a"
+		"..........i..a"
+		".............a"
+		"......haa...aa"
+		"mmmmmmmmaaaaam"
+
+		// Level 9
+		"mmmmmmmmhhhhhm"
+		"......hhh...hh"
+		".............h"
+		".............h"
+		".............h"
+		"......hhh...hh"
+		"mmmmmmmmhhhhhm",
+
+		// Connections:
+		"0:  0, 5, 3: 4\n"  /* Type 0, BLOCK_FACE_XM */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BlazePlatformOverhang
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BridgeCrossing:
+	// The data has been exported from gallery Nether, area index 17, ID 159
+	{
+		// Size:
+		15, 8, 15,  // SizeX = 15, SizeY = 8, SizeZ = 15
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 7\n"  /* netherbrickstairs */
+		"c:114: 5\n"  /* netherbrickstairs */
+		"d:114: 4\n"  /* netherbrickstairs */
+		"e:114: 6\n"  /* netherbrickstairs */
+		"f: 44:14\n"  /* step */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"aammmmmmmmmmmaa"
+		"aammmmmmmmmmmaa"
+		"aammmmmmmmmmmaa"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+
+		// Level 2
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmbbbmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"aacmmmmmmmmmdaa"
+		"aacmmmmmmmmmdaa"
+		"aacmmmmmmmmmdaa"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmeeemmmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+
+		// Level 3
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmbbbmmmmmm"
+		"mmmmmmfffmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"aaacfmmmmmfdaaa"
+		"aaacfmmmmmfdaaa"
+		"aaacfmmmmmfdaaa"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmfffmmmmmm"
+		"mmmmmmeeemmmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+
+		// Level 4
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"eeeeeeaaaeeeeee"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"bbbbbdaaacbbbbb"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+		"mmmmmdaaacmmmmm"
+
+		// Level 5
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+
+		// Level 6
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"aaaaaa...aaaaaa"
+		"..............."
+		"..............."
+		"..............."
+		"aaaaaa...aaaaaa"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+
+		// Level 7
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"..............."
+		"..............."
+		"..............."
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+
+		// Level 8
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"..............."
+		"..............."
+		"..............."
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm",
+		
+		// Connections:
+		"0:  0, 5,  7: 4\n"  /* Type 0, BLOCK_FACE_XM */
+		"0:  7, 5,  0: 2\n"  /* Type 0, BLOCK_FACE_ZM */
+		"0: 14, 5,  7: 5\n"  /* Type 0, BLOCK_FACE_XP */
+		"0:  7, 5, 14: 3\n"  /* Type 0, BLOCK_FACE_ZP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BridgeCrossing
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BridgeCrumble1:
+	// The data has been exported from gallery Nether, area index 19, ID 161
+	{
+		// Size:
+		9, 6, 5,  // SizeX = 9, SizeY = 6, SizeZ = 5
+
+		// Block definitions:
+		".: 19: 0\n"  /* sponge */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 5\n"  /* netherbrickstairs */
+		"c: 44:14\n"  /* step */
+		"d:114: 6\n"  /* netherbrickstairs */
+		"e:114: 7\n"  /* netherbrickstairs */,
+
+		// Block data:
+		// Level 1
+		"........."
+		"aa......."
+		"aa......."
+		"aa......."
+		"........."
+
+		// Level 2
+		"........."
+		"aab......"
+		"aab......"
+		"aab......"
+		"........."
+
+		// Level 3
+		"........."
+		"aaabc...."
+		"aaabc...."
+		"aaabc...."
+		"........."
+
+		// Level 4
+		"ddddddd.."
+		"aaaaaaaa."
+		"aaaaaaaaa"
+		"aaaaaaa.."
+		"eeeee...."
+
+		// Level 5
+		"aaaaaaaaa"
+		"aaaaa...."
+		"aaaaaa..."
+		"aaaaaa..."
+		"aaaaaaaa."
+
+		// Level 6
+		"aaaaaa..."
+		"........."
+		"........."
+		"........."
+		"aaaaaaa..",
+
+		// Connections:
+		"0:  0, 5, 2: 4\n"  /* Type 0, BLOCK_FACE_XM */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BridgeCrumble1
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BridgeCrumble2
+	// The data has been exported from gallery Nether, area index 18, ID 160
+	{
+		// Size:
+		13, 6, 5,  // SizeX = 13, SizeY = 6, SizeZ = 5
+
+		// Block definitions:
+		".: 19: 0\n"  /* sponge */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 5\n"  /* netherbrickstairs */
+		"c: 44:14\n"  /* step */
+		"d:114: 6\n"  /* netherbrickstairs */
+		"e:114: 7\n"  /* netherbrickstairs */,
+
+		// Block data:
+		// Level 1
+		"............."
+		"aa..........."
+		"aa..........."
+		"aa..........."
+		"............."
+
+		// Level 2
+		"............."
+		"aab.........."
+		"aab.........."
+		"aab.........."
+		"............."
+
+		// Level 3
+		"............."
+		"aaabc........"
+		"aaabc........"
+		"aaabc........"
+		"............."
+
+		// Level 4
+		"ddddddddd...."
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaa...."
+		"aaaaaaaaaaaa."
+		"eeeeeeeee...."
+
+		// Level 5
+		"aaaaaaaaaaaa."
+		"aaaaaaaaaa..."
+		"aaaaaaaaaaa.."
+		"aaaaaaaaa...."
+		"aaaaaaaaaaaaa"
+
+		// Level 6
+		"aaaaaaaaa...."
+		"............."
+		"............."
+		"............."
+		"aaaaaaaaaa...",
+
+		// Connections:
+		"0:  0, 5, 2: 4\n"  /* Type 0, BLOCK_FACE_XM */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BridgeCrumble2
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// BridgeSegment:
+	// The data has been exported from gallery Nether, area index 16, ID 158
+	{
+		// Size:
+		15, 8, 5,  // SizeX = 15, SizeY = 8, SizeZ = 5
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 5\n"  /* netherbrickstairs */
+		"c:114: 4\n"  /* netherbrickstairs */
+		"d: 44:14\n"  /* step */
+		"e:114: 6\n"  /* netherbrickstairs */
+		"f:114: 7\n"  /* netherbrickstairs */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"mmmmmmmmmmmmmmm"
+		"aammmmmmmmmmmaa"
+		"aammmmmmmmmmmaa"
+		"aammmmmmmmmmmaa"
+		"mmmmmmmmmmmmmmm"
+
+		// Level 2
+		"mmmmmmmmmmmmmmm"
+		"aabmmmmmmmmmcaa"
+		"aabmmmmmmmmmcaa"
+		"aabmmmmmmmmmcaa"
+		"mmmmmmmmmmmmmmm"
+
+		// Level 3
+		"mmmmmmmmmmmmmmm"
+		"aaabdmmmmmdcaaa"
+		"aaabdmmmmmdcaaa"
+		"aaabdmmmmmdcaaa"
+		"mmmmmmmmmmmmmmm"
+
+		// Level 4
+		"eeeeeeeeeeeeeee"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"fffffffffffffff"
+
+		// Level 5
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+
+		// Level 6
+		"aaaaaaaaaaaaaaa"
+		"..............."
+		"..............."
+		"..............."
+		"aaaaaaaaaaaaaaa"
+
+		// Level 7
+		"mmmmmmmmmmmmmmm"
+		"..............."
+		"..............."
+		"..............."
+		"mmmmmmmmmmmmmmm"
+
+		// Level 8
+		"mmmmmmmmmmmmmmm"
+		"..............."
+		"..............."
+		"..............."
+		"mmmmmmmmmmmmmmm",
+
+		// Connections:
+		"0:  0, 5, 2: 4\n"  /* Type 0, BLOCK_FACE_XM */
+		"0: 14, 5, 2: 5\n"  /* Type 0, BLOCK_FACE_XP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BridgeSegment
+
+
+	// BridgeTee:
+	// The data has been exported from gallery Nether, area index 39, ID 290
+	{
+		// Size:
+		15, 8, 10,  // SizeX = 15, SizeY = 8, SizeZ = 10
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 5\n"  /* netherbrickstairs */
+		"c:114: 4\n"  /* netherbrickstairs */
+		"d:114: 6\n"  /* netherbrickstairs */
+		"e: 44:14\n"  /* step */
+		"f:114: 7\n"  /* netherbrickstairs */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"mmmmmmmmmmmmmmm"
+		"aammmmmmmmmmmaa"
+		"aammmmmmmmmmmaa"
+		"aammmmmmmmmmmaa"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+
+		// Level 2
+		"mmmmmmmmmmmmmmm"
+		"aabmmmmmmmmmcaa"
+		"aabmmmmmmmmmcaa"
+		"aabmmmmmmmmmcaa"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmdddmmmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+
+		// Level 3
+		"mmmmmmmmmmmmmmm"
+		"aaabemmmmmecaaa"
+		"aaabemmmmmecaaa"
+		"aaabemmmmmecaaa"
+		"mmmmmmmmmmmmmmm"
+		"mmmmmmeeemmmmmm"
+		"mmmmmmdddmmmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+		"mmmmmmaaammmmmm"
+
+		// Level 4
+		"ddddddddddddddd"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"fffffcaaabfffff"
+		"mmmmmcaaabmmmmm"
+		"mmmmmcaaabmmmmm"
+		"mmmmmcaaabmmmmm"
+		"mmmmmcaaabmmmmm"
+		"mmmmmcaaabmmmmm"
+
+		// Level 5
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+		"mmmmmaaaaammmmm"
+
+		// Level 6
+		"aaaaaaaaaaaaaaa"
+		"..............."
+		"..............."
+		"..............."
+		"aaaaaa...aaaaaa"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+		"mmmmma...ammmmm"
+
+		// Level 7
+		"mmmmmmmmmmmmmmm"
+		"..............."
+		"..............."
+		"..............."
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+
+		// Level 8
+		"mmmmmmmmmmmmmmm"
+		"..............."
+		"..............."
+		"..............."
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm"
+		"mmmmmm...mmmmmm",
+
+		// Connections:
+		"0:  0, 5, 2: 4\n"  /* Type 0, BLOCK_FACE_XM */
+		"0: 14, 5, 2: 5\n"  /* Type 0, BLOCK_FACE_XP */
+		"0:  7, 5, 9: 3\n"  /* Type 0, BLOCK_FACE_ZP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // BridgeTee
+
+
+	// Corridor11:
+	// The data has been exported from gallery Nether, area index 36, ID 287
+	{
+		// Size:
+		11, 6, 5,  // SizeX = 11, SizeY = 6, SizeZ = 5
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"c:114: 2\n"  /* netherbrickstairs */
+		"d:114: 3\n"  /* netherbrickstairs */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+
+		// Level 2
+		"aaaaaaaaaaa"
+		"..........."
+		"..........."
+		"..........."
+		"aaaaaaaaaaa"
+
+		// Level 3
+		"abababababa"
+		"..........."
+		"..........."
+		"..........."
+		"abababababa"
+
+		// Level 4
+		"abababababa"
+		"..........."
+		"..........."
+		"..........."
+		"abababababa"
+
+		// Level 5
+		"abababababa"
+		"..........."
+		"..........."
+		"..........."
+		"abababababa"
+
+		// Level 6
+		"ccccccccccc"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"ddddddddddd",
+
+		// Connections:
+		"1:  0, 1, 2: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 10, 1, 2: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // Corridor11
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// Corridor13:
+	// The data has been exported from gallery Nether, area index 35, ID 286
+	{
+		// Size:
+		13, 6, 5,  // SizeX = 13, SizeY = 6, SizeZ = 5
+
+		// Block definitions:
+		"a:112: 0\n"  /* netherbrick */
+		".:  0: 0\n"  /* air */
+		"c:113: 0\n"  /* netherbrickfence */
+		"d:114: 2\n"  /* netherbrickstairs */
+		"e:114: 3\n"  /* netherbrickstairs */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 2
+		"aaaaaaaaaaaaa"
+		"............."
+		"............."
+		"............."
+		"aaaaaaaaaaaaa"
+
+		// Level 3
+		"acacacacacaca"
+		"............."
+		"............."
+		"............."
+		"acacacacacaca"
+
+		// Level 4
+		"acacacacacaca"
+		"............."
+		"............."
+		"............."
+		"acacacacacaca"
+
+		// Level 5
+		"acacacacacaca"
+		"............."
+		"............."
+		"............."
+		"acacacacacaca"
+
+		// Level 6
+		"ddddddddddddd"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"eeeeeeeeeeeee",
+		
+		// Connections:
+		"1:  0, 1, 2: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 12, 1, 2: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+		
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // Corridor13
+
+
+	// CorridorCorner5:
+	// The data has been exported from gallery Nether, area index 10, ID 40
+	{
+		// Size:
+		11, 6, 11,  // SizeX = 11, SizeY = 6, SizeZ = 11
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"c:114: 2\n"  /* netherbrickstairs */
+		"d:114: 0\n"  /* netherbrickstairs */
+		"e:114: 3\n"  /* netherbrickstairs */
+		"f:114: 1\n"  /* netherbrickstairs */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+
+		// Level 2
+		"aaaaaaaaaaa"
+		"a.........."
+		"a.........."
+		"a.........."
+		"a...aaaaaaa"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+
+		// Level 3
+		"abababababa"
+		"b.........."
+		"a.........."
+		"b.........."
+		"a...abababa"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+
+		// Level 4
+		"abababababa"
+		"b.........."
+		"a.........."
+		"b.........."
+		"a...abababa"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+
+		// Level 5
+		"abababababa"
+		"b.........."
+		"a.........."
+		"b.........."
+		"a...abababa"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+
+		// Level 6
+		"ccccccccccc"
+		"daaaaaaaaaa"
+		"daaaaaaaaaa"
+		"daaaaaaaaaa"
+		"daaaeeeeeee"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm",
+		
+		// Connections:
+		"1: 10, 1,  2: 5\n"  /* Type 1, BLOCK_FACE_XP */
+		"1:  2, 1, 10: 3\n"  /* Type 1, BLOCK_FACE_ZP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // CorridorCorner5
+
+
+	// CorridorCorner5:
+	// The data has been exported from gallery Nether, area index 10, ID 40
+	{
+		// Size:
+		11, 6, 11,  // SizeX = 11, SizeY = 6, SizeZ = 11
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"c:114: 2\n"  /* netherbrickstairs */
+		"d:114: 0\n"  /* netherbrickstairs */
+		"e:114: 3\n"  /* netherbrickstairs */
+		"f:114: 1\n"  /* netherbrickstairs */
+		"g: 54: 5\n"  /* chest */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaaaaaaaa"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+		"aaaaammmmmm"
+
+		// Level 2
+		"aaaaaaaaaaa"
+		"ag........."
+		"a.........."
+		"a.........."
+		"a...aaaaaaa"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+		"a...ammmmmm"
+
+		// Level 3
+		"abababababa"
+		"b.........."
+		"a.........."
+		"b.........."
+		"a...abababa"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+
+		// Level 4
+		"abababababa"
+		"b.........."
+		"a.........."
+		"b.........."
+		"a...abababa"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+
+		// Level 5
+		"abababababa"
+		"b.........."
+		"a.........."
+		"b.........."
+		"a...abababa"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+		"b...bmmmmmm"
+		"a...ammmmmm"
+
+		// Level 6
+		"ccccccccccc"
+		"daaaaaaaaaa"
+		"daaaaaaaaaa"
+		"daaaaaaaaaa"
+		"daaaeeeeeee"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm"
+		"daaafmmmmmm",
+		
+		// Connections:
+		"1: 10, 1,  2: 5\n"  /* Type 1, BLOCK_FACE_XP */
+		"1:  2, 1, 10: 3\n"  /* Type 1, BLOCK_FACE_ZP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // CorridorCorner5Chest
+
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// CorridorStairs:
+	// The data has been exported from gallery Nether, area index 12, ID 42
+	{
+		// Size:
+		9, 13, 5,  // SizeX = 9, SizeY = 13, SizeZ = 5
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:114: 0\n"  /* netherbrickstairs */
+		"c:113: 0\n"  /* netherbrickfence */
+		"d:114: 2\n"  /* netherbrickstairs */
+		"e:114: 3\n"  /* netherbrickstairs */
+		"f: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaa"
+		"aaaaaaaaa"
+		"aaaaaaaaa"
+		"aaaaaaaaa"
+		"aaaaaaaaa"
+
+		// Level 2
+		"aaaaaaaaa"
+		".baaaaaaa"
+		".baaaaaaa"
+		".baaaaaaa"
+		"aaaaaaaaa"
+
+		// Level 3
+		"acaaaaaaa"
+		"..baaaaaa"
+		"..baaaaaa"
+		"..baaaaaa"
+		"acaaaaaaa"
+
+		// Level 4
+		"acaaaaaaa"
+		"...baaaaa"
+		"...baaaaa"
+		"...baaaaa"
+		"acaaaaaaa"
+
+		// Level 5
+		"acacaaaaa"
+		"....baaaa"
+		"....baaaa"
+		"....baaaa"
+		"acacaaaaa"
+
+		// Level 6
+		"aaacaaaaa"
+		".....baaa"
+		".....baaa"
+		".....baaa"
+		"aaacaaaaa"
+
+		// Level 7
+		"daacacaaa"
+		"a.....baa"
+		"a.....baa"
+		"a.....baa"
+		"eaacacaaa"
+
+		// Level 8
+		"fdaaacaaa"
+		"fa.....ba"
+		"fa.....ba"
+		"fa.....ba"
+		"feaaacaaa"
+
+		// Level 9
+		"ffdaacaca"
+		"ffa......"
+		"ffa......"
+		"ffa......"
+		"ffeaacaca"
+
+		// Level 10
+		"fffdaaaca"
+		"fffa....."
+		"fffa....."
+		"fffa....."
+		"fffeaaaca"
+
+		// Level 11
+		"ffffdaaca"
+		"ffffa...."
+		"ffffa...."
+		"ffffa...."
+		"ffffeaaca"
+
+		// Level 12
+		"fffffdaaa"
+		"fffffa..."
+		"fffffa..."
+		"fffffa..."
+		"fffffeaaa"
+
+		// Level 13
+		"ffffffddd"
+		"ffffffaaa"
+		"ffffffaaa"
+		"ffffffaaa"
+		"ffffffeee",
+
+		// Connections:
+		"1: 0, 1, 2: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 8, 8, 2: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+		
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // CorridorStairs
+
+
+	// LavaStaircase:
+	// The data has been exported from gallery Nether, area index 28, ID 278
+	{
+		// Size:
+		15, 11, 15,  // SizeX = 15, SizeY = 11, SizeZ = 15
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"c: 11: 0\n"  /* lava */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+
+		// Level 2
+		"aaaaaaaa...aaaa"
+		"aaaaa.........a"
+		"aaaaa.........a"
+		"aaaaab........a"
+		"accca...aaaa..a"
+		"accca...acca..a"
+		"acccaaaaacca..a"
+		"acccccccccca..a"
+		"acccaaaaacca..a"
+		"accca...acca..a"
+		"accca...aaaa..a"
+		"aaaaab........a"
+		"aaaaa.........a"
+		"aaaaa.........a"
+		"aaaaaaaa...aaaa"
+
+		// Level 3
+		"aaaaaaaa...aaaa"
+		"aaaa..........a"
+		"aaaa..........a"
+		"aaaabb........a"
+		"aaaa..........a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"aaaa..........a"
+		"aaaabb........a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"aaaaaaaa...aaaa"
+
+		// Level 4
+		"aaaaaaaa...aaaa"
+		"a.............a"
+		"a.............a"
+		"a..bb.........a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"a..bb.........a"
+		"a.............a"
+		"a.............a"
+		"aaaaaaaa...aaaa"
+
+		// Level 5
+		"aaaaaaaabbbaaaa"
+		"a.............a"
+		"a.............a"
+		"a..b..........a"
+		"a..b..........a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"a.............a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"a..b..........a"
+		"a..b..........a"
+		"a.............a"
+		"a.............a"
+		"aaaaaaaabbbaaaa"
+
+		// Level 6
+		"aaaaaaaaaaaaaaa"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"a..b..........a"
+		"a..b..........a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"aaaa..........a"
+		"a..b..........a"
+		"a..b..........a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"aaaaaaaaaaaaaaa"
+
+		// Level 7
+		"aaaaaaaaaaaaaaa"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"a..b..........a"
+		"...b..........a"
+		"...b..........a"
+		"...b..........a"
+		"a..b..........a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"a.............a"
+		"aaaaaaaaaaaaaaa"
+
+		// Level 8
+		"aababababababaa"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"..............b"
+		"..............a"
+		"..............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"aababababababaa"
+
+		// Level 9
+		"aababababababaa"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"..............b"
+		"..............a"
+		"..............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"aababababababaa"
+
+		// Level 10
+		"aababababababaa"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"..............b"
+		"..............a"
+		"..............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"b.............b"
+		"a.............a"
+		"aababababababaa"
+
+		// Level 11
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa"
+		"aaaaaaaaaaaaaaa",
+		
+		// Connections:
+		"1:  0, 6,  7: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"0:  9, 1,  0: 2\n"  /* Type 0, BLOCK_FACE_ZM */
+		"0:  9, 1, 14: 3\n"  /* Type 0, BLOCK_FACE_ZP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // LavaStaircase
+
+
+	// LavaStaircaseBig:
+	// The data has been exported from gallery Nether, area index 31, ID 282
+	{
+		// Size:
+		12, 15, 15,  // SizeX = 12, SizeY = 15, SizeZ = 15
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b: 10: 0\n"  /* lava */
+		"c:113: 0\n"  /* netherbrickfence */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+
+		// Level 2
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"abbbbbaaaaaa"
+		"abbbbbbaaaaa"
+		"abbbbbba...."
+		"abbbbbba...."
+		"abbbbbba...."
+		"abbbbbbaaaaa"
+		"abbbbb.aaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+
+		// Level 3
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"abbbbbaaaaaa"
+		"abbbbbba...a"
+		"abbbbbba...."
+		"abbbbbba...."
+		"abbbbbba...."
+		"abbbbbba...a"
+		"abbbbb.aaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+
+		// Level 4
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"abbbbbaa...a"
+		"abbbbbba...a"
+		"abbbbbba...."
+		"abbbbbba...."
+		"abbbbbba...."
+		"abbbbbba...a"
+		"abbbbbaa...a"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+
+		// Level 5
+		"aaaaaaaaaaaa"
+		"aaaaa......a"
+		"aaaaa......a"
+		"aaaaacc....a"
+		"a.....cc...a"
+		"a......c...a"
+		"a......c...."
+		"a......c...."
+		"a......c...."
+		"a......c...a"
+		"a.....cc...a"
+		"aaaaacc....a"
+		"aaaaa......a"
+		"aaaaa......a"
+		"aaaaaaaaaaaa"
+
+		// Level 6
+		"aaaaaaaaaaaa"
+		"aaaa.......a"
+		"aaaa.......a"
+		"aaaacc.....a"
+		"aaaa.......a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaa.......a"
+		"aaaacc.....a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"aaaaaaaaaaaa"
+
+		// Level 7
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..cc......a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"a..cc......a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 8
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..c.......a"
+		"a..c.......a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"a..........a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"a..c.......a"
+		"a..c.......a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 9
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..c.......a"
+		"a..c.......a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"aaaa.......a"
+		"a..c.......a"
+		"a..c.......a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 10
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..c.......a"
+		"...c.......a"
+		"...c.......a"
+		"...c.......a"
+		"a..c.......a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 11
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"...........a"
+		"...........a"
+		"...........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 12
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"...........a"
+		"...........a"
+		"...........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 13
+		"aaaaaaaaaaaa"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"...........a"
+		"...........a"
+		"...........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"a..........a"
+		"aaaaaaaaaaaa"
+
+		// Level 14
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+		"aaaaaaaaaaaa"
+
+		// Level 15
+		"aaaaaaaaaaaa"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"abbbbbbbbbba"
+		"aaaaaaaaaaaa",
+		
+		// Connections:
+		"1:  0, 9,  7: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 11, 1,  7: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // LavaStaircaseBig
+
+
+	// MidStaircase:
+	// The data has been exported from gallery Nether, area index 23, ID 165
+	{
+		// Size:
+		13, 8, 13,  // SizeX = 13, SizeY = 8, SizeZ = 13
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b: 88: 0\n"  /* soulsand */
+		"c:115: 7\n"  /* netherwartblock */
+		"d:114: 3\n"  /* netherbrickstairs */
+		"e:114: 0\n"  /* netherbrickstairs */
+		"f:114: 1\n"  /* netherbrickstairs */
+		"g:114: 2\n"  /* netherbrickstairs */
+		"h: 10: 0\n"  /* lava */
+		"i:113: 0\n"  /* netherbrickfence */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaabbbbbaaaa"
+		"aaaabbbbbaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaabbbbbaaaa"
+		"aaaabbbbbaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 2
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaacccccaaaa"
+		"addecccccfdda"
+		"...eaaaaad..."
+		"...eaaaaa...."
+		"...eaaaaag..."
+		"agggcccccfgga"
+		"aaaacccccaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 3
+		"aaaaaaaaaaaaa"
+		"aha.......aha"
+		"aaa.......aaa"
+		"a...........a"
+		"a...........a"
+		"....eaaaa...."
+		"....eaaaa...."
+		"....eaaaa...."
+		"a...........a"
+		"a...........a"
+		"aaa.......aaa"
+		"aha.......aha"
+		"aaaaaaaaaaaaa"
+
+		// Level 4
+		"aaaiiaaaiiaaa"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		".....eaaa...."
+		".....eaaa...."
+		".....eaaa...."
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"aaaiiaaaiiaaa"
+
+		// Level 5
+		"aaaiiaaaiiaaa"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"......eaa...."
+		"......eaa...."
+		"......eaa...."
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"aaaiiaaaiiaaa"
+
+		// Level 6
+		"aaaaaaaaaaaaa"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a......ea...a"
+		"a......ea...a"
+		"a......ea...a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"a...........a"
+		"aaaaaaaaaaaaa"
+
+		// Level 7
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaa....eaaaa"
+		"aaaa....eaaaa"
+		"aaaa....eaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 8
+		"iaiaiaiaiaiai"
+		"a...........a"
+		"i...........i"
+		"a...........a"
+		"i...........i"
+		"a............"
+		"i............"
+		"a............"
+		"i...........i"
+		"a...........a"
+		"i...........i"
+		"a...........a"
+		"iaiaiaiaiaiai",
+
+		// Connections:
+		"1:  0, 1, 6: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 12, 1, 6: 5\n"  /* Type 1, BLOCK_FACE_XP */
+		"1: 12, 7, 6: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // MidStaircase
+
+
+	// StairsToOpen1:
+	// The data has been exported from gallery Nether, area index 27, ID 277
+	{
+		// Size:
+		7, 10, 7,  // SizeX = 7, SizeY = 10, SizeZ = 7
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+
+		// Level 2
+		"aa...aa"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"aaaaaaa"
+		"aaaaaaa"
+
+		// Level 3
+		"aa...aa"
+		"a.....a"
+		"b.....b"
+		"a.....a"
+		"b.....b"
+		"a.aaaaa"
+		"aabaaba"
+
+		// Level 4
+		"aa...aa"
+		"a.....a"
+		"b.....b"
+		"a.....a"
+		"b.....b"
+		"a..aaaa"
+		"aabaaba"
+
+		// Level 5
+		"aabbbaa"
+		"a.....a"
+		"b.....b"
+		"a.....a"
+		"b.....b"
+		"a...aaa"
+		"aabaaba"
+
+		// Level 6
+		"aaaaaaa"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a....aa"
+		"aaaaaaa"
+
+		// Level 7
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"a.....a"
+		"aaaaaaa"
+
+		// Level 8
+		"aaaaaaa"
+		"a.....a"
+		"a......"
+		"a......"
+		"a......"
+		"a.....a"
+		"aaaaaaa"
+
+		// Level 9
+		"mmmmmmm"
+		"m.....m"
+		"m......"
+		"m......"
+		"m......"
+		"m.....m"
+		"mmmmmmm"
+
+		// Level 10
+		"mmmmmmm"
+		"m.....m"
+		"m......"
+		"m......"
+		"m......"
+		"m.....m"
+		"mmmmmmm",
+		
+		// Connections:
+		"0: 3, 1, 0: 2\n"  /* Type 0, BLOCK_FACE_ZM */
+		"0: 6, 7, 3: 5\n"  /* Type 0, BLOCK_FACE_XP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // StairsToOpen1
+
+
+	// StairsToOpen2:
+	// The data has been exported from gallery Nether, area index 8, ID 35
+	{
+		// Size:
+		7, 10, 7,  // SizeX = 7, SizeY = 10, SizeZ = 7
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+
+		// Level 2
+		"aa...aa"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"aaaaaaa"
+		"aaaaaaa"
+
+		// Level 3
+		"aa...aa"
+		"a.....a"
+		"b.....b"
+		"a.....a"
+		"b.....b"
+		"a.aaaaa"
+		"aabaaba"
+
+		// Level 4
+		"aa...aa"
+		"a.....a"
+		"b.....b"
+		"a.....a"
+		"b.....b"
+		"a..aaaa"
+		"aabaaba"
+
+		// Level 5
+		"aabbbaa"
+		"a.....a"
+		"b.....b"
+		"a.....a"
+		"b.....b"
+		"a...aaa"
+		"aabaaba"
+
+		// Level 6
+		"aaaaaaa"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a....aa"
+		"aaaaaaa"
+
+		// Level 7
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"a.....a"
+		"aaaaaaa"
+
+		// Level 8
+		"aaaaaaa"
+		"a.....a"
+		"......a"
+		"......a"
+		"......a"
+		"a.....a"
+		"aaaaaaa"
+
+		// Level 9
+		"mmmmmmm"
+		"m.....m"
+		"......m"
+		"......m"
+		"......m"
+		"m.....m"
+		"mmmmmmm"
+
+		// Level 10
+		"mmmmmmm"
+		"m.....m"
+		"......m"
+		"......m"
+		"......m"
+		"m.....m"
+		"mmmmmmm",
+		
+		// Connections:
+		"0: 3, 1, 0: 2\n"  /* Type 0, BLOCK_FACE_ZM */
+		"0: 0, 7, 3: 4\n"  /* Type 0, BLOCK_FACE_XM */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // StairsToOpen2
+
+
+	// Tee2x4:
+	// The data has been exported from gallery Nether, area index 40, ID 291
+	{
+		// Size:
+		13, 6, 7,  // SizeX = 13, SizeY = 6, SizeZ = 7
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"c:114: 0\n"  /* netherbrickstairs */
+		"d:114: 1\n"  /* netherbrickstairs */
+		"e:114: 2\n"  /* netherbrickstairs */
+		"f:114: 3\n"  /* netherbrickstairs */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"mmmmaaaaammmm"
+		"mmmmaaaaammmm"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 2
+		"mmmma...ammmm"
+		"mmmma...ammmm"
+		"aaaaa...aaaaa"
+		"............."
+		"............."
+		"............."
+		"aaaaaaaaaaaaa"
+
+		// Level 3
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"ababa...ababa"
+		"............."
+		"............."
+		"............."
+		"ababababababa"
+
+		// Level 4
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"ababa...ababa"
+		"............."
+		"............."
+		"............."
+		"ababababababa"
+
+		// Level 5
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"ababa...ababa"
+		"............."
+		"............."
+		"............."
+		"ababababababa"
+
+		// Level 6
+		"mmmmcaaadmmmm"
+		"mmmmcaaadmmmm"
+		"eeeecaaadeeee"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"fffffffffffff",
+
+		// Connections:
+		"1:  0, 1, 4: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1:  6, 1, 0: 2\n"  /* Type 1, BLOCK_FACE_ZM */
+		"1: 12, 1, 4: 5\n"  /* Type 1, BLOCK_FACE_XP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // Tee2x4
+
+
+	// Tee4x4:
+	// The data has been exported from gallery Nether, area index 41, ID 292
+	{
+		// Size:
+		13, 6, 9,  // SizeX = 13, SizeY = 6, SizeZ = 9
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */
+		"c:114: 0\n"  /* netherbrickstairs */
+		"d:114: 1\n"  /* netherbrickstairs */
+		"e:114: 2\n"  /* netherbrickstairs */
+		"f:114: 3\n"  /* netherbrickstairs */
+		"m: 19: 0\n"  /* sponge */,
+
+		// Block data:
+		// Level 1
+		"mmmmaaaaammmm"
+		"mmmmaaaaammmm"
+		"mmmmaaaaammmm"
+		"mmmmaaaaammmm"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 2
+		"mmmma...ammmm"
+		"mmmma...ammmm"
+		"mmmma...ammmm"
+		"mmmma...ammmm"
+		"aaaaa...aaaaa"
+		"............."
+		"............."
+		"............."
+		"aaaaaaaaaaaaa"
+
+		// Level 3
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"ababa...ababa"
+		"............."
+		"............."
+		"............."
+		"ababababababa"
+
+		// Level 4
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"ababa...ababa"
+		"............."
+		"............."
+		"............."
+		"ababababababa"
+
+		// Level 5
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"mmmma...ammmm"
+		"mmmmb...bmmmm"
+		"ababa...ababa"
+		"............."
+		"............."
+		"............."
+		"ababababababa"
+
+		// Level 6
+		"mmmmcaaadmmmm"
+		"mmmmcaaadmmmm"
+		"mmmmcaaadmmmm"
+		"mmmmcaaadmmmm"
+		"eeeecaaadeeee"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"fffffffffffff",
+
+		// Connections:
+		"1:  0, 1,  6: 4\n"  /* Type 1, BLOCK_FACE_XM */
+		"1: 12, 1,  6: 5\n"  /* Type 1, BLOCK_FACE_XP */
+		"1:  6, 1,  0: 2\n"  /* Type 1, BLOCK_FACE_ZM */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // Tee4x4
+
+	// Turret:
+	// The data has been exported from gallery Nether, area index 7, ID 34
+	{
+		// Size:
+		7, 6, 7,  // SizeX = 7, SizeY = 6, SizeZ = 7
+
+		// Block definitions:
+		".:  0: 0\n"  /* air */
+		"a:112: 0\n"  /* netherbrick */
+		"b:113: 0\n"  /* netherbrickfence */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+		"aaaaaaa"
+
+		// Level 2
+		"aa...aa"
+		"a.....a"
+		"......."
+		"......."
+		"......."
+		"a.....a"
+		"aa...aa"
+
+		// Level 3
+		"aa...aa"
+		"a.....a"
+		"......."
+		"......."
+		"......."
+		"a.....a"
+		"aa...aa"
+
+		// Level 4
+		"aa...aa"
+		"a.....a"
+		"......."
+		"......."
+		"......."
+		"a.....a"
+		"aa...aa"
+
+		// Level 5
+		"aabbbaa"
+		"a.....a"
+		"b.....b"
+		"b.....b"
+		"b.....b"
+		"a.....a"
+		"aabbbaa"
+
+		// Level 6
+		"aaaaaaa"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"a.....a"
+		"aaaaaaa",
+
+		// Connections:
+		"0: 0, 1, 3: 4\n"  /* Type 0, BLOCK_FACE_XM */
+		"0: 3, 1, 0: 2\n"  /* Type 0, BLOCK_FACE_ZM */
+		"0: 6, 1, 3: 5\n"  /* Type 0, BLOCK_FACE_XP */
+		"0: 3, 1, 6: 3\n"  /* Type 0, BLOCK_FACE_ZP */,
+
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},  // Turret
+
+} ;  // g_NetherFortPrefabs1
+
+
+
+
+
+const cPrefab::sDef g_NetherFortStartingPrefabs1[] =
+{
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// CentralRoom:
+	// The data has been exported from gallery Nether, area index 22, ID 164
+	{
+		// Size:
+		13, 9, 13,  // SizeX = 13, SizeY = 9, SizeZ = 13
+
+		// Block definitions:
+		"a:112: 0\n"  /* netherbrick */
+		"b:  0: 0\n"  /* air */
+		"c: 10: 0\n"  /* lava */
+		"d:113: 0\n"  /* netherbrickfence */,
+
+		// Block data:
+		// Level 1
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 2
+		"aaaaabbbaaaaa"
+		"aaaaabbbaaaaa"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+		"aabbbaaabbbaa"
+		"aabbbacabbbaa"
+		"aabbbaaabbbaa"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+		"aabbbbbbbbbaa"
+		"aaaaabbbaaaaa"
+		"aaaaabbbaaaaa"
+
+		// Level 3
+		"aaaaabbbaaaaa"
+		"aaadabbbadaaa"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"aaadabbbadaaa"
+		"aaaaabbbaaaaa"
+
+		// Level 4
+		"aaaaabbbaaaaa"
+		"aaadabbbadaaa"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"adbbbbbbbbbda"
+		"aabbbbbbbbbaa"
+		"aaadabbbadaaa"
+		"aaaaabbbaaaaa"
+
+		// Level 5
+		"adadadddadada"
+		"daaaabbbaaaad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"daaaabbbaaaad"
+		"adadabbbadada"
+
+		// Level 6
+		"adadaaaaadada"
+		"daaaaaaaaaaad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"dabbbbbbbbbad"
+		"aabbbbbbbbbaa"
+		"daaaaaaaaaaad"
+		"adadaaaaadada"
+
+		// Level 7
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 8
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+		"aaaaaaaaaaaaa"
+
+		// Level 9
+		"dadadadadadad"
+		"abbbbbbbbbbba"
+		"dbbbbbbbbbbbd"
+		"abbbbbbbbbbba"
+		"dbbbbbbbbbbbd"
+		"abbbbbbbbbbba"
+		"dbbbbbbbbbbbd"
+		"abbbbbbbbbbba"
+		"dbbbbbbbbbbbd"
+		"abbbbbbbbbbba"
+		"dbbbbbbbbbbbd"
+		"abbbbbbbbbbba"
+		"dadadadadadad",
+
+		// Connections:
+		"0: 6, 1,  0: 2\n"  /* Type 0, BLOCK_FACE_ZM */
+		"1: 6, 1, 12: 3\n"  /* Type 1, BLOCK_FACE_ZP */,
+		
+		// AllowedRotations:
+		7,  /* 1, 2, 3 CCW rotations */
+		
+		// Merge strategy:
+		cBlockArea::msSpongePrint,
+	},
+} ;  // g_NetherFortStartingPrefabs1
+
+const size_t g_NetherFortPrefabs1Count = ARRAYCOUNT(g_NetherFortPrefabs1);
+const size_t g_NetherFortStartingPrefabs1Count = ARRAYCOUNT(g_NetherFortStartingPrefabs1);
+
+
+
+
diff --git a/src/Generating/Prefabs/NetherFortPrefabs.h b/src/Generating/Prefabs/NetherFortPrefabs.h
new file mode 100644
index 000000000..37a91689d
--- /dev/null
+++ b/src/Generating/Prefabs/NetherFortPrefabs.h
@@ -0,0 +1,15 @@
+
+// NetherFortPrefabs.h
+
+// Declares the data used for nether fortress prefabs
+
+#include "../Prefab.h"
+
+
+
+
+
+extern const cPrefab::sDef g_NetherFortPrefabs1[];
+extern const cPrefab::sDef g_NetherFortStartingPrefabs1[];
+extern const size_t g_NetherFortPrefabs1Count;
+extern const size_t g_NetherFortStartingPrefabs1Count;
diff --git a/src/Generating/Ravines.cpp b/src/Generating/Ravines.cpp
index cfda47e32..e64f55214 100644
--- a/src/Generating/Ravines.cpp
+++ b/src/Generating/Ravines.cpp
@@ -117,7 +117,7 @@ void cStructGenRavines::ClearCache(void)
 
 
 
-void cStructGenRavines::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenRavines::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
diff --git a/src/Generating/Ravines.h b/src/Generating/Ravines.h
index 05164a5b2..c76b9f19f 100644
--- a/src/Generating/Ravines.h
+++ b/src/Generating/Ravines.h
@@ -17,7 +17,7 @@
 
 
 class cStructGenRavines :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenRavines(int a_Seed, int a_Size);
@@ -37,8 +37,8 @@ protected:
 	/// Returns all ravines that *may* intersect the given chunk. All the ravines are valid until the next call to this function.
 	void GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cRavines & a_Ravines);
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
diff --git a/src/Generating/StructGen.cpp b/src/Generating/StructGen.cpp
index da6227801..db9d5578c 100644
--- a/src/Generating/StructGen.cpp
+++ b/src/Generating/StructGen.cpp
@@ -51,28 +51,10 @@ const int NEST_SIZE_GRAVEL = 32;
 
 
 
-template <typename T> T Clamp(T a_Value, T a_Min, T a_Max)
-{
-	return (a_Value < a_Min) ? a_Min : ((a_Value > a_Max) ? a_Max : a_Value);
-}
-
-
-
-
-
-static bool SortTreeBlocks(const sSetBlock & a_First, const sSetBlock & a_Second)
-{
-	return (a_First.BlockType == E_BLOCK_LOG) && (a_Second.BlockType != E_BLOCK_LOG);
-}
-
-
-
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenTrees:
 
-void cStructGenTrees::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenTrees::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
@@ -324,7 +306,7 @@ int cStructGenTrees::GetNumTrees(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenOreNests:
 
-void cStructGenOreNests::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenOreNests::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
@@ -431,7 +413,7 @@ void cStructGenOreNests::GenerateOre(int a_ChunkX, int a_ChunkZ, BLOCKTYPE a_Ore
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenLakes:
 
-void cStructGenLakes::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenLakes::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
@@ -563,7 +545,7 @@ cStructGenDirectOverhangs::cStructGenDirectOverhangs(int a_Seed) :
 
 
 
-void cStructGenDirectOverhangs::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenDirectOverhangs::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	// If there is no column of the wanted biome, bail out:
 	if (!HasWantedBiome(a_ChunkDesc))
@@ -596,7 +578,7 @@ void cStructGenDirectOverhangs::GenStructures(cChunkDesc & a_ChunkDesc)
 			m_Noise2.IntNoise3DInt(BaseX + INTERPOL_X * x, BaseY, BaseZ + INTERPOL_Z * z) /
 			256;
 	}  // for x, z - FloorLo[]
-	LinearUpscale2DArrayInPlace(FloorLo, 17, 17, INTERPOL_X, INTERPOL_Z);
+	LinearUpscale2DArrayInPlace<17, 17, INTERPOL_X, INTERPOL_Z>(FloorLo);
 	
 	// Interpolate segments:
 	for (int Segment = BaseY; Segment < MaxHeight; Segment += SEGMENT_HEIGHT)
@@ -609,7 +591,7 @@ void cStructGenDirectOverhangs::GenStructures(cChunkDesc & a_ChunkDesc)
 				m_Noise2.IntNoise3DInt(BaseX + INTERPOL_Z * x, Segment + SEGMENT_HEIGHT, BaseZ + INTERPOL_Z * z) /
 				256;
 		}  // for x, z - FloorLo[]
-		LinearUpscale2DArrayInPlace(FloorHi, 17, 17, INTERPOL_X, INTERPOL_Z);
+		LinearUpscale2DArrayInPlace<17, 17, INTERPOL_X, INTERPOL_Z>(FloorHi);
 		
 		// Interpolate between FloorLo and FloorHi:
 		for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++)
@@ -683,7 +665,7 @@ cStructGenDistortedMembraneOverhangs::cStructGenDistortedMembraneOverhangs(int a
 
 
 
-void cStructGenDistortedMembraneOverhangs::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenDistortedMembraneOverhangs::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	const NOISE_DATATYPE Frequency = (NOISE_DATATYPE)16;
 	const NOISE_DATATYPE Amount = (NOISE_DATATYPE)1;
diff --git a/src/Generating/StructGen.h b/src/Generating/StructGen.h
index 853748bb8..9176bc192 100644
--- a/src/Generating/StructGen.h
+++ b/src/Generating/StructGen.h
@@ -21,7 +21,7 @@
 
 
 class cStructGenTrees :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenTrees(int a_Seed, cBiomeGen * a_BiomeGen, cTerrainHeightGen * a_HeightGen, cTerrainCompositionGen * a_CompositionGen) :
@@ -64,8 +64,8 @@ protected:
 		const cChunkDef::BiomeMap & a_Biomes
 	);
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -73,7 +73,7 @@ protected:
 
 
 class cStructGenOreNests :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenOreNests(int a_Seed) : m_Noise(a_Seed), m_Seed(a_Seed) {}
@@ -82,8 +82,8 @@ protected:
 	cNoise m_Noise;
 	int    m_Seed;
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 	
 	void GenerateOre(int a_ChunkX, int a_ChunkZ, BLOCKTYPE a_OreType, int a_MaxHeight, int a_NumNests, int a_NestSize, cChunkDef::BlockTypes & a_BlockTypes, int a_Seq);
 } ;
@@ -93,7 +93,7 @@ protected:
 
 
 class cStructGenLakes :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenLakes(int a_Seed, BLOCKTYPE a_Fluid, cTerrainHeightGen & a_HeiGen, int a_Probability) :
@@ -112,8 +112,8 @@ protected:
 	cTerrainHeightGen & m_HeiGen;
 	int                 m_Probability;  ///< Chance, 0 .. 100, of a chunk having the lake
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 	
 	/// Creates a lake image for the specified chunk into a_Lake
 	void CreateLakeImage(int a_ChunkX, int a_ChunkZ, cBlockArea & a_Lake);
@@ -125,7 +125,7 @@ protected:
 
 
 class cStructGenDirectOverhangs :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenDirectOverhangs(int a_Seed);
@@ -134,8 +134,8 @@ protected:
 	cNoise    m_Noise1;
 	cNoise    m_Noise2;
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 
 	bool HasWantedBiome(cChunkDesc & a_ChunkDesc) const;
 } ;
@@ -145,7 +145,7 @@ protected:
 
 
 class cStructGenDistortedMembraneOverhangs :
-	public cStructureGen
+	public cFinishGen
 {
 public:
 	cStructGenDistortedMembraneOverhangs(int a_Seed);
@@ -156,8 +156,8 @@ protected:
 	cNoise m_NoiseZ;
 	cNoise m_NoiseH;
 	
-	// cStructureGen override:
-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+	// cFinishGen override:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
diff --git a/src/Generating/Trees.cpp b/src/Generating/Trees.cpp
index 7e8a3c75f..4909587b1 100644
--- a/src/Generating/Trees.cpp
+++ b/src/Generating/Trees.cpp
@@ -382,6 +382,24 @@ void GetBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Nois
 
 
 
+void GetAcaciaTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
+{
+	// TODO
+}
+
+
+
+
+
+void GetDarkoakTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
+{
+	// TODO
+}
+
+
+
+
+
 void GetTallBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
 {
 	int Height = 9 + (a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) % 3);
@@ -577,7 +595,7 @@ void GetPineTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise
 		{
 			break;
 		}
-		ASSERT(LayerSize < ARRAYCOUNT(BigOs));
+		ASSERT((size_t)LayerSize < ARRAYCOUNT(BigOs));
 		PushCoordBlocks(a_BlockX, h, a_BlockZ, a_OtherBlocks, BigOs[LayerSize].Coords, BigOs[LayerSize].Count, E_BLOCK_LEAVES, E_META_LEAVES_CONIFER);
 		h--;
 	}
diff --git a/src/Generating/Trees.h b/src/Generating/Trees.h
index 514158eb7..00f343a3d 100644
--- a/src/Generating/Trees.h
+++ b/src/Generating/Trees.h
@@ -63,6 +63,12 @@ void GetLargeAppleTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a
 /// Generates an image of a random birch tree
 void GetBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks);
 
+/// Generates an image of a random acacia tree
+void GetAcaciaTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks);
+
+/// Generates an image of a random darkoak tree
+void GetDarkoakTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks);
+
 /// Generates an image of a random large birch tree
 void GetTallBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks,sSetBlockVector & a_OtherBlocks);
 
diff --git a/src/Globals.h b/src/Globals.h
index d2080b8eb..26a0d87a9 100644
--- a/src/Globals.h
+++ b/src/Globals.h
@@ -29,6 +29,9 @@
 	
 	// Disabling this warning, because we know what we're doing when we're doing this:
 	#pragma warning(disable: 4355)  // 'this' used in initializer list
+
+	// Disabled because it's useless:
+	#pragma warning(disable: 4512)  // 'class': assignment operator could not be generated - reported for each class that has a reference-type member
 	
 	// 2014_01_06 xoft: Disabled this warning because MSVC is stupid and reports it in obviously wrong places
 	// #pragma warning(3 : 4244) // Conversion from 'type1' to 'type2', possible loss of data
@@ -38,14 +41,25 @@
 	// No alignment needed in MSVC
 	#define ALIGN_8
 	#define ALIGN_16
+	
+	#define FORMATSTRING(formatIndex, va_argsIndex)
+
+	// MSVC has its own custom version of zu format
+	#define SIZE_T_FMT "%Iu"
+	#define SIZE_T_FMT_PRECISION(x) "%" #x "Iu"
+	#define SIZE_T_FMT_HEX "%Ix"
+	
+	#define NORETURN      __declspec(noreturn)
 
 #elif defined(__GNUC__)
 
 	// TODO: Can GCC explicitly mark classes as abstract (no instances can be created)?
 	#define abstract
 
-	// TODO: Can GCC mark virtual methods as overriding (forcing them to have a virtual function of the same signature in the base class)
-	#define override
+	// override is part of c++11
+	#if __cplusplus < 201103L
+  		#define override
+	#endif	
 
 	#define OBSOLETE __attribute__((deprecated))
 
@@ -54,6 +68,14 @@
 
 	// Some portability macros :)
 	#define stricmp strcasecmp
+	
+	#define FORMATSTRING(formatIndex, va_argsIndex) __attribute__((format (printf, formatIndex, va_argsIndex)))
+
+	#define SIZE_T_FMT "%zu"
+	#define SIZE_T_FMT_PRECISION(x) "%" #x "zu"
+	#define SIZE_T_FMT_HEX "%zx"
+	
+	#define NORETURN      __attribute((__noreturn__))
 
 #else
 
@@ -79,8 +101,15 @@
 #endif
 
 
+#ifdef  _DEBUG
+	#define NORETURNDEBUG NORETURN
+#else
+	#define NORETURNDEBUG
+#endif
 
 
+#include <stddef.h>
+
 
 // Integral types with predefined sizes:
 typedef long long Int64;
@@ -91,8 +120,26 @@ typedef unsigned long long UInt64;
 typedef unsigned int       UInt32;
 typedef unsigned short     UInt16;
 
+typedef unsigned char Byte;
+
 
+// If you get an error about specialization check the size of integral types
+template <typename T, size_t Size, bool x = sizeof(T) == Size>
+class SizeChecker;
 
+template <typename T, size_t Size>
+class SizeChecker<T, Size, true>
+{
+  T v;
+};
+
+template class SizeChecker<Int64, 8>;
+template class SizeChecker<Int32, 4>;
+template class SizeChecker<Int16, 2>;
+
+template class SizeChecker<UInt64, 8>;
+template class SizeChecker<UInt32, 4>;
+template class SizeChecker<UInt16, 2>;
 
 // A macro to disallow the copy constructor and operator= functions
 // This should be used in the private: declarations for any class that shouldn't allow copying itself
@@ -174,7 +221,7 @@ typedef unsigned short     UInt16;
 #include <memory>
 #include <set>
 #include <queue>
-
+#include <limits>
 
 
 
@@ -215,28 +262,52 @@ typedef unsigned short     UInt16;
 // Pretty much the same as ASSERT() but stays in Release builds
 #define VERIFY( x ) ( !!(x) || ( LOGERROR("Verification failed: %s, file %s, line %i", #x, __FILE__, __LINE__ ), exit(1), 0 ) )
 
+// Same as assert but in all Self test builds
+#ifdef SELF_TEST
+#define assert_test(x) ( !!(x) || (assert(!#x), exit(1), 0))
+#endif
+
 
 
 
 
-/// A generic interface used mainly in ForEach() functions
+/** A generic interface used mainly in ForEach() functions */
 template <typename Type> class cItemCallback
 {
 public:
-	/// Called for each item in the internal list; return true to stop the loop, or false to continue enumerating
+	virtual ~cItemCallback() {}
+	
+	/** Called for each item in the internal list; return true to stop the loop, or false to continue enumerating */
 	virtual bool Item(Type * a_Type) = 0;
 } ;
 
 
 
 
+/** Clamp X to the specified range. */
+template <typename T>
+T Clamp(T a_Value, T a_Min, T a_Max)
+{
+	return (a_Value < a_Min) ? a_Min : ((a_Value > a_Max) ? a_Max : a_Value);
+}
+
+
+
+
+
+#ifndef TOLUA_TEMPLATE_BIND
+#define TOLUA_TEMPLATE_BIND(x)
+#endif
+
+
+
+
 
 // Common headers (part 2, with macros):
 #include "ChunkDef.h"
 #include "BiomeDef.h"
 #include "BlockID.h"
+#include "BlockInfo.h"
 #include "Entities/Effects.h"
 
 
-
-
diff --git a/src/Group.cpp b/src/Group.cpp
index 448d29d87..9c2467144 100644
--- a/src/Group.cpp
+++ b/src/Group.cpp
@@ -3,35 +3,39 @@
 
 #include "Group.h"
 
-void cGroup::AddCommand( std::string a_Command )
+
+
+
+
+void cGroup::AddCommand( AString a_Command )
 {
 	m_Commands[ a_Command ] = true;
 }
 
-void cGroup::AddPermission( std::string a_Permission )
+
+
+
+
+void cGroup::AddPermission( AString a_Permission )
 {
 	m_Permissions[ a_Permission ] = true;
 }
 
-bool cGroup::HasCommand( std::string a_Command )
-{
-	if( m_Commands.find("*") != m_Commands.end() ) return true;
-
-	CommandMap::iterator itr = m_Commands.find( a_Command );
-	if( itr != m_Commands.end() )
-	{
-		if( itr->second ) return true;
-	}
-
-	for( GroupList::iterator itr = m_Inherits.begin(); itr != m_Inherits.end(); ++itr )
-	{
-		if( (*itr)->HasCommand( a_Command ) ) return true;
-	}
-	return false;
-}
+
+
+
 
 void cGroup::InheritFrom( cGroup* a_Group )
 {
 	m_Inherits.remove( a_Group );
 	m_Inherits.push_back( a_Group );
-}
\ No newline at end of file
+}
+
+
+
+
+
+void cGroup::ClearPermission()
+{
+	m_Permissions.clear();
+}
diff --git a/src/Group.h b/src/Group.h
index 65ee1a60a..8bee6f7ed 100644
--- a/src/Group.h
+++ b/src/Group.h
@@ -11,19 +11,19 @@ public:			// tolua_export
 	cGroup() {}
 	~cGroup() {}
 
-	void SetName( std::string a_Name ) { m_Name = a_Name; }				// tolua_export
-	const std::string & GetName() const { return m_Name; }				// tolua_export
-	void SetColor( std::string a_Color ) { m_Color = a_Color; }			// tolua_export
-	void AddCommand( std::string a_Command );							// tolua_export
-	void AddPermission( std::string a_Permission );						// tolua_export
-	void InheritFrom( cGroup* a_Group );								// tolua_export
-
-	bool HasCommand( std::string a_Command );							// tolua_export
-
-	typedef std::map< std::string, bool > PermissionMap;
+	void SetName( AString a_Name ) { m_Name = a_Name; }				// tolua_export
+	const AString & GetName() const { return m_Name; }				// tolua_export
+	void SetColor( AString a_Color ) { m_Color = a_Color; }			// tolua_export
+	void AddCommand( AString a_Command );							// tolua_export
+	void AddPermission( AString a_Permission );						// tolua_export
+	void InheritFrom( cGroup* a_Group );							// tolua_export
+
+	typedef std::map< AString, bool > PermissionMap;
 	const PermissionMap & GetPermissions() const { return m_Permissions; }
 
-	typedef std::map< std::string, bool > CommandMap;
+	void ClearPermission(void);
+
+	typedef std::map< AString, bool > CommandMap;
 	const CommandMap & GetCommands() const { return m_Commands; }
 
 	const AString & GetColor() const { return m_Color; }					// tolua_export
@@ -31,8 +31,8 @@ public:			// tolua_export
 	typedef std::list< cGroup* > GroupList;
 	const GroupList & GetInherits() const { return m_Inherits; }
 private:
-	std::string m_Name;
-	std::string m_Color;
+	AString m_Name;
+	AString m_Color;
 
 	PermissionMap m_Permissions;
 	CommandMap m_Commands;
diff --git a/src/GroupManager.cpp b/src/GroupManager.cpp
index 792acc2c3..33b601e82 100644
--- a/src/GroupManager.cpp
+++ b/src/GroupManager.cpp
@@ -44,6 +44,66 @@ cGroupManager::cGroupManager()
 	: m_pState( new sGroupManagerState )
 {
 	LOGD("-- Loading Groups --");
+	
+	LoadGroups();
+	CheckUsers();
+	
+	LOGD("-- Groups Successfully Loaded --");
+}
+
+
+
+
+
+void cGroupManager::GenerateDefaultUsersIni(cIniFile & a_IniFile)
+{
+	LOGWARN("Regenerating users.ini, all users will be reset");
+	a_IniFile.AddHeaderComment(" This file stores the players' groups.");
+	a_IniFile.AddHeaderComment(" The format is:");
+	a_IniFile.AddHeaderComment(" [PlayerName]");
+	a_IniFile.AddHeaderComment(" Groups = GroupName1, GroupName2, ...");
+
+	a_IniFile.WriteFile("users.ini");
+}
+
+
+
+
+
+void cGroupManager::CheckUsers(void)
+{
+	cIniFile IniFile;
+	if (!IniFile.ReadFile("users.ini"))
+	{
+		GenerateDefaultUsersIni(IniFile);
+		return;
+	}
+	
+	unsigned int NumKeys = IniFile.GetNumKeys();
+	for (size_t i = 0; i < NumKeys; i++)
+	{
+		AString Player = IniFile.GetKeyName( i );
+		AString Groups = IniFile.GetValue(Player, "Groups", "");
+		if (!Groups.empty())
+		{
+			AStringVector Split = StringSplit( Groups, "," );
+			for( unsigned int i = 0; i < Split.size(); i++ )
+			{
+				if (!ExistsGroup(Split[i]))
+				{
+					LOGWARNING("The group %s for player %s was not found!", Split[i].c_str(), Player.c_str());
+				}
+			}
+		}
+	}
+}
+
+
+
+
+
+void cGroupManager::LoadGroups()
+{
 	cIniFile IniFile;
 	if (!IniFile.ReadFile("groups.ini"))
 	{
@@ -58,62 +118,77 @@ cGroupManager::cGroupManager()
 		IniFile.SetValue("Moderator", "Color", "2", true);
 		IniFile.SetValue("Moderator", "Inherits", "Player", true);
 
-		IniFile.SetValue("Player", "Permissions", "core.build", true);
+		IniFile.SetValue("Player", "Permissions", "core.portal", true);
 		IniFile.SetValue("Player", "Color", "f", true);
 		IniFile.SetValue("Player", "Inherits", "Default", true);
 
-		IniFile.SetValue("Default", "Permissions", "core.help,core.playerlist,core.pluginlist,core.spawn,core.listworlds,core.back,core.motd,core.gotoworld,core.coords,core.viewdistance", true);
+		IniFile.SetValue("Default", "Permissions", "core.help,core.plugins,core.spawn,core.worlds,core.back,core.motd,core.build,core.locate,core.viewdistance", true);
 		IniFile.SetValue("Default", "Color", "f", true);
 
 		IniFile.WriteFile("groups.ini");
 	}
 
 	unsigned int NumKeys = IniFile.GetNumKeys();
-	for( unsigned int i = 0; i < NumKeys; i++ )
+	for (size_t i = 0; i < NumKeys; i++)
 	{
-		std::string KeyName = IniFile.GetKeyName( i );
+		AString KeyName = IniFile.GetKeyName( i );
 		cGroup* Group = GetGroup( KeyName.c_str() );
+		
+		Group->ClearPermission(); // Needed in case the groups are reloaded.
 
 		LOGD("Loading group: %s", KeyName.c_str() );
 
-		Group->SetName( KeyName );
-		char Color = IniFile.GetValue( KeyName, "Color", "-" )[0];
-		if( Color != '-' )
-			Group->SetColor( cChatColor::Color + Color );
+		Group->SetName(KeyName);
+		AString Color = IniFile.GetValue(KeyName, "Color", "-");
+		if ((Color != "-") && (Color.length() >= 1))
+		{
+			Group->SetColor(cChatColor::Color + Color[0]);
+		}
 		else
-			Group->SetColor( cChatColor::White );
+		{
+			Group->SetColor(cChatColor::White);
+		}
 
-		AString Commands = IniFile.GetValue( KeyName, "Commands", "" );
-		if( Commands.size() > 0 )
+		AString Commands = IniFile.GetValue(KeyName, "Commands", "");
+		if (!Commands.empty())
 		{
-			AStringVector Split = StringSplit( Commands, "," );
-			for( unsigned int i = 0; i < Split.size(); i++)
+			AStringVector Split = StringSplitAndTrim(Commands, ",");
+			for (size_t i = 0; i < Split.size(); i++)
 			{
-				Group->AddCommand( Split[i] );
+				Group->AddCommand(Split[i]);
 			}
 		}
 
-		AString Permissions = IniFile.GetValue( KeyName, "Permissions", "" );
-		if( Permissions.size() > 0 )
+		AString Permissions = IniFile.GetValue(KeyName, "Permissions", "");
+		if (!Permissions.empty())
 		{
-			AStringVector Split = StringSplit( Permissions, "," );
-			for( unsigned int i = 0; i < Split.size(); i++)
+			AStringVector Split = StringSplitAndTrim(Permissions, ",");
+			for (size_t i = 0; i < Split.size(); i++)
 			{
-				Group->AddPermission( Split[i] );
+				Group->AddPermission(Split[i]);
 			}
 		}
 
-		std::string Groups = IniFile.GetValue( KeyName, "Inherits", "" );
-		if( Groups.size() > 0 )
+		AString Groups = IniFile.GetValue(KeyName, "Inherits", "");
+		if (!Groups.empty())
 		{
-			AStringVector Split = StringSplit( Groups, "," );
-			for( unsigned int i = 0; i < Split.size(); i++)
+			AStringVector Split = StringSplitAndTrim(Groups, ",");
+			for (size_t i = 0; i < Split.size(); i++)
 			{
-				Group->InheritFrom( GetGroup( Split[i].c_str() ) );
+				Group->InheritFrom(GetGroup(Split[i].c_str()));
 			}
 		}
 	}
-	LOGD("-- Groups Successfully Loaded --");
+}
+
+
+
+
+
+bool cGroupManager::ExistsGroup( const AString & a_Name )
+{
+	GroupMap::iterator itr = m_pState->Groups.find( a_Name );
+	return ( itr != m_pState->Groups.end() );
 }
 
 
diff --git a/src/GroupManager.h b/src/GroupManager.h
index d911f976c..9e1689a76 100644
--- a/src/GroupManager.h
+++ b/src/GroupManager.h
@@ -14,7 +14,13 @@ class cGroup;
 class cGroupManager
 {
 public:
+	bool ExistsGroup(const AString & a_Name);
 	cGroup * GetGroup(const AString & a_Name);
+	void LoadGroups(void);
+	void CheckUsers(void);
+	
+	/** Writes the default header to the specified ini file, and saves it as "users.ini". */
+	static void GenerateDefaultUsersIni(cIniFile & a_IniFile);
 	
 private:
 	friend class cRoot;
diff --git a/src/HTTPServer/EnvelopeParser.cpp b/src/HTTPServer/EnvelopeParser.cpp
index 8dbe05f14..fd4f3836d 100644
--- a/src/HTTPServer/EnvelopeParser.cpp
+++ b/src/HTTPServer/EnvelopeParser.cpp
@@ -20,7 +20,7 @@ cEnvelopeParser::cEnvelopeParser(cCallbacks & a_Callbacks) :
 
 
 
-int cEnvelopeParser::Parse(const char * a_Data, int a_Size)
+size_t cEnvelopeParser::Parse(const char * a_Data, size_t a_Size)
 {
 	if (!m_IsInHeaders)
 	{
@@ -55,7 +55,7 @@ int cEnvelopeParser::Parse(const char * a_Data, int a_Size)
 		{
 			// An error has occurred
 			m_IsInHeaders = false;
-			return -1;
+			return AString::npos;
 		}
 		Last = idxCRLF + 2;
 		idxCRLF = m_IncomingData.find("\r\n", idxCRLF + 2);
diff --git a/src/HTTPServer/EnvelopeParser.h b/src/HTTPServer/EnvelopeParser.h
index 6430fbebf..e96d80abe 100644
--- a/src/HTTPServer/EnvelopeParser.h
+++ b/src/HTTPServer/EnvelopeParser.h
@@ -19,7 +19,10 @@ public:
 	class cCallbacks
 	{
 	public:
-		/// Called when a full header line is parsed
+		// Force a virtual destructor in descendants:
+		virtual ~cCallbacks() {}
+		
+		/** Called when a full header line is parsed */
 		virtual void OnHeaderLine(const AString & a_Key, const AString & a_Value) = 0;
 	} ;
 	
@@ -27,40 +30,41 @@ public:
 	cEnvelopeParser(cCallbacks & a_Callbacks);
 	
 	/** Parses the incoming data.
-	Returns the number of bytes consumed from the input. The bytes not consumed are not part of the envelope header
+	Returns the number of bytes consumed from the input. The bytes not consumed are not part of the envelope header.
+	Returns AString::npos on error
 	*/
-	int Parse(const char * a_Data, int a_Size);
+	size_t Parse(const char * a_Data, size_t a_Size);
 	
-	/// Makes the parser forget everything parsed so far, so that it can be reused for parsing another datastream
+	/** Makes the parser forget everything parsed so far, so that it can be reused for parsing another datastream */
 	void Reset(void);
 	
-	/// Returns true if more input is expected for the envelope header
+	/** Returns true if more input is expected for the envelope header */
 	bool IsInHeaders(void) const { return m_IsInHeaders; }
 	
-	/// Sets the IsInHeaders flag; used by cMultipartParser to simplify the parser initial conditions
+	/** Sets the IsInHeaders flag; used by cMultipartParser to simplify the parser initial conditions */
 	void SetIsInHeaders(bool a_IsInHeaders) { m_IsInHeaders = a_IsInHeaders; }
 	
 public:
-	/// Callbacks to call for the various events
+	/** Callbacks to call for the various events */
 	cCallbacks & m_Callbacks;
 	
-	/// Set to true while the parser is still parsing the envelope headers. Once set to true, the parser will not consume any more data.
+	/** Set to true while the parser is still parsing the envelope headers. Once set to true, the parser will not consume any more data. */
 	bool m_IsInHeaders;
 	
-	/// Buffer for the incoming data until it is parsed
+	/** Buffer for the incoming data until it is parsed */
 	AString m_IncomingData;
 	
-	/// Holds the last parsed key; used for line-wrapped values
+	/** Holds the last parsed key; used for line-wrapped values */
 	AString m_LastKey;
 	
-	/// Holds the last parsed value; used for line-wrapped values
+	/** Holds the last parsed value; used for line-wrapped values */
 	AString m_LastValue;
 
 
-	/// Notifies the callback of the key/value stored in m_LastKey/m_LastValue, then erases them
+	/** Notifies the callback of the key/value stored in m_LastKey/m_LastValue, then erases them */
 	void NotifyLast(void);
 	
-	/// Parses one line of header data. Returns true if successful
+	/** Parses one line of header data. Returns true if successful */
 	bool ParseLine(const char * a_Data, size_t a_Size);
 } ;
 
diff --git a/src/HTTPServer/HTTPConnection.cpp b/src/HTTPServer/HTTPConnection.cpp
index 78b7ce4d9..da4df0e34 100644
--- a/src/HTTPServer/HTTPConnection.cpp
+++ b/src/HTTPServer/HTTPConnection.cpp
@@ -67,10 +67,10 @@ void cHTTPConnection::Send(const cHTTPResponse & a_Response)
 
 
 
-void cHTTPConnection::Send(const void * a_Data, int a_Size)
+void cHTTPConnection::Send(const void * a_Data, size_t a_Size)
 {
 	ASSERT(m_State == wcsSendingResp);
-	AppendPrintf(m_OutgoingData, "%x\r\n", a_Size);
+	AppendPrintf(m_OutgoingData, SIZE_T_FMT_HEX "\r\n", a_Size);
 	m_OutgoingData.append((const char *)a_Data, a_Size);
 	m_OutgoingData.append("\r\n");
 	m_HTTPServer.NotifyConnectionWrite(*this);
@@ -144,7 +144,7 @@ void cHTTPConnection::Terminate(void)
 
 
 
-void cHTTPConnection::DataReceived(const char * a_Data, int a_Size)
+void cHTTPConnection::DataReceived(const char * a_Data, size_t a_Size)
 {
 	switch (m_State)
 	{
@@ -155,8 +155,8 @@ void cHTTPConnection::DataReceived(const char * a_Data, int a_Size)
 				m_CurrentRequest = new cHTTPRequest;
 			}
 
-			int BytesConsumed = m_CurrentRequest->ParseHeaders(a_Data, a_Size);
-			if (BytesConsumed < 0)
+			size_t BytesConsumed = m_CurrentRequest->ParseHeaders(a_Data, a_Size);
+			if (BytesConsumed == AString::npos)
 			{
 				delete m_CurrentRequest;
 				m_CurrentRequest = NULL;
@@ -174,7 +174,7 @@ void cHTTPConnection::DataReceived(const char * a_Data, int a_Size)
 			m_State = wcsRecvBody;
 			m_HTTPServer.NewRequest(*this, *m_CurrentRequest);
 			m_CurrentRequestBodyRemaining = m_CurrentRequest->GetContentLength();
-			if (m_CurrentRequestBodyRemaining < 0)
+			if (m_CurrentRequestBodyRemaining == AString::npos)
 			{
 				// The body length was not specified in the request, assume zero
 				m_CurrentRequestBodyRemaining = 0;
@@ -197,7 +197,7 @@ void cHTTPConnection::DataReceived(const char * a_Data, int a_Size)
 			ASSERT(m_CurrentRequest != NULL);
 			if (m_CurrentRequestBodyRemaining > 0)
 			{
-				int BytesToConsume = std::min(m_CurrentRequestBodyRemaining, a_Size);
+				size_t BytesToConsume = std::min(m_CurrentRequestBodyRemaining, (size_t)a_Size);
 				m_HTTPServer.RequestBody(*this, *m_CurrentRequest, a_Data, BytesToConsume);
 				m_CurrentRequestBodyRemaining -= BytesToConsume;
 			}
diff --git a/src/HTTPServer/HTTPConnection.h b/src/HTTPServer/HTTPConnection.h
index 5b8103554..fc11f1ba6 100644
--- a/src/HTTPServer/HTTPConnection.h
+++ b/src/HTTPServer/HTTPConnection.h
@@ -51,7 +51,7 @@ public:
 	void Send(const cHTTPResponse & a_Response);
 	
 	/** Sends the data as the response (may be called multiple times) */
-	void Send(const void * a_Data, int a_Size);
+	void Send(const void * a_Data, size_t a_Size);
 
 	/** Sends the data as the response (may be called multiple times) */
 	void Send(const AString & a_Data) { Send(a_Data.data(), a_Data.size()); }
@@ -87,11 +87,11 @@ protected:
 
 	/** Number of bytes that remain to read for the complete body of the message to be received.
 	Valid only in wcsRecvBody */
-	int m_CurrentRequestBodyRemaining;
+	size_t m_CurrentRequestBodyRemaining;
 	
 	
 	// cSocketThreads::cCallback overrides:
-	virtual void DataReceived   (const char * a_Data, int a_Size) override;  // Data is received from the client
+	virtual void DataReceived   (const char * a_Data, size_t a_Size) override;  // Data is received from the client
 	virtual void GetOutgoingData(AString & a_Data) override;  // Data can be sent to client
 	virtual void SocketClosed   (void) override;  // The socket has been closed for any reason
 } ;
diff --git a/src/HTTPServer/HTTPFormParser.cpp b/src/HTTPServer/HTTPFormParser.cpp
index e661ea6f9..9ddfb82f1 100644
--- a/src/HTTPServer/HTTPFormParser.cpp
+++ b/src/HTTPServer/HTTPFormParser.cpp
@@ -52,7 +52,7 @@ cHTTPFormParser::cHTTPFormParser(cHTTPRequest & a_Request, cCallbacks & a_Callba
 
 
 
-cHTTPFormParser::cHTTPFormParser(eKind a_Kind, const char * a_Data, int a_Size, cCallbacks & a_Callbacks) :
+cHTTPFormParser::cHTTPFormParser(eKind a_Kind, const char * a_Data, size_t a_Size, cCallbacks & a_Callbacks) :
 	m_Callbacks(a_Callbacks),
 	m_Kind(a_Kind),
 	m_IsValid(true)
@@ -64,7 +64,7 @@ cHTTPFormParser::cHTTPFormParser(eKind a_Kind, const char * a_Data, int a_Size,
 
 
 
-void cHTTPFormParser::Parse(const char * a_Data, int a_Size)
+void cHTTPFormParser::Parse(const char * a_Data, size_t a_Size)
 {
 	if (!m_IsValid)
 	{
@@ -243,7 +243,7 @@ void cHTTPFormParser::OnPartHeader(const AString & a_Key, const AString & a_Valu
 
 
 
-void cHTTPFormParser::OnPartData(const char * a_Data, int a_Size)
+void cHTTPFormParser::OnPartData(const char * a_Data, size_t a_Size)
 {
 	if (m_CurrentPartName.empty())
 	{
diff --git a/src/HTTPServer/HTTPFormParser.h b/src/HTTPServer/HTTPFormParser.h
index a554ca5a4..edc6d2471 100644
--- a/src/HTTPServer/HTTPFormParser.h
+++ b/src/HTTPServer/HTTPFormParser.h
@@ -36,11 +36,14 @@ public:
 	class cCallbacks
 	{
 	public:
+		// Force a virtual destructor in descendants:
+		virtual ~cCallbacks() {}
+		
 		/// Called when a new file part is encountered in the form data
 		virtual void OnFileStart(cHTTPFormParser & a_Parser, const AString & a_FileName) = 0;
 		
 		/// Called when more file data has come for the current file in the form data
-		virtual void OnFileData(cHTTPFormParser & a_Parser, const char * a_Data, int a_Size) = 0;
+		virtual void OnFileData(cHTTPFormParser & a_Parser, const char * a_Data, size_t a_Size) = 0;
 		
 		/// Called when the current file part has ended in the form data
 		virtual void OnFileEnd(cHTTPFormParser & a_Parser) = 0;
@@ -51,10 +54,10 @@ public:
 	cHTTPFormParser(cHTTPRequest & a_Request, cCallbacks & a_Callbacks);
 	
 	/// Creates a parser with the specified content type that reads data from a string
-	cHTTPFormParser(eKind a_Kind, const char * a_Data, int a_Size, cCallbacks & a_Callbacks);
+	cHTTPFormParser(eKind a_Kind, const char * a_Data, size_t a_Size, cCallbacks & a_Callbacks);
 	
 	/// Adds more data into the parser, as the request body is received
-	void Parse(const char * a_Data, int a_Size);
+	void Parse(const char * a_Data, size_t a_Size);
 	
 	/** Notifies that there's no more data incoming and the parser should finish its parsing.
 	Returns true if parsing successful
@@ -103,7 +106,7 @@ protected:
 	// cMultipartParser::cCallbacks overrides:
 	virtual void OnPartStart (void) override;
 	virtual void OnPartHeader(const AString & a_Key, const AString & a_Value) override;
-	virtual void OnPartData  (const char * a_Data, int a_Size) override;
+	virtual void OnPartData  (const char * a_Data, size_t a_Size) override;
 	virtual void OnPartEnd   (void) override;
 } ;
 
diff --git a/src/HTTPServer/HTTPMessage.cpp b/src/HTTPServer/HTTPMessage.cpp
index 98627eb8e..4a3611050 100644
--- a/src/HTTPServer/HTTPMessage.cpp
+++ b/src/HTTPServer/HTTPMessage.cpp
@@ -25,7 +25,7 @@
 
 cHTTPMessage::cHTTPMessage(eKind a_Kind) :
 	m_Kind(a_Kind),
-	m_ContentLength(-1)
+	m_ContentLength(AString::npos)
 {
 }
 
@@ -81,23 +81,23 @@ cHTTPRequest::cHTTPRequest(void) :
 
 
 
-int cHTTPRequest::ParseHeaders(const char * a_Data, int a_Size)
+size_t cHTTPRequest::ParseHeaders(const char * a_Data, size_t a_Size)
 {
 	if (!m_IsValid)
 	{
-		return -1;
+		return AString::npos;
 	}
 	
 	if (m_Method.empty())
 	{
 		// The first line hasn't been processed yet
-		int res = ParseRequestLine(a_Data, a_Size);
-		if ((res < 0) || (res == a_Size))
+		size_t res = ParseRequestLine(a_Data, a_Size);
+		if ((res == AString::npos) || (res == a_Size))
 		{
 			return res;
 		}
-		int res2 = m_EnvelopeParser.Parse(a_Data + res, a_Size - res);
-		if (res2 < 0)
+		size_t res2 = m_EnvelopeParser.Parse(a_Data + res, a_Size - res);
+		if (res2 == AString::npos)
 		{
 			m_IsValid = false;
 			return res2;
@@ -107,8 +107,8 @@ int cHTTPRequest::ParseHeaders(const char * a_Data, int a_Size)
 	
 	if (m_EnvelopeParser.IsInHeaders())
 	{
-		int res = m_EnvelopeParser.Parse(a_Data, a_Size);
-		if (res < 0)
+		size_t res = m_EnvelopeParser.Parse(a_Data, a_Size);
+		if (res == AString::npos)
 		{
 			m_IsValid = false;
 		}
@@ -138,7 +138,7 @@ AString cHTTPRequest::GetBareURL(void) const
 
 
 
-int cHTTPRequest::ParseRequestLine(const char * a_Data, int a_Size)
+size_t cHTTPRequest::ParseRequestLine(const char * a_Data, size_t a_Size)
 {	
 	m_IncomingHeaderData.append(a_Data, a_Size);
 	size_t IdxEnd = m_IncomingHeaderData.size();
@@ -158,7 +158,7 @@ int cHTTPRequest::ParseRequestLine(const char * a_Data, int a_Size)
 	if (LineStart >= IdxEnd)
 	{
 		m_IsValid = false;
-		return -1;
+		return AString::npos;
 	}
 	
 	int NumSpaces = 0;
@@ -186,7 +186,7 @@ int cHTTPRequest::ParseRequestLine(const char * a_Data, int a_Size)
 					{
 						// Too many spaces in the request
 						m_IsValid = false;
-						return -1;
+						return AString::npos;
 					}
 				}
 				NumSpaces += 1;
@@ -198,13 +198,13 @@ int cHTTPRequest::ParseRequestLine(const char * a_Data, int a_Size)
 				{
 					// LF too early, without a CR, without two preceeding spaces or too soon after the second space
 					m_IsValid = false;
-					return -1;
+					return AString::npos;
 				}
 				// Check that there's HTTP/version at the end
 				if (strncmp(a_Data + URLEnd + 1, "HTTP/1.", 7) != 0)
 				{
 					m_IsValid = false;
-					return -1;
+					return AString::npos;
 				}
 				m_Method = m_IncomingHeaderData.substr(LineStart, MethodEnd - LineStart);
 				m_URL = m_IncomingHeaderData.substr(MethodEnd + 1, URLEnd - MethodEnd - 1);
diff --git a/src/HTTPServer/HTTPMessage.h b/src/HTTPServer/HTTPMessage.h
index ab3338db7..dab942136 100644
--- a/src/HTTPServer/HTTPMessage.h
+++ b/src/HTTPServer/HTTPMessage.h
@@ -39,10 +39,10 @@ public:
 	void AddHeader(const AString & a_Key, const AString & a_Value);
 	
 	void SetContentType  (const AString & a_ContentType) { m_ContentType   = a_ContentType; }
-	void SetContentLength(int a_ContentLength)           { m_ContentLength = a_ContentLength; }
+	void SetContentLength(size_t a_ContentLength)        { m_ContentLength = a_ContentLength; }
 	
 	const AString & GetContentType  (void) const { return m_ContentType; }
-	int             GetContentLength(void) const { return m_ContentLength; }
+	size_t          GetContentLength(void) const { return m_ContentLength; }
 
 protected:
 	typedef std::map<AString, AString> cNameValueMap;
@@ -54,8 +54,10 @@ protected:
 	/** Type of the content; parsed by AddHeader(), set directly by SetContentLength() */
 	AString m_ContentType;
 
-	/** Length of the content that is to be received. -1 when the object is created, parsed by AddHeader() or set directly by SetContentLength() */
-	int m_ContentLength;
+	/** Length of the content that is to be received.
+	AString::npos when the object is created.
+	Parsed by AddHeader() or set directly by SetContentLength() */
+	size_t m_ContentLength;
 } ;
 
 
@@ -72,12 +74,12 @@ public:
 	cHTTPRequest(void);
 	
 	/** Parses the request line and then headers from the received data.
-	Returns the number of bytes consumed or a negative number for error
+	Returns the number of bytes consumed or AString::npos number for error
 	*/
-	int ParseHeaders(const char * a_Data, int a_Size);
+	size_t ParseHeaders(const char * a_Data, size_t a_Size);
 	
 	/** Returns true if the request did contain a Content-Length header */
-	bool HasReceivedContentLength(void) const { return (m_ContentLength >= 0); }
+	bool HasReceivedContentLength(void) const { return (m_ContentLength != AString::npos); }
 	
 	/** Returns the method used in the request */
 	const AString & GetMethod(void) const { return m_Method; }
@@ -145,7 +147,7 @@ protected:
 	/** Parses the incoming data for the first line (RequestLine)
 	Returns the number of bytes consumed, or -1 for an error
 	*/
-	int ParseRequestLine(const char * a_Data, int a_Size);
+	size_t ParseRequestLine(const char * a_Data, size_t a_Size);
 	
 	// cEnvelopeParser::cCallbacks overrides:
 	virtual void OnHeaderLine(const AString & a_Key, const AString & a_Value) override;
diff --git a/src/HTTPServer/HTTPServer.cpp b/src/HTTPServer/HTTPServer.cpp
index f6f5b0f8b..eaf8405a3 100644
--- a/src/HTTPServer/HTTPServer.cpp
+++ b/src/HTTPServer/HTTPServer.cpp
@@ -29,6 +29,8 @@ class cDebugCallbacks :
 {
 		virtual void OnRequestBegun(cHTTPConnection & a_Connection, cHTTPRequest & a_Request) override
 		{
+			UNUSED(a_Connection);
+			
 			if (cHTTPFormParser::HasFormData(a_Request))
 			{
 				a_Request.SetUserData(new cHTTPFormParser(a_Request, *this));
@@ -36,8 +38,10 @@ class cDebugCallbacks :
 		}
 		
 		
-		virtual void OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size) override
+		virtual void OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, size_t a_Size) override
 		{
+			UNUSED(a_Connection);
+			
 			cHTTPFormParser * FormParser = (cHTTPFormParser *)(a_Request.GetUserData());
 			if (FormParser != NULL)
 			{
@@ -96,7 +100,7 @@ class cDebugCallbacks :
 		}
 		
 		
-		virtual void OnFileData(cHTTPFormParser & a_Parser, const char * a_Data, int a_Size) override
+		virtual void OnFileData(cHTTPFormParser & a_Parser, const char * a_Data, size_t a_Size) override
 		{
 			// TODO
 		}
@@ -238,7 +242,7 @@ void cHTTPServer::NewRequest(cHTTPConnection & a_Connection, cHTTPRequest & a_Re
 
 
 
-void cHTTPServer::RequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size)
+void cHTTPServer::RequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, size_t a_Size)
 {
 	m_Callbacks->OnRequestBody(a_Connection, a_Request, a_Data, a_Size);
 }
diff --git a/src/HTTPServer/HTTPServer.h b/src/HTTPServer/HTTPServer.h
index 24baf8c95..8eff7d879 100644
--- a/src/HTTPServer/HTTPServer.h
+++ b/src/HTTPServer/HTTPServer.h
@@ -37,20 +37,23 @@ public:
 	class cCallbacks
 	{
 	public:
+		virtual ~cCallbacks() {}
+		
 		/** Called when a new request arrives over a connection and its headers have been parsed.
 		The request body needn't have arrived yet.
 		*/
 		virtual void OnRequestBegun(cHTTPConnection & a_Connection, cHTTPRequest & a_Request) = 0;
 		
-		/// Called when another part of request body has arrived.
-		virtual void OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size) = 0;
+		/** Called when another part of request body has arrived.
+		May be called multiple times for a single request. */
+		virtual void OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, size_t a_Size) = 0;
 		
 		/// Called when the request body has been fully received in previous calls to OnRequestBody()
 		virtual void OnRequestFinished(cHTTPConnection & a_Connection, cHTTPRequest & a_Request) = 0;
 	} ;
 	
 	cHTTPServer(void);
-	~cHTTPServer();
+	virtual ~cHTTPServer();
 	
 	/// Initializes the server on the specified ports
 	bool Initialize(const AString & a_PortsIPv4, const AString & a_PortsIPv6);
@@ -88,8 +91,9 @@ protected:
 	/// Called by cHTTPConnection when it finishes parsing the request header
 	void NewRequest(cHTTPConnection & a_Connection, cHTTPRequest & a_Request);
 	
-	/// Called by cHTTPConenction when it receives more data for the request body
-	void RequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size);
+	/** Called by cHTTPConenction when it receives more data for the request body.
+	May be called multiple times for a single request. */
+	void RequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, size_t a_Size);
 	
 	/// Called by cHTTPConnection when it detects that the request has finished (all of its body has been received)
 	void RequestFinished(cHTTPConnection & a_Connection, cHTTPRequest & a_Request);
diff --git a/src/HTTPServer/MultipartParser.cpp b/src/HTTPServer/MultipartParser.cpp
index 14c2c00fa..309495dd7 100644
--- a/src/HTTPServer/MultipartParser.cpp
+++ b/src/HTTPServer/MultipartParser.cpp
@@ -97,8 +97,6 @@ cMultipartParser::cMultipartParser(const AString & a_ContentType, cCallbacks & a
 	m_EnvelopeParser(*this),
 	m_HasHadData(false)
 {
-	static AString s_Multipart = "multipart/";
-	
 	// Check that the content type is multipart:
 	AString ContentType(a_ContentType);
 	if (strncmp(ContentType.c_str(), "multipart/", 10) != 0)
@@ -146,7 +144,7 @@ cMultipartParser::cMultipartParser(const AString & a_ContentType, cCallbacks & a
 
 
 
-void cMultipartParser::Parse(const char * a_Data, int a_Size)
+void cMultipartParser::Parse(const char * a_Data, size_t a_Size)
 {
 	// Skip parsing if invalid
 	if (!m_IsValid)
@@ -160,8 +158,8 @@ void cMultipartParser::Parse(const char * a_Data, int a_Size)
 	{
 		if (m_EnvelopeParser.IsInHeaders())
 		{
-			int BytesConsumed = m_EnvelopeParser.Parse(m_IncomingData.data(), m_IncomingData.size());
-			if (BytesConsumed < 0)
+			size_t BytesConsumed = m_EnvelopeParser.Parse(m_IncomingData.data(), m_IncomingData.size());
+			if (BytesConsumed == AString::npos)
 			{
 				m_IsValid = false;
 				return;
diff --git a/src/HTTPServer/MultipartParser.h b/src/HTTPServer/MultipartParser.h
index d853929ed..ad76ad650 100644
--- a/src/HTTPServer/MultipartParser.h
+++ b/src/HTTPServer/MultipartParser.h
@@ -22,50 +22,53 @@ public:
 	class cCallbacks
 	{
 	public:
-		/// Called when a new part starts
+		// Force a virtual destructor in descendants:
+		virtual ~cCallbacks() {}
+		
+		/** Called when a new part starts */
 		virtual void OnPartStart(void) = 0;
 		
-		/// Called when a complete header line is received for a part
+		/** Called when a complete header line is received for a part */
 		virtual void OnPartHeader(const AString & a_Key, const AString & a_Value) = 0;
 		
-		/// Called when body for a part is received
-		virtual void OnPartData(const char * a_Data, int a_Size) = 0;
+		/** Called when body for a part is received */
+		virtual void OnPartData(const char * a_Data, size_t a_Size) = 0;
 		
-		/// Called when the current part ends
+		/** Called when the current part ends */
 		virtual void OnPartEnd(void) = 0;
 	} ;
 	
-	/// Creates the parser, expects to find the boundary in a_ContentType
+	/** Creates the parser, expects to find the boundary in a_ContentType */
 	cMultipartParser(const AString & a_ContentType, cCallbacks & a_Callbacks);
 	
-	/// Parses more incoming data
-	void Parse(const char * a_Data, int a_Size);
+	/** Parses more incoming data */
+	void Parse(const char * a_Data, size_t a_Size);
 	
 protected:
-	/// The callbacks to call for various parsing events
+	/** The callbacks to call for various parsing events */
 	cCallbacks & m_Callbacks;
 	
-	/// True if the data parsed so far is valid; if false, further parsing is skipped
+	/** True if the data parsed so far is valid; if false, further parsing is skipped */
 	bool m_IsValid;
 	
-	/// Parser for each part's envelope
+	/** Parser for each part's envelope */
 	cEnvelopeParser m_EnvelopeParser;
 	
-	/// Buffer for the incoming data until it is parsed
+	/** Buffer for the incoming data until it is parsed */
 	AString m_IncomingData;
 	
-	/// The boundary, excluding both the initial "--" and the terminating CRLF
+	/** The boundary, excluding both the initial "--" and the terminating CRLF */
 	AString m_Boundary;
 	
-	/// Set to true if some data for the current part has already been signalized to m_Callbacks. Used for proper CRLF inserting.
+	/** Set to true if some data for the current part has already been signalized to m_Callbacks. Used for proper CRLF inserting. */
 	bool m_HasHadData;
 	
 	
-	/// Parse one line of incoming data. The CRLF has already been stripped from a_Data / a_Size
-	void ParseLine(const char * a_Data, int a_Size);
+	/** Parse one line of incoming data. The CRLF has already been stripped from a_Data / a_Size */
+	void ParseLine(const char * a_Data, size_t a_Size);
 	
-	/// Parse one line of incoming data in the headers section of a part. The CRLF has already been stripped from a_Data / a_Size
-	void ParseHeaderLine(const char * a_Data, int a_Size);
+	/** Parse one line of incoming data in the headers section of a part. The CRLF has already been stripped from a_Data / a_Size */
+	void ParseHeaderLine(const char * a_Data, size_t a_Size);
 	
 	// cEnvelopeParser overrides:
 	virtual void OnHeaderLine(const AString & a_Key, const AString & a_Value) override;
diff --git a/src/HTTPServer/NameValueParser.cpp b/src/HTTPServer/NameValueParser.cpp
index 9ea8594ae..3f6c17dda 100644
--- a/src/HTTPServer/NameValueParser.cpp
+++ b/src/HTTPServer/NameValueParser.cpp
@@ -24,7 +24,7 @@ public:
 
 		// Now try parsing char-by-char, to debug transitions across datachunk boundaries:
 		cNameValueParser Parser2;
-		for (int i = 0; i < sizeof(Data) - 1; i++)
+		for (size_t i = 0; i < sizeof(Data) - 1; i++)
 		{
 			Parser2.Parse(Data + i, 1);
 		}
@@ -82,7 +82,7 @@ cNameValueParser::cNameValueParser(bool a_AllowsKeyOnly) :
 
 
 
-cNameValueParser::cNameValueParser(const char * a_Data, int a_Size, bool a_AllowsKeyOnly) :
+cNameValueParser::cNameValueParser(const char * a_Data, size_t a_Size, bool a_AllowsKeyOnly) :
 	m_State(psKeySpace),
 	m_AllowsKeyOnly(a_AllowsKeyOnly)
 {
@@ -93,12 +93,12 @@ cNameValueParser::cNameValueParser(const char * a_Data, int a_Size, bool a_Allow
 
 
 
-void cNameValueParser::Parse(const char * a_Data, int a_Size)
+void cNameValueParser::Parse(const char * a_Data, size_t a_Size)
 {
 	ASSERT(m_State != psFinished);  // Calling Parse() after Finish() is wrong!
 	
 	int Last = 0;
-	for (int i = 0; i < a_Size;)
+	for (size_t i = 0; i < a_Size;)
 	{
 		switch (m_State)
 		{
diff --git a/src/HTTPServer/NameValueParser.h b/src/HTTPServer/NameValueParser.h
index 07dc0b942..9794614fa 100644
--- a/src/HTTPServer/NameValueParser.h
+++ b/src/HTTPServer/NameValueParser.h
@@ -21,10 +21,10 @@ public:
 	cNameValueParser(bool a_AllowsKeyOnly = true);
 	
 	/// Creates an empty parser, then parses the data given. Doesn't call Finish(), so more data can be parsed later
-	cNameValueParser(const char * a_Data, int a_Size, bool a_AllowsKeyOnly = true);
+	cNameValueParser(const char * a_Data, size_t a_Size, bool a_AllowsKeyOnly = true);
 	
 	/// Parses the data given
-	void Parse(const char * a_Data, int a_Size);
+	void Parse(const char * a_Data, size_t a_Size);
 	
 	/// Notifies the parser that no more data will be coming. Returns true if the parser state is valid
 	bool Finish(void);
diff --git a/src/Inventory.cpp b/src/Inventory.cpp
index 0e1cedc85..c7c089d5f 100644
--- a/src/Inventory.cpp
+++ b/src/Inventory.cpp
@@ -204,6 +204,12 @@ void cInventory::SetSlot(int a_SlotNum, const cItem & a_Item)
 		return;
 	}
 	Grid->SetSlot(GridSlotNum, a_Item);
+
+	// Broadcast the Equipped Item, if the Slot is changed.
+	if ((Grid == &m_HotbarSlots) && (m_EquippedSlotNum == (a_SlotNum - invHotbarOffset)))
+	{
+		m_Owner.GetWorld()->BroadcastEntityEquipment(m_Owner, 0, a_Item, m_Owner.GetClientHandle());
+	}
 }
 
 
@@ -515,6 +521,31 @@ bool cInventory::AddToBar( cItem & a_Item, const int a_Offset, const int a_Size,
 
 
 
+void cInventory::UpdateItems(void)
+{
+	const cItem & Slot = GetEquippedItem();
+
+	if (Slot.IsEmpty())
+	{
+		return;
+	}
+
+	switch (Slot.m_ItemType)
+	{
+		case E_ITEM_MAP:
+		{
+			ItemHandler(Slot.m_ItemType)->OnUpdate(m_Owner.GetWorld(), &m_Owner, Slot);
+			break;
+		}
+
+		default: break;
+	}
+}
+
+
+
+
+
 void cInventory::SaveToJson(Json::Value & a_Value)
 {
 	// The JSON originally included the 4 crafting slots and the result, so we have to put empty items there, too:
diff --git a/src/Inventory.h b/src/Inventory.h
index 3c6a19de8..1ad7c4776 100644
--- a/src/Inventory.h
+++ b/src/Inventory.h
@@ -52,6 +52,8 @@ public:
 	
 	cInventory(cPlayer & a_Owner);
 	
+	virtual ~cInventory() {}
+	
 	// tolua_begin
 
 	/// Removes all items from the entire inventory
@@ -150,6 +152,9 @@ public:
 	/// Sends the slot contents to the owner
 	void SendSlot(int a_SlotNum);
 
+	/// Update items (e.g. Maps)
+	void UpdateItems(void);
+
 	/// Converts an armor slot number into the ID for the EntityEquipment packet
 	static int ArmorSlotNumToEntityEquipmentID(short a_ArmorSlotNum);
 
diff --git a/src/Item.cpp b/src/Item.cpp
index fb561d7b2..093147b54 100644
--- a/src/Item.cpp
+++ b/src/Item.cpp
@@ -1,4 +1,4 @@
-
+
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Item.h"
@@ -139,6 +139,16 @@ void cItem::GetJson(Json::Value & a_OutValue) const
 		{
 			a_OutValue["Lore"] = m_Lore;
 		}
+
+		if ((m_ItemType == E_ITEM_FIREWORK_ROCKET) || (m_ItemType == E_ITEM_FIREWORK_STAR))
+		{
+			a_OutValue["Flicker"] = m_FireworkItem.m_HasFlicker;
+			a_OutValue["Trail"] = m_FireworkItem.m_HasTrail;
+			a_OutValue["Type"] = m_FireworkItem.m_Type;
+			a_OutValue["FlightTimeInTicks"] = m_FireworkItem.m_FlightTimeInTicks;
+			a_OutValue["Colours"] = m_FireworkItem.ColoursToString(m_FireworkItem);
+			a_OutValue["FadeColours"] = m_FireworkItem.FadeColoursToString(m_FireworkItem);
+		}
 	}
 }
 
@@ -157,6 +167,16 @@ void cItem::FromJson(const Json::Value & a_Value)
 		m_Enchantments.AddFromString(a_Value.get("ench", "").asString());
 		m_CustomName = a_Value.get("Name", "").asString();
 		m_Lore = a_Value.get("Lore", "").asString();
+
+		if ((m_ItemType == E_ITEM_FIREWORK_ROCKET) || (m_ItemType == E_ITEM_FIREWORK_STAR))
+		{
+			m_FireworkItem.m_HasFlicker = a_Value.get("Flicker", false).asBool();
+			m_FireworkItem.m_HasTrail = a_Value.get("Trail", false).asBool();
+			m_FireworkItem.m_Type = (NIBBLETYPE)a_Value.get("Type", 0).asInt();
+			m_FireworkItem.m_FlightTimeInTicks = (short)a_Value.get("FlightTimeInTicks", 0).asInt();
+			m_FireworkItem.ColoursFromString(a_Value.get("Colours", "").asString(), m_FireworkItem);
+			m_FireworkItem.FadeColoursFromString(a_Value.get("FadeColours", "").asString(), m_FireworkItem);
+		}
 	}
 }
 
@@ -302,7 +322,7 @@ cItem * cItems::Get(int a_Idx)
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to get an out-of-bounds item at index %d; there are currently %d items. Returning a nil.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to get an out-of-bounds item at index %d; there are currently " SIZE_T_FMT " items. Returning a nil.", a_Idx, size());
 		return NULL;
 	}
 	return &at(a_Idx);
@@ -316,7 +336,7 @@ void cItems::Set(int a_Idx, const cItem & a_Item)
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently %d items. Not setting.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently " SIZE_T_FMT " items. Not setting.", a_Idx, size());
 		return;
 	}
 	at(a_Idx) = a_Item;
@@ -330,7 +350,7 @@ void cItems::Delete(int a_Idx)
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to delete an item at an out-of-bounds index %d; there are currently %d items. Ignoring.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to delete an item at an out-of-bounds index %d; there are currently " SIZE_T_FMT " items. Ignoring.", a_Idx, size());
 		return;
 	}
 	erase(begin() + a_Idx);
@@ -344,7 +364,7 @@ void cItems::Set(int a_Idx, short a_ItemType, char a_ItemCount, short a_ItemDama
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently %d items. Not setting.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently " SIZE_T_FMT " items. Not setting.", a_Idx, size());
 		return;
 	}
 	at(a_Idx) = cItem(a_ItemType, a_ItemCount, a_ItemDamage);
diff --git a/src/Item.h b/src/Item.h
index 1a070eafd..620c77b29 100644
--- a/src/Item.h
+++ b/src/Item.h
@@ -11,6 +11,7 @@
 
 #include "Defines.h"
 #include "Enchantments.h"
+#include "WorldStorage/FireworksSerializer.h"
 
 
 
@@ -32,18 +33,19 @@ namespace Json
 class cItem
 {
 public:
-	/// Creates an empty item
+	/** Creates an empty item */
 	cItem(void) :
 		m_ItemType(E_ITEM_EMPTY),
 		m_ItemCount(0),
 		m_ItemDamage(0),
 		m_CustomName(""),
-		m_Lore("")
+		m_Lore(""),
+		m_FireworkItem()
 	{
 	}
 	
 	
-	/// Creates an item of the specified type, by default 1 piece with no damage and no enchantments
+	/** Creates an item of the specified type, by default 1 piece with no damage and no enchantments */
 	cItem(
 		short a_ItemType,
 		char a_ItemCount = 1,
@@ -57,7 +59,8 @@ public:
 		m_ItemDamage  (a_ItemDamage),
 		m_Enchantments(a_Enchantments),
 		m_CustomName  (a_CustomName),
-		m_Lore        (a_Lore)
+		m_Lore        (a_Lore),
+		m_FireworkItem()
 	{
 		if (!IsValidItem(m_ItemType))
 		{
@@ -70,14 +73,15 @@ public:
 	}
 	
 	
-	/// Creates an exact copy of the item
+	/** Creates an exact copy of the item */
 	cItem(const cItem & a_CopyFrom) :
 		m_ItemType    (a_CopyFrom.m_ItemType),
 		m_ItemCount   (a_CopyFrom.m_ItemCount),
 		m_ItemDamage  (a_CopyFrom.m_ItemDamage),
 		m_Enchantments(a_CopyFrom.m_Enchantments),
 		m_CustomName  (a_CopyFrom.m_CustomName),
-		m_Lore        (a_CopyFrom.m_Lore)
+		m_Lore        (a_CopyFrom.m_Lore),
+		m_FireworkItem(a_CopyFrom.m_FireworkItem)
 	{
 	}
 	
@@ -90,6 +94,7 @@ public:
 		m_Enchantments.Clear();
 		m_CustomName = "";
 		m_Lore = "";
+		m_FireworkItem.EmptyData();
 	}
 	
 	
@@ -106,8 +111,8 @@ public:
 		return ((m_ItemType <= 0) || (m_ItemCount <= 0));
 	}
 	
-	/* Returns true if this itemstack can stack with the specified stack (types match, enchantments etc.) ItemCounts are ignored!
-	*/
+	/* Returns true if this itemstack can stack with the specified stack (types match, enchantments etc.)
+	ItemCounts are ignored. */
 	bool IsEqual(const cItem & a_Item) const
 	{
 		return (
@@ -115,7 +120,8 @@ public:
 			(m_ItemDamage == a_Item.m_ItemDamage) &&
 			(m_Enchantments == a_Item.m_Enchantments) &&
 			(m_CustomName == a_Item.m_CustomName) &&
-			(m_Lore == a_Item.m_Lore)
+			(m_Lore == a_Item.m_Lore) &&
+			m_FireworkItem.IsEqualTo(a_Item.m_FireworkItem)
 		);
 	}
 	
@@ -135,39 +141,39 @@ public:
 	bool IsCustomNameEmpty(void) const { return (m_CustomName.empty()); }
 	bool IsLoreEmpty(void) const { return (m_Lore.empty()); }	
 
-	/// Returns a copy of this item with m_ItemCount set to 1. Useful to preserve enchantments etc. on stacked items
+	/** Returns a copy of this item with m_ItemCount set to 1. Useful to preserve enchantments etc. on stacked items */
 	cItem CopyOne(void) const;
 	
-	/// Adds the specified count to this object and returns the reference to self (useful for chaining)
+	/** Adds the specified count to this object and returns the reference to self (useful for chaining) */
 	cItem & AddCount(char a_AmountToAdd);
 	
-	/// Returns the maximum damage value that this item can have; zero if damage is not applied
+	/** Returns the maximum damage value that this item can have; zero if damage is not applied */
 	short GetMaxDamage(void) const;
 	
-	/// Damages a weapon / tool. Returns true when damage reaches max value and the item should be destroyed
+	/** Damages a weapon / tool. Returns true when damage reaches max value and the item should be destroyed */
 	bool DamageItem(short a_Amount = 1);
 
 	inline bool IsDamageable(void) const { return (GetMaxDamage() > 0); }
 	
-	/// Returns true if the item is stacked up to its maximum stacking.
+	/** Returns true if the item is stacked up to its maximum stacking. */
 	bool IsFullStack(void) const;
 	
-	/// Returns the maximum amount of stacked items of this type.
+	/** Returns the maximum amount of stacked items of this type. */
 	char GetMaxStackSize(void) const;
 
 	// tolua_end
 	
-	/// Returns the cItemHandler responsible for this item type
+	/** Returns the cItemHandler responsible for this item type */
 	cItemHandler * GetHandler(void) const;
 	
-	/// Saves the item data into JSON representation
+	/** Saves the item data into JSON representation */
 	void GetJson(Json::Value & a_OutValue) const;
 	
-	/// Loads the item data from JSON representation
+	/** Loads the item data from JSON representation */
 	void FromJson(const Json::Value & a_Value);
 	
-	/// Returns true if the specified item type is enchantable (as per 1.2.5 protocol requirements)
-	static bool IsEnchantable(short a_ItemType);
+	/** Returns true if the specified item type is enchantable (as per 1.2.5 protocol requirements) */
+	static bool IsEnchantable(short a_ItemType); // tolua_export
 
 	/** Fills a_Enchantments with the list of enchantments applicable to the specified item type */
 	static void cItem::GetApplicableEnchantmentsForType(short a_ItemType, cEnchantmentsArray & a_Enchantments);
@@ -177,9 +183,11 @@ public:
 	short         m_ItemType;
 	char          m_ItemCount;
 	short         m_ItemDamage;
+	cEnchantments m_Enchantments;
 	AString       m_CustomName;
 	AString       m_Lore;
-	cEnchantments m_Enchantments;
+
+	cFireworkItem m_FireworkItem;
 };
 // tolua_end
 
@@ -196,7 +204,7 @@ class cItems  // tolua_export
 public:
 	// tolua_begin
 	
-	/// Need a Lua-accessible constructor
+	/** Need a Lua-accessible constructor */
 	cItems(void) {}
 	
 	cItem * Get   (int a_Idx);
@@ -204,7 +212,7 @@ public:
 	void    Add   (const cItem & a_Item) {push_back(a_Item); }
 	void    Delete(int a_Idx);
 	void    Clear (void) {clear(); }
-	int     Size  (void) {return size(); }
+	size_t  Size  (void) {return size(); }
 	void    Set   (int a_Idx, short a_ItemType, char a_ItemCount, short a_ItemDamage);
 
 	void    Add   (short a_ItemType, char a_ItemCount, short a_ItemDamage)
@@ -219,7 +227,7 @@ public:
 
 
 
-/// Used to store loot probability tables
+/** Used to store loot probability tables */
 class cLootProbab
 {
 public:
diff --git a/src/ItemGrid.cpp b/src/ItemGrid.cpp
index e8b58695f..34a267bab 100644
--- a/src/ItemGrid.cpp
+++ b/src/ItemGrid.cpp
@@ -369,6 +369,13 @@ int cItemGrid::ChangeSlotCount(int a_SlotNum, int a_AddToCount)
 	}
 	
 	m_Slots[a_SlotNum].m_ItemCount += a_AddToCount;
+
+	cItemHandler * Handler = cItemHandler::GetItemHandler(m_Slots[a_SlotNum].m_ItemType);
+	if (m_Slots[a_SlotNum].m_ItemCount > Handler->GetMaxStackSize())
+	{
+		m_Slots[a_SlotNum].m_ItemCount = Handler->GetMaxStackSize();
+	}
+
 	TriggerListeners(a_SlotNum);
 	return m_Slots[a_SlotNum].m_ItemCount;
 }
diff --git a/src/ItemGrid.h b/src/ItemGrid.h
index b344e3daf..c34d5e9e2 100644
--- a/src/ItemGrid.h
+++ b/src/ItemGrid.h
@@ -20,11 +20,13 @@ class cItemGrid
 public:
 	// tolua_end
 	
-	/// This class is used as a callback for when a slot changes
+	/** This class is used as a callback for when a slot changes */
 	class cListener
 	{
 	public:
-		/// Called whenever a slot changes
+		virtual ~cListener() {}
+		
+		/** Called whenever a slot changes */
 		virtual void OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum) = 0;
 	} ;
 	typedef std::vector<cListener *> cListeners;
@@ -38,12 +40,12 @@ public:
 	int GetHeight  (void) const { return m_Height; }
 	int GetNumSlots(void) const { return m_NumSlots; }
 	
-	/// Converts XY coords into slot number; returns -1 on invalid coords
+	/** Converts XY coords into slot number; returns -1 on invalid coords */
 	int GetSlotNum(int a_X, int a_Y) const;
 	
 	// tolua_end
 
-	/// Converts slot number into XY coords; sets coords to -1 on invalid slot number. Exported in ManualBindings.cpp
+	/** Converts slot number into XY coords; sets coords to -1 on invalid slot number. Exported in ManualBindings.cpp */
 	void GetSlotCoords(int a_SlotNum, int & a_X, int & a_Y) const;
 
 	// tolua_begin
@@ -62,16 +64,16 @@ public:
 	void EmptySlot(int a_X, int a_Y);
 	void EmptySlot(int a_SlotNum);
 	
-	/// Returns true if the specified slot is empty or the slot doesn't exist
+	/** Returns true if the specified slot is empty or the slot doesn't exist */
 	bool IsSlotEmpty(int a_SlotNum) const;
 	
-	/// Returns true if the specified slot is empty or the slot doesn't exist
+	/** Returns true if the specified slot is empty or the slot doesn't exist */
 	bool IsSlotEmpty(int a_X, int a_Y) const;
 	
-	/// Sets all items as empty
+	/** Sets all items as empty */
 	void Clear(void);
 	
-	/// Returns number of items out of a_ItemStack that can fit in the storage
+	/** Returns number of items out of a_ItemStack that can fit in the storage */
 	int HowManyCanFit(const cItem & a_ItemStack, bool a_AllowNewStacks = true);
 	
 	/** Adds as many items out of a_ItemStack as can fit.
@@ -117,37 +119,37 @@ public:
 	*/
 	cItem RemoveOneItem(int a_X, int a_Y);
 	
-	/// Returns the number of items of type a_Item that are stored
+	/** Returns the number of items of type a_Item that are stored */
 	int HowManyItems(const cItem & a_Item);
 	
-	/// Returns true if there are at least as many items of type a_ItemStack as in a_ItemStack
+	/** Returns true if there are at least as many items of type a_ItemStack as in a_ItemStack */
 	bool HasItems(const cItem & a_ItemStack);
 	
-	/// Returns the index of the first empty slot; -1 if all full
+	/** Returns the index of the first empty slot; -1 if all full */
 	int GetFirstEmptySlot(void) const;
 
-	/// Returns the index of the first non-empty slot; -1 if all empty
+	/** Returns the index of the first non-empty slot; -1 if all empty */
 	int GetFirstUsedSlot(void) const;
 
-	/// Returns the index of the last empty slot; -1 if all full
+	/** Returns the index of the last empty slot; -1 if all full */
 	int GetLastEmptySlot(void) const;
 	
-	/// Returns the index of the last used slot; -1 if all empty
+	/** Returns the index of the last used slot; -1 if all empty */
 	int GetLastUsedSlot(void) const;
 
-	/// Returns the index of the first empty slot following a_StartFrom (a_StartFrom is not checked)
+	/** Returns the index of the first empty slot following a_StartFrom (a_StartFrom is not checked) */
 	int GetNextEmptySlot(int a_StartFrom) const;
 	
-	/// Returns the index of the first used slot following a_StartFrom (a_StartFrom is not checked)
+	/** Returns the index of the first used slot following a_StartFrom (a_StartFrom is not checked) */
 	int GetNextUsedSlot(int a_StartFrom) const;
 	
-	/// Copies the contents into a cItems object; preserves the original a_Items contents
+	/** Copies the contents into a cItems object; preserves the original a_Items contents */
 	void CopyToItems(cItems & a_Items) const;
 
-	/// Adds the specified damage to the specified item; returns true if the item broke (but the item is left intact)
+	/** Adds the specified damage to the specified item; returns true if the item broke (but the item is left intact) */
 	bool DamageItem(int a_SlotNum, short a_Amount);
 	
-	/// Adds the specified damage to the specified item; returns true if the item broke (but the item is left intact)
+	/** Adds the specified damage to the specified item; returns true if the item broke (but the item is left intact) */
 	bool DamageItem(int a_X, int a_Y, short a_Amount);
 	
 	// tolua_end
@@ -159,10 +161,10 @@ public:
 	*/
 	void GenerateRandomLootWithBooks(const cLootProbab * a_LootProbabs, size_t a_CountLootProbabs, int a_NumSlots, int a_Seed);
 	
-	/// Adds a callback that gets called whenever a slot changes. Must not be called from within the listener callback!
+	/** Adds a callback that gets called whenever a slot changes. Must not be called from within the listener callback! */
 	void AddListener(cListener & a_Listener);
 	
-	/// Removes a slot-change-callback. Must not be called from within the listener callback!
+	/** Removes a slot-change-callback. Must not be called from within the listener callback! */
 	void RemoveListener(cListener & a_Listener);
 
 	// tolua_begin
@@ -177,7 +179,7 @@ protected:
 	cCriticalSection m_CSListeners;  ///< CS that guards the m_Listeners against multi-thread access
 	bool             m_IsInTriggerListeners;  ///< Set to true while TriggerListeners is running, to detect attempts to manipulate listener list while triggerring
 	
-	/// Calls all m_Listeners for the specified slot number
+	/** Calls all m_Listeners for the specified slot number */
 	void TriggerListeners(int a_SlotNum);
 
 	/** Adds up to a_Num items out of a_ItemStack, as many as can fit, in specified slot
diff --git a/src/Items/ItemBed.h b/src/Items/ItemBed.h
index 9b7c8bff8..f23d69731 100644
--- a/src/Items/ItemBed.h
+++ b/src/Items/ItemBed.h
@@ -26,7 +26,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemBoat.h b/src/Items/ItemBoat.h
index 79c8e9589..42f4ffc8f 100644
--- a/src/Items/ItemBoat.h
+++ b/src/Items/ItemBoat.h
@@ -1,4 +1,3 @@
-
 // ItemBoat.h
 
 // Declares the various boat ItemHandlers
@@ -29,9 +28,9 @@ public:
 	
 	
 	
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
-		if (a_Dir > 0)
+		if ((a_Dir != BLOCK_FACE_YM) && (a_Dir != BLOCK_FACE_NONE))
 		{
 			return false;
 		}
@@ -40,12 +39,20 @@ public:
 			public cBlockTracer::cCallbacks
 		{
 		public:
-			Vector3d Pos;
-			virtual bool OnNextBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, char a_EntryFace) override
+			Vector3d m_Pos;
+			bool m_HasFound;
+			
+			cCallbacks(void) :
+				m_HasFound(false)
+			{
+			}
+			
+			virtual bool OnNextBlock(int a_CBBlockX, int a_CBBlockY, int a_CBBlockZ, BLOCKTYPE a_CBBlockType, NIBBLETYPE a_CBBlockMeta, char a_CBEntryFace) override
 			{
-				if (a_BlockType != E_BLOCK_AIR)
+				if (a_CBBlockType != E_BLOCK_AIR)
 				{
-					Pos = Vector3d(a_BlockX, a_BlockY, a_BlockZ);
+					m_Pos.Set(a_CBBlockX, a_CBBlockY, a_CBBlockZ);
+					m_HasFound = true;
 					return true;
 				}
 				return false;
@@ -58,15 +65,15 @@ public:
 
 		Tracer.Trace(Start.x, Start.y, Start.z, End.x, End.y, End.z);
 
-		double x = Callbacks.Pos.x;
-		double y = Callbacks.Pos.y;
-		double z = Callbacks.Pos.z;
-		
-		if ((x == 0) && (y == 0) && (z == 0))
+		if (!Callbacks.m_HasFound)
 		{
 			return false;
 		}
 
+		double x = Callbacks.m_Pos.x;
+		double y = Callbacks.m_Pos.y;
+		double z = Callbacks.m_Pos.z;
+		
 		cBoat * Boat = new cBoat(x + 0.5, y + 1, z + 0.5);
 		Boat->Initialize(a_World);
 
diff --git a/src/Items/ItemBow.h b/src/Items/ItemBow.h
index d533c21fd..410c5f512 100644
--- a/src/Items/ItemBow.h
+++ b/src/Items/ItemBow.h
@@ -27,7 +27,7 @@ public:
 	}
 	
 	
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		ASSERT(a_Player != NULL);
 		
@@ -42,7 +42,7 @@ public:
 	}
 	
 	
-	virtual void OnItemShoot(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) override
+	virtual void OnItemShoot(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
 	{
 		// Actual shot - produce the arrow with speed based on the ticks that the bow was charged
 		ASSERT(a_Player != NULL);
diff --git a/src/Items/ItemBrewingStand.h b/src/Items/ItemBrewingStand.h
index 4ff14d4b4..d5eefb855 100644
--- a/src/Items/ItemBrewingStand.h
+++ b/src/Items/ItemBrewingStand.h
@@ -25,7 +25,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemBucket.h b/src/Items/ItemBucket.h
index c9a632580..68c89dd85 100644
--- a/src/Items/ItemBucket.h
+++ b/src/Items/ItemBucket.h
@@ -6,6 +6,7 @@
 #include "../Simulator/FluidSimulator.h"
 #include "../Blocks/BlockHandler.h"
 #include "../LineBlockTracer.h"
+#include "../BlockInServerPluginInterface.h"
 
 
 
@@ -21,7 +22,7 @@ public:
 
 	}
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		switch (m_ItemType)
 		{
@@ -92,7 +93,7 @@ public:
 	}
 
 
-	bool PlaceFluid(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, BLOCKTYPE a_FluidBlock)
+	bool PlaceFluid(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, BLOCKTYPE a_FluidBlock)
 	{			
 		if (a_BlockFace < 0)
 		{
@@ -142,7 +143,9 @@ public:
 			cBlockHandler * Handler = BlockHandler(CurrentBlock);
 			if (Handler->DoesDropOnUnsuitable())
 			{
-				Handler->DropBlock(a_World, a_Player, a_BlockX, a_BlockY, a_BlockZ);
+				cChunkInterface ChunkInterface(a_World->GetChunkMap());
+				cBlockInServerPluginInterface PluginInterface(*a_World);
+				Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, a_Player, a_BlockX, a_BlockY, a_BlockZ);
 			}
 		}
 
@@ -169,12 +172,12 @@ public:
 			
 			virtual bool OnNextBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, char a_EntryFace) override
 			{
-				if (a_BlockMeta != 0)  // Even if it was a water block it would not be a source.
-				{
-					return false;
-				}
 				if (IsBlockWater(a_BlockType) || IsBlockLava(a_BlockType))
 				{
+					if (a_BlockMeta != 0) // GetBlockFromTrace is called for scooping up fluids; the hit block should be a source
+					{
+						return false;
+					}
 					m_HasHitFluid = true;
 					m_Pos.Set(a_BlockX, a_BlockY, a_BlockZ);
 					return true;
diff --git a/src/Items/ItemCake.h b/src/Items/ItemCake.h
new file mode 100644
index 000000000..48e23ed59
--- /dev/null
+++ b/src/Items/ItemCake.h
@@ -0,0 +1,41 @@
+
+#pragma once
+
+#include "ItemHandler.h"
+
+
+
+
+
+class cItemCakeHandler :
+	public cItemHandler
+{
+public:
+	cItemCakeHandler(int a_ItemType) :
+		cItemHandler(a_ItemType)
+	{
+	}
+
+
+	virtual bool IsPlaceable(void) override
+	{
+		return true;
+	}
+
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = E_BLOCK_CAKE;
+		a_BlockMeta = 0;
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Items/ItemCauldron.h b/src/Items/ItemCauldron.h
index 8b2ddc29f..07ae12660 100644
--- a/src/Items/ItemCauldron.h
+++ b/src/Items/ItemCauldron.h
@@ -25,7 +25,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemComparator.h b/src/Items/ItemComparator.h
index 3a5d1d200..60d9c3648 100644
--- a/src/Items/ItemComparator.h
+++ b/src/Items/ItemComparator.h
@@ -24,7 +24,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemDoor.h b/src/Items/ItemDoor.h
index 72ea0beed..f3677c28c 100644
--- a/src/Items/ItemDoor.h
+++ b/src/Items/ItemDoor.h
@@ -25,18 +25,20 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
 		a_BlockType = (m_ItemType == E_ITEM_WOODEN_DOOR) ? E_BLOCK_WOODEN_DOOR : E_BLOCK_IRON_DOOR;
-		return BlockHandler(a_BlockType)->GetPlacementBlockTypeMeta(
-			a_World, a_Player, 
+		cChunkInterface ChunkInterface(a_World->GetChunkMap());
+		bool Meta = BlockHandler(a_BlockType)->GetPlacementBlockTypeMeta(
+			ChunkInterface, a_Player, 
 			a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, 
 			a_CursorX, a_CursorY, a_CursorZ,
 			a_BlockType, a_BlockMeta
 		);
+		return Meta;
 	}
 } ;
 
diff --git a/src/Items/ItemDye.h b/src/Items/ItemDye.h
index 190cdc510..ccf4714f7 100644
--- a/src/Items/ItemDye.h
+++ b/src/Items/ItemDye.h
@@ -19,7 +19,7 @@ public:
 
 	}
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		// Handle growing the plants:
 		if (a_Item.m_ItemDamage == E_META_DYE_WHITE)
diff --git a/src/Items/ItemEmptyMap.h b/src/Items/ItemEmptyMap.h
new file mode 100644
index 000000000..953673382
--- /dev/null
+++ b/src/Items/ItemEmptyMap.h
@@ -0,0 +1,62 @@
+
+// ItemEmptyMap.h
+
+
+
+
+
+#pragma once
+
+#include "../Entities/Entity.h"
+#include "../Item.h"
+
+
+
+
+
+class cItemEmptyMapHandler :
+	public cItemHandler
+{
+	typedef cItemHandler super;
+
+	static const unsigned int DEFAULT_SCALE = 0;
+	
+public:
+	cItemEmptyMapHandler() :
+		super(E_ITEM_EMPTY_MAP)
+	{
+	}
+
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
+	{
+		UNUSED(a_Item);
+		UNUSED(a_BlockX);
+		UNUSED(a_BlockZ);
+		UNUSED(a_Dir);
+
+		// The map center is fixed at the central point of the 8x8 block of chunks you are standing in when you right-click it.
+
+		const int RegionWidth = cChunkDef::Width * 8;
+
+		int CenterX = (int)(floor(a_Player->GetPosX() / (float) RegionWidth) * RegionWidth);
+		int CenterZ = (int)(floor(a_Player->GetPosZ() / (float) RegionWidth) * RegionWidth);
+
+		cMap * NewMap = a_World->GetMapManager().CreateMap(CenterX, CenterZ, DEFAULT_SCALE);
+
+		// Remove empty map from inventory
+		if (!a_Player->GetInventory().RemoveOneEquippedItem())
+		{
+			ASSERT(!"Inventory mismatch");
+			return true;
+		}
+
+		if (NewMap == NULL)
+		{
+			return true;
+		}
+
+		a_Player->GetInventory().AddItem(cItem(E_ITEM_MAP, 1, (short)(NewMap->GetID() & 0x7fff)), true, true);
+
+		return true;
+	}
+} ;
diff --git a/src/Items/ItemFishingRod.h b/src/Items/ItemFishingRod.h
index b2eaee63a..0431b88b7 100644
--- a/src/Items/ItemFishingRod.h
+++ b/src/Items/ItemFishingRod.h
@@ -84,7 +84,7 @@ public:
 	{
 	}
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		if (a_Dir != BLOCK_FACE_NONE)
 		{
@@ -123,7 +123,7 @@ public:
 						}
 						case 2:
 						{
-							Drops.Add(cItem(E_ITEM_FISHING_ROD, 1, a_World->GetTickRandomNumber(50))); // Fishing rod with durability. TODO: Enchantments on it
+							Drops.Add(cItem(E_ITEM_FISHING_ROD, 1, (short)a_World->GetTickRandomNumber(50)));  // Fishing rod with durability. TODO: Enchantments on it
 							break;
 						}
 						case 3:
@@ -152,7 +152,7 @@ public:
 					}
 					else if (Junk <= 4)
 					{
-						Drops.Add(cItem(E_ITEM_BOW, 1, a_World->GetTickRandomNumber(64)));
+						Drops.Add(cItem(E_ITEM_BOW, 1, (short)a_World->GetTickRandomNumber(64)));
 					}
 					else if (Junk <= 9)
 					{
@@ -230,4 +230,4 @@ public:
 		}
 		return true;
 	}
-} ;
\ No newline at end of file
+} ;
diff --git a/src/Items/ItemFlowerPot.h b/src/Items/ItemFlowerPot.h
index befa2ff21..60bf87985 100644
--- a/src/Items/ItemFlowerPot.h
+++ b/src/Items/ItemFlowerPot.h
@@ -25,7 +25,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemFood.h b/src/Items/ItemFood.h
index 2ae572331..961cf482d 100644
--- a/src/Items/ItemFood.h
+++ b/src/Items/ItemFood.h
@@ -31,7 +31,7 @@ public:
 			// Please keep alpha-sorted.
 			case E_ITEM_BAKED_POTATO:     return FoodInfo(6, 7.2);
 			case E_ITEM_BREAD:            return FoodInfo(5, 6);
-			case E_ITEM_CARROT:           return FoodInfo(4, 4.8);
+			// Carrots handled in ItemSeeds
 			case E_ITEM_COOKED_CHICKEN:   return FoodInfo(6, 7.2);
 			case E_ITEM_COOKED_FISH:      return FoodInfo(5, 6);
 			case E_ITEM_COOKED_PORKCHOP:  return FoodInfo(8, 12.8);
@@ -39,8 +39,9 @@ public:
 			case E_ITEM_GOLDEN_APPLE:     return FoodInfo(4, 9.6);
 			case E_ITEM_GOLDEN_CARROT:    return FoodInfo(6, 14.4);
 			case E_ITEM_MELON_SLICE:      return FoodInfo(2, 1.2);
+			case E_ITEM_MUSHROOM_SOUP:    return FoodInfo(6, 7.2);
 			case E_ITEM_POISONOUS_POTATO: return FoodInfo(2, 1.2, 60);
-			case E_ITEM_POTATO:           return FoodInfo(1, 0.6);
+			// Potatoes handled in ItemSeeds
 			case E_ITEM_PUMPKIN_PIE:      return FoodInfo(8, 4.8);
 			case E_ITEM_RAW_BEEF:         return FoodInfo(3, 1.8);
 			case E_ITEM_RAW_CHICKEN:      return FoodInfo(2, 1.2, 30);
@@ -50,7 +51,6 @@ public:
 			case E_ITEM_ROTTEN_FLESH:     return FoodInfo(4, 0.8, 80);
 			case E_ITEM_SPIDER_EYE:       return FoodInfo(2, 3.2, 100);
 			case E_ITEM_STEAK:            return FoodInfo(8, 12.8);
-			case E_ITEM_MUSHROOM_SOUP:    return FoodInfo(6, 7.2);
 		}
 		LOGWARNING("%s: Unknown food item (%d), returning zero nutrition", __FUNCTION__, m_ItemType);
 		return FoodInfo(0, 0.f);
diff --git a/src/Items/ItemHandler.cpp b/src/Items/ItemHandler.cpp
index 250e21dc4..1e77717e3 100644
--- a/src/Items/ItemHandler.cpp
+++ b/src/Items/ItemHandler.cpp
@@ -5,6 +5,7 @@
 #include "../World.h"
 #include "../Entities/Player.h"
 #include "../FastRandom.h"
+#include "../BlockInServerPluginInterface.h"
 
 // Handlers:
 #include "ItemBed.h"
@@ -12,19 +13,25 @@
 #include "ItemBow.h"
 #include "ItemBrewingStand.h"
 #include "ItemBucket.h"
+#include "ItemCake.h"
 #include "ItemCauldron.h"
 #include "ItemCloth.h"
 #include "ItemComparator.h"
 #include "ItemDoor.h"
 #include "ItemDye.h"
+#include "ItemEmptyMap.h"
 #include "ItemFishingRod.h"
 #include "ItemFlowerPot.h"
 #include "ItemFood.h"
+#include "ItemItemFrame.h"
 #include "ItemHoe.h"
 #include "ItemLeaves.h"
 #include "ItemLighter.h"
+#include "ItemLilypad.h"
+#include "ItemMap.h"
 #include "ItemMinecart.h"
 #include "ItemNetherWart.h"
+#include "ItemPainting.h"
 #include "ItemPickaxe.h"
 #include "ItemThrowable.h"
 #include "ItemRedstoneDust.h"
@@ -34,6 +41,7 @@
 #include "ItemShears.h"
 #include "ItemShovel.h"
 #include "ItemSign.h"
+#include "ItemMobHead.h"
 #include "ItemSpawnEgg.h"
 #include "ItemSugarcane.h"
 #include "ItemSword.h"
@@ -88,6 +96,7 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 		
 		// Single item per handler, alphabetically sorted:
 		case E_BLOCK_LEAVES:           return new cItemLeavesHandler(a_ItemType);
+		case E_BLOCK_NEW_LEAVES:       return new cItemLeavesHandler(a_ItemType);
 		case E_BLOCK_SAPLING:          return new cItemSaplingHandler(a_ItemType);
 		case E_BLOCK_WOOL:             return new cItemClothHandler(a_ItemType);
 		case E_ITEM_BED:               return new cItemBedHandler(a_ItemType);
@@ -95,20 +104,28 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 		case E_ITEM_BOTTLE_O_ENCHANTING: return new cItemBottleOEnchantingHandler();
 		case E_ITEM_BOW:               return new cItemBowHandler;
 		case E_ITEM_BREWING_STAND:     return new cItemBrewingStandHandler(a_ItemType);
+		case E_ITEM_CAKE:              return new cItemCakeHandler(a_ItemType);
 		case E_ITEM_CAULDRON:          return new cItemCauldronHandler(a_ItemType);
 		case E_ITEM_COMPARATOR:        return new cItemComparatorHandler(a_ItemType);
 		case E_ITEM_DYE:               return new cItemDyeHandler(a_ItemType);
 		case E_ITEM_EGG:               return new cItemEggHandler();
+		case E_ITEM_EMPTY_MAP:         return new cItemEmptyMapHandler();
 		case E_ITEM_ENDER_PEARL:       return new cItemEnderPearlHandler();
+		case E_ITEM_FIRE_CHARGE:       return new cItemLighterHandler(a_ItemType);
 		case E_ITEM_FIREWORK_ROCKET:   return new cItemFireworkHandler();
 		case E_ITEM_FISHING_ROD:       return new cItemFishingRodHandler(a_ItemType);
 		case E_ITEM_FLINT_AND_STEEL:   return new cItemLighterHandler(a_ItemType);
 		case E_ITEM_FLOWER_POT:        return new cItemFlowerPotHandler(a_ItemType);
+		case E_BLOCK_LILY_PAD:         return new cItemLilypadHandler(a_ItemType);
+		case E_ITEM_MAP:               return new cItemMapHandler();
+		case E_ITEM_ITEM_FRAME:        return new cItemItemFrameHandler(a_ItemType);
 		case E_ITEM_NETHER_WART:       return new cItemNetherWartHandler(a_ItemType);
+		case E_ITEM_PAINTING:          return new cItemPaintingHandler(a_ItemType);
 		case E_ITEM_REDSTONE_DUST:     return new cItemRedstoneDustHandler(a_ItemType);
 		case E_ITEM_REDSTONE_REPEATER: return new cItemRedstoneRepeaterHandler(a_ItemType);
 		case E_ITEM_SHEARS:            return new cItemShearsHandler(a_ItemType);
 		case E_ITEM_SIGN:              return new cItemSignHandler(a_ItemType);
+		case E_ITEM_HEAD:              return new cItemMobHeadHandler(a_ItemType);
 		case E_ITEM_SNOWBALL:          return new cItemSnowballHandler();
 		case E_ITEM_SPAWN_EGG:         return new cItemSpawnEggHandler(a_ItemType);
 		case E_ITEM_SUGARCANE:         return new cItemSugarcaneHandler(a_ItemType);
@@ -180,23 +197,28 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 			return new cItemMinecartHandler(a_ItemType);
 		}
 		
-		// Food:
+		// Food (please keep alpha-sorted):
+		// (carrots and potatoes handled in SeedHandler as both seed and food
+		case E_ITEM_BAKED_POTATO:
 		case E_ITEM_BREAD:
+		case E_ITEM_COOKED_CHICKEN:
+		case E_ITEM_COOKED_FISH:
+		case E_ITEM_COOKED_PORKCHOP:
 		case E_ITEM_COOKIE:
+		case E_ITEM_GOLDEN_APPLE:
+		case E_ITEM_GOLDEN_CARROT:
 		case E_ITEM_MELON_SLICE:
-		case E_ITEM_RAW_CHICKEN:
-		case E_ITEM_COOKED_CHICKEN:
+		case E_ITEM_MUSHROOM_SOUP:
+		case E_ITEM_POISONOUS_POTATO:
+		case E_ITEM_PUMPKIN_PIE:
 		case E_ITEM_RAW_BEEF:
-		case E_ITEM_RAW_PORKCHOP:
-		case E_ITEM_STEAK:
-		case E_ITEM_COOKED_PORKCHOP:
+		case E_ITEM_RAW_CHICKEN:
 		case E_ITEM_RAW_FISH:
-		case E_ITEM_COOKED_FISH:
+		case E_ITEM_RAW_PORKCHOP:
 		case E_ITEM_RED_APPLE:
-		case E_ITEM_GOLDEN_APPLE:
 		case E_ITEM_ROTTEN_FLESH:
-		case E_ITEM_MUSHROOM_SOUP:
 		case E_ITEM_SPIDER_EYE:
+		case E_ITEM_STEAK:
 		{
 			return new cItemFoodHandler(a_ItemType);
 		}
@@ -230,8 +252,16 @@ cItemHandler::cItemHandler(int a_ItemType)
 
 
 
-bool cItemHandler::OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir)
+bool cItemHandler::OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir)
 {
+	UNUSED(a_World);
+	UNUSED(a_Player);
+	UNUSED(a_Item);
+	UNUSED(a_BlockX);
+	UNUSED(a_BlockY);
+	UNUSED(a_BlockZ);
+	UNUSED(a_Dir);
+
 	return false;
 }
 
@@ -239,8 +269,16 @@ bool cItemHandler::OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem &
 
 
 
-bool cItemHandler::OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir)
+bool cItemHandler::OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir)
 {
+	UNUSED(a_World);
+	UNUSED(a_Player);
+	UNUSED(a_Item);
+	UNUSED(a_BlockX);
+	UNUSED(a_BlockY);
+	UNUSED(a_BlockZ);
+	UNUSED(a_Dir);
+	
 	return false;
 }
 
@@ -250,14 +288,18 @@ bool cItemHandler::OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cI
 
 void cItemHandler::OnBlockDestroyed(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ)
 {
+	UNUSED(a_Item);
+	
 	BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-	cBlockHandler * Handler = cBlockHandler::GetBlockHandler(Block);
+	cBlockHandler * Handler = cBlockInfo::GetHandler(Block);
 
 	if (a_Player->IsGameModeSurvival())
 	{
 		if (!BlockRequiresSpecialTool(Block) || CanHarvestBlock(Block))
 		{
-			Handler->DropBlock(a_World, a_Player, a_BlockX, a_BlockY, a_BlockZ);
+			cChunkInterface ChunkInterface(a_World->GetChunkMap());
+			cBlockInServerPluginInterface PluginInterface(*a_World);
+			Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, a_Player, a_BlockX, a_BlockY, a_BlockZ);
 		}
 	}
 	
@@ -270,7 +312,9 @@ void cItemHandler::OnBlockDestroyed(cWorld * a_World, cPlayer * a_Player, const
 
 void cItemHandler::OnFoodEaten(cWorld * a_World, cPlayer * a_Player, cItem * a_Item)
 {
-
+	UNUSED(a_World);
+	UNUSED(a_Player);
+	UNUSED(a_Item);
 }
 
 
@@ -297,8 +341,9 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_BOWL:                 return 64;
 		case E_ITEM_BREAD:                return 64;
 		case E_ITEM_BREWING_STAND:        return 64;
-		case E_ITEM_BUCKET:               return 1;  // TODO: change this to 16 when turning compatibility to 1.3
+		case E_ITEM_BUCKET:               return 16;
 		case E_ITEM_CARROT:               return 64;
+		case E_ITEM_CAKE:                 return 1;
 		case E_ITEM_CAULDRON:             return 64;
 		case E_ITEM_CLAY:                 return 64;
 		case E_ITEM_CLAY_BRICK:           return 64;
@@ -334,6 +379,7 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_GUNPOWDER:            return 64;
 		case E_ITEM_HEAD:                 return 64;
 		case E_ITEM_IRON:                 return 64;
+		case E_ITEM_ITEM_FRAME:           return 64;
 		case E_ITEM_LEATHER:              return 64;
 		case E_ITEM_MAGMA_CREAM:          return 64;
 		case E_ITEM_MAP:                  return 64;
@@ -341,7 +387,7 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_MELON_SLICE:          return 64;
 		case E_ITEM_NETHER_BRICK:         return 64;
 		case E_ITEM_NETHER_WART:          return 64;
-		case E_ITEM_PAINTINGS:            return 64;
+		case E_ITEM_PAINTING:             return 64;
 		case E_ITEM_PAPER:                return 64;
 		case E_ITEM_POISONOUS_POTATO:     return 64;
 		case E_ITEM_POTATO:               return 64;
@@ -442,6 +488,8 @@ bool cItemHandler::IsPlaceable(void)
 
 bool cItemHandler::CanHarvestBlock(BLOCKTYPE a_BlockType)
 {
+	UNUSED(a_BlockType);
+	
 	return false;
 }
 
@@ -451,22 +499,23 @@ bool cItemHandler::CanHarvestBlock(BLOCKTYPE a_BlockType)
 
 bool cItemHandler::GetPlacementBlockTypeMeta(
 	cWorld * a_World, cPlayer * a_Player,
-	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 	int a_CursorX, int a_CursorY, int a_CursorZ,
 	BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 )
 {
 	ASSERT(m_ItemType < 256);  // Items with IDs above 255 should all be handled by specific handlers
 	
-	if (m_ItemType > 256)
+	if (m_ItemType >= 256)
 	{
-		LOGERROR("%s: Item %d has no valid block!", __FUNCTION__, m_ItemType);
+		LOGERROR("%s: Item %d is not eligible for direct block placement!", __FUNCTION__, m_ItemType);
 		return false;
 	}
 	
-	cBlockHandler * BlockH = BlockHandler(m_ItemType);
+	cBlockHandler * BlockH = BlockHandler((BLOCKTYPE)m_ItemType);
+	cChunkInterface ChunkInterface(a_World->GetChunkMap());
 	return BlockH->GetPlacementBlockTypeMeta(
-		a_World, a_Player,
+		ChunkInterface, a_Player,
 		a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, 
 		a_CursorX, a_CursorY, a_CursorZ,
 		a_BlockType, a_BlockMeta
@@ -479,6 +528,8 @@ bool cItemHandler::GetPlacementBlockTypeMeta(
 
 bool cItemHandler::EatItem(cPlayer * a_Player, cItem * a_Item)
 {
+	UNUSED(a_Item);
+	
 	FoodInfo Info = GetFoodInfo();
 
 	if ((Info.FoodLevel > 0) || (Info.Saturation > 0.f))
@@ -507,7 +558,7 @@ bool cItemHandler::EatItem(cPlayer * a_Player, cItem * a_Item)
 
 cItemHandler::FoodInfo cItemHandler::GetFoodInfo()
 {
-	return FoodInfo(0, 0.f);
+	return FoodInfo(0, 0);
 }
 
 
diff --git a/src/Items/ItemHandler.h b/src/Items/ItemHandler.h
index db0ffc9db..5b6c239cc 100644
--- a/src/Items/ItemHandler.h
+++ b/src/Items/ItemHandler.h
@@ -21,20 +21,31 @@ class cItemHandler
 public:
 	cItemHandler(int a_ItemType);
 	
+	// Force virtual destructor
+	virtual ~cItemHandler() {}
+	
 	/// Called when the player tries to use the item (right mouse button). Return false to make the item unusable. DEFAULT: False
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir);
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir);
 	
 	/// Called when the client sends the SHOOT status in the lclk packet
-	virtual void OnItemShoot(cPlayer *, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) 
+	virtual void OnItemShoot(cPlayer *, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) 
 	{
 		UNUSED(a_BlockX);
 		UNUSED(a_BlockY);
 		UNUSED(a_BlockZ);
 		UNUSED(a_BlockFace);
 	}
+
+	/// Called every tick while the item is on the player's inventory (Used by maps) - For now, called only for equipped items
+	virtual void OnUpdate(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item)
+	{
+		UNUSED(a_World);
+		UNUSED(a_Player);
+		UNUSED(a_Item);
+	}
 	
 	/// Called while the player diggs a block using this item
-	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_HeldItem, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace);
+	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_HeldItem, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace);
 	
 	/// Called when the player destroys a block using this item. This also calls the drop function for the destroyed block
 	virtual void OnBlockDestroyed(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_X, int a_Y, int a_Z);
@@ -80,7 +91,7 @@ public:
 	*/
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	);
diff --git a/src/Items/ItemHoe.h b/src/Items/ItemHoe.h
index 7b6b3e6ac..29f7c83d5 100644
--- a/src/Items/ItemHoe.h
+++ b/src/Items/ItemHoe.h
@@ -19,7 +19,7 @@ public:
 
 	}
 
-	virtual bool OnItemUse(cWorld *a_World, cPlayer *a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld *a_World, cPlayer *a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
 
diff --git a/src/Items/ItemItemFrame.h b/src/Items/ItemItemFrame.h
new file mode 100644
index 000000000..27e7dba35
--- /dev/null
+++ b/src/Items/ItemItemFrame.h
@@ -0,0 +1,57 @@
+
+#pragma once
+
+#include "ItemHandler.h"
+#include "Entities/ItemFrame.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cItemItemFrameHandler :
+	public cItemHandler
+{
+public:
+	cItemItemFrameHandler(int a_ItemType)
+		: cItemHandler(a_ItemType)
+	{
+
+	}
+
+	virtual bool OnItemUse(cWorld *a_World, cPlayer *a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
+	{
+		if ((a_Dir == BLOCK_FACE_NONE) || (a_Dir == BLOCK_FACE_YP) || (a_Dir == BLOCK_FACE_YM))
+		{
+			// Client sends this if clicked on top or bottom face
+			return false;
+		}
+
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_Dir); // Make sure block that will be occupied is free
+		BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_Dir, true); // We want the clicked block, so go back again
+
+		if (Block == E_BLOCK_AIR)
+		{
+			cItemFrame * ItemFrame = new cItemFrame(a_Dir, a_BlockX, a_BlockY, a_BlockZ);
+			if (!ItemFrame->Initialize(a_World))
+			{
+				delete ItemFrame;
+				return false;
+			}
+
+			if (!a_Player->IsGameModeCreative())
+			{
+				a_Player->GetInventory().RemoveOneEquippedItem();
+			}
+
+			return true;
+
+		}
+		return false;
+	}
+};
+
+
+
+
diff --git a/src/Items/ItemLeaves.h b/src/Items/ItemLeaves.h
index 60222eaa9..12cb45d1c 100644
--- a/src/Items/ItemLeaves.h
+++ b/src/Items/ItemLeaves.h
@@ -20,7 +20,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemLighter.h b/src/Items/ItemLighter.h
index 4281a2d0c..32f49cab6 100644
--- a/src/Items/ItemLighter.h
+++ b/src/Items/ItemLighter.h
@@ -19,32 +19,56 @@ public:
 	{
 	}
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
 	{
 		if (a_BlockFace < 0)
 		{
 			return false;
 		}
 		
-		a_Player->UseEquippedItem();
+		if (!a_Player->IsGameModeCreative())
+		{
+			switch (m_ItemType)
+			{
+				case E_ITEM_FLINT_AND_STEEL:
+				{
+					a_Player->UseEquippedItem();
+					break;
+				}
+				case E_ITEM_FIRE_CHARGE:
+				{
+					a_Player->GetInventory().RemoveOneEquippedItem();
+					break;
+				}
+				default:
+				{
+					ASSERT(!"Unknown Lighter Item!");
+				}
+			}
+		}
 
 		switch (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ))
 		{
 			case E_BLOCK_TNT:
 			{
 				// Activate the TNT:
-				a_World->BroadcastSoundEffect("random.fuse", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.6f);
-				a_World->SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5, 4);  // 4 seconds to boom
+				a_World->BroadcastSoundEffect("game.tnt.primed", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 1.0f, 1.0f);
 				a_World->SetBlock(a_BlockX,a_BlockY,a_BlockZ, E_BLOCK_AIR, 0);
+				a_World->SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5);  // 80 ticks to boom
 				break;
 			}
 			default:
 			{
 				// Light a fire next to/on top of the block if air:
 				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
+				if ((a_BlockY < 0) || (a_BlockY >= cChunkDef::Height))
+				{
+					break;
+				}
 				if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_AIR)
 				{
 					a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_FIRE, 0);
+					a_World->BroadcastSoundEffect("fire.ignite", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 1.0F, 1.04F);
 					break;
 				}
 			}
diff --git a/src/Items/ItemLilypad.h b/src/Items/ItemLilypad.h
new file mode 100644
index 000000000..8fc1d8543
--- /dev/null
+++ b/src/Items/ItemLilypad.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "ItemHandler.h"
+#include "../Entities/Player.h"
+#include "Vector3.h"
+#include "../LineBlockTracer.h"
+#include "BlockInfo.h"
+
+
+
+
+
+class cItemLilypadHandler :
+	public cItemHandler
+{
+	typedef cItemHandler super;
+
+public:
+	cItemLilypadHandler(int a_ItemType):
+		super(a_ItemType)
+	{
+
+	}
+
+
+	virtual bool IsPlaceable(void) override
+	{
+		return false; // Set as not placeable so OnItemUse is called
+	}
+
+
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		if (a_BlockFace > BLOCK_FACE_NONE)
+		{
+			// Clicked on the side of a submerged block; vanilla allows placement, so should we
+			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_LILY_PAD, 0);
+			if (!a_Player->IsGameModeCreative())
+			{
+				a_Player->GetInventory().RemoveOneEquippedItem();
+			}
+			return true;
+		}
+
+		class cCallbacks :
+			public cBlockTracer::cCallbacks
+		{
+		public:
+			cCallbacks(cWorld * a_CBWorld) :
+				m_HasHitFluid(false),
+				m_World(a_CBWorld)
+			{
+			}
+
+			virtual bool OnNextBlock(int a_CBBlockX, int a_CBBlockY, int a_CBBlockZ, BLOCKTYPE a_CBBlockType, NIBBLETYPE a_CBBlockMeta, char a_CBEntryFace) override
+			{
+				if (IsBlockWater(a_CBBlockType))
+				{
+					if ((a_CBBlockMeta != 0) || (a_CBEntryFace == BLOCK_FACE_NONE)) // The hit block should be a source. The FACE_NONE check is clicking whilst submerged
+					{
+						return false;
+					}
+					AddFaceDirection(a_CBBlockX, a_CBBlockY, a_CBBlockZ, BLOCK_FACE_YP);  // Always place pad at top of water block
+					BLOCKTYPE Block = m_World->GetBlock(a_CBBlockX, a_CBBlockY, a_CBBlockZ);
+					if (
+						!IsBlockWater(Block) &&
+						cBlockInfo::FullyOccupiesVoxel(Block)
+						)
+					{
+						// Can't place lilypad on air/in another block!
+						return true;
+					}
+					m_HasHitFluid = true;
+					m_Pos.Set(a_CBBlockX, a_CBBlockY, a_CBBlockZ);
+					return true;
+				}
+				return false;
+			}
+
+			Vector3i m_Pos;
+			bool m_HasHitFluid;
+			cWorld * m_World;
+
+		};
+
+		cCallbacks Callbacks(a_World);
+		cLineBlockTracer Tracer(*a_Player->GetWorld(), Callbacks);
+		Vector3d Start(a_Player->GetEyePosition() + a_Player->GetLookVector());
+		Vector3d End(a_Player->GetEyePosition() + a_Player->GetLookVector() * 5);
+
+		Tracer.Trace(Start.x, Start.y, Start.z, End.x, End.y, End.z);
+
+		if (Callbacks.m_HasHitFluid)
+		{
+			a_World->SetBlock(Callbacks.m_Pos.x, Callbacks.m_Pos.y, Callbacks.m_Pos.z, E_BLOCK_LILY_PAD, 0);
+			if (!a_Player->IsGameModeCreative())
+			{
+				a_Player->GetInventory().RemoveOneEquippedItem();
+			}
+			return true;
+		}
+
+		return false;
+	}
+};
+
+
+
+
diff --git a/src/Items/ItemMap.h b/src/Items/ItemMap.h
new file mode 100644
index 000000000..056fe0fe7
--- /dev/null
+++ b/src/Items/ItemMap.h
@@ -0,0 +1,43 @@
+
+// ItemMap.h
+
+
+
+
+
+#pragma once
+
+#include "../Entities/Entity.h"
+#include "../Item.h"
+
+
+
+
+
+class cItemMapHandler :
+	public cItemHandler
+{
+	typedef cItemHandler super;
+
+	static const unsigned int DEFAULT_RADIUS = 128;
+	
+public:
+	cItemMapHandler() :
+		super(E_ITEM_MAP)
+	{
+	}
+
+	virtual void OnUpdate(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item)
+	{
+		cMap * Map = a_World->GetMapManager().GetMapData((unsigned)a_Item.m_ItemDamage);
+
+		if (Map == NULL)
+		{
+			return;
+		}
+
+		Map->UpdateRadius(*a_Player, DEFAULT_RADIUS);
+
+		Map->UpdateClient(a_Player);
+	}
+} ;
diff --git a/src/Items/ItemMinecart.h b/src/Items/ItemMinecart.h
index 4071f8c60..25500aeb9 100644
--- a/src/Items/ItemMinecart.h
+++ b/src/Items/ItemMinecart.h
@@ -1,4 +1,3 @@
-
 // ItemMinecart.h
 
 // Declares the various minecart ItemHandlers
@@ -28,7 +27,7 @@ public:
 	
 	
 	
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		if (a_Dir < 0)
 		{
@@ -72,6 +71,11 @@ public:
 			}
 		}  // switch (m_ItemType)
 		Minecart->Initialize(a_World);
+
+		if (!a_Player->IsGameModeCreative())
+		{
+			a_Player->GetInventory().RemoveOneEquippedItem();
+		}
 		return true;
 	}
 	
diff --git a/src/Items/ItemMobHead.h b/src/Items/ItemMobHead.h
new file mode 100644
index 000000000..5ae040282
--- /dev/null
+++ b/src/Items/ItemMobHead.h
@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include "ItemHandler.h"
+#include "../World.h"
+
+
+
+
+
+class cItemMobHeadHandler :
+	public cItemHandler
+{
+public:
+	cItemMobHeadHandler(int a_ItemType) :
+		cItemHandler(a_ItemType)
+	{
+	}
+
+
+	virtual bool IsPlaceable(void) override
+	{
+		return true;
+	}
+
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = E_BLOCK_HEAD;
+		a_BlockMeta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage & 0x0f);
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Items/ItemNetherWart.h b/src/Items/ItemNetherWart.h
index aa4a44340..a6a9a286a 100644
--- a/src/Items/ItemNetherWart.h
+++ b/src/Items/ItemNetherWart.h
@@ -25,7 +25,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
@@ -51,4 +51,4 @@ public:
 
 		return true;
 	}
-} ;
\ No newline at end of file
+} ;
diff --git a/src/Items/ItemPainting.h b/src/Items/ItemPainting.h
new file mode 100644
index 000000000..b85098221
--- /dev/null
+++ b/src/Items/ItemPainting.h
@@ -0,0 +1,98 @@
+
+#pragma once
+
+#include "ItemHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+#include "../Entities/Painting.h"
+
+
+
+
+
+class cItemPaintingHandler :
+	public cItemHandler
+{
+public:
+	cItemPaintingHandler(int a_ItemType)
+		: cItemHandler(a_ItemType)
+	{
+	}
+
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
+	{
+		if (a_Dir == BLOCK_FACE_NONE)
+		{
+			// Client sends this if clicked on top or bottom face
+			return false;
+		}
+
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_Dir); // Make sure block that will be occupied is free
+		BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_Dir, true); // We want the clicked block, so go back again
+
+		if (Block == E_BLOCK_AIR)
+		{
+			int Dir = 0;
+
+			// The client uses different values for painting directions and block faces. Our constants are for the block faces, so we convert them here to painting faces
+			switch (a_Dir)
+			{
+				case BLOCK_FACE_ZP: break; // Initialised to zero
+				case BLOCK_FACE_ZM: Dir = 2; break;
+				case BLOCK_FACE_XM: Dir = 1; break;
+				case BLOCK_FACE_XP: Dir = 3; break;
+				default: ASSERT(!"Unhandled block face when trying spawn painting!"); return false;
+			}
+
+			static const struct // Define all the possible painting titles
+			{
+				AString Title;
+			} gPaintingTitlesList[] =
+			{
+				{ "Kebab" },
+				{ "Aztec" },
+				{ "Alban" },
+				{ "Aztec2" },
+				{ "Bomb" },
+				{ "Plant" },
+				{ "Wasteland" },
+				{ "Wanderer" },
+				{ "Graham" },
+				{ "Pool" },
+				{ "Courbet" },
+				{ "Sunset" },
+				{ "Sea" },
+				{ "Creebet" },
+				{ "Match" },
+				{ "Bust" },
+				{ "Stage" },
+				{ "Void" },
+				{ "SkullAndRoses" },
+				{ "Wither" },
+				{ "Fighters" },
+				{ "Skeleton" },
+				{ "DonkeyKong" },
+				{ "Pointer" },
+				{ "Pigscene" },
+				{ "BurningSkull" }
+			};
+
+			cPainting * Painting = new cPainting(gPaintingTitlesList[a_World->GetTickRandomNumber(ARRAYCOUNT(gPaintingTitlesList) - 1)].Title, Dir, a_BlockX, a_BlockY, a_BlockZ);
+			Painting->Initialize(a_World);
+
+			if (!a_Player->IsGameModeCreative())
+			{
+				a_Player->GetInventory().RemoveOneEquippedItem();
+			}
+
+			return true;
+
+		}
+		return false;
+	}
+};
+
+
+
+
diff --git a/src/Items/ItemPickaxe.h b/src/Items/ItemPickaxe.h
index bde7f0905..2a8e40daa 100644
--- a/src/Items/ItemPickaxe.h
+++ b/src/Items/ItemPickaxe.h
@@ -19,17 +19,13 @@ public:
 	{
 		switch(m_ItemType)
 		{
-		case E_ITEM_WOODEN_PICKAXE:
-		case E_ITEM_GOLD_PICKAXE:
-			return 1;
-		case E_ITEM_STONE_PICKAXE:
-			return 2;
-		case E_ITEM_IRON_PICKAXE:
-			return 3;
-		case E_ITEM_DIAMOND_PICKAXE:
-			return 4;
-		default:
-			return 0;
+			case E_ITEM_WOODEN_PICKAXE:  return 1;
+			case E_ITEM_GOLD_PICKAXE:    return 1;
+			case E_ITEM_STONE_PICKAXE:   return 2;
+			case E_ITEM_IRON_PICKAXE:    return 3;
+			case E_ITEM_DIAMOND_PICKAXE: return 4;
+
+			default: return 0;
 		}
 	}
 	
@@ -61,6 +57,10 @@ public:
 				return PickaxeLevel() >= 2;
 			}
 			
+			case E_BLOCK_ANVIL:
+			case E_BLOCK_ENCHANTMENT_TABLE:
+			case E_BLOCK_FURNACE:
+			case E_BLOCK_LIT_FURNACE:
 			case E_BLOCK_COAL_ORE:
 			case E_BLOCK_STONE:
 			case E_BLOCK_COBBLESTONE:
diff --git a/src/Items/ItemRedstoneDust.h b/src/Items/ItemRedstoneDust.h
index de90c8075..274d905a5 100644
--- a/src/Items/ItemRedstoneDust.h
+++ b/src/Items/ItemRedstoneDust.h
@@ -22,12 +22,12 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
-		if (!g_BlockFullyOccupiesVoxel[a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ)]) // Some solid blocks, such as cocoa beans, are not suitable for dust
+		if (!cBlockInfo::FullyOccupiesVoxel(a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ))) // Some solid blocks, such as cocoa beans, are not suitable for dust
 		{
 			return false;
 		}
diff --git a/src/Items/ItemRedstoneRepeater.h b/src/Items/ItemRedstoneRepeater.h
index e71c8e672..c5fb5d566 100644
--- a/src/Items/ItemRedstoneRepeater.h
+++ b/src/Items/ItemRedstoneRepeater.h
@@ -24,7 +24,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemSapling.h b/src/Items/ItemSapling.h
index dc0810a45..61b1a32be 100644
--- a/src/Items/ItemSapling.h
+++ b/src/Items/ItemSapling.h
@@ -20,7 +20,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemSeeds.h b/src/Items/ItemSeeds.h
index 67f0d38bd..7283edcee 100644
--- a/src/Items/ItemSeeds.h
+++ b/src/Items/ItemSeeds.h
@@ -22,10 +22,30 @@ public:
 	{
 		return true;
 	}
+
+	virtual bool IsFood(void) override
+	{
+		switch (m_ItemType) // Special cases, both a seed and food
+		{
+			case E_ITEM_CARROT:
+			case E_ITEM_POTATO: return true;
+			default:            return false;
+		}	
+	}
+
+	virtual FoodInfo GetFoodInfo(void) override
+	{
+		switch (m_ItemType)
+		{
+			case E_ITEM_CARROT: return FoodInfo(4, 4.8);
+			case E_ITEM_POTATO: return FoodInfo(1, 0.6);
+			default:            return FoodInfo(0, 0);
+		}		
+	}
 	
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemShears.h b/src/Items/ItemShears.h
index 6a17607ee..39d2776fa 100644
--- a/src/Items/ItemShears.h
+++ b/src/Items/ItemShears.h
@@ -25,13 +25,13 @@ public:
 	}
 	
 	
-	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-		if (Block == E_BLOCK_LEAVES)
+		if ((Block == E_BLOCK_LEAVES) || (Block == E_BLOCK_NEW_LEAVES))
 		{
 			cItems Drops;
-			Drops.push_back(cItem(E_BLOCK_LEAVES, 1, a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x03));
+			Drops.push_back(cItem(Block, 1, a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x03));
 			a_World->SpawnItemPickups(Drops, a_BlockX, a_BlockY, a_BlockZ);
 
 			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
@@ -49,6 +49,7 @@ public:
 			case E_BLOCK_COBWEB:
 			case E_BLOCK_VINES:
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			{
 				return true;
 			}
diff --git a/src/Items/ItemShovel.h b/src/Items/ItemShovel.h
index d0625ef1c..873d5ae25 100644
--- a/src/Items/ItemShovel.h
+++ b/src/Items/ItemShovel.h
@@ -6,6 +6,7 @@
 #include "../Entities/Player.h"
 
 #include "../Blocks/BlockHandler.h"
+#include "../BlockInServerPluginInterface.h"
 
 
 
@@ -20,12 +21,14 @@ public:
 
 	}
 
-	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
 		if (Block == E_BLOCK_SNOW)
 		{
-			BlockHandler(Block)->DropBlock(a_World, a_Player, a_BlockX, a_BlockY, a_BlockZ);
+			cChunkInterface ChunkInterface(a_World->GetChunkMap());
+			cBlockInServerPluginInterface PluginInterface(*a_World);
+			BlockHandler(Block)->DropBlock(ChunkInterface,*a_World, PluginInterface, a_Player, a_BlockX, a_BlockY, a_BlockZ);
 
 			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
 			a_Player->UseEquippedItem();
@@ -38,4 +41,4 @@ public:
 	{
 		return (a_BlockType == E_BLOCK_SNOW);
 	}
-};
\ No newline at end of file
+};
diff --git a/src/Items/ItemSign.h b/src/Items/ItemSign.h
index 8c134ab83..60cf0f5f8 100644
--- a/src/Items/ItemSign.h
+++ b/src/Items/ItemSign.h
@@ -27,7 +27,7 @@ public:
 	
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemSpawnEgg.h b/src/Items/ItemSpawnEgg.h
index 407d655de..0d6019398 100644
--- a/src/Items/ItemSpawnEgg.h
+++ b/src/Items/ItemSpawnEgg.h
@@ -19,7 +19,7 @@ public:
 	}
 
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
 	{
 		if (a_BlockFace < 0)
 		{
diff --git a/src/Items/ItemSugarcane.h b/src/Items/ItemSugarcane.h
index ce93aa3e5..e891cc367 100644
--- a/src/Items/ItemSugarcane.h
+++ b/src/Items/ItemSugarcane.h
@@ -23,7 +23,7 @@ public:
 
 	virtual bool GetPlacementBlockTypeMeta(
 		cWorld * a_World, cPlayer * a_Player,
-		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
diff --git a/src/Items/ItemThrowable.h b/src/Items/ItemThrowable.h
index fc24e775a..c6a4e714e 100644
--- a/src/Items/ItemThrowable.h
+++ b/src/Items/ItemThrowable.h
@@ -26,7 +26,7 @@ public:
 	}
 	
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		if (!a_Player->IsGameModeCreative())
 		{
@@ -35,7 +35,7 @@ public:
 
 		Vector3d Pos = a_Player->GetThrowStartPos();
 		Vector3d Speed = a_Player->GetLookVector() * m_SpeedCoeff;
-		a_World->CreateProjectile(Pos.x, Pos.y, Pos.z, m_ProjectileKind, a_Player, &Speed);
+		a_World->CreateProjectile(Pos.x, Pos.y, Pos.z, m_ProjectileKind, a_Player, a_Player->GetEquippedItem(), &Speed);
 
 		return true;
 	}
@@ -120,21 +120,21 @@ public:
 	{
 	}
 
-	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_AIR)
 		{
 			return false;
 		}
 
+		a_World->CreateProjectile(a_BlockX + 0.5, a_BlockY + 1, a_BlockZ + 0.5, m_ProjectileKind, a_Player, a_Player->GetEquippedItem());
+
 		if (!a_Player->IsGameModeCreative())
 		{
 			a_Player->GetInventory().RemoveOneEquippedItem();
 		}
 
-		a_World->CreateProjectile(a_BlockX + 0.5, a_BlockY + 1, a_BlockZ + 0.5, m_ProjectileKind, a_Player, 0);
-
 		return true;
 	}
 
-};
\ No newline at end of file
+};
diff --git a/src/LeakFinder.cpp b/src/LeakFinder.cpp
index 9d7f185ba..42a5afe56 100644
--- a/src/LeakFinder.cpp
+++ b/src/LeakFinder.cpp
@@ -862,8 +862,10 @@ static int MyAllocHook(int nAllocType, void *pvData,
 		{
 			// RequestID was found
 			size_t temp = g_CurrentMemUsage;
-			g_CurrentMemUsage -= nSize ;
-			g_pCRTTable->Remove(lRequest);
+			if (g_pCRTTable->Remove(lRequest))
+			{
+				g_CurrentMemUsage -= nSize;
+			}
 			if (g_CurrentMemUsage > temp)
 			{
 				printf("********************************************\n");
@@ -896,8 +898,11 @@ static int MyAllocHook(int nAllocType, void *pvData,
 			// Try to find the RequestID in the Hash-Table, mark it that it was freed
 			lReallocRequest = pHead->lRequest;
 			size_t temp = g_CurrentMemUsage;
-			g_CurrentMemUsage -= pHead->nDataSize;
 			bRet = g_pCRTTable->Remove(lReallocRequest);
+			if (bRet)
+			{
+				g_CurrentMemUsage -= pHead->nDataSize;
+			}
 			if (g_CurrentMemUsage > temp)
 			{
 				printf("********************************************\n");
diff --git a/src/LightingThread.cpp b/src/LightingThread.cpp
index a823c08cc..302473d71 100644
--- a/src/LightingThread.cpp
+++ b/src/LightingThread.cpp
@@ -6,18 +6,13 @@
 #include "Globals.h"
 #include "LightingThread.h"
 #include "ChunkMap.h"
+#include "ChunkStay.h"
 #include "World.h"
 
 
 
 
 
-/// If more than this many chunks are in the queue, a warning is printed to the log
-#define WARN_ON_QUEUE_SIZE 800
-
-
-
-
 
 /// Chunk data callback that takes the chunk data and puts them into cLightingThread's m_BlockTypes[] / m_HeightMap[]:
 class cReader :
@@ -109,9 +104,14 @@ void cLightingThread::Stop(void)
 {
 	{
 		cCSLock Lock(m_CS);
-		for (sItems::iterator itr = m_Queue.begin(), end = m_Queue.end(); itr != end; ++itr)
+		for (cChunkStays::iterator itr = m_PendingQueue.begin(), end = m_PendingQueue.end(); itr != end; ++itr)
 		{
-			delete itr->m_ChunkStay;
+			delete *itr;
+		}
+		m_PendingQueue.clear();
+		for (cChunkStays::iterator itr = m_Queue.begin(), end = m_Queue.end(); itr != end; ++itr)
+		{
+			delete *itr;
 		}
 		m_Queue.clear();
 	}
@@ -129,25 +129,14 @@ void cLightingThread::QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback
 {
 	ASSERT(m_World != NULL);  // Did you call Start() properly?
 	
-	cChunkStay * ChunkStay = new cChunkStay(m_World);
-	ChunkStay->Add(a_ChunkX + 1, ZERO_CHUNK_Y, a_ChunkZ + 1);
-	ChunkStay->Add(a_ChunkX + 1, ZERO_CHUNK_Y, a_ChunkZ);
-	ChunkStay->Add(a_ChunkX + 1, ZERO_CHUNK_Y, a_ChunkZ - 1);
-	ChunkStay->Add(a_ChunkX,     ZERO_CHUNK_Y, a_ChunkZ + 1);
-	ChunkStay->Add(a_ChunkX,     ZERO_CHUNK_Y, a_ChunkZ);
-	ChunkStay->Add(a_ChunkX,     ZERO_CHUNK_Y, a_ChunkZ - 1);
-	ChunkStay->Add(a_ChunkX - 1, ZERO_CHUNK_Y, a_ChunkZ + 1);
-	ChunkStay->Add(a_ChunkX - 1, ZERO_CHUNK_Y, a_ChunkZ);
-	ChunkStay->Add(a_ChunkX - 1, ZERO_CHUNK_Y, a_ChunkZ - 1);
-	ChunkStay->Enable();
-	ChunkStay->Load();
-	cCSLock Lock(m_CS);
-	m_Queue.push_back(sItem(a_ChunkX, a_ChunkZ, ChunkStay, a_CallbackAfter));
-	if (m_Queue.size() > WARN_ON_QUEUE_SIZE)
+	cChunkStay * ChunkStay = new cLightingChunkStay(*this, a_ChunkX, a_ChunkZ, a_CallbackAfter);
 	{
-		LOGINFO("Lighting thread overloaded, %d items in queue", m_Queue.size());
+		// The ChunkStay will enqueue itself using the QueueChunkStay() once it is fully loaded
+		// In the meantime, put it into the PendingQueue so that it can be removed when stopping the thread
+		cCSLock Lock(m_CS);
+		m_PendingQueue.push_back(ChunkStay);
 	}
-	m_evtItemAdded.Set();
+	ChunkStay->Enable(*m_World->GetChunkMap());
 }
 
 
@@ -157,7 +146,7 @@ void cLightingThread::QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback
 void cLightingThread::WaitForQueueEmpty(void)
 {
 	cCSLock Lock(m_CS);
-	while (!m_ShouldTerminate && (!m_Queue.empty() || !m_PostponedQueue.empty()))
+	while (!m_ShouldTerminate && (!m_Queue.empty() || !m_PendingQueue.empty()))
 	{
 		cCSUnlock Unlock(Lock);
 		m_evtQueueEmpty.Wait();
@@ -171,43 +160,7 @@ void cLightingThread::WaitForQueueEmpty(void)
 size_t cLightingThread::GetQueueLength(void)
 {
 	cCSLock Lock(m_CS);
-	return m_Queue.size() + m_PostponedQueue.size();
-}
-
-
-
-
-
-void cLightingThread::ChunkReady(int a_ChunkX, int a_ChunkZ)
-{
-	// Check all the items in the m_PostponedQueue, if the chunk is their neighbor, move the item to m_Queue
-	
-	bool NewlyAdded = false;
-	{
-		cCSLock Lock(m_CS);
-		for (sItems::iterator itr = m_PostponedQueue.begin(); itr != m_PostponedQueue.end(); )
-		{
-			if (
-				(itr->x - a_ChunkX >= -1) && (itr->x - a_ChunkX <= 1) &&
-				(itr->z - a_ChunkZ >= -1) && (itr->z - a_ChunkZ <= 1)
-			)
-			{
-				// It is a neighbor
-				m_Queue.push_back(*itr);
-				itr = m_PostponedQueue.erase(itr);
-				NewlyAdded = true;
-			}
-			else
-			{
-				++itr;
-			}
-		}  // for itr - m_PostponedQueue[]
-	}  // Lock(m_CS)
-	
-	if (NewlyAdded)
-	{
-		m_evtItemAdded.Set();  // Notify the thread it has some work to do
-	}
+	return m_Queue.size() + m_PendingQueue.size();
 }
 
 
@@ -233,14 +186,14 @@ void cLightingThread::Execute(void)
 		}
 		
 		// Process one items from the queue:
-		sItem Item;
+		cLightingChunkStay * Item;
 		{
 			cCSLock Lock(m_CS);
 			if (m_Queue.empty())
 			{
 				continue;
 			}
-			Item = m_Queue.front();
+			Item = (cLightingChunkStay *)m_Queue.front();
 			m_Queue.pop_front();
 			if (m_Queue.empty())
 			{
@@ -248,7 +201,7 @@ void cLightingThread::Execute(void)
 			}
 		}  // CSLock(m_CS)
 		
-		LightChunk(Item);
+		LightChunk(*Item);
 	}
 }
 
@@ -257,23 +210,11 @@ void cLightingThread::Execute(void)
 
 
 
-void cLightingThread::LightChunk(cLightingThread::sItem & a_Item)
+void cLightingThread::LightChunk(cLightingChunkStay & a_Item)
 {
 	cChunkDef::BlockNibbles BlockLight, SkyLight;
 	
-	if (!ReadChunks(a_Item.x, a_Item.z))
-	{
-		// Neighbors not available. Re-queue in the postponed queue
-		cCSLock Lock(m_CS);
-		m_PostponedQueue.push_back(a_Item);
-		return;
-	}
-	
-	/*
-	// DEBUG: torch somewhere:
-	m_BlockTypes[19 + 24 * cChunkDef::Width * 3 + (m_HeightMap[24 + 24 * cChunkDef::Width * 3] / 2) * BlocksPerYLayer] = E_BLOCK_TORCH;
-	// m_HeightMap[24 + 24 * cChunkDef::Width * 3]++;
-	*/
+	ReadChunks(a_Item.m_ChunkX, a_Item.m_ChunkZ);
 	
 	PrepareBlockLight();
 	CalcLight(m_BlockLight);
@@ -339,13 +280,13 @@ void cLightingThread::LightChunk(cLightingThread::sItem & a_Item)
 	CompressLight(m_BlockLight, BlockLight);
 	CompressLight(m_SkyLight, SkyLight);
 	
-	m_World->ChunkLighted(a_Item.x, a_Item.z, BlockLight, SkyLight);
+	m_World->ChunkLighted(a_Item.m_ChunkX, a_Item.m_ChunkZ, BlockLight, SkyLight);
 
-	if (a_Item.m_Callback != NULL)
+	if (a_Item.m_CallbackAfter != NULL)
 	{
-		a_Item.m_Callback->Call(a_Item.x, a_Item.z);
+		a_Item.m_CallbackAfter->Call(a_Item.m_ChunkX, a_Item.m_ChunkZ);
 	}
-	delete a_Item.m_ChunkStay;
+	delete &a_Item;
 }
 
 
@@ -444,7 +385,7 @@ void cLightingThread::PrepareBlockLight(void)
 			int idx = BaseZ + x;
 			for (int y = m_HeightMap[idx], Index = idx + y * BlocksPerYLayer; y >= 0; y--, Index -= BlocksPerYLayer)
 			{
-				if (g_BlockLightValue[m_BlockTypes[Index]] == 0)
+				if (cBlockInfo::GetLightValue(m_BlockTypes[Index]) == 0)
 				{
 					continue;
 				}
@@ -454,7 +395,7 @@ void cLightingThread::PrepareBlockLight(void)
 				m_SeedIdx1[m_NumSeeds++] = Index;
 
 				// Light it up:
-				m_BlockLight[Index] = g_BlockLightValue[m_BlockTypes[Index]];
+				m_BlockLight[Index] = cBlockInfo::GetLightValue(m_BlockTypes[Index]);
 			}
 		}
 	}
@@ -561,3 +502,63 @@ void cLightingThread::CompressLight(NIBBLETYPE * a_LightArray, NIBBLETYPE * a_Ch
 
 
 
+
+void cLightingThread::QueueChunkStay(cLightingChunkStay & a_ChunkStay)
+{
+	// Move the ChunkStay from the Pending queue to the lighting queue.
+	{
+		cCSLock Lock(m_CS);
+		m_PendingQueue.remove(&a_ChunkStay);
+		m_Queue.push_back(&a_ChunkStay);
+	}
+	m_evtItemAdded.Set();
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cLightingThread::cLightingChunkStay:
+
+cLightingThread::cLightingChunkStay::cLightingChunkStay(cLightingThread & a_LightingThread, int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter) :
+	m_LightingThread(a_LightingThread),
+	m_ChunkX(a_ChunkX),
+	m_ChunkZ(a_ChunkZ),
+	m_CallbackAfter(a_CallbackAfter)
+{
+	Add(a_ChunkX + 1, a_ChunkZ + 1);
+	Add(a_ChunkX + 1, a_ChunkZ);
+	Add(a_ChunkX + 1, a_ChunkZ - 1);
+	Add(a_ChunkX,     a_ChunkZ + 1);
+	Add(a_ChunkX,     a_ChunkZ);
+	Add(a_ChunkX,     a_ChunkZ - 1);
+	Add(a_ChunkX - 1, a_ChunkZ + 1);
+	Add(a_ChunkX - 1, a_ChunkZ);
+	Add(a_ChunkX - 1, a_ChunkZ - 1);
+}
+
+
+
+
+
+bool cLightingThread::cLightingChunkStay::OnAllChunksAvailable(void)
+{
+	m_LightingThread.QueueChunkStay(*this);
+	
+	// Keep the ChunkStay alive:
+	return false;
+}
+
+
+
+
+
+void cLightingThread::cLightingChunkStay::OnDisabled(void)
+{
+	// Nothing needed in this callback
+}
+
+
+
+
diff --git a/src/LightingThread.h b/src/LightingThread.h
index d8ce59f01..770ae809f 100644
--- a/src/LightingThread.h
+++ b/src/LightingThread.h
@@ -33,6 +33,7 @@ Chunks from m_PostponedQueue are moved back into m_Queue when their neighbors ge
 
 #include "OSSupport/IsThread.h"
 #include "ChunkDef.h"
+#include "ChunkStay.h"
 
 
 
@@ -41,9 +42,6 @@ Chunks from m_PostponedQueue are moved back into m_Queue when their neighbors ge
 // fwd: "cWorld.h"
 class cWorld;
 
-// fwd: "cChunkMap.h"
-class cChunkStay;
-
 
 
 
@@ -62,43 +60,54 @@ public:
 	
 	void Stop(void);
 	
-	/// Queues the entire chunk for lighting
+	/** Queues the entire chunk for lighting */
 	void QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter = NULL);
 	
-	/// Blocks until the queue is empty or the thread is terminated
+	/** Blocks until the queue is empty or the thread is terminated */
 	void WaitForQueueEmpty(void);
 	
 	size_t GetQueueLength(void);
 	
-	/// Called from cWorld when a chunk gets valid. Chunks in m_PostponedQueue may need moving into m_Queue
-	void ChunkReady(int a_ChunkX, int a_ChunkZ);
-	
 protected:
 
-	struct sItem
+	class cLightingChunkStay :
+		public cChunkStay
 	{
-		int x, z;
-		cChunkStay * m_ChunkStay;
-		cChunkCoordCallback * m_Callback;
+	public:
+		cLightingThread & m_LightingThread;
+		int m_ChunkX;
+		int m_ChunkZ;
+		cChunkCoordCallback * m_CallbackAfter;
+		
+		cLightingChunkStay(cLightingThread & a_LightingThread, int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter);
 		
-		sItem(void) {}  // empty default constructor needed
-		sItem(int a_X, int a_Z, cChunkStay * a_ChunkStay, cChunkCoordCallback * a_Callback) :
-			x(a_X),
-			z(a_Z),
-			m_ChunkStay(a_ChunkStay),
-			m_Callback(a_Callback)
+	protected:
+		virtual void OnChunkAvailable(int a_ChunkX, int a_ChunkZ) override 
 		{
+			UNUSED(a_ChunkX);
+			UNUSED(a_ChunkZ);
 		}
+		virtual bool OnAllChunksAvailable(void) override;
+		virtual void OnDisabled(void) override;
 	} ;
 	
-	typedef std::list<sItem> sItems;
+	typedef std::list<cChunkStay *> cChunkStays;
+	
+	
+	cWorld * m_World;
 	
-	cWorld *         m_World;
+	/** The mutex to protect m_Queue and m_PendingQueue */
 	cCriticalSection m_CS;
-	sItems           m_Queue;
-	sItems           m_PostponedQueue;  // Chunks that have been postponed due to missing neighbors
-	cEvent           m_evtItemAdded;    // Set when queue is appended, or to stop the thread
-	cEvent           m_evtQueueEmpty;   // Set when the queue gets empty
+	
+	/** The ChunkStays that are loaded and are waiting to be lit. */
+	cChunkStays m_Queue;
+
+	/** The ChunkStays that are waiting for load. Used for stopping the thread. */
+	cChunkStays m_PendingQueue;
+
+	cEvent m_evtItemAdded;    // Set when queue is appended, or to stop the thread
+	cEvent m_evtQueueEmpty;   // Set when the queue gets empty
+	
 	
 	// Buffers for the 3x3 chunk data
 	// These buffers alone are 1.7 MiB in size, therefore they cannot be located on the stack safely - some architectures may have only 1 MiB for stack, or even less
@@ -124,49 +133,47 @@ protected:
 
 	virtual void Execute(void) override;
 
-	/// Lights the entire chunk. If neighbor chunks don't exist, touches them and re-queues the chunk
-	void LightChunk(sItem & a_Item);
+	/** Lights the entire chunk. If neighbor chunks don't exist, touches them and re-queues the chunk */
+	void LightChunk(cLightingChunkStay & a_Item);
 	
-	/// Prepares m_BlockTypes and m_HeightMap data; returns false if any of the chunks fail. Zeroes out the light arrays
+	/** Prepares m_BlockTypes and m_HeightMap data; returns false if any of the chunks fail. Zeroes out the light arrays */
 	bool ReadChunks(int a_ChunkX, int a_ChunkZ);
 	
-	/// Uses m_HeightMap to initialize the m_SkyLight[] data; fills in seeds for the skylight
+	/** Uses m_HeightMap to initialize the m_SkyLight[] data; fills in seeds for the skylight */
 	void PrepareSkyLight(void);
 	
-	/// Uses m_BlockTypes to initialize the m_BlockLight[] data; fills in seeds for the blocklight
+	/** Uses m_BlockTypes to initialize the m_BlockLight[] data; fills in seeds for the blocklight */
 	void PrepareBlockLight(void);
 	
-	/// Calculates light in the light array specified, using stored seeds
+	/** Calculates light in the light array specified, using stored seeds */
 	void CalcLight(NIBBLETYPE * a_Light);
 	
-	/// Does one step in the light calculation - one seed propagation and seed recalculation
+	/** Does one step in the light calculation - one seed propagation and seed recalculation */
 	void CalcLightStep(
 		NIBBLETYPE * a_Light, 
 		int a_NumSeedsIn,    unsigned char * a_IsSeedIn,  unsigned int * a_SeedIdxIn,
 		int & a_NumSeedsOut, unsigned char * a_IsSeedOut, unsigned int * a_SeedIdxOut
 	);
 	
-	/// Compresses from 1-block-per-byte (faster calc) into 2-blocks-per-byte (MC storage):
+	/** Compresses from 1-block-per-byte (faster calc) into 2-blocks-per-byte (MC storage): */
 	void CompressLight(NIBBLETYPE * a_LightArray, NIBBLETYPE * a_ChunkLight);
 	
 	inline void PropagateLight(
 		NIBBLETYPE * a_Light, 
-		int a_SrcIdx, int a_DstIdx,
+		unsigned int a_SrcIdx, unsigned int a_DstIdx,
 		int & a_NumSeedsOut, unsigned char * a_IsSeedOut, unsigned int * a_SeedIdxOut
 	)
 	{
-		ASSERT(a_SrcIdx >= 0);
-		ASSERT(a_SrcIdx < (int)ARRAYCOUNT(m_SkyLight));
-		ASSERT(a_DstIdx >= 0);
-		ASSERT(a_DstIdx < (int)ARRAYCOUNT(m_BlockTypes));
+		ASSERT(a_SrcIdx < ARRAYCOUNT(m_SkyLight));
+		ASSERT(a_DstIdx < ARRAYCOUNT(m_BlockTypes));
 		
-		if (a_Light[a_SrcIdx] <= a_Light[a_DstIdx] + g_BlockSpreadLightFalloff[m_BlockTypes[a_DstIdx]])
+		if (a_Light[a_SrcIdx] <= a_Light[a_DstIdx] + cBlockInfo::GetSpreadLightFalloff(m_BlockTypes[a_DstIdx]))
 		{
 			// We're not offering more light than the dest block already has
 			return;
 		}
 
-		a_Light[a_DstIdx] = a_Light[a_SrcIdx] - g_BlockSpreadLightFalloff[m_BlockTypes[a_DstIdx]];
+		a_Light[a_DstIdx] = a_Light[a_SrcIdx] - cBlockInfo::GetSpreadLightFalloff(m_BlockTypes[a_DstIdx]);
 		if (!a_IsSeedOut[a_DstIdx])
 		{
 			a_IsSeedOut[a_DstIdx] = true;
@@ -174,6 +181,10 @@ protected:
 		}
 	}
 	
+	/** Queues a chunkstay that has all of its chunks loaded.
+	Called by cLightingChunkStay when all of its chunks are loaded. */
+	void QueueChunkStay(cLightingChunkStay & a_ChunkStay);
+	
 } ;
 
 
diff --git a/src/LineBlockTracer.cpp b/src/LineBlockTracer.cpp
index da1c7f2fd..f4f29e833 100644
--- a/src/LineBlockTracer.cpp
+++ b/src/LineBlockTracer.cpp
@@ -5,7 +5,7 @@
 
 #include "Globals.h"
 #include "LineBlockTracer.h"
-#include "Vector3d.h"
+#include "Vector3.h"
 #include "World.h"
 #include "Chunk.h"
 
diff --git a/src/LinearUpscale.h b/src/LinearUpscale.h
index b337b3219..0b04408cf 100644
--- a/src/LinearUpscale.h
+++ b/src/LinearUpscale.h
@@ -18,7 +18,7 @@ Therefore, there is no cpp file.
 
 InPlace upscaling works on a single array and assumes that the values to work on have already
 been interspersed into the array to the cell boundaries.
-Specifically, a_Array[x * a_AnchorStepX + y * a_AnchorStepY] contains the anchor value.
+Specifically, a_Array[x * AnchorStepX + y * AnchorStepY] contains the anchor value.
 
 Regular upscaling takes two arrays and "moves" the input from src to dst; src is expected packed.
 */
@@ -29,46 +29,48 @@ Regular upscaling takes two arrays and "moves" the input from src to dst; src is
 /**
 Linearly interpolates values in the array between the equidistant anchor points (upscales).
 Works in-place (input is already present at the correct output coords)
+Uses templates to make it possible for the compiler to further optimizer the loops
 */
-template<typename TYPE> void LinearUpscale2DArrayInPlace(
-	TYPE * a_Array,
-	int a_SizeX, int a_SizeY,  // Dimensions of the array
-	int a_AnchorStepX, int a_AnchorStepY  // Distances between the anchor points in each direction
-)
+template<
+	int SizeX, int SizeY,  // Dimensions of the array
+	int AnchorStepX, int AnchorStepY,
+	typename TYPE
+>
+void LinearUpscale2DArrayInPlace(TYPE * a_Array)
 {
 	// First interpolate columns where the anchor points are:
-	int LastYCell = a_SizeY - a_AnchorStepY;
-	for (int y = 0; y < LastYCell; y += a_AnchorStepY)
+	int LastYCell = SizeY - AnchorStepY;
+	for (int y = 0; y < LastYCell; y += AnchorStepY)
 	{
-		int Idx = a_SizeX * y;
-		for (int x = 0; x < a_SizeX; x += a_AnchorStepX)
+		int Idx = SizeX * y;
+		for (int x = 0; x < SizeX; x += AnchorStepX)
 		{
 			TYPE StartValue = a_Array[Idx];
-			TYPE EndValue   = a_Array[Idx + a_SizeX * a_AnchorStepY];
+			TYPE EndValue   = a_Array[Idx + SizeX * AnchorStepY];
 			TYPE Diff = EndValue - StartValue;
-			for (int CellY = 1; CellY < a_AnchorStepY; CellY++)
+			for (int CellY = 1; CellY < AnchorStepY; CellY++)
 			{
-				a_Array[Idx + a_SizeX * CellY] = StartValue + Diff * CellY / a_AnchorStepY;
+				a_Array[Idx + SizeX * CellY] = StartValue + Diff * CellY / AnchorStepY;
 			}  // for CellY
-			Idx += a_AnchorStepX;
+			Idx += AnchorStepX;
 		}  // for x
 	}  // for y
 
 	// Now interpolate in rows, each row has values in the anchor columns
-	int LastXCell = a_SizeX - a_AnchorStepX;
-	for (int y = 0; y < a_SizeY; y++)
+	int LastXCell = SizeX - AnchorStepX;
+	for (int y = 0; y < SizeY; y++)
 	{
-		int Idx = a_SizeX * y;
-		for (int x = 0; x < LastXCell; x += a_AnchorStepX)
+		int Idx = SizeX * y;
+		for (int x = 0; x < LastXCell; x += AnchorStepX)
 		{
 			TYPE StartValue = a_Array[Idx];
-			TYPE EndValue   = a_Array[Idx + a_AnchorStepX];
+			TYPE EndValue   = a_Array[Idx + AnchorStepX];
 			TYPE Diff = EndValue - StartValue;
-			for (int CellX = 1; CellX < a_AnchorStepX; CellX++)
+			for (int CellX = 1; CellX < AnchorStepX; CellX++)
 			{
-				a_Array[Idx + CellX] = StartValue + CellX * Diff / a_AnchorStepX;
+				a_Array[Idx + CellX] = StartValue + CellX * Diff / AnchorStepX;
 			}  // for CellY
-			Idx += a_AnchorStepX;
+			Idx += AnchorStepX;
 		}
 	}
 }
diff --git a/src/Log.cpp b/src/Log.cpp
index 2d6be0f59..a7be04b1a 100644
--- a/src/Log.cpp
+++ b/src/Log.cpp
@@ -42,7 +42,7 @@ cLog::~cLog()
 
 
 
-cLog* cLog::GetInstance()
+cLog * cLog::GetInstance()
 {
 	if (s_Log != NULL)
 	{
@@ -92,7 +92,7 @@ void cLog::ClearLog()
 	if( m_File )
 		fclose (m_File);
 	#endif
-	m_File = 0;
+	m_File = NULL;
 }
 
 
@@ -118,7 +118,7 @@ void cLog::Log(const char * a_Format, va_list argList)
 
 	AString Line;
 	#ifdef _DEBUG
-	Printf(Line, "[%04x|%02d:%02d:%02d] %s", cIsThread::GetCurrentID(), timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, Message.c_str());
+	Printf(Line, "[%04lx|%02d:%02d:%02d] %s", cIsThread::GetCurrentID(), timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, Message.c_str());
 	#else
 	Printf(Line, "[%02d:%02d:%02d] %s", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, Message.c_str());
 	#endif
diff --git a/src/Log.h b/src/Log.h
index cba248dae..d6a406154 100644
--- a/src/Log.h
+++ b/src/Log.h
@@ -14,8 +14,8 @@ private:
 public:
 	cLog(const AString & a_FileName);
 	~cLog();
-	void Log(const char * a_Format, va_list argList);
-	void Log(const char * a_Format, ...);
+	void Log(const char * a_Format, va_list argList) FORMATSTRING(2, 0);
+	void Log(const char * a_Format, ...) FORMATSTRING(2, 3);
 	// tolua_begin
 	void SimpleLog(const char * a_String);
 	void OpenLog(const char * a_FileName);
diff --git a/src/MCLogger.cpp b/src/MCLogger.cpp
index 4f3e5dc0f..80fa7b173 100644
--- a/src/MCLogger.cpp
+++ b/src/MCLogger.cpp
@@ -93,25 +93,30 @@ void cMCLogger::InitLog(const AString & a_FileName)
 
 
 
-void cMCLogger::LogSimple(const char* a_Text, int a_LogType /* = 0 */ )
+void cMCLogger::LogSimple(const char * a_Text, eLogLevel a_LogLevel)
 {
-	switch( a_LogType )
+	switch (a_LogLevel)
 	{
-		case 0:
+		case llRegular:
+		{
 			LOG("%s", a_Text);
 			break;
-		case 1:
+		}
+		case llInfo:
+		{
 			LOGINFO("%s", a_Text);
 			break;
-		case 2:
+		}
+		case llWarning:
+		{
 			LOGWARN("%s", a_Text);
 			break;
-		case 3:
+		}
+		case llError:
+		{
 			LOGERROR("%s", a_Text);
 			break;
-		default:
-			LOG("(#%d#: %s", a_LogType, a_Text);
-			break;
+		}
 	}
 }
 
diff --git a/src/MCLogger.h b/src/MCLogger.h
index c949a4cdf..c0150c124 100644
--- a/src/MCLogger.h
+++ b/src/MCLogger.h
@@ -10,25 +10,36 @@ class cLog;
 
 
 
-class cMCLogger														// tolua_export
-{																	// tolua_export
-public:																// tolua_export
-	/// Creates a logger with the default filename, "logs/LOG_<timestamp>.log"
+// tolua_begin
+class cMCLogger
+{
+public:
+	enum eLogLevel
+	{
+		llRegular,
+		llInfo,
+		llWarning,
+		llError,
+	};
+	// tolua_end
+	
+	/** Creates a logger with the default filename, "logs/LOG_<timestamp>.log" */
 	cMCLogger(void);
 	
-	/// Creates a logger with the specified filename inside "logs" folder
+	/** Creates a logger with the specified filename inside "logs" folder */
 	cMCLogger(const AString & a_FileName);  // tolua_export
 	
 	~cMCLogger();													// tolua_export
 
-	void Log(const char* a_Format, va_list a_ArgList);
-	void Info(const char* a_Format, va_list a_ArgList);
-	void Warn(const char* a_Format, va_list a_ArgList);
-	void Error(const char* a_Format, va_list a_ArgList);
+	void Log  (const char * a_Format, va_list a_ArgList) FORMATSTRING(2, 0);
+	void Info (const char * a_Format, va_list a_ArgList) FORMATSTRING(2, 0);
+	void Warn (const char * a_Format, va_list a_ArgList) FORMATSTRING(2, 0);
+	void Error(const char * a_Format, va_list a_ArgList) FORMATSTRING(2, 0);
 
-	void LogSimple(const char* a_Text, int a_LogType = 0 );			// tolua_export
+	/** Logs the simple text message at the specified log level. */
+	void LogSimple(const char * a_Text, eLogLevel a_LogLevel = llRegular);  // tolua_export
 
-	static cMCLogger* GetInstance();
+	static cMCLogger * GetInstance();
 private:
 	enum eColorScheme
 	{
@@ -57,10 +68,10 @@ private:
 
 
 
-extern void LOG(const char* a_Format, ...);
-extern void LOGINFO(const char* a_Format, ...);
-extern void LOGWARN(const char* a_Format, ...);
-extern void LOGERROR(const char* a_Format, ...);
+extern void LOG(const char* a_Format, ...)      FORMATSTRING(1, 2);
+extern void LOGINFO(const char* a_Format, ...)  FORMATSTRING(1, 2);
+extern void LOGWARN(const char* a_Format, ...)  FORMATSTRING(1, 2);
+extern void LOGERROR(const char* a_Format, ...) FORMATSTRING(1, 2);
 
 
 
diff --git a/src/Map.cpp b/src/Map.cpp
new file mode 100644
index 000000000..79370b097
--- /dev/null
+++ b/src/Map.cpp
@@ -0,0 +1,633 @@
+
+// Map.cpp
+
+#include "Globals.h"
+
+#include "Map.h"
+
+#include "ClientHandle.h"
+#include "World.h"
+#include "Chunk.h"
+#include "Entities/Player.h"
+#include "FastRandom.h"
+
+
+
+
+
+cMapDecorator::cMapDecorator(cMap * a_Map, eType a_Type, int a_X, int a_Z, int a_Rot)
+	: m_Map(a_Map)
+	, m_Type(a_Type)
+	, m_PixelX(a_X)
+	, m_PixelZ(a_Z)
+	, m_Rot(a_Rot)
+	, m_Player(NULL)
+{
+}
+
+
+
+
+
+cMapDecorator::cMapDecorator(cMap * a_Map, cPlayer * a_Player)
+	: m_Map(a_Map)
+	, m_Type(E_TYPE_PLAYER)
+	, m_Player(a_Player)
+{
+	Update();
+}
+
+
+
+
+
+void cMapDecorator::Update(void)
+{
+	if (m_Player != NULL)
+	{
+		ASSERT(m_Map != NULL);
+		unsigned int PixelWidth = m_Map->GetPixelWidth();
+
+		int InsideWidth  = (m_Map->GetWidth()  / 2) - 1;
+		int InsideHeight = (m_Map->GetHeight() / 2) - 1;
+
+		int PixelX = (int) (m_Player->GetPosX() - m_Map->GetCenterX()) / PixelWidth;
+		int PixelZ = (int) (m_Player->GetPosZ() - m_Map->GetCenterZ()) / PixelWidth;
+
+		// Center of pixel
+		m_PixelX = (2 * PixelX) + 1;
+		m_PixelZ = (2 * PixelZ) + 1;
+
+		if ((PixelX > -InsideWidth) && (PixelX <= InsideWidth) && (PixelZ > -InsideHeight) && (PixelZ <= InsideHeight))
+		{
+			double Yaw = m_Player->GetYaw();
+
+			if (m_Map->GetDimension() == dimNether)
+			{
+				cFastRandom Random;
+
+				Int64 WorldAge = m_Player->GetWorld()->GetWorldAge();
+
+				// TODO 2014-02-19 xdot: Refine
+				m_Rot = Random.NextInt(16, (int) WorldAge);
+			}
+			else
+			{
+				m_Rot = (int) (Yaw * 16) / 360;
+			}
+
+			m_Type = E_TYPE_PLAYER;
+		}
+		else
+		{
+			if ((abs(PixelX) > 320.0) || (abs(PixelZ) > 320.0))
+			{
+				// TODO 2014-02-18 xdot: Remove decorator
+			}
+
+			m_Rot = 0;
+
+			m_Type = E_TYPE_PLAYER_OUTSIDE;
+
+			// Move to border
+			if (PixelX <= -InsideWidth)
+			{
+				m_PixelX = (2 * -InsideWidth) + 1;
+			}
+			if (PixelZ <= -InsideHeight)
+			{
+				m_PixelZ = (2 * -InsideHeight) + 1;
+			}
+			if (PixelX > InsideWidth)
+			{
+				m_PixelX = (2 * InsideWidth) + 1;
+			}
+			if (PixelZ > InsideHeight)
+			{
+				m_PixelZ = (2 * InsideHeight) + 1;
+			}
+		}
+	}
+}
+
+
+
+
+
+cMap::cMap(unsigned int a_ID, cWorld * a_World)
+	: m_ID(a_ID)
+	, m_Width(cChunkDef::Width * 8)
+	, m_Height(cChunkDef::Width * 8)
+	, m_Scale(3)
+	, m_CenterX(0)
+	, m_CenterZ(0)
+	, m_World(a_World)
+{
+	m_Data.assign(m_Width * m_Height, E_BASE_COLOR_TRANSPARENT);
+
+	Printf(m_Name, "map_%i", m_ID);
+}
+
+
+
+
+
+cMap::cMap(unsigned int a_ID, int a_CenterX, int a_CenterZ, cWorld * a_World, unsigned int a_Scale)
+	: m_ID(a_ID)
+	, m_Width(cChunkDef::Width * 8)
+	, m_Height(cChunkDef::Width * 8)
+	, m_Scale(a_Scale)
+	, m_CenterX(a_CenterX)
+	, m_CenterZ(a_CenterZ)
+	, m_World(a_World)
+{
+	m_Data.assign(m_Width * m_Height, E_BASE_COLOR_TRANSPARENT);
+
+	Printf(m_Name, "map_%i", m_ID);
+}
+
+
+
+
+
+void cMap::UpdateRadius(int a_PixelX, int a_PixelZ, unsigned int a_Radius)
+{
+	int PixelRadius = a_Radius / GetPixelWidth();
+
+	unsigned int StartX = Clamp(a_PixelX - PixelRadius, 0, (int)m_Width);
+	unsigned int StartZ = Clamp(a_PixelZ - PixelRadius, 0, (int)m_Height);
+
+	unsigned int EndX   = Clamp(a_PixelX + PixelRadius, 0, (int)m_Width);
+	unsigned int EndZ   = Clamp(a_PixelZ + PixelRadius, 0, (int)m_Height);
+
+	for (unsigned int X = StartX; X < EndX; ++X)
+	{
+		for (unsigned int Z = StartZ; Z < EndZ; ++Z)
+		{
+			int dX = X - a_PixelX;
+			int dZ = Z - a_PixelZ;
+
+			if ((dX * dX) + (dZ * dZ) < (PixelRadius * PixelRadius))
+			{
+				UpdatePixel(X, Z);
+			}
+		}
+	}
+}
+
+
+
+
+
+void cMap::UpdateRadius(cPlayer & a_Player, unsigned int a_Radius)
+{
+	unsigned int PixelWidth = GetPixelWidth();
+
+	int PixelX = (int) (a_Player.GetPosX() - m_CenterX) / PixelWidth + (m_Width  / 2);
+	int PixelZ = (int) (a_Player.GetPosZ() - m_CenterZ) / PixelWidth + (m_Height / 2);
+
+	UpdateRadius(PixelX, PixelZ, a_Radius);
+}
+
+
+
+
+
+bool cMap::UpdatePixel(unsigned int a_X, unsigned int a_Z)
+{
+	unsigned int PixelWidth = GetPixelWidth();
+
+	int BlockX = m_CenterX + ((a_X - (m_Width  / 2)) * PixelWidth);
+	int BlockZ = m_CenterZ + ((a_Z - (m_Height / 2)) * PixelWidth);
+
+	int ChunkX, ChunkY, ChunkZ;
+	m_World->BlockToChunk(BlockX, 0, BlockZ, ChunkX, ChunkY, ChunkZ);
+
+	int RelX = BlockX - (ChunkX * cChunkDef::Width);
+	int RelZ = BlockZ - (ChunkZ * cChunkDef::Width);
+
+	class cCalculatePixelCb :
+		public cChunkCallback
+	{
+		cMap * m_Map;
+
+		int m_RelX, m_RelZ;
+
+		ColorID m_PixelData;
+
+	public:
+		cCalculatePixelCb(cMap * a_Map, int a_RelX, int a_RelZ)
+			: m_Map(a_Map), m_RelX(a_RelX), m_RelZ(a_RelZ), m_PixelData(E_BASE_COLOR_TRANSPARENT) {}
+
+		virtual bool Item(cChunk * a_Chunk) override
+		{
+			if (a_Chunk == NULL)
+			{
+				return false;
+			}
+
+			unsigned int PixelWidth = m_Map->GetPixelWidth();
+
+			if (m_Map->GetDimension() == dimNether)
+			{
+				// TODO 2014-02-22 xdot: Nether maps
+
+				return false;
+			}
+
+			typedef std::map<ColorID, unsigned int> ColorCountMap;
+			ColorCountMap ColorCounts;
+
+			// Count surface blocks
+			for (unsigned int X = m_RelX; X < m_RelX + PixelWidth; ++X)
+			{
+				for (unsigned int Z = m_RelZ; Z < m_RelZ + PixelWidth; ++Z)
+				{
+					// unsigned int WaterDepth = 0;
+
+					BLOCKTYPE TargetBlock = E_BLOCK_AIR;
+					NIBBLETYPE TargetMeta = 0;
+
+					int Height = a_Chunk->GetHeight(X, Z);
+
+					while (Height > 0)
+					{
+						a_Chunk->GetBlockTypeMeta(X, Height, Z, TargetBlock, TargetMeta);
+
+						// TODO 2014-02-22 xdot: Check if block color is transparent
+						if (TargetBlock == E_BLOCK_AIR)
+						{
+							--Height;
+							continue;
+						}
+						// TODO 2014-02-22 xdot: Check if block is liquid
+						/*
+						else if (false)
+						{
+							--Height;
+							++WaterDepth;
+							continue;
+						}
+						*/
+
+						break;
+					}
+
+					// TODO 2014-02-22 xdot: Query block color
+					ColorID Color = E_BASE_COLOR_BROWN;
+
+					// Debug - Temporary
+					switch (TargetBlock)
+					{
+						case E_BLOCK_GRASS:
+						{
+							Color = E_BASE_COLOR_LIGHT_GREEN; break;
+						}
+						case E_BLOCK_STATIONARY_WATER:
+						case E_BLOCK_WATER:
+						{
+							Color = E_BASE_COLOR_BLUE; break;
+						}
+					}
+
+					++ColorCounts[Color];
+				}
+			}
+
+			// Find dominant color
+			ColorID PixelColor = E_BASE_COLOR_TRANSPARENT;
+
+			unsigned int MaxCount = 0;
+
+			for (ColorCountMap::iterator it = ColorCounts.begin(); it != ColorCounts.end(); ++it)
+			{
+				if (it->second > MaxCount)
+				{
+					PixelColor = it->first;
+					MaxCount = it->second;
+				}
+			}
+
+			// TODO 2014-02-22 xdot: Adjust brightness
+			unsigned int dColor = 1;
+
+			m_PixelData = PixelColor + dColor;
+
+			return false;
+		}
+
+		ColorID GetPixelData(void) const
+		{
+			return m_PixelData;
+		}
+	} CalculatePixelCb(this, RelX, RelZ);
+
+	ASSERT(m_World != NULL);
+	m_World->DoWithChunk(ChunkX, ChunkZ, CalculatePixelCb);
+
+	SetPixel(a_X, a_Z, CalculatePixelCb.GetPixelData());
+
+	return true;
+}
+
+
+
+
+
+void cMap::UpdateDecorators(void)
+{
+	for (cMapDecoratorList::iterator it = m_Decorators.begin(); it != m_Decorators.end(); ++it)
+	{
+		it->Update();
+	}
+}
+
+
+
+
+
+void cMap::AddPlayer(cPlayer * a_Player, Int64 a_WorldAge)
+{
+	cClientHandle * Handle = a_Player->GetClientHandle();
+	if (Handle == NULL)
+	{
+		return;
+	}
+
+	cMapClient MapClient;
+
+	MapClient.m_LastUpdate = a_WorldAge;
+	MapClient.m_SendInfo   = true;
+	MapClient.m_Handle     = Handle;
+	MapClient.m_DataUpdate = 0;
+	MapClient.m_NextDecoratorUpdate = 0;
+
+	m_Clients.push_back(MapClient);
+
+	cMapDecorator PlayerDecorator(this, a_Player);
+
+	m_Decorators.push_back(PlayerDecorator);
+}
+
+
+
+
+
+void cMap::RemoveInactiveClients(Int64 a_WorldAge)
+{
+	for (cMapClientList::iterator it = m_Clients.begin(); it != m_Clients.end();)
+	{
+		if (it->m_LastUpdate < a_WorldAge)
+		{
+			// Remove associated decorators
+			for (cMapDecoratorList::iterator it2 = m_Decorators.begin(); it2 != m_Decorators.end();)
+			{
+				if (it2->GetPlayer()->GetClientHandle() == it->m_Handle)
+				{
+					// Erase decorator
+					cMapDecoratorList::iterator temp = it2;
+					++it2;
+					m_Decorators.erase(temp);
+				}
+				else
+				{
+					++it2;
+				}
+			}
+
+			// Erase client
+			cMapClientList::iterator temp = it;
+			++it;
+			m_Clients.erase(temp);
+		}
+		else
+		{
+			++it;
+		}
+	}
+}
+
+
+
+
+
+void cMap::StreamNext(cMapClient & a_Client)
+{
+	cClientHandle * Handle = a_Client.m_Handle;
+
+	if (a_Client.m_SendInfo)
+	{
+		Handle->SendMapInfo(m_ID, m_Scale);
+
+		a_Client.m_SendInfo = false;
+
+		return;
+	}
+
+	++a_Client.m_NextDecoratorUpdate;
+
+	if (a_Client.m_NextDecoratorUpdate >= 4)
+	{
+		// TODO 2014-02-19 xdot
+		// This is dangerous as the player object may have been destroyed before the decorator is erased from the list
+		UpdateDecorators();
+
+		Handle->SendMapDecorators(m_ID, m_Decorators);
+
+		a_Client.m_NextDecoratorUpdate = 0;
+	}
+	else
+	{
+		++a_Client.m_DataUpdate;
+
+		unsigned int Y = (a_Client.m_DataUpdate * 11) % m_Width;
+
+		const Byte * Colors = &m_Data[Y * m_Height];
+
+		Handle->SendMapColumn(m_ID, Y, 0, Colors, m_Height);
+	}
+}
+
+
+
+
+
+void cMap::UpdateClient(cPlayer * a_Player)
+{
+	ASSERT(a_Player != NULL);
+	cClientHandle * Handle = a_Player->GetClientHandle();
+
+	if (Handle == NULL)
+	{
+		return;
+	}
+
+	Int64 WorldAge = a_Player->GetWorld()->GetWorldAge();
+
+	RemoveInactiveClients(WorldAge - 5);
+
+	// Linear search for client state
+	for (cMapClientList::iterator it = m_Clients.begin(); it != m_Clients.end(); ++it)
+	{
+		if (it->m_Handle == Handle)
+		{
+			it->m_LastUpdate = WorldAge;
+
+			StreamNext(*it);
+
+			return;
+		}
+	}
+
+	// New player, construct a new client state
+	AddPlayer(a_Player, WorldAge);
+}
+
+
+
+
+
+void cMap::EraseData(void)
+{
+	m_Data.assign(m_Width * m_Height, 0);
+}
+
+
+
+
+
+eDimension cMap::GetDimension(void) const
+{
+	ASSERT(m_World != NULL);
+	return m_World->GetDimension();
+}
+
+
+
+
+
+
+void cMap::Resize(unsigned int a_Width, unsigned int a_Height)
+{
+	if ((m_Width == a_Width) && (m_Height == a_Height))
+	{
+		return;
+	}
+
+	m_Width = a_Width;
+	m_Height = a_Height;
+
+	m_Data.assign(m_Width * m_Height, 0);
+}
+
+
+
+
+
+void cMap::SetPosition(int a_CenterX, int a_CenterZ)
+{
+	m_CenterX = a_CenterX;
+	m_CenterZ = a_CenterZ;
+}
+
+
+
+
+
+void cMap::SetScale(unsigned int a_Scale)
+{
+	if (m_Scale == a_Scale)
+	{
+		return;
+	}
+
+	m_Scale = a_Scale;
+
+	for (cMapClientList::iterator it = m_Clients.begin(); it != m_Clients.end(); ++it)
+	{
+		it->m_SendInfo = true;
+	}
+}
+
+
+
+
+
+bool cMap::SetPixel(unsigned int a_X, unsigned int a_Z, cMap::ColorID a_Data)
+{
+	if ((a_X < m_Width) && (a_Z < m_Height))
+	{
+		m_Data[a_Z + (a_X * m_Height)] = a_Data;
+
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+
+
+
+
+cMap::ColorID cMap::GetPixel(unsigned int a_X, unsigned int a_Z)
+{
+	if ((a_X < m_Width) && (a_Z < m_Height))
+	{
+		return m_Data[a_Z + (a_X * m_Height)];
+	}
+	else
+	{
+		return E_BASE_COLOR_TRANSPARENT;
+	}
+}
+
+
+
+
+
+void cMap::SendTo(cClientHandle & a_Client)
+{
+	a_Client.SendMapInfo(m_ID, m_Scale);
+
+	for (unsigned int i = 0; i < m_Width; ++i)
+	{
+		const Byte* Colors = &m_Data[i * m_Height];
+
+		a_Client.SendMapColumn(m_ID, i, 0, Colors, m_Height);
+	}
+
+	a_Client.SendMapDecorators(m_ID, m_Decorators);
+}
+
+
+
+
+
+unsigned int cMap::GetNumPixels(void) const
+{
+	return m_Width * m_Height;
+}
+
+
+
+
+
+unsigned int cMap::GetNumDecorators(void) const
+{
+	return m_Decorators.size();
+}
+
+
+
+
+unsigned int cMap::GetPixelWidth(void) const
+{
+	return (int) pow(2.0, (double) m_Scale);
+}
+
+
+
+
+
diff --git a/src/Map.h b/src/Map.h
new file mode 100644
index 000000000..ee7c537b1
--- /dev/null
+++ b/src/Map.h
@@ -0,0 +1,264 @@
+
+// Map.h
+
+// Implementation of in-game coloured maps
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#include "BlockID.h"
+
+
+
+
+
+class cClientHandle;
+class cWorld;
+class cPlayer;
+class cMap;
+
+
+
+
+
+/** Encapsulates a map decorator.
+ *
+ * A map decorator represents an object drawn on the map that can move freely.
+ * (e.g. player trackers and item frame pointers)
+ *
+ * Excluding manually placed decorators,
+ * decorators are automatically managed (allocated and freed) by their parent cMap instance.
+ */
+class cMapDecorator
+{
+public:
+
+	enum eType
+	{
+		E_TYPE_PLAYER         = 0x00,
+		E_TYPE_ITEM_FRAME     = 0x01,
+
+		/** Player outside of the boundaries of the map. */
+		E_TYPE_PLAYER_OUTSIDE = 0x06
+	};
+
+
+public:
+
+	/** Constructs a map decorator fixed at the specified pixel coordinates. (DEBUG) */
+	cMapDecorator(cMap * a_Map, eType a_Type, int a_X, int a_Z, int a_Rot);
+
+	/** Constructs a map decorator that tracks a player. */
+	cMapDecorator(cMap * a_Map, cPlayer * a_Player);
+
+	/** Updates the decorator. */
+	void Update(void);
+
+	unsigned int GetPixelX(void) const { return m_PixelX; }
+	unsigned int GetPixelZ(void) const { return m_PixelZ; }
+
+	unsigned int GetRot(void) const { return m_Rot; }
+
+	eType GetType(void) const { return m_Type; }
+
+	cPlayer * GetPlayer(void) { return m_Player; }
+
+
+protected:
+
+	cMap * m_Map;
+
+	eType m_Type;
+
+	unsigned int m_PixelX;
+	unsigned int m_PixelZ;
+
+	unsigned int m_Rot;
+
+	cPlayer * m_Player;
+
+};
+
+typedef std::list<cMapDecorator> cMapDecoratorList;
+
+
+
+
+
+// tolua_begin
+
+/** Encapsulates an in-game world map. */
+class cMap
+{
+public:
+
+	enum eBaseColor
+	{
+		E_BASE_COLOR_TRANSPARENT = 0,  /* Air     */
+		E_BASE_COLOR_LIGHT_GREEN = 4,  /* Grass   */
+		E_BASE_COLOR_LIGHT_BROWN = 8,  /* Sand    */
+		E_BASE_COLOR_GRAY_1      = 12, /* Cloth   */
+		E_BASE_COLOR_RED         = 16, /* TNT     */
+		E_BASE_COLOR_PALE_BLUE   = 20, /* Ice     */
+		E_BASE_COLOR_GRAY_2      = 24, /* Iron    */
+		E_BASE_COLOR_DARK_GREEN  = 28, /* Foliage */
+		E_BASE_COLOR_WHITE       = 32, /* Snow    */
+		E_BASE_COLOR_LIGHT_GRAY  = 36, /* Clay    */
+		E_BASE_COLOR_BROWN       = 40, /* Dirt    */
+		E_BASE_COLOR_DARK_GRAY   = 44, /* Stone   */
+		E_BASE_COLOR_BLUE        = 48, /* Water   */
+		E_BASE_COLOR_DARK_BROWN  = 52  /* Wood    */
+	};
+
+	typedef Byte ColorID;
+
+	// tolua_end
+
+	typedef std::vector<ColorID> cColorList;
+
+
+public:
+
+	/** Construct an empty map. */
+	cMap(unsigned int a_ID, cWorld * a_World);
+
+	/** Construct an empty map at the specified coordinates. */
+	cMap(unsigned int a_ID, int a_CenterX, int a_CenterZ, cWorld * a_World, unsigned int a_Scale = 3);
+
+	/** Send this map to the specified client. WARNING: Slow */
+	void SendTo(cClientHandle & a_Client);
+
+	/** Update a circular region with the specified radius and center (in pixels). */
+	void UpdateRadius(int a_PixelX, int a_PixelZ, unsigned int a_Radius);
+
+	/** Update a circular region around the specified player. */
+	void UpdateRadius(cPlayer & a_Player, unsigned int a_Radius);
+
+	/** Send next update packet to the specified player and remove invalid decorators/clients. */
+	void UpdateClient(cPlayer * a_Player);
+
+	// tolua_begin
+
+	/** Erase pixel data */
+	void EraseData(void);
+
+	void Resize(unsigned int a_Width, unsigned int a_Height);
+
+	void SetPosition(int a_CenterX, int a_CenterZ);
+
+	void SetScale(unsigned int a_Scale);
+
+	bool SetPixel(unsigned int a_X, unsigned int a_Z, ColorID a_Data);
+
+	ColorID GetPixel(unsigned int a_X, unsigned int a_Z);
+
+	unsigned int GetWidth (void) const { return m_Width;  }
+	unsigned int GetHeight(void) const { return m_Height; }
+
+	unsigned int GetScale(void) const { return m_Scale; }
+
+	int GetCenterX(void) const { return m_CenterX; }
+	int GetCenterZ(void) const { return m_CenterZ; }
+
+	unsigned int GetID(void) const { return m_ID; }
+
+	cWorld * GetWorld(void) { return m_World; }
+
+	AString GetName(void) { return m_Name; }
+
+	eDimension GetDimension(void) const;
+
+	unsigned int GetNumPixels(void) const;
+
+	unsigned int GetPixelWidth(void) const;
+
+	// tolua_end
+
+	unsigned int GetNumDecorators(void) const;
+
+	const cColorList & GetData(void) const { return m_Data; }
+
+	static const char * GetClassStatic(void)  // Needed for ManualBindings's DoWith templates
+	{
+		return "cMap";
+	}
+
+
+protected:
+
+	/** Encapsulates the state of a map client.
+	 *
+	 * In order to enhance performace, maps are streamed column-by-column to each client.
+	 * This structure stores the state of the stream.
+	 */
+	struct cMapClient
+	{
+		cClientHandle * m_Handle;
+
+		/** Whether the map scale was modified and needs to be resent. */
+		bool m_SendInfo;
+
+		/** Ticks since last decorator update. */
+		unsigned int m_NextDecoratorUpdate;
+
+		/** Number of pixel data updates. */
+		Int64 m_DataUpdate;
+
+		Int64 m_LastUpdate;
+	};
+
+	typedef std::list<cMapClient> cMapClientList;
+
+
+private:
+
+	/** Update the associated decorators. */
+	void UpdateDecorators(void);
+
+	/** Update the specified pixel. */
+	bool UpdatePixel(unsigned int a_X, unsigned int a_Z);
+
+	/** Add a new map client. */
+	void AddPlayer(cPlayer * a_Player, Int64 a_WorldAge);
+
+	/** Remove inactive or invalid clients. */
+	void RemoveInactiveClients(Int64 a_WorldAge);
+
+	/** Send next update packet to the specified client. */
+	void StreamNext(cMapClient & a_Client);
+
+	unsigned int m_ID;
+
+	unsigned int m_Width;
+	unsigned int m_Height;
+
+	/** The zoom level, 2^scale square blocks per pixel */
+	unsigned int m_Scale;
+
+	int m_CenterX;
+	int m_CenterZ;
+
+	/** Column-major array of colours */
+	cColorList m_Data;
+
+	cWorld * m_World;
+
+	cMapDecoratorList m_Decorators;
+
+	cMapClientList m_Clients;
+
+	AString m_Name;
+
+	friend class cMapSerializer;
+
+}; // tolua_export
+
+
+
diff --git a/src/MapManager.cpp b/src/MapManager.cpp
new file mode 100644
index 000000000..9d02eafb4
--- /dev/null
+++ b/src/MapManager.cpp
@@ -0,0 +1,178 @@
+
+// MapManager.cpp
+
+#include "Globals.h"
+
+#include "MapManager.h"
+
+#include "World.h"
+#include "WorldStorage/MapSerializer.h"
+
+
+
+
+
+cMapManager::cMapManager(cWorld * a_World)
+	: m_World(a_World)
+{
+	ASSERT(m_World != NULL);
+}
+
+
+
+
+
+bool cMapManager::DoWithMap(int a_ID, cMapCallback & a_Callback)
+{
+	cCSLock Lock(m_CS);
+	cMap * Map = GetMapData(a_ID);
+
+	if (Map == NULL)
+	{
+		return false;
+	}
+	else
+	{
+		a_Callback.Item(Map);
+		return true;
+	}
+}
+
+
+
+
+
+bool cMapManager::ForEachMap(cMapCallback & a_Callback)
+{
+	cCSLock Lock(m_CS);
+	for (cMapList::iterator itr = m_MapData.begin(); itr != m_MapData.end(); ++itr)
+	{
+		cMap * Map = &(*itr);
+		if (a_Callback.Item(Map))
+		{
+			return false;
+		}
+	}  // for itr - m_MapData[]
+	return true;
+}
+
+
+
+
+
+cMap * cMapManager::GetMapData(unsigned int a_ID)
+{
+	if (a_ID < m_MapData.size())
+	{
+		return &m_MapData[a_ID];
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+
+
+
+
+cMap * cMapManager::CreateMap(int a_CenterX, int a_CenterY, int a_Scale)
+{
+	cCSLock Lock(m_CS);
+
+	if (m_MapData.size() >= 65536)
+	{
+		LOGWARN("Could not craft map - Too many maps in use");
+		return NULL;
+	}
+
+	cMap Map(m_MapData.size(), a_CenterX, a_CenterY, m_World, a_Scale);
+
+	m_MapData.push_back(Map);
+
+	return &m_MapData[Map.GetID()];
+}
+
+
+
+
+
+unsigned int cMapManager::GetNumMaps(void) const
+{
+	return m_MapData.size();
+}
+
+
+
+
+
+void cMapManager::LoadMapData(void)
+{
+	cCSLock Lock(m_CS);
+
+	cIDCountSerializer IDSerializer(m_World->GetName());
+
+	if (!IDSerializer.Load())
+	{
+		return;
+	}
+
+	unsigned int MapCount = IDSerializer.GetMapCount();
+
+	m_MapData.clear();
+
+	for (unsigned int i = 0; i < MapCount; ++i)
+	{
+		cMap Map(i, m_World);
+
+		cMapSerializer Serializer(m_World->GetName(), &Map);
+
+		if (!Serializer.Load())
+		{
+			LOGWARN("Could not load map #%i", Map.GetID());
+		}
+
+		m_MapData.push_back(Map);
+	}
+}
+
+
+
+
+
+void cMapManager::SaveMapData(void)
+{
+	cCSLock Lock(m_CS);
+
+	if (m_MapData.empty())
+	{
+		return;
+	}
+
+	cIDCountSerializer IDSerializer(m_World->GetName());
+
+	IDSerializer.SetMapCount(m_MapData.size());
+
+	if (!IDSerializer.Save())
+	{
+		LOGERROR("Could not save idcounts.dat");
+		return;
+	}
+
+	for (cMapList::iterator it = m_MapData.begin(); it != m_MapData.end(); ++it)
+	{
+		cMap & Map = *it;
+
+		cMapSerializer Serializer(m_World->GetName(), &Map);
+
+		if (!Serializer.Save())
+		{
+			LOGWARN("Could not save map #%i", Map.GetID());
+		}
+	}
+}
+
+
+
+
+
diff --git a/src/MapManager.h b/src/MapManager.h
new file mode 100644
index 000000000..80e6d16d1
--- /dev/null
+++ b/src/MapManager.h
@@ -0,0 +1,78 @@
+
+// MapManager.h
+
+
+
+
+
+#pragma once
+
+
+
+
+
+#include "Map.h"
+
+
+
+
+typedef cItemCallback<cMap> cMapCallback;
+
+
+
+
+// tolua_begin
+
+/** Manages the in-game maps of a single world - Thread safe. */
+class cMapManager
+{
+public:
+	// tolua_end
+
+	cMapManager(cWorld * a_World);
+
+	/** Returns the map with the specified ID, NULL if out of range.
+	 *
+	 * WARNING: The returned map object is not thread safe.
+	 */
+	cMap * GetMapData(unsigned int a_ID);
+
+	/** Creates a new map. Returns NULL on error */
+	cMap * CreateMap(int a_CenterX, int a_CenterY, int a_Scale = 3);
+
+	/** Calls the callback for the map with the specified ID.
+	 *
+	 * Returns true if the map was found and the callback called, false if map not found. 
+	 * Callback return ignored.
+	 */
+	bool DoWithMap(int a_ID, cMapCallback & a_Callback); // Exported in ManualBindings.cpp
+
+	/** Calls the callback for each map. 
+	 *
+	 * Returns true if all maps processed, false if the callback aborted by returning true.
+	 */
+	bool ForEachMap(cMapCallback & a_Callback);
+
+	unsigned int GetNumMaps(void) const; // tolua_export
+
+	/** Loads the map data from the disk */
+	void LoadMapData(void);
+
+	/** Saves the map data to the disk */
+	void SaveMapData(void);
+
+
+private:
+
+	typedef std::vector<cMap> cMapList;
+
+	cCriticalSection m_CS;
+
+	cMapList m_MapData;
+
+	cWorld * m_World;
+
+}; // tolua_export
+
+
+
diff --git a/src/Matrix4.h b/src/Matrix4.h
new file mode 100644
index 000000000..456677f0f
--- /dev/null
+++ b/src/Matrix4.h
@@ -0,0 +1,224 @@
+
+#pragma once
+
+
+
+#define _USE_MATH_DEFINES // Enable non-standard math defines (MSVC)
+#include <math.h>
+
+
+
+
+
+template <typename T>
+// tolua_begin
+class Matrix4
+{
+
+	TOLUA_TEMPLATE_BIND((T, float, double))
+
+	// tolua_end
+
+public:
+
+	T cell[16];
+
+	// tolua_begin
+
+	inline Matrix4(void)
+	{
+		Identity();
+	}
+
+	inline Matrix4(const Matrix4 & a_Rhs)
+	{
+		*this = a_Rhs;
+	}
+
+	inline Matrix4 & operator = (const Matrix4 & a_Rhs)
+	{
+		for (unsigned int i = 0; i < 16; ++i)
+		{
+			cell[i] = a_Rhs.cell[i];
+		}
+		return *this;
+	}
+
+	inline T & operator [] (int a_N)
+	{
+		ASSERT(a_N < 16);
+		return cell[a_N];
+	}
+
+	inline void Identity()
+	{
+		cell[1]  = cell[2]  = cell[3]  = cell[4]  = 0;
+		cell[6]  = cell[7]  = cell[8]  = cell[9]  = 0;
+		cell[11] = cell[12] = cell[13] = cell[14] = 0;
+
+		cell[0] = cell[5] = cell[10] = cell[15] = 1;
+	}
+
+	inline void Init(const Vector3<T> & a_Pos, T a_RX, T a_RY, T a_RZ)
+	{
+		Matrix4<T> t;
+		t.RotateX(a_RZ);
+		RotateY(a_RY);
+		Concatenate(t);
+		t.RotateZ(a_RX);
+		Concatenate(t);
+		Translate(a_Pos);
+	}
+
+	inline void RotateX(T a_RX)
+	{
+		T sx = (T) sin(a_RX * M_PI / 180);
+		T cx = (T) cos(a_RX * M_PI / 180);
+
+		Identity();
+
+		cell[5] = cx;  cell[6]  = sx;
+		cell[9] = -sx; cell[10] = cx;
+	}
+
+	inline void RotateY(T a_RY)
+	{
+		T sy = (T) sin(a_RY * M_PI / 180);
+		T cy = (T) cos(a_RY * M_PI / 180);
+
+		Identity();
+
+		cell[0] = cy; cell[2] = -sy;
+		cell[8] = sy; cell[10] = cy;
+	}
+
+	inline void RotateZ(T a_RZ)
+	{
+		T sz = (T) sin(a_RZ * M_PI / 180);
+		T cz = (T) cos(a_RZ * M_PI / 180);
+
+		Identity();
+
+		cell[0] = cz;  cell[1] = sz;
+		cell[4] = -sz; cell[5] = cz;
+	}
+
+	inline void Translate(const Vector3<T> & a_Pos)
+	{ 
+		cell[3]  += a_Pos.x;
+		cell[7]  += a_Pos.y;
+		cell[11] += a_Pos.z;
+	}
+
+	inline void SetTranslation(const Vector3<T> & a_Pos)
+	{
+		cell[3]  = a_Pos.x;
+		cell[7]  = a_Pos.y;
+		cell[11] = a_Pos.z;
+	}
+
+	inline void Concatenate(const Matrix4 & m2)
+	{
+		Matrix4 res;
+
+		for (unsigned int c = 0; c < 4; ++c)
+		{
+			for (unsigned int r = 0; r < 4; ++r)
+			{
+				res.cell[r * 4 + c] = (
+					cell[r * 4 + 0] * m2.cell[c + 0] +
+					cell[r * 4 + 1] * m2.cell[c + 4] +
+					cell[r * 4 + 2] * m2.cell[c + 8] +
+					cell[r * 4 + 3] * m2.cell[c + 12]
+				);
+			}
+		}
+
+		*this = res;
+	}
+
+	inline Vector3<T> Transform(const Vector3<T> & v) const
+	{
+		T x  = cell[0] * v.x + cell[1] * v.y + cell[2]  * v.z + cell[3];
+		T y  = cell[4] * v.x + cell[5] * v.y + cell[6]  * v.z + cell[7];
+		T z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
+
+		return Vector3<T>(x, y, z);
+	}
+
+	inline void Invert(void)
+	{
+		Matrix4 t;
+
+		T tx = -cell[3];
+		T ty = -cell[7];
+		T tz = -cell[11];
+
+		for (unsigned int h = 0; h < 3; ++h)
+		{
+			for (unsigned int v = 0; v < 3; ++v)
+			{
+				t.cell[h + v * 4] = cell[v + h * 4];
+			}
+		}
+
+		for (unsigned int i = 0; i < 11; ++i)
+		{
+			cell[i] = t.cell[i];
+		}
+
+		cell[3]  = tx * cell[0] + ty * cell[1] + tz * cell[2];
+		cell[7]  = tx * cell[4] + ty * cell[5] + tz * cell[6];
+		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
+	}
+
+	inline Vector3<T> GetXColumn(void) const
+	{
+		return Vector3<T>(cell[0], cell[1], cell[2]);
+	}
+
+	inline Vector3<T> GetYColumn(void) const
+	{
+		return Vector3<T>(cell[4], cell[5], cell[6]);
+	}
+
+	inline Vector3<T> GetZColumn(void) const
+	{
+		return Vector3<T>(cell[8], cell[9], cell[10]);
+	}
+
+	inline void SetXColumn(const Vector3<T> & a_X)
+	{
+		cell[0] = a_X.x;
+		cell[1] = a_X.y;
+		cell[2] = a_X.z;
+	}
+
+	inline void SetYColumn(const Vector3<T> & a_Y)
+	{
+		cell[4] = a_Y.x;
+		cell[5] = a_Y.y;
+		cell[6] = a_Y.z;
+	}
+
+	inline void SetZColumn(const Vector3<T> & a_Z)
+	{
+		cell[8]  = a_Z.x;
+		cell[9]  = a_Z.y;
+		cell[10] = a_Z.z;
+	}
+};
+// tolua_end
+
+
+
+
+// tolua_begin
+typedef Matrix4<double> Matrix4d;
+typedef Matrix4<float>  Matrix4f;
+// tolua_end
+
+
+
+
+
diff --git a/src/Matrix4f.cpp b/src/Matrix4f.cpp
deleted file mode 100644
index d0a407a99..000000000
--- a/src/Matrix4f.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-// _X: empty file??
diff --git a/src/Matrix4f.h b/src/Matrix4f.h
deleted file mode 100644
index 249c92f5f..000000000
--- a/src/Matrix4f.h
+++ /dev/null
@@ -1,225 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-#include "Vector3f.h"
-
-class Matrix4f
-{
-public:
-	enum
-	{
-		TX=3,
-		TY=7,
-		TZ=11,
-		D0=0, D1=5, D2=10, D3=15,
-		SX=D0, SY=D1, SZ=D2,
-		W=D3
-	};
-	Matrix4f() { Identity(); }
-	float& operator [] ( int a_N ) { return cell[a_N]; }
-	void Identity()
-	{
-		cell[1] = cell[2] = cell[TX] = cell[4] = cell[6] = cell[TY] =
-		cell[8] = cell[9] = cell[TZ] = cell[12] = cell[13] = cell[14] = 0;
-		cell[D0] = cell[D1] = cell[D2] = cell[W] = 1;
-	}
-	void Init( Vector3f a_Pos, float a_RX, float a_RY, float a_RZ )
-	{
-		Matrix4f t;
-		t.RotateX( a_RZ );
-		RotateY( a_RY );
-		Concatenate( t );
-		t.RotateZ( a_RX );
-		Concatenate( t );
-		Translate( a_Pos );
-	}
-	void RotateX( float a_RX )
-	{
-		float sx = (float)sin( a_RX * M_PI / 180 );
-		float cx = (float)cos( a_RX * M_PI / 180 );
-		Identity();
-		cell[5] = cx, cell[6] = sx, cell[9] = -sx, cell[10] = cx;
-	}
-	void RotateY( float a_RY )
-	{
-		float sy = (float)sin( a_RY * M_PI / 180 );
-		float cy = (float)cos( a_RY * M_PI / 180 );
-		Identity ();
-		cell[0] = cy, cell[2] = -sy, cell[8] = sy, cell[10] = cy;
-	}
-	void RotateZ( float a_RZ )
-	{
-		float sz = (float)sin( a_RZ * M_PI / 180 );
-		float cz = (float)cos( a_RZ * M_PI / 180 );
-		Identity ();
-		cell[0] = cz, cell[1] = sz, cell[4] = -sz, cell[5] = cz;
-	}
-	void Translate( Vector3f a_Pos ) { cell[TX] += a_Pos.x; cell[TY] += a_Pos.y; cell[TZ] += a_Pos.z; }
-	void SetTranslation( Vector3f a_Pos ) { cell[TX] = a_Pos.x; cell[TY] = a_Pos.y; cell[TZ] = a_Pos.z; }
-	void Concatenate( const Matrix4f& m2 )
-	{
-		Matrix4f res;
-		int c;
-		for ( c = 0; c < 4; c++ ) for ( int r = 0; r < 4; r++ )
-			res.cell[r * 4 + c] = cell[r * 4] * m2.cell[c] +
-				  				  cell[r * 4 + 1] * m2.cell[c + 4] +
-								  cell[r * 4 + 2] * m2.cell[c + 8] +
-								  cell[r * 4 + 3] * m2.cell[c + 12];
-		for ( c = 0; c < 16; c++ ) cell[c] = res.cell[c];
-	}
-	Vector3f Transform( const Vector3f& v ) const
-	{
-		float x  = cell[0] * v.x + cell[1] * v.y + cell[2] * v.z + cell[3];
-		float y  = cell[4] * v.x + cell[5] * v.y + cell[6] * v.z + cell[7];
-		float z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
-		return Vector3f( x, y, z );
-	}
-	void Invert()
-	{
-		Matrix4f t;
-		int h, i;
-		float tx = -cell[3], ty = -cell[7], tz = -cell[11];
-		for ( h = 0; h < 3; h++ ) for ( int v = 0; v < 3; v++ ) t.cell[h + v * 4] = cell[v + h * 4];
-		for ( i = 0; i < 11; i++ ) cell[i] = t.cell[i];
-		cell[3] = tx * cell[0] + ty * cell[1] + tz * cell[2];
-		cell[7] = tx * cell[4] + ty * cell[5] + tz * cell[6];
-		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
-	}
-	Vector3f GetXColumn() { return Vector3f( cell[0], cell[1], cell[2] ); }
-	Vector3f GetYColumn() { return Vector3f( cell[4], cell[5], cell[6] ); }
-	Vector3f GetZColumn() { return Vector3f( cell[8], cell[9], cell[10] ); }
-	void SetXColumn( const Vector3f & a_X )
-	{
-		cell[0] = a_X.x;
-		cell[1] = a_X.y;
-		cell[2] = a_X.z;
-	}
-	void SetYColumn( const Vector3f & a_Y )
-	{
-		cell[4] = a_Y.x;
-		cell[5] = a_Y.y;
-		cell[6] = a_Y.z;
-	}
-	void SetZColumn( const Vector3f & a_Z )
-	{
-		cell[8] = a_Z.x;
-		cell[9] = a_Z.y;
-		cell[10] = a_Z.z;
-	}
-	float cell[16];
-};
-
-
-
-
-
-class Matrix4d
-{
-public:
-	enum
-	{
-		TX=3,
-		TY=7,
-		TZ=11,
-		D0=0, D1=5, D2=10, D3=15,
-		SX=D0, SY=D1, SZ=D2,
-		W=D3
-	};
-	Matrix4d() { Identity(); }
-	double& operator [] ( int a_N ) { return cell[a_N]; }
-	void Identity()
-	{
-		cell[1] = cell[2] = cell[TX] = cell[4] = cell[6] = cell[TY] =
-		cell[8] = cell[9] = cell[TZ] = cell[12] = cell[13] = cell[14] = 0;
-		cell[D0] = cell[D1] = cell[D2] = cell[W] = 1;
-	}
-	void Init( Vector3f a_Pos, double a_RX, double a_RY, double a_RZ )
-	{
-		Matrix4d t;
-		t.RotateX( a_RZ );
-		RotateY( a_RY );
-		Concatenate( t );
-		t.RotateZ( a_RX );
-		Concatenate( t );
-		Translate( a_Pos );
-	}
-	void RotateX( double a_RX )
-	{
-		double sx = (double)sin( a_RX * M_PI / 180 );
-		double cx = (double)cos( a_RX * M_PI / 180 );
-		Identity();
-		cell[5] = cx, cell[6] = sx, cell[9] = -sx, cell[10] = cx;
-	}
-	void RotateY( double a_RY )
-	{
-		double sy = (double)sin( a_RY * M_PI / 180 );
-		double cy = (double)cos( a_RY * M_PI / 180 );
-		Identity ();
-		cell[0] = cy, cell[2] = -sy, cell[8] = sy, cell[10] = cy;
-	}
-	void RotateZ( double a_RZ )
-	{
-		double sz = (double)sin( a_RZ * M_PI / 180 );
-		double cz = (double)cos( a_RZ * M_PI / 180 );
-		Identity ();
-		cell[0] = cz, cell[1] = sz, cell[4] = -sz, cell[5] = cz;
-	}
-	void Translate( Vector3d a_Pos ) { cell[TX] += a_Pos.x; cell[TY] += a_Pos.y; cell[TZ] += a_Pos.z; }
-	void SetTranslation( Vector3d a_Pos ) { cell[TX] = a_Pos.x; cell[TY] = a_Pos.y; cell[TZ] = a_Pos.z; }
-	void Concatenate( const Matrix4d & m2 )
-	{
-		Matrix4d res;
-		int c;
-		for ( c = 0; c < 4; c++ ) for ( int r = 0; r < 4; r++ )
-			res.cell[r * 4 + c] = cell[r * 4] * m2.cell[c] +
-				  				  cell[r * 4 + 1] * m2.cell[c + 4] +
-								  cell[r * 4 + 2] * m2.cell[c + 8] +
-								  cell[r * 4 + 3] * m2.cell[c + 12];
-		for ( c = 0; c < 16; c++ ) cell[c] = res.cell[c];
-	}
-	Vector3d Transform( const Vector3d & v ) const
-	{
-		double x  = cell[0] * v.x + cell[1] * v.y + cell[2] * v.z + cell[3];
-		double y  = cell[4] * v.x + cell[5] * v.y + cell[6] * v.z + cell[7];
-		double z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
-		return Vector3d( x, y, z );
-	}
-	void Invert()
-	{
-		Matrix4d t;
-		int h, i;
-		double tx = -cell[3], ty = -cell[7], tz = -cell[11];
-		for ( h = 0; h < 3; h++ ) for ( int v = 0; v < 3; v++ ) t.cell[h + v * 4] = cell[v + h * 4];
-		for ( i = 0; i < 11; i++ ) cell[i] = t.cell[i];
-		cell[3] = tx * cell[0] + ty * cell[1] + tz * cell[2];
-		cell[7] = tx * cell[4] + ty * cell[5] + tz * cell[6];
-		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
-	}
-	Vector3d GetXColumn() { return Vector3d( cell[0], cell[1], cell[2] ); }
-	Vector3d GetYColumn() { return Vector3d( cell[4], cell[5], cell[6] ); }
-	Vector3d GetZColumn() { return Vector3d( cell[8], cell[9], cell[10] ); }
-	void SetXColumn( const Vector3d & a_X )
-	{
-		cell[0] = a_X.x;
-		cell[1] = a_X.y;
-		cell[2] = a_X.z;
-	}
-	void SetYColumn( const Vector3d & a_Y )
-	{
-		cell[4] = a_Y.x;
-		cell[5] = a_Y.y;
-		cell[6] = a_Y.z;
-	}
-	void SetZColumn( const Vector3d & a_Z )
-	{
-		cell[8] = a_Z.x;
-		cell[9] = a_Z.y;
-		cell[10] = a_Z.z;
-	}
-	double cell[16];
-} ;
-
-
-
-
diff --git a/src/MersenneTwister.h b/src/MersenneTwister.h
index dc7134a93..759b8a1ae 100644
--- a/src/MersenneTwister.h
+++ b/src/MersenneTwister.h
@@ -62,7 +62,7 @@
 class MTRand {
 // Data
 public:
-	typedef long uint32;  // unsigned integer type, at least 32 bits
+	typedef UInt32 uint32;  // unsigned integer type, at least 32 bits
 	
 	enum { N = 624 };       // length of state vector
 	enum { SAVE = N + 1 };  // length of array for save()
@@ -72,7 +72,7 @@ protected:
 	
 	uint32 state[N];   // internal state
 	uint32 *pNext;     // next value to get from state
-	int left;          // number of values left before reload needed
+	uint32 left;       // number of values left before reload needed
 
 // Methods
 public:
@@ -162,9 +162,9 @@ inline void MTRand::initialize( const uint32 seed )
 	// See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
 	// In previous versions, most significant bits (MSBs) of the seed affect
 	// only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
-	register uint32 *s = state;
-	register uint32 *r = state;
-	register int i = 1;
+	uint32 *s = state;
+	uint32 *r = state;
+	uint32 i = 1;
 	*s++ = seed & 0xffffffffUL;
 	for( ; i < N; ++i )
 	{
@@ -178,8 +178,8 @@ inline void MTRand::reload()
 	// Generate N new values in state
 	// Made clearer and faster by Matthew Bellew (matthew.bellew@home.com)
 	static const int MmN = int(M) - int(N);  // in case enums are unsigned
-	register uint32 *p = state;
-	register int i;
+	uint32 *p = state;
+	int i;
 	for( i = N - M; i--; ++p )
 		*p = twist( p[M], p[0], p[1] );
 	for( i = M; --i; ++p )
@@ -205,9 +205,9 @@ inline void MTRand::seed( uint32 *const bigSeed, const uint32 seedLength )
 	// in each element are discarded.
 	// Just call seed() if you want to get array from /dev/urandom
 	initialize(19650218UL);
-	register int i = 1;
-	register uint32 j = 0;
-	register int k = ( N > seedLength ? N : seedLength );
+	uint32 i = 1;
+	uint32 j = 0;
+	uint32 k = ( (uint32)N > seedLength ? (uint32)N : seedLength );
 	for( ; k; --k )
 	{
 		state[i] =
@@ -238,7 +238,7 @@ inline void MTRand::seed()
 	
 	// First try getting an array from /dev/urandom
 
-	/* // Commented out by FakeTruth because doing this 200 times a tick is SUUUUPEERRR SLOW!!~~!ÕNe
+	/* // Commented out by FakeTruth because doing this 200 times a tick is SUUUUPEERRR SLOW!!~~!\D5Ne
 	FILE* urandom = fopen( "/dev/urandom", "rb" );
 	if( urandom )
 	{
@@ -268,9 +268,9 @@ inline MTRand::MTRand()
 
 inline MTRand::MTRand( const MTRand& o )
 {
-	register const uint32 *t = o.state;
-	register uint32 *s = state;
-	register int i = N;
+	const uint32 *t = o.state;
+	uint32 *s = state;
+	int i = N;
 	for( ; i--; *s++ = *t++ ) {}
 	left = o.left;
 	pNext = &state[N-left];
@@ -284,7 +284,7 @@ inline MTRand::uint32 MTRand::randInt()
 	if( left == 0 ) reload();
 	--left;
 	
-	register uint32 s1;
+	uint32 s1;
 	s1 = *pNext++;
 	s1 ^= (s1 >> 11);
 	s1 ^= (s1 <<  7) & 0x9d2c5680UL;
@@ -358,18 +358,18 @@ inline double MTRand::operator()()
 
 inline void MTRand::save( uint32* saveArray ) const
 {
-	register const uint32 *s = state;
-	register uint32 *sa = saveArray;
-	register int i = N;
+	const uint32 *s = state;
+	uint32 *sa = saveArray;
+	int i = N;
 	for( ; i--; *sa++ = *s++ ) {}
 	*sa = left;
 }
 
 inline void MTRand::load( uint32 *const loadArray )
 {
-	register uint32 *s = state;
-	register uint32 *la = loadArray;
-	register int i = N;
+	uint32 *s = state;
+	uint32 *la = loadArray;
+	int i = N;
 	for( ; i--; *s++ = *la++ ) {}
 	left = *la;
 	pNext = &state[N-left];
@@ -377,16 +377,16 @@ inline void MTRand::load( uint32 *const loadArray )
 
 inline std::ostream& operator<<( std::ostream& os, const MTRand& mtrand )
 {
-	register const MTRand::uint32 *s = mtrand.state;
-	register int i = mtrand.N;
+	const MTRand::uint32 *s = mtrand.state;
+	int i = mtrand.N;
 	for( ; i--; os << *s++ << "\t" ) {}
 	return os << mtrand.left;
 }
 
 inline std::istream& operator>>( std::istream& is, MTRand& mtrand )
 {
-	register MTRand::uint32 *s = mtrand.state;
-	register int i = mtrand.N;
+	MTRand::uint32 *s = mtrand.state;
+	int i = mtrand.N;
 	for( ; i--; is >> *s++ ) {}
 	is >> mtrand.left;
 	mtrand.pNext = &mtrand.state[mtrand.N-mtrand.left];
@@ -396,9 +396,9 @@ inline std::istream& operator>>( std::istream& is, MTRand& mtrand )
 inline MTRand& MTRand::operator=( const MTRand& o )
 {
 	if( this == &o ) return (*this);
-	register const uint32 *t = o.state;
-	register uint32 *s = state;
-	register int i = N;
+	const uint32 *t = o.state;
+	uint32 *s = state;
+	int i = N;
 	for( ; i--; *s++ = *t++ ) {}
 	left = o.left;
 	pNext = &state[N-left];
diff --git a/src/MobProximityCounter.cpp b/src/MobProximityCounter.cpp
index 583a71579..6c44ea458 100644
--- a/src/MobProximityCounter.cpp
+++ b/src/MobProximityCounter.cpp
@@ -59,7 +59,7 @@ cMobProximityCounter::sIterablePair cMobProximityCounter::getMobWithinThosesDist
 	{
 		if (toReturn.m_Begin == m_DistanceToMonster.end())
 		{
-			if (a_DistanceMin == -1 || itr->first > a_DistanceMin)
+			if ((a_DistanceMin == 1) || (itr->first > a_DistanceMin))
 			{
 				toReturn.m_Begin = itr; // this is the first one with distance > a_DistanceMin;
 			}
@@ -67,7 +67,7 @@ cMobProximityCounter::sIterablePair cMobProximityCounter::getMobWithinThosesDist
 
 		if (toReturn.m_Begin != m_DistanceToMonster.end())
 		{
-			if (a_DistanceMax != -1 && itr->first > a_DistanceMax)
+			if ((a_DistanceMax != 1) && (itr->first > a_DistanceMax))
 			{
 				toReturn.m_End = itr; // this is just after the last one with distance < a_DistanceMax
 				// Note : if we are not going through this, it's ok, toReturn.m_End will be end();
diff --git a/src/MobSpawner.cpp b/src/MobSpawner.cpp
index 4d0b2777b..05da5d01c 100644
--- a/src/MobSpawner.cpp
+++ b/src/MobSpawner.cpp
@@ -126,9 +126,14 @@ cMonster::eType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
 
 bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, cMonster::eType a_MobType, EMCSBiome a_Biome)
 {
-	BLOCKTYPE TargetBlock;
+	BLOCKTYPE TargetBlock = E_BLOCK_AIR;
 	if (m_AllowedTypes.find(a_MobType) != m_AllowedTypes.end() && a_Chunk->UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, TargetBlock))
 	{
+		if ((a_RelY + 1 > cChunkDef::Height) || (a_RelY - 1 < 0))
+		{
+			return false;
+		}
+
 		NIBBLETYPE BlockLight = a_Chunk->GetBlockLight(a_RelX, a_RelY, a_RelZ);
 		NIBBLETYPE SkyLight = a_Chunk->GetSkyLight(a_RelX, a_RelY, a_RelZ);
 		BLOCKTYPE BlockAbove = a_Chunk->GetBlock(a_RelX, a_RelY + 1, a_RelZ);
@@ -145,7 +150,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 
 			case cMonster::mtBat:
 			{
-				return (a_RelY <= 63) && (BlockLight <= 4) && (SkyLight <= 4) && (TargetBlock == E_BLOCK_AIR) && (!g_BlockTransparent[BlockAbove]);
+				return (a_RelY <= 63) && (BlockLight <= 4) && (SkyLight <= 4) && (TargetBlock == E_BLOCK_AIR) && !cBlockInfo::IsTransparent(BlockAbove);
 			}
 
 			case cMonster::mtChicken:
@@ -157,7 +162,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
 					(BlockAbove == E_BLOCK_AIR) &&
-					(!g_BlockTransparent[BlockBelow]) &&
+					(!cBlockInfo::IsTransparent(BlockBelow)) &&
 					(BlockBelow == E_BLOCK_GRASS) &&
 					(SkyLight >= 9)
 				);
@@ -169,7 +174,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 					(TargetBlock == E_BLOCK_AIR) &&
 					(BlockAbove == E_BLOCK_AIR) &&
 					(
-						(BlockBelow == E_BLOCK_GRASS) || (BlockBelow == E_BLOCK_LEAVES)
+						(BlockBelow == E_BLOCK_GRASS) || (BlockBelow == E_BLOCK_LEAVES) || (BlockBelow == E_BLOCK_NEW_LEAVES)
 					) &&
 					(a_RelY >= 62) &&
 					(m_Random.NextInt(3, a_Biome) != 0)
@@ -188,7 +193,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 							(TargetBlock == E_BLOCK_AIR) &&
 							(BlockAbove == E_BLOCK_AIR) &&
 							(BlockTop == E_BLOCK_AIR) &&
-							(!g_BlockTransparent[BlockBelow]) &&
+							(!cBlockInfo::IsTransparent(BlockBelow)) &&
 							(SkyLight <= 7) &&
 							(BlockLight <= 7)
 						);
@@ -200,7 +205,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 			case cMonster::mtSpider:
 			{
 				bool CanSpawn = true;
-				bool HaveFloor = false;
+				bool HasFloor = false;
 				for (int x = 0; x < 2; ++x)
 				{
 					for(int z = 0; z < 2; ++z)
@@ -211,16 +216,16 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 						{
 							return false;
 						}
-						HaveFloor = (
-							HaveFloor ||
+						HasFloor = (
+							HasFloor ||
 							(
 								a_Chunk->UnboundedRelGetBlockType(a_RelX + x, a_RelY - 1, a_RelZ + z, TargetBlock) &&
-								!g_BlockTransparent[TargetBlock]
+								!cBlockInfo::IsTransparent(TargetBlock)
 							)
 						);
 					}
 				}
-				return CanSpawn && HaveFloor && (SkyLight <= 7) && (BlockLight <= 7);
+				return CanSpawn && HasFloor && (SkyLight <= 7) && (BlockLight <= 7);
 			}
 			
 			case cMonster::mtCreeper:
@@ -230,7 +235,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
 					(BlockAbove == E_BLOCK_AIR) &&
-					(!g_BlockTransparent[BlockBelow]) &&
+					(!cBlockInfo::IsTransparent(BlockBelow)) &&
 					(SkyLight <= 7) &&
 					(BlockLight <= 7) &&
 					(m_Random.NextInt(2, a_Biome) == 0)
@@ -242,7 +247,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
 					(BlockAbove == E_BLOCK_AIR) &&
-					(!g_BlockTransparent[BlockBelow]) &&
+					(!cBlockInfo::IsTransparent(BlockBelow)) &&
 					(
 						(a_RelY <= 40) || (a_Biome == biSwampland)
 					)
@@ -255,7 +260,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
 					(BlockAbove == E_BLOCK_AIR) &&
-					(!g_BlockTransparent[BlockBelow]) &&
+					(!cBlockInfo::IsTransparent(BlockBelow)) &&
 					(m_Random.NextInt(20, a_Biome) == 0)
 				);
 			}
diff --git a/src/Mobs/AggressiveMonster.cpp b/src/Mobs/AggressiveMonster.cpp
index cc7e7da2b..0901f85a9 100644
--- a/src/Mobs/AggressiveMonster.cpp
+++ b/src/Mobs/AggressiveMonster.cpp
@@ -4,17 +4,15 @@
 #include "AggressiveMonster.h"
 
 #include "../World.h"
-#include "../Vector3f.h"
 #include "../Entities/Player.h"
-#include "../MersenneTwister.h"
+#include "../Tracer.h"
 
 
 
 
 
 cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
-	super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height),
-	m_ChaseTime(999999)
+	super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height)
 {
 	m_EMPersonality = AGGRESSIVE;
 }
@@ -27,32 +25,23 @@ cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eType a_Mob
 void cAggressiveMonster::InStateChasing(float a_Dt)
 {
 	super::InStateChasing(a_Dt);
-	m_ChaseTime += a_Dt;
+
 	if (m_Target != NULL)
 	{
 		if (m_Target->IsPlayer())
 		{
-			cPlayer * Player = (cPlayer *) m_Target;
-			if (Player->IsGameModeCreative())
+			if (((cPlayer *)m_Target)->IsGameModeCreative())
 			{
 				m_EMState = IDLE;
 				return;
 			}
 		}
 
-		Vector3f Pos = Vector3f( GetPosition() );
-		Vector3f Their = Vector3f( m_Target->GetPosition() );
-		if ((Their - Pos).Length() <= m_AttackRange)
+		if (((float)m_FinalDestination.x != (float)m_Target->GetPosX()) || ((float)m_FinalDestination.z != (float)m_Target->GetPosZ()))
 		{
-			Attack(a_Dt);
+			MoveToPosition(m_Target->GetPosition());
 		}
-		MoveToPosition(Their + Vector3f(0, 0.65f, 0));
 	}
-	else if (m_ChaseTime > 5.f)
-	{
-		m_ChaseTime = 0;
-		m_EMState = IDLE;
-	}	
 } 
 
 
@@ -61,8 +50,11 @@ void cAggressiveMonster::InStateChasing(float a_Dt)
 
 void cAggressiveMonster::EventSeePlayer(cEntity * a_Entity)
 {
-	super::EventSeePlayer(a_Entity);
-	m_EMState = CHASING;
+	if (!((cPlayer *)a_Entity)->IsGameModeCreative())
+	{
+		super::EventSeePlayer(a_Entity);
+		m_EMState = CHASING;
+	}
 }
 
 
@@ -73,25 +65,44 @@ void cAggressiveMonster::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	super::Tick(a_Dt, a_Chunk);
 
-	m_SeePlayerInterval += a_Dt;
+	if (m_EMState == CHASING)
+	{
+		CheckEventLostPlayer();
+	}
+	else
+	{
+		CheckEventSeePlayer();
+	}
+
+	if (m_Target == NULL)
+		return;
 
-	if (m_SeePlayerInterval > 1)
+	cTracer LineOfSight(GetWorld());
+	Vector3d AttackDirection(m_Target->GetPosition() - GetPosition());
+
+	if (ReachedFinalDestination() && !LineOfSight.Trace(GetPosition(), AttackDirection, (int)AttackDirection.Length()))
 	{
-		int rem = m_World->GetTickRandomNumber(3) + 1;  // Check most of the time but miss occasionally
+		// Attack if reached destination, target isn't null, and have a clear line of sight to target (so won't attack through walls)
+		Attack(a_Dt / 1000);
+	}
+}
 
-		m_SeePlayerInterval = 0.0;
-		if (rem >= 2)
-		{
-			if (m_EMState == CHASING)
-			{
-				CheckEventLostPlayer();
-			}
-			else
-			{
-				CheckEventSeePlayer();
-			}
-		}
+
+
+
+
+void cAggressiveMonster::Attack(float a_Dt)
+{
+	m_AttackInterval += a_Dt * m_AttackRate;
+
+	if ((m_Target != NULL) && (m_AttackInterval > 3.0))
+	{
+		// Setting this higher gives us more wiggle room for attackrate
+		m_AttackInterval = 0.0;
+		m_Target->TakeDamage(dtMobAttack, this, m_AttackDamage, 0);
 	}
 }
 
 
+
+
diff --git a/src/Mobs/AggressiveMonster.h b/src/Mobs/AggressiveMonster.h
index 5a0d93f3d..152260f95 100644
--- a/src/Mobs/AggressiveMonster.h
+++ b/src/Mobs/AggressiveMonster.h
@@ -13,16 +13,15 @@ class cAggressiveMonster :
 	typedef cMonster super;
 	
 public:
+
 	cAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
 
 	virtual void Tick          (float a_Dt, cChunk & a_Chunk) override;
 	virtual void InStateChasing(float a_Dt) override;
 	
 	virtual void EventSeePlayer(cEntity *) override;
+	virtual void Attack(float a_Dt);
 
-	
-protected:
-	float m_ChaseTime;
 } ;
 
 
diff --git a/src/Mobs/Bat.cpp b/src/Mobs/Bat.cpp
index b9c82996b..1417ddd9e 100644
--- a/src/Mobs/Bat.cpp
+++ b/src/Mobs/Bat.cpp
@@ -2,7 +2,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Bat.h"
-#include "../Vector3d.h"
+#include "../Vector3.h"
 #include "../Chunk.h"
 
 
diff --git a/src/Mobs/Blaze.cpp b/src/Mobs/Blaze.cpp
index f9c05b17a..84ff8929b 100644
--- a/src/Mobs/Blaze.cpp
+++ b/src/Mobs/Blaze.cpp
@@ -19,7 +19,11 @@ cBlaze::cBlaze(void) :
 
 void cBlaze::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_BLAZE_ROD);
+	if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
+	{
+		int LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+		AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_BLAZE_ROD);
+	}
 }
 
 
@@ -49,4 +53,4 @@ void cBlaze::Attack(float a_Dt)
 		m_AttackInterval = 0.0;
 		// ToDo: Shoot 3 fireballs instead of 1.
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Mobs/Blaze.h b/src/Mobs/Blaze.h
index cdb3a1306..5970451c7 100644
--- a/src/Mobs/Blaze.h
+++ b/src/Mobs/Blaze.h
@@ -20,7 +20,3 @@ public:
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void Attack(float a_Dt) override;
 } ;
-
-
-
-
diff --git a/src/Mobs/Cavespider.cpp b/src/Mobs/Cavespider.cpp
index aba1ff9f5..94e93283d 100644
--- a/src/Mobs/Cavespider.cpp
+++ b/src/Mobs/Cavespider.cpp
@@ -31,8 +31,16 @@ void cCavespider::Tick(float a_Dt, cChunk & a_Chunk)
 
 void cCavespider::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_STRING);
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_SPIDER_EYE);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STRING);
+	if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
+	{
+		AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_SPIDER_EYE);
+	}
 }
 
 
diff --git a/src/Mobs/Chicken.cpp b/src/Mobs/Chicken.cpp
index 087fd088a..f7e44238f 100644
--- a/src/Mobs/Chicken.cpp
+++ b/src/Mobs/Chicken.cpp
@@ -9,7 +9,6 @@
 
 
 
-
 cChicken::cChicken(void) :
 	super("Chicken", mtChicken, "mob.chicken.hurt", "mob.chicken.hurt", 0.3, 0.4),
 	m_EggDropTimer(0)
@@ -49,8 +48,13 @@ void cChicken::Tick(float a_Dt, cChunk & a_Chunk)
 
 void cChicken::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_FEATHER);
-	a_Drops.push_back(cItem(IsOnFire() ? E_ITEM_COOKED_CHICKEN : E_ITEM_RAW_CHICKEN, 1));
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_FEATHER);
+	AddRandomDropItem(a_Drops, 1, 1, IsOnFire() ? E_ITEM_COOKED_CHICKEN : E_ITEM_RAW_CHICKEN);
 }
 
 
diff --git a/src/Mobs/Chicken.h b/src/Mobs/Chicken.h
index 979c4d8a0..a4c1d6b9e 100644
--- a/src/Mobs/Chicken.h
+++ b/src/Mobs/Chicken.h
@@ -19,8 +19,9 @@ public:
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
-private:
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_SEEDS); }
 
+private:
 
 	int m_EggDropTimer;
 } ;
diff --git a/src/Mobs/Cow.cpp b/src/Mobs/Cow.cpp
index 9eb74dac2..9914df6b5 100644
--- a/src/Mobs/Cow.cpp
+++ b/src/Mobs/Cow.cpp
@@ -21,8 +21,13 @@ cCow::cCow(void) :
 
 void cCow::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_LEATHER);
-	AddRandomDropItem(a_Drops, 1, 3, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER);
+	AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF);
 }
 
 
@@ -41,5 +46,3 @@ void cCow::OnRightClicked(cPlayer & a_Player)
 	}
 }
 
-
-
diff --git a/src/Mobs/Cow.h b/src/Mobs/Cow.h
index 0391d4a31..973171ab5 100644
--- a/src/Mobs/Cow.h
+++ b/src/Mobs/Cow.h
@@ -19,6 +19,9 @@ public:
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
+
 } ;
 
 
diff --git a/src/Mobs/Creeper.cpp b/src/Mobs/Creeper.cpp
index 4e11ae13e..3471b4cf1 100644
--- a/src/Mobs/Creeper.cpp
+++ b/src/Mobs/Creeper.cpp
@@ -3,6 +3,8 @@
 
 #include "Creeper.h"
 #include "../World.h"
+#include "../Entities/ProjectileEntity.h"
+#include "../Entities/Player.h"
 
 
 
@@ -11,7 +13,9 @@
 cCreeper::cCreeper(void) :
 	super("Creeper", mtCreeper, "mob.creeper.say", "mob.creeper.say", 0.6, 1.8),
 	m_bIsBlowing(false),
-	m_bIsCharged(false)
+	m_bIsCharged(false),
+	m_BurnedWithFlintAndSteel(false),
+	m_ExplodingTimer(0)
 {
 }
 
@@ -19,11 +23,52 @@ cCreeper::cCreeper(void) :
 
 
 
+void cCreeper::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	super::Tick(a_Dt, a_Chunk);
+
+	if (!ReachedFinalDestination() && !m_BurnedWithFlintAndSteel)
+	{
+		m_ExplodingTimer = 0;
+		m_bIsBlowing = false;
+		m_World->BroadcastEntityMetadata(*this);
+	}
+	else
+	{
+		if (m_bIsBlowing)
+		{
+			m_ExplodingTimer += 1;			
+		}
+
+		if (m_ExplodingTimer == 30)
+		{
+			m_World->DoExplosionAt((m_bIsCharged ? 5 : 3), GetPosX(), GetPosY(), GetPosZ(), false, esMonster, this);
+			Destroy();
+		}
+	}
+}
+
+
+
+
+
 void cCreeper::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_GUNPOWDER);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER);
 
-	// TODO Check if killed by a skeleton, then drop random music disk
+	if ((a_Killer != NULL) && (a_Killer->IsProjectile()))
+	{
+		if (((cMonster *)((cProjectileEntity *)a_Killer)->GetCreator())->GetMobType() == mtSkeleton)
+		{
+			// 12 music discs. TickRand starts from 0, so range = 11. Disk IDs start at 2256, so add that. There.
+			AddRandomDropItem(a_Drops, 1, 1, (short)m_World->GetTickRandomNumber(11) + 2256);
+		}
+	}
 }
 
 
@@ -45,3 +90,35 @@ void cCreeper::DoTakeDamage(TakeDamageInfo & a_TDI)
 
 
 
+
+void cCreeper::Attack(float a_Dt)
+{
+	UNUSED(a_Dt);
+
+	if (!m_bIsBlowing)
+	{
+		m_World->BroadcastSoundEffect("game.tnt.primed", (int)GetPosX() * 8, (int)GetPosY() * 8, (int)GetPosZ() * 8, 1.f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
+		m_bIsBlowing = true;
+		m_World->BroadcastEntityMetadata(*this);
+	}
+}
+
+
+
+
+
+void cCreeper::OnRightClicked(cPlayer & a_Player)
+{
+	if ((a_Player.GetEquippedItem().m_ItemType == E_ITEM_FLINT_AND_STEEL))
+	{
+		if (!a_Player.IsGameModeCreative())
+		{
+			a_Player.UseEquippedItem();
+		}
+		m_World->BroadcastSoundEffect("game.tnt.primed", (int)GetPosX() * 8, (int)GetPosY() * 8, (int)GetPosZ() * 8, 1.f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
+		m_bIsBlowing = true;
+		m_World->BroadcastEntityMetadata(*this);
+		m_BurnedWithFlintAndSteel = true;
+	}
+}
+
diff --git a/src/Mobs/Creeper.h b/src/Mobs/Creeper.h
index c3d4edeae..9abca369b 100644
--- a/src/Mobs/Creeper.h
+++ b/src/Mobs/Creeper.h
@@ -19,13 +19,17 @@ public:
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
+	virtual void Attack(float a_Dt) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+	virtual void OnRightClicked(cPlayer & a_Player) override;
 
 	bool IsBlowing(void) const {return m_bIsBlowing; }
 	bool IsCharged(void) const {return m_bIsCharged; }
 
 private:
 
-	bool m_bIsBlowing, m_bIsCharged;
+	bool m_bIsBlowing, m_bIsCharged, m_BurnedWithFlintAndSteel;
+	int m_ExplodingTimer;
 
 } ;
 
diff --git a/src/Mobs/Enderman.cpp b/src/Mobs/Enderman.cpp
index a784131e4..becc99a86 100644
--- a/src/Mobs/Enderman.cpp
+++ b/src/Mobs/Enderman.cpp
@@ -21,7 +21,12 @@ cEnderman::cEnderman(void) :
 
 void cEnderman::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_ENDER_PEARL);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_ENDER_PEARL);
 }
 
 
diff --git a/src/Mobs/Ghast.cpp b/src/Mobs/Ghast.cpp
index 96a29b2d8..fe18f5e76 100644
--- a/src/Mobs/Ghast.cpp
+++ b/src/Mobs/Ghast.cpp
@@ -18,8 +18,13 @@ cGhast::cGhast(void) :
 
 void cGhast::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_GUNPOWDER);
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_GHAST_TEAR);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER);
+	AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_GHAST_TEAR);
 }
 
 
diff --git a/src/Mobs/Horse.cpp b/src/Mobs/Horse.cpp
index bb9a4e3f6..9d130301f 100644
--- a/src/Mobs/Horse.cpp
+++ b/src/Mobs/Horse.cpp
@@ -140,7 +140,12 @@ void cHorse::OnRightClicked(cPlayer & a_Player)
 
 void cHorse::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_LEATHER);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER);
 	if (m_bIsSaddled)
 	{
 		a_Drops.push_back(cItem(E_ITEM_SADDLE, 1));
diff --git a/src/Mobs/IronGolem.cpp b/src/Mobs/IronGolem.cpp
index 47c961098..dae4615e4 100644
--- a/src/Mobs/IronGolem.cpp
+++ b/src/Mobs/IronGolem.cpp
@@ -18,7 +18,9 @@ cIronGolem::cIronGolem(void) :
 
 void cIronGolem::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
+	UNUSED(a_Killer);
 	AddRandomDropItem(a_Drops, 0, 5, E_ITEM_IRON);
+	AddRandomDropItem(a_Drops, 0, 2, E_BLOCK_FLOWER);
 }
 
 
diff --git a/src/Mobs/IronGolem.h b/src/Mobs/IronGolem.h
index d49ff4cab..41c60438c 100644
--- a/src/Mobs/IronGolem.h
+++ b/src/Mobs/IronGolem.h
@@ -18,6 +18,10 @@ public:
 	CLASS_PROTODEF(cIronGolem);
 	
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+
+	// Iron golems do not drown
+	virtual void HandleAir(void) override {}
+	virtual void SetSwimState(cChunk & a_Chunk) override {}
 } ;
 
 
diff --git a/src/Mobs/Magmacube.cpp b/src/Mobs/Magmacube.cpp
index 86447ff6b..05405f082 100644
--- a/src/Mobs/Magmacube.cpp
+++ b/src/Mobs/Magmacube.cpp
@@ -19,7 +19,11 @@ cMagmaCube::cMagmaCube(int a_Size) :
 
 void cMagmaCube::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_MAGMA_CREAM);
+	UNUSED(a_Killer);
+	if (GetSize() > 1)
+	{
+		AddRandomUncommonDropItem(a_Drops, 25.0f, E_ITEM_MAGMA_CREAM);
+	}
 }
 
 
diff --git a/src/Mobs/Monster.cpp b/src/Mobs/Monster.cpp
index 98b6c1d28..aa6071515 100644
--- a/src/Mobs/Monster.cpp
+++ b/src/Mobs/Monster.cpp
@@ -8,14 +8,9 @@
 #include "../World.h"
 #include "../Entities/Player.h"
 #include "../Entities/ExpOrb.h"
-#include "../Defines.h"
 #include "../MonsterConfig.h"
 #include "../MersenneTwister.h"
 
-#include "../Vector3f.h"
-#include "../Vector3i.h"
-#include "../Vector3d.h"
-#include "../Tracer.h"
 #include "../Chunk.h"
 #include "../FastRandom.h"
 
@@ -74,21 +69,25 @@ cMonster::cMonster(const AString & a_ConfigName, eType a_MobType, const AString
 	: super(etMonster, a_Width, a_Height)
 	, m_EMState(IDLE)
 	, m_EMPersonality(AGGRESSIVE)
-	, m_SightDistance(25)
 	, m_Target(NULL)
-	, m_AttackRate(3)
-	, m_IdleInterval(0)
 	, m_bMovingToDestination(false)
-	, m_DestinationTime( 0 )
-	, m_DestroyTimer( 0 )
-	, m_Jump(0)
+	, m_LastGroundHeight(POSY_TOINT)
+	, m_IdleInterval(0)
+	, m_DestroyTimer(0)
 	, m_MobType(a_MobType)
 	, m_SoundHurt(a_SoundHurt)
 	, m_SoundDeath(a_SoundDeath)
-	, m_SeePlayerInterval (0)
-	, m_AttackDamage(1.0f)
-	, m_AttackRange(2.0f)
+	, m_AttackRate(3)
+	, m_AttackDamage(1)
+	, m_AttackRange(2)
 	, m_AttackInterval(0)
+	, m_SightDistance(25)
+	, m_DropChanceWeapon(0.085f)
+	, m_DropChanceHelmet(0.085f)
+	, m_DropChanceChestplate(0.085f)
+	, m_DropChanceLeggings(0.085f)
+	, m_DropChanceBoots(0.085f)
+	, m_CanPickUpLoot(true)
 	, m_BurnsInDaylight(false)
 {
 	if (!a_ConfigName.empty())
@@ -110,11 +109,119 @@ void cMonster::SpawnOn(cClientHandle & a_Client)
 
 
 
-void cMonster::MoveToPosition( const Vector3f & a_Position )
+void cMonster::TickPathFinding()
+{
+	const int PosX = (int)floor(GetPosX());
+	const int PosY = (int)floor(GetPosY());
+	const int PosZ = (int)floor(GetPosZ());
+
+	m_FinalDestination.y = (double)FindFirstNonAirBlockPosition(m_FinalDestination.x, m_FinalDestination.z);
+
+	std::vector<Vector3d> m_PotentialCoordinates;
+	m_TraversedCoordinates.push_back(Vector3i(PosX, PosY, PosZ));
+
+	static const struct // Define which directions to try to move to
+	{
+		int x, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0},
+		{-1, 0},
+		{ 0, 1},
+		{ 0,-1},
+	} ;
+	
+	if ((PosY - 1 < 0) || (PosY + 2 > cChunkDef::Height) /* PosY + 1 will never be true if PosY + 2 is not */)
+	{
+		// Too low/high, can't really do anything
+		FinishPathFinding();
+		return;
+	}
+
+	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
+	{
+		if (IsCoordinateInTraversedList(Vector3i(gCrossCoords[i].x + PosX, PosY, gCrossCoords[i].z + PosZ)))
+		{
+			continue;
+		}
+
+		BLOCKTYPE BlockAtY = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY, gCrossCoords[i].z + PosZ);
+		BLOCKTYPE BlockAtYP = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY + 1, gCrossCoords[i].z + PosZ);
+		BLOCKTYPE BlockAtYPP = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY + 2, gCrossCoords[i].z + PosZ);
+		BLOCKTYPE BlockAtYM = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY - 1, gCrossCoords[i].z + PosZ);
+
+		if ((!cBlockInfo::IsSolid(BlockAtY)) && (!cBlockInfo::IsSolid(BlockAtYP)) && (!IsBlockLava(BlockAtYM)) && (BlockAtY != E_BLOCK_FENCE) && (BlockAtY != E_BLOCK_FENCE_GATE))
+		{
+			m_PotentialCoordinates.push_back(Vector3d((gCrossCoords[i].x + PosX), PosY, gCrossCoords[i].z + PosZ));
+		}
+		else if ((cBlockInfo::IsSolid(BlockAtY)) && (!cBlockInfo::IsSolid(BlockAtYP)) && (!cBlockInfo::IsSolid(BlockAtYPP)) && (!IsBlockLava(BlockAtYM)) && (BlockAtY != E_BLOCK_FENCE) && (BlockAtY != E_BLOCK_FENCE_GATE))
+		{
+			m_PotentialCoordinates.push_back(Vector3d((gCrossCoords[i].x + PosX), PosY + 1, gCrossCoords[i].z + PosZ));
+		}
+	}
+
+	if (!m_PotentialCoordinates.empty())
+	{
+		Vector3f ShortestCoords = m_PotentialCoordinates.front();
+		for (std::vector<Vector3d>::const_iterator itr = m_PotentialCoordinates.begin(); itr != m_PotentialCoordinates.end(); ++itr)
+		{
+			Vector3f Distance = m_FinalDestination - ShortestCoords;
+			Vector3f Distance2 = m_FinalDestination - *itr;
+			if (Distance.SqrLength() > Distance2.SqrLength())
+			{
+				ShortestCoords = *itr;
+			}
+		}
+
+		m_Destination = ShortestCoords;
+		m_Destination.z += 0.5f;
+		m_Destination.x += 0.5f;
+	}
+	else
+	{
+		FinishPathFinding();
+	}
+}
+
+
+
+
+
+void cMonster::MoveToPosition(const Vector3f & a_Position)
 {
+	FinishPathFinding();
+
+	m_FinalDestination = a_Position;
 	m_bMovingToDestination = true;
+	TickPathFinding();
+}
 
-	m_Destination = a_Position;
+
+
+
+
+void cMonster::MoveToPosition(const Vector3d & a_Position)
+{
+	FinishPathFinding();
+
+	m_FinalDestination = a_Position;
+	m_bMovingToDestination = true;
+	TickPathFinding();
+}
+
+
+
+bool cMonster::IsCoordinateInTraversedList(Vector3i a_Coords)
+{
+	for (std::vector<Vector3i>::const_iterator itr = m_TraversedCoordinates.begin(); itr != m_TraversedCoordinates.end(); ++itr)
+	{
+		if (itr->Equals(a_Coords))
+		{
+			return true;
+		}
+	}
+
+	return false;
 }
 
 
@@ -123,9 +230,10 @@ void cMonster::MoveToPosition( const Vector3f & a_Position )
 
 bool cMonster::ReachedDestination()
 {
-	Vector3f Distance = (m_Destination) - GetPosition();
-	if( Distance.SqrLength() < 2.f )
+	if ((m_Destination - GetPosition()).Length() < 0.5f)
+	{
 		return true;
+	}
 
 	return false;
 }
@@ -133,6 +241,19 @@ bool cMonster::ReachedDestination()
 
 
 
+bool cMonster::ReachedFinalDestination()
+{
+	if ((GetPosition() - m_FinalDestination).Length() <= m_AttackRange)
+	{
+		return true;
+	}
+	
+	return false;
+}
+
+
+
+
 
 void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 {
@@ -149,25 +270,35 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 		return;
 	}
 
+	if ((m_Target != NULL) && m_Target->IsDestroyed())
+		m_Target = NULL;
+
 	// Burning in daylight
 	HandleDaylightBurning(a_Chunk);
-	
-	HandlePhysics(a_Dt,a_Chunk);
-	BroadcastMovementUpdate();
 
 	a_Dt /= 1000;
 
 	if (m_bMovingToDestination)
 	{
-		Vector3f Pos( GetPosition() );
-		Vector3f Distance = m_Destination - Pos;
-		if( !ReachedDestination() )
+		if (m_bOnGround)
+		{
+			m_Destination.y = FindFirstNonAirBlockPosition(m_Destination.x, m_Destination.z);
+
+			if (DoesPosYRequireJump((int)floor(m_Destination.y)))
+			{
+				m_bOnGround = false;
+				AddPosY(1.5); // Jump!!
+			}
+		}
+
+		Vector3f Distance = m_Destination - GetPosition();
+		if(!ReachedDestination() && !ReachedFinalDestination()) // If we haven't reached any sort of destination, move
 		{
 			Distance.y = 0;
 			Distance.Normalize();
-			Distance *= 3;
-			SetSpeedX( Distance.x );
-			SetSpeedZ( Distance.z );
+			Distance *= 5;
+			SetSpeedX(Distance.x);
+			SetSpeedZ(Distance.z);
 
 			if (m_EMState == ESCAPING)
 			{	//Runs Faster when escaping :D otherwise they just walk away
@@ -177,40 +308,19 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 		}
 		else
 		{
-			m_bMovingToDestination = false;
-		}
-
-		if( GetSpeed().SqrLength() > 0.f )
-		{
-			if( m_bOnGround )
+			if (ReachedFinalDestination()) // If we have reached the ultimate, final destination, stop pathfinding and attack if appropriate
+			{
+				FinishPathFinding();
+			}
+			else
 			{
-				Vector3f NormSpeed = Vector3f(GetSpeed()).NormalizeCopy();
-				Vector3f NextBlock = Vector3f( GetPosition() ) + NormSpeed;
-				int NextHeight;
-				if (!m_World->TryGetHeight((int)NextBlock.x, (int)NextBlock.z, NextHeight))
-				{
-					// The chunk at NextBlock is not loaded
-					return;
-				}
-				if( NextHeight > (GetPosY() - 1.0) && (NextHeight - GetPosY()) < 2.5 )
-				{
-					m_bOnGround = false;
-					SetSpeedY(5.f); // Jump!!
-				}
+				TickPathFinding(); // We have reached the next point in our path, calculate another point
 			}
 		}
 	}
 
-	Vector3d Distance = m_Destination - GetPosition();
-	if (Distance.SqrLength() > 0.1f)
-	{
-		double Rotation, Pitch;
-		Distance.Normalize();
-		VectorToEuler( Distance.x, Distance.y, Distance.z, Rotation, Pitch );
-		SetHeadYaw (Rotation);
-		SetYaw( Rotation );
-		SetPitch( -Pitch );
-	}
+	SetPitchAndYawFromDestination();
+	HandleFalling();
 
 	switch (m_EMState)
 	{
@@ -219,21 +329,113 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 			// If enemy passive we ignore checks for player visibility
 			InStateIdle(a_Dt);
 			break;
-		}
-	
+		}	
 		case CHASING:
 		{
 			// If we do not see a player anymore skip chasing action
 			InStateChasing(a_Dt);
 			break;
-		}
-	
+		}	
 		case ESCAPING:
 		{
 			InStateEscaping(a_Dt);
 			break;
 		}
 	}  // switch (m_EMState)
+
+	BroadcastMovementUpdate();
+}
+
+
+
+
+void cMonster::SetPitchAndYawFromDestination()
+{
+	Vector3d FinalDestination = m_FinalDestination;
+	if (m_Target != NULL)
+	{
+		if (m_Target->IsPlayer())
+		{
+			FinalDestination.y = ((cPlayer *)m_Target)->GetStance();
+		}
+		else
+		{
+			FinalDestination.y = GetHeight();
+		}
+	}
+
+	Vector3d Distance = FinalDestination - GetPosition();
+	if (Distance.SqrLength() > 0.1f)
+	{
+		{
+			double Rotation, Pitch;
+			Distance.Normalize();
+			VectorToEuler(Distance.x, Distance.y, Distance.z, Rotation, Pitch);
+			SetHeadYaw(Rotation);
+			SetPitch(-Pitch);
+		}
+
+		{
+			Vector3d BodyDistance = m_Destination - GetPosition();
+			double Rotation, Pitch;
+			Distance.Normalize();
+			VectorToEuler(BodyDistance.x, BodyDistance.y, BodyDistance.z, Rotation, Pitch);
+			SetYaw(Rotation);
+		}
+	}
+}
+
+
+
+
+void cMonster::HandleFalling()
+{
+	if (m_bOnGround)
+	{
+		int Damage = (m_LastGroundHeight - POSY_TOINT) - 3;
+
+		if (Damage > 0)
+		{
+			TakeDamage(dtFalling, NULL, Damage, Damage, 0);
+
+			// Fall particles
+			GetWorld()->BroadcastSoundParticleEffect(2006, POSX_TOINT, POSY_TOINT - 1, POSZ_TOINT, Damage /* Used as particle effect speed modifier */);
+		}
+
+		m_LastGroundHeight = (int)floor(GetPosY());
+	}
+}
+
+
+
+
+int cMonster::FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ)
+{
+	int PosY = (int)floor(GetPosY());
+
+	if (PosY < 0)
+		PosY = 0;
+	else if (PosY > cChunkDef::Height)
+		PosY = cChunkDef::Height;
+
+	if (!cBlockInfo::IsSolid(m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))))
+	{
+		while (!cBlockInfo::IsSolid(m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))) && (PosY > 0))
+		{
+			PosY--;
+		}
+
+		return PosY + 1;
+	}
+	else
+	{
+		while (cBlockInfo::IsSolid(m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))) && (PosY < cChunkDef::Height))
+		{
+			PosY++;
+		}
+
+		return PosY;
+	}
 }
 
 
@@ -244,11 +446,13 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
 void cMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
 {
 	super::DoTakeDamage(a_TDI);
-	if((m_SoundHurt != "") && (m_Health > 0)) m_World->BroadcastSoundEffect(m_SoundHurt, (int)(GetPosX() * 8), (int)(GetPosY() * 8), (int)(GetPosZ() * 8), 1.0f, 0.8f);
+
+	if((m_SoundHurt != "") && (m_Health > 0))
+		m_World->BroadcastSoundEffect(m_SoundHurt, (int)(GetPosX() * 8), (int)(GetPosY() * 8), (int)(GetPosZ() * 8), 1.0f, 0.8f);
+
 	if (a_TDI.Attacker != NULL)
 	{
 		m_Target = a_TDI.Attacker;
-		AddReference(m_Target);
 	}
 }
 
@@ -330,55 +534,12 @@ void cMonster::KilledBy(cEntity * a_Killer)
 
 
 
-//----State Logic
-
-const char *cMonster::GetState()
-{
-	switch(m_EMState)
-	{
-		case IDLE:      return "Idle";
-		case ATTACKING: return "Attacking";
-		case CHASING:   return "Chasing";
-		default:        return "Unknown";
-	}
-}
-
-
-
-
-
-// for debugging
-void cMonster::SetState(const AString & a_State)
-{
-	if (a_State.compare("Idle") == 0)
-	{
-		m_EMState = IDLE;
-	}
-	else if (a_State.compare("Attacking") == 0)
-	{
-		m_EMState = ATTACKING;
-	}
-	else if (a_State.compare("Chasing") == 0)
-	{
-		m_EMState = CHASING;
-	}
-	else
-	{
-		LOGD("cMonster::SetState(): Invalid state");
-		ASSERT(!"Invalid state");
-	}
-}
-
-
-
-
-
 //Checks to see if EventSeePlayer should be fired
 //monster sez: Do I see the player
 void cMonster::CheckEventSeePlayer(void)
 {
 	// TODO: Rewrite this to use cWorld's DoWithPlayers()
-	cPlayer * Closest = FindClosestPlayer();
+	cPlayer * Closest = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance, false);
 
 	if (Closest != NULL)
 	{
@@ -391,14 +552,10 @@ void cMonster::CheckEventSeePlayer(void)
 
 
 void cMonster::CheckEventLostPlayer(void)
-{
-	Vector3f pos;
-	cTracer LineOfSight(GetWorld());
-	
+{	
 	if (m_Target != NULL)
 	{
-		pos = m_Target->GetPosition();
-		if ((pos - GetPosition()).Length() > m_SightDistance || LineOfSight.Trace(GetPosition(),(pos - GetPosition()), (int)(pos - GetPosition()).Length()))
+		if ((m_Target->GetPosition() - GetPosition()).Length() > m_SightDistance)
 		{
 			EventLosePlayer();
 		}
@@ -418,7 +575,6 @@ void cMonster::CheckEventLostPlayer(void)
 void cMonster::EventSeePlayer(cEntity * a_SeenPlayer)
 {
 	m_Target = a_SeenPlayer;
-	AddReference(m_Target);
 }
 
 
@@ -427,7 +583,6 @@ void cMonster::EventSeePlayer(cEntity * a_SeenPlayer)
 
 void cMonster::EventLosePlayer(void)
 {
-	Dereference(m_Target);
 	m_Target = NULL;
 	m_EMState = IDLE;
 }
@@ -436,28 +591,35 @@ void cMonster::EventLosePlayer(void)
 
 
 
-// What to do if in Idle State
 void cMonster::InStateIdle(float a_Dt)
 {
+	if (m_bMovingToDestination)
+	{
+		return; // Still getting there
+	}
+
 	m_IdleInterval += a_Dt;
+
 	if (m_IdleInterval > 1)
 	{
-		// at this interval the results are predictable
+		// At this interval the results are predictable
 		int rem = m_World->GetTickRandomNumber(6) + 1;
-		// LOGD("Moving: int: %3.3f rem: %i",idle_interval,rem);
-		m_IdleInterval -= 1;		// So nothing gets dropped when the server hangs for a few seconds
-		Vector3f Dist;
-		Dist.x = (float)(m_World->GetTickRandomNumber(10) - 5);
-		Dist.z = (float)(m_World->GetTickRandomNumber(10) - 5);
+		m_IdleInterval -= 1; // So nothing gets dropped when the server hangs for a few seconds
+
+		Vector3d Dist;
+		Dist.x = (double)m_World->GetTickRandomNumber(10) - 5;
+		Dist.z = (double)m_World->GetTickRandomNumber(10) - 5;
+
 		if ((Dist.SqrLength() > 2)  && (rem >= 3))
 		{
-			m_Destination.x = (float)(GetPosX() + Dist.x);
-			m_Destination.z = (float)(GetPosZ() + Dist.z);
-			int PosY;
-			if (m_World->TryGetHeight((int)m_Destination.x, (int)m_Destination.z, PosY))
+			Vector3d Destination(GetPosX() + Dist.x, 0, GetPosZ() + Dist.z);
+
+			int NextHeight = FindFirstNonAirBlockPosition(Destination.x, Destination.z);
+
+			if (IsNextYPosReachable(NextHeight))
 			{
-				m_Destination.y = (float)PosY + 1.2f;
-				MoveToPosition(m_Destination);
+				Destination.y = NextHeight;
+				MoveToPosition(Destination);
 			}
 		}
 	}
@@ -500,33 +662,6 @@ void cMonster::InStateEscaping(float a_Dt)
 
 
 
-// Do attack here
-// a_Dt is passed so we can set attack rate
-void cMonster::Attack(float a_Dt)
-{
-	m_AttackInterval += a_Dt * m_AttackRate;
-    if ((m_Target != NULL) && (m_AttackInterval > 3.0))
-    {
-        // Setting this higher gives us more wiggle room for attackrate
-        m_AttackInterval = 0.0;
-        ((cPawn *)m_Target)->TakeDamage(*this);
-    }
-}
-
-
-
-
-
-// Checks for Players close by and if they are visible return the closest
-cPlayer * cMonster::FindClosestPlayer(void)
-{
-	return m_World->FindClosestPlayer(GetPosition(), m_SightDistance);
-}
-
-
-
-
-
 void cMonster::GetMonsterConfig(const AString & a_Name)
 {
 	cRoot::Get()->GetMonsterConfig()->AssignAttributes(this, a_Name);
@@ -536,42 +671,6 @@ void cMonster::GetMonsterConfig(const AString & a_Name)
 
 
 
-void cMonster::SetAttackRate(int ar)
-{
-	m_AttackRate = (float)ar;
-}
-
-
-
-
-
-void cMonster::SetAttackRange(float ar)
-{
-	m_AttackRange = ar;
-}
-
-
-
-
-
-void cMonster::SetAttackDamage(float ad)
-{
-	m_AttackDamage = ad;
-}
-
-
-
-
-
-void cMonster::SetSightDistance(float sd)
-{
-	m_SightDistance = sd;
-}
-
-
-
-
-
 AString cMonster::MobTypeToString(cMonster::eType a_MobType)
 {
 	// Mob types aren't sorted, so we need to search linearly:
@@ -635,6 +734,8 @@ cMonster::eType cMonster::StringToMobType(const AString & a_Name)
 
 cMonster::eFamily cMonster::FamilyFromType(eType a_Type)
 {
+	// Passive-agressive mobs are counted in mob spawning code as passive
+
 	switch (a_Type)
 	{
 		case mtBat:          return mfAmbient;
@@ -659,6 +760,7 @@ cMonster::eFamily cMonster::FamilyFromType(eType a_Type)
 		case mtSquid:        return mfWater;
 		case mtVillager:     return mfPassive;
 		case mtWitch:        return mfHostile;
+		case mtWither:       return mfHostile;
 		case mtWolf:         return mfHostile;
 		case mtZombie:       return mfHostile;
 		case mtZombiePigman: return mfHostile;
@@ -699,7 +801,7 @@ cMonster * cMonster::NewMonsterFromType(cMonster::eType a_MobType)
 		case mtMagmaCube:
 		case mtSlime:
 		{
-			toReturn = new cSlime    (Random.NextInt(2) + 1);
+			toReturn = new cSlime(Random.NextInt(2) + 1);
 			break;
 		}
 		case mtSkeleton:
@@ -787,6 +889,76 @@ void cMonster::AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned
 
 
 
+void cMonster::AddRandomUncommonDropItem(cItems & a_Drops, float a_Chance, short a_Item, short a_ItemHealth)
+{
+	MTRand r1;
+	int Count = r1.randInt() % 1000;
+	if (Count < (a_Chance * 10))
+	{
+		a_Drops.push_back(cItem(a_Item, 1, a_ItemHealth));
+	}
+}
+
+
+
+
+
+void cMonster::AddRandomRareDropItem(cItems & a_Drops, cItems & a_Items, short a_LootingLevel)
+{
+	MTRand r1;
+	int Count = r1.randInt() % 200;
+	if (Count < (5 + a_LootingLevel))
+	{
+		int Rare = r1.randInt() % a_Items.Size();
+		a_Drops.push_back(a_Items.at(Rare));
+	}
+}
+
+
+
+
+
+void cMonster::AddRandomArmorDropItem(cItems & a_Drops, short a_LootingLevel)
+{
+	MTRand r1;
+	if (r1.randInt() % 200 < ((m_DropChanceHelmet * 200) + (a_LootingLevel * 2)))
+	{
+		if (!GetEquippedHelmet().IsEmpty()) a_Drops.push_back(GetEquippedHelmet());
+	}
+	
+	if (r1.randInt() % 200 < ((m_DropChanceChestplate * 200) + (a_LootingLevel * 2)))
+	{
+		if (!GetEquippedChestplate().IsEmpty()) a_Drops.push_back(GetEquippedChestplate());
+	}
+	
+	if (r1.randInt() % 200 < ((m_DropChanceLeggings * 200) + (a_LootingLevel * 2)))
+	{
+		if (!GetEquippedLeggings().IsEmpty()) a_Drops.push_back(GetEquippedLeggings());
+	}
+	
+	if (r1.randInt() % 200 < ((m_DropChanceBoots * 200) + (a_LootingLevel * 2)))
+	{
+		if (!GetEquippedBoots().IsEmpty()) a_Drops.push_back(GetEquippedBoots());
+	}
+}
+
+
+
+
+
+void cMonster::AddRandomWeaponDropItem(cItems & a_Drops, short a_LootingLevel)
+{
+	MTRand r1;
+	if (r1.randInt() % 200 < ((m_DropChanceWeapon * 200) + (a_LootingLevel * 2)))
+	{
+		if (!GetEquippedWeapon().IsEmpty()) a_Drops.push_back(GetEquippedWeapon());
+	}
+}
+
+
+
+
+
 void cMonster::HandleDaylightBurning(cChunk & a_Chunk)
 {
 	if (!m_BurnsInDaylight)
@@ -803,6 +975,13 @@ void cMonster::HandleDaylightBurning(cChunk & a_Chunk)
 	
 	int RelX = (int)floor(GetPosX()) - GetChunkX() * cChunkDef::Width;
 	int RelZ = (int)floor(GetPosZ()) - GetChunkZ() * cChunkDef::Width;
+
+	if (!a_Chunk.IsLightValid())
+	{
+		m_World->QueueLightChunk(GetChunkX(), GetChunkZ());
+		return;
+	}
+
 	if (
 		(a_Chunk.GetSkyLight(RelX, RelY, RelZ) == 15) &&             // In the daylight
 		(a_Chunk.GetBlock(RelX, RelY, RelZ) != E_BLOCK_SOULSAND) &&  // Not on soulsand
diff --git a/src/Mobs/Monster.h b/src/Mobs/Monster.h
index dafb33574..776426a0d 100644
--- a/src/Mobs/Monster.h
+++ b/src/Mobs/Monster.h
@@ -5,12 +5,12 @@
 #include "../Defines.h"
 #include "../BlockID.h"
 #include "../Item.h"
+#include "../Enchantments.h"
 
 
 
 
 
-class Vector3f;
 class cClientHandle;
 class cWorld;
 
@@ -74,8 +74,6 @@ public:
 	enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState;
 	enum MPersonality{PASSIVE,AGGRESSIVE,COWARDLY} m_EMPersonality;
 	
-	float m_SightDistance;
-	
 	/** Creates the mob object.
 	* If a_ConfigName is not empty, the configuration is loaded using GetMonsterConfig()
 	* a_MobType is the type of the mob (also used in the protocol ( http://wiki.vg/Entities#Mobs , 2012_12_22))
@@ -94,20 +92,16 @@ public:
 	virtual void KilledBy(cEntity * a_Killer) override;
 
 	virtual void MoveToPosition(const Vector3f & a_Position);
+	virtual void MoveToPosition(const Vector3d & a_Position); // tolua_export
 	virtual bool ReachedDestination(void);
 	
 	// tolua_begin
 	eType GetMobType(void) const {return m_MobType; }
 	eFamily GetMobFamily(void) const;
 	// tolua_end
-
-
-	const char * GetState();
-	void SetState(const AString & str);
 	
 	virtual void CheckEventSeePlayer(void);
 	virtual void EventSeePlayer(cEntity * a_Player);
-	virtual cPlayer * FindClosestPlayer();		// non static is easier. also virtual so other mobs can implement their own searching algo 
 	
 	/// Reads the monster configuration for the specified monster name and assigns it to this object.
 	void GetMonsterConfig(const AString & a_Name);
@@ -119,13 +113,24 @@ public:
 	virtual void InStateChasing (float a_Dt);
 	virtual void InStateEscaping(float a_Dt);
 	
-	virtual void Attack(float a_Dt);
+	int GetAttackRate() { return (int)m_AttackRate; }
+	void SetAttackRate(float a_AttackRate) { m_AttackRate = a_AttackRate; }
+	void SetAttackRange(int a_AttackRange) { m_AttackRange = a_AttackRange; }
+	void SetAttackDamage(int a_AttackDamage) { m_AttackDamage = a_AttackDamage; }
+	void SetSightDistance(int a_SightDistance) { m_SightDistance = a_SightDistance; }
 	
-	int GetAttackRate(){return (int)m_AttackRate;}
-	void SetAttackRate(int ar);
-	void SetAttackRange(float ar);
-	void SetAttackDamage(float ad);
-	void SetSightDistance(float sd);
+	float GetDropChanceWeapon() { return m_DropChanceWeapon; }
+	float GetDropChanceHelmet() { return m_DropChanceHelmet; }
+	float GetDropChanceChestplate() { return m_DropChanceChestplate; }
+	float GetDropChanceLeggings() { return m_DropChanceLeggings; }
+	float GetDropChanceBoots() { return m_DropChanceBoots; }
+	bool CanPickUpLoot() { return m_CanPickUpLoot; }
+	void SetDropChanceWeapon(float a_DropChanceWeapon) { m_DropChanceWeapon = a_DropChanceWeapon; }
+	void SetDropChanceHelmet(float a_DropChanceHelmet) { m_DropChanceHelmet = a_DropChanceHelmet; }
+	void SetDropChanceChestplate(float a_DropChanceChestplate) { m_DropChanceChestplate = a_DropChanceChestplate; }
+	void SetDropChanceLeggings(float a_DropChanceLeggings) { m_DropChanceLeggings = a_DropChanceLeggings; }
+	void SetDropChanceBoots(float a_DropChanceBoots) { m_DropChanceBoots = a_DropChanceBoots; }
+	void SetCanPickUpLoot(bool a_CanPickUpLoot) { m_CanPickUpLoot = a_CanPickUpLoot; }
 	
 	/// Sets whether the mob burns in daylight. Only evaluated at next burn-decision tick
 	void SetBurnsInDaylight(bool a_BurnsInDaylight) { m_BurnsInDaylight = a_BurnsInDaylight; }
@@ -159,34 +164,101 @@ public:
 
 protected:
 	
-	cEntity * m_Target;
-	float m_AttackRate;
-	float m_IdleInterval;
+	/* ======= PATHFINDING ======= */
 
-	Vector3f m_Destination;
+	/** A pointer to the entity this mobile is aiming to reach */
+	cEntity * m_Target;
+	/** Coordinates of the next position that should be reached */
+	Vector3d m_Destination;
+	/** Coordinates for the ultimate, final destination. */
+	Vector3d m_FinalDestination;
+	/** Returns if the ultimate, final destination has been reached */
+	bool ReachedFinalDestination(void);
+
+	/** Stores if mobile is currently moving towards the ultimate, final destination */
 	bool m_bMovingToDestination;
-	bool m_bPassiveAggressive;
+	/** Finds the first non-air block position (not the highest, as cWorld::GetHeight does)
+		If current Y is nonsolid, goes down to try to find a solid block, then returns that + 1
+		If current Y is solid, goes up to find first nonsolid block, and returns that */
+	int FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ);
+	/** Returns if a monster can actually reach a given height by jumping or walking */
+	inline bool IsNextYPosReachable(int a_PosY)
+	{
+		return (
+			(a_PosY <= (int)floor(GetPosY())) ||
+			DoesPosYRequireJump(a_PosY)
+			);
+	}
+	/** Returns if a monster can reach a given height by jumping */
+	inline bool DoesPosYRequireJump(int a_PosY)
+	{
+		return ((a_PosY > (int)floor(GetPosY())) && (a_PosY == (int)floor(GetPosY()) + 1));
+	}
+
+	/** A semi-temporary list to store the traversed coordinates during active pathfinding so we don't visit them again */
+	std::vector<Vector3i> m_TraversedCoordinates;
+	/** Returns if coordinate is in the traversed list */
+	bool IsCoordinateInTraversedList(Vector3i a_Coords);
+
+	/** Finds the next place to go
+		This is based on the ultimate, final destination and the current position, as well as the traversed coordinates, and any environmental hazards */
+	void TickPathFinding(void);
+	/** Finishes a pathfinding task, be it due to failure or something else */
+	inline void FinishPathFinding(void)
+	{
+		m_TraversedCoordinates.clear();
+		m_bMovingToDestination = false;
+	}
+	/** Sets the body yaw and head yaw/pitch based on next/ultimate destinations */
+	void SetPitchAndYawFromDestination(void);
+
+	/* =========================== */
+	/* ========= FALLING ========= */
 
-	float m_DestinationTime;
+	virtual void HandleFalling(void);
+	int m_LastGroundHeight;
 
+	/* =========================== */
+
+	float m_IdleInterval;
 	float m_DestroyTimer;
-	float m_Jump;
 
 	eType m_MobType;
 
 	AString m_SoundHurt;
 	AString m_SoundDeath;
 
-	float m_SeePlayerInterval;
-	float m_AttackDamage;
-	float m_AttackRange;
+	float m_AttackRate;	
+	int m_AttackDamage;
+	int m_AttackRange;
 	float m_AttackInterval;
+	int m_SightDistance;
+	
+	float m_DropChanceWeapon;
+	float m_DropChanceHelmet;
+	float m_DropChanceChestplate;
+	float m_DropChanceLeggings;
+	float m_DropChanceBoots;
+	bool m_CanPickUpLoot;
 	
+	void HandleDaylightBurning(cChunk & a_Chunk);
 	bool m_BurnsInDaylight;
 
-	void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0);
+	/** Adds a random number of a_Item between a_Min and a_Max to itemdrops a_Drops*/
+	void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0);	
+	
+	/** Adds a item a_Item with the chance of a_Chance (in percent) to itemdrops a_Drops*/
+	void AddRandomUncommonDropItem(cItems & a_Drops, float a_Chance, short a_Item, short a_ItemHealth = 0);	
+	
+	/** Adds one rare item out of the list of rare items a_Items modified by the looting level a_LootingLevel(I-III or custom) to the itemdrop a_Drops*/
+	void AddRandomRareDropItem(cItems & a_Drops, cItems & a_Items, short a_LootingLevel); 
+	
+	/** Adds armor that is equipped with the chance saved in m_DropChance[...] (this will be greter than 1 if piccked up or 0.085 + (0.01 per LootingLevel) if born with) to the drop*/
+	void AddRandomArmorDropItem(cItems & a_Drops, short a_LootingLevel);
+	
+	/** Adds weapon that is equipped with the chance saved in m_DropChance[...] (this will be greter than 1 if piccked up or 0.085 + (0.01 per LootingLevel) if born with) to the drop*/
+	void AddRandomWeaponDropItem(cItems & a_Drops, short a_LootingLevel);
 	
-	void HandleDaylightBurning(cChunk & a_Chunk);
 
 } ; // tolua_export
 
diff --git a/src/Mobs/Mooshroom.cpp b/src/Mobs/Mooshroom.cpp
index 940e2db44..81bd3e3b4 100644
--- a/src/Mobs/Mooshroom.cpp
+++ b/src/Mobs/Mooshroom.cpp
@@ -2,12 +2,12 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Mooshroom.h"
+#include "../Entities/Player.h"
 
 
 
 
 
-// TODO: Milk Cow
 
 
 
@@ -24,10 +24,52 @@ cMooshroom::cMooshroom(void) :
 
 void cMooshroom::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_LEATHER);
-	AddRandomDropItem(a_Drops, 1, 3, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER);
+	AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF);
 }
 
 
 
 
+
+void cMooshroom::OnRightClicked(cPlayer & a_Player)
+{
+	switch (a_Player.GetEquippedItem().m_ItemType)
+	{
+		case E_ITEM_BUCKET:
+		{
+			if (!a_Player.IsGameModeCreative())
+			{
+				a_Player.GetInventory().RemoveOneEquippedItem();
+				a_Player.GetInventory().AddItem(E_ITEM_MILK);
+			}
+		} break;
+		case E_ITEM_BOWL:
+		{
+			if (!a_Player.IsGameModeCreative())
+			{
+				a_Player.GetInventory().RemoveOneEquippedItem();
+				a_Player.GetInventory().AddItem(E_ITEM_MUSHROOM_SOUP);
+			}
+		} break;
+		case E_ITEM_SHEARS:
+		{
+			if (!a_Player.IsGameModeCreative())
+			{
+				a_Player.UseEquippedItem();
+			}
+
+			cItems Drops;
+			Drops.push_back(cItem(E_BLOCK_RED_MUSHROOM, 5, 0));
+			m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10);
+			m_World->SpawnMob(GetPosX(), GetPosY(), GetPosZ(), cMonster::mtCow);
+			Destroy();
+		} break;
+	}
+}
+
diff --git a/src/Mobs/Mooshroom.h b/src/Mobs/Mooshroom.h
index 73f6348b6..16f6c8248 100644
--- a/src/Mobs/Mooshroom.h
+++ b/src/Mobs/Mooshroom.h
@@ -18,6 +18,9 @@ public:
 	CLASS_PROTODEF(cMooshroom);
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void OnRightClicked(cPlayer & a_Player) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
 } ;
 
 
diff --git a/src/Mobs/PassiveAggressiveMonster.cpp b/src/Mobs/PassiveAggressiveMonster.cpp
index 28de65905..4b45f9a2a 100644
--- a/src/Mobs/PassiveAggressiveMonster.cpp
+++ b/src/Mobs/PassiveAggressiveMonster.cpp
@@ -25,8 +25,7 @@ void cPassiveAggressiveMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
 	
 	if ((m_Target != NULL) && (m_Target->IsPlayer()))
 	{
-		cPlayer * Player = (cPlayer *) m_Target;
-		if (Player->GetGameMode() != 1)
+		if (!((cPlayer *)m_Target)->IsGameModeCreative())
 		{
 			m_EMState = CHASING;
 		}
diff --git a/src/Mobs/PassiveMonster.cpp b/src/Mobs/PassiveMonster.cpp
index 91ceb5a53..904cd63cc 100644
--- a/src/Mobs/PassiveMonster.cpp
+++ b/src/Mobs/PassiveMonster.cpp
@@ -2,9 +2,8 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "PassiveMonster.h"
-#include "../MersenneTwister.h"
 #include "../World.h"
-
+#include "../Entities/Player.h"
 
 
 
@@ -36,19 +35,22 @@ void cPassiveMonster::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	super::Tick(a_Dt, a_Chunk);
 
-	m_SeePlayerInterval += a_Dt;
-
-	if (m_SeePlayerInterval > 1)  // Check every second
+	if (m_EMState == ESCAPING)
 	{
-		int rem = m_World->GetTickRandomNumber(3) + 1;  // Check most of the time but miss occasionally
-
-		m_SeePlayerInterval = 0.0;
-		if (rem >= 2)
+		CheckEventLostPlayer();
+	}
+	cItem FollowedItem = GetFollowedItem();
+	if (FollowedItem.IsEmpty())
+	{
+		return;
+	}
+	cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance);
+	if (a_Closest_Player != NULL)
+	{
+		if (a_Closest_Player->GetEquippedItem().IsEqual(FollowedItem))
 		{
-			if (m_EMState == ESCAPING)
-			{
-				CheckEventLostPlayer();
-			} 
+			Vector3d PlayerPos = a_Closest_Player->GetPosition();
+			MoveToPosition(PlayerPos);
 		}
 	}
 }
diff --git a/src/Mobs/PassiveMonster.h b/src/Mobs/PassiveMonster.h
index 14a6be6b1..0b3c155da 100644
--- a/src/Mobs/PassiveMonster.h
+++ b/src/Mobs/PassiveMonster.h
@@ -19,6 +19,9 @@ public:
 
 	/// When hit by someone, run away
 	virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
+	/** Returns the item that the animal of this class follows when a player holds it in hand
+	Return an empty item not to follow (default). */
+	virtual const cItem GetFollowedItem(void) const { return cItem(); }
 
 } ;
 
diff --git a/src/Mobs/Pig.cpp b/src/Mobs/Pig.cpp
index 0871a38a9..e862f5aaa 100644
--- a/src/Mobs/Pig.cpp
+++ b/src/Mobs/Pig.cpp
@@ -21,7 +21,12 @@ cPig::cPig(void) :
 
 void cPig::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 1, 3, IsOnFire() ? E_ITEM_COOKED_PORKCHOP : E_ITEM_RAW_PORKCHOP);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_COOKED_PORKCHOP : E_ITEM_RAW_PORKCHOP);
 	if (m_bIsSaddled)
 	{
 		a_Drops.push_back(cItem(E_ITEM_SADDLE, 1));
@@ -73,5 +78,3 @@ void cPig::OnRightClicked(cPlayer & a_Player)
 
 
 
-
-
diff --git a/src/Mobs/Pig.h b/src/Mobs/Pig.h
index 4fd0d8db8..d434324c1 100644
--- a/src/Mobs/Pig.h
+++ b/src/Mobs/Pig.h
@@ -19,6 +19,9 @@ public:
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_CARROT); }
+
 	bool IsSaddled(void) const { return m_bIsSaddled; }
 
 private:
diff --git a/src/Mobs/Sheep.cpp b/src/Mobs/Sheep.cpp
index bda4ccff8..c64360153 100644
--- a/src/Mobs/Sheep.cpp
+++ b/src/Mobs/Sheep.cpp
@@ -13,7 +13,8 @@
 cSheep::cSheep(int a_Color) :
 	super("Sheep", mtSheep, "mob.sheep.say", "mob.sheep.say", 0.6, 1.3),
 	m_IsSheared(false),
-	m_WoolColor(a_Color)
+	m_WoolColor(a_Color),
+	m_TimeToStopEating(-1)
 {
 }
 
@@ -60,3 +61,50 @@ void cSheep::OnRightClicked(cPlayer & a_Player)
 		m_World->BroadcastEntityMetadata(*this);
 	}
 }
+
+
+
+
+
+void cSheep::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	super::Tick(a_Dt, a_Chunk);
+	int PosX = POSX_TOINT;
+	int PosY = POSY_TOINT - 1;
+	int PosZ = POSZ_TOINT;
+
+	if ((PosY <= 0) || (PosY > cChunkDef::Height))
+	{
+		return;
+	}
+
+	if (m_TimeToStopEating > 0)
+	{
+		m_bMovingToDestination = false; // The sheep should not move when he's eating
+		m_TimeToStopEating--;
+
+		if (m_TimeToStopEating == 0)
+		{
+			if (m_World->GetBlock(PosX, PosY, PosZ) == E_BLOCK_GRASS) // Make sure grass hasn't been destroyed in the meantime
+			{
+				// The sheep ate the grass so we change it to dirt
+				m_World->SetBlock(PosX, PosY, PosZ, E_BLOCK_DIRT, 0);
+				GetWorld()->BroadcastSoundParticleEffect(2001, PosX, PosY, PosX, E_BLOCK_GRASS);
+				m_IsSheared = false;
+				m_World->BroadcastEntityMetadata(*this);
+			}
+		}
+	}
+	else
+	{
+		if (m_World->GetTickRandomNumber(600) == 1)
+		{
+			if (m_World->GetBlock(PosX, PosY, PosZ) == E_BLOCK_GRASS)
+			{
+				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_SHEEP_EATING);
+				m_TimeToStopEating = 40;
+			}
+		}
+	}
+}
+
diff --git a/src/Mobs/Sheep.h b/src/Mobs/Sheep.h
index 8293a2c05..402e8e61c 100644
--- a/src/Mobs/Sheep.h
+++ b/src/Mobs/Sheep.h
@@ -19,6 +19,10 @@ public:
 	
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
+
 	bool IsSheared(void) const { return m_IsSheared; }
 	int GetFurColor(void) const { return m_WoolColor; }
 
@@ -26,6 +30,7 @@ private:
 	
 	bool m_IsSheared;
 	int m_WoolColor;
+	int m_TimeToStopEating;
 
 } ;
 
diff --git a/src/Mobs/Skeleton.cpp b/src/Mobs/Skeleton.cpp
index 509c2191e..1685f40c5 100644
--- a/src/Mobs/Skeleton.cpp
+++ b/src/Mobs/Skeleton.cpp
@@ -20,8 +20,26 @@ cSkeleton::cSkeleton(bool IsWither) :
 
 void cSkeleton::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_ARROW);
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_BONE);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	if (IsWither())
+	{
+		AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_COAL);
+		cItems RareDrops;
+		RareDrops.Add(cItem(E_ITEM_HEAD, 1, 1));
+		AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel);
+	}
+	else
+	{
+		AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_ARROW);
+		
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_BONE);
+	AddRandomArmorDropItem(a_Drops, LootingLevel);
+	AddRandomWeaponDropItem(a_Drops, LootingLevel);
 }
 
 
@@ -30,15 +48,18 @@ void cSkeleton::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 
 void cSkeleton::MoveToPosition(const Vector3f & a_Position)
 {
-	m_Destination = a_Position;
-
 	// If the destination is in the sun and if it is not night AND the skeleton isn't on fire then block the movement.
-	if (!IsOnFire() && m_World->GetTimeOfDay() < 13187 && m_World->GetBlockSkyLight((int) a_Position.x, (int) a_Position.y, (int) a_Position.z) == 15)
+	if (
+		!IsOnFire() &&
+		(m_World->GetTimeOfDay() < 13187) &&
+		(m_World->GetBlockSkyLight((int) a_Position.x, (int) a_Position.y, (int) a_Position.z) == 15)
+		)
 	{
 		m_bMovingToDestination = false;
 		return;
 	}
-	m_bMovingToDestination = true;
+
+	super::MoveToPosition(a_Position);
 }
 
 
@@ -67,4 +88,4 @@ void cSkeleton::Attack(float a_Dt)
 		m_World->BroadcastSpawnEntity(*Arrow);
 		m_AttackInterval = 0.0;
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Mobs/Slime.cpp b/src/Mobs/Slime.cpp
index 19f376c21..52a52bb39 100644
--- a/src/Mobs/Slime.cpp
+++ b/src/Mobs/Slime.cpp
@@ -20,8 +20,15 @@ cSlime::cSlime(int a_Size) :
 
 void cSlime::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	// TODO: only when tiny
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_SLIMEBALL);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	if (GetSize() == 1)
+	{
+		AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_SLIMEBALL);
+	}
 }
 
 
diff --git a/src/Mobs/SnowGolem.cpp b/src/Mobs/SnowGolem.cpp
index 06021cca5..c1979a495 100644
--- a/src/Mobs/SnowGolem.cpp
+++ b/src/Mobs/SnowGolem.cpp
@@ -19,7 +19,8 @@ cSnowGolem::cSnowGolem(void) :
 
 void cSnowGolem::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 5, E_ITEM_SNOWBALL);
+	UNUSED(a_Killer);
+	AddRandomDropItem(a_Drops, 0, 15, E_ITEM_SNOWBALL);
 }
 
 
@@ -29,7 +30,7 @@ void cSnowGolem::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 void cSnowGolem::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	super::Tick(a_Dt, a_Chunk);
-	if (IsBiomeNoDownfall((EMCSBiome) m_World->GetBiomeAt((int) floor(GetPosX()), (int) floor(GetPosZ())) ))
+	if (IsBiomeNoDownfall(m_World->GetBiomeAt((int) floor(GetPosX()), (int) floor(GetPosZ())) ))
 	{
 		TakeDamage(*this);
 	}
@@ -37,7 +38,7 @@ void cSnowGolem::Tick(float a_Dt, cChunk & a_Chunk)
 	{
 		BLOCKTYPE BlockBelow = m_World->GetBlock((int) floor(GetPosX()), (int) floor(GetPosY()) - 1, (int) floor(GetPosZ()));
 		BLOCKTYPE Block = m_World->GetBlock((int) floor(GetPosX()), (int) floor(GetPosY()), (int) floor(GetPosZ()));
-		if (Block == E_BLOCK_AIR && g_BlockIsSolid[BlockBelow])
+		if (Block == E_BLOCK_AIR && cBlockInfo::IsSolid(BlockBelow))
 		{
 			m_World->SetBlock((int) floor(GetPosX()), (int) floor(GetPosY()), (int) floor(GetPosZ()), E_BLOCK_SNOW, 0);
 		}
diff --git a/src/Mobs/Spider.cpp b/src/Mobs/Spider.cpp
index b19a5dcef..8b978ff6b 100644
--- a/src/Mobs/Spider.cpp
+++ b/src/Mobs/Spider.cpp
@@ -18,8 +18,16 @@ cSpider::cSpider(void) :
 
 void cSpider::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_STRING);
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_SPIDER_EYE);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STRING);
+	if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf")))
+	{
+		AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_SPIDER_EYE);
+	}
 }
 
 
diff --git a/src/Mobs/Squid.cpp b/src/Mobs/Squid.cpp
index a311108ae..bd0e141a0 100644
--- a/src/Mobs/Squid.cpp
+++ b/src/Mobs/Squid.cpp
@@ -2,7 +2,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Squid.h"
-#include "../Vector3d.h"
+#include "../Vector3.h"
 #include "../Chunk.h"
 
 
@@ -21,7 +21,12 @@ cSquid::cSquid(void) :
 void cSquid::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
 	// Drops 0-3 Ink Sacs
-	AddRandomDropItem(a_Drops, 0, 3, E_ITEM_DYE, E_META_DYE_BLACK);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 3 + LootingLevel, E_ITEM_DYE, E_META_DYE_BLACK);
 }
 
 
@@ -43,7 +48,8 @@ void cSquid::Tick(float a_Dt, cChunk & a_Chunk)
 	}
 	int RelX = (int)floor(Pos.x) - a_Chunk.GetPosX() * cChunkDef::Width;
 	int RelZ = (int)floor(Pos.z) - a_Chunk.GetPosZ() * cChunkDef::Width;
-	if (!IsBlockWater(a_Chunk.GetBlock(RelX, RelY, RelZ)) && !IsOnFire())
+	BLOCKTYPE BlockType;
+	if (a_Chunk.UnboundedRelGetBlockType(RelX, RelY, RelZ, BlockType) && !IsBlockWater(BlockType) && !IsOnFire())
 	{
 		// Burn for 10 ticks, then decide again
 		StartBurning(10);
diff --git a/src/Mobs/Squid.h b/src/Mobs/Squid.h
index ad299b95c..a9dba8b70 100644
--- a/src/Mobs/Squid.h
+++ b/src/Mobs/Squid.h
@@ -21,6 +21,9 @@ public:
 	
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 
+	// Squids do not drown (or float)
+	virtual void HandleAir(void) override {}
+	virtual void SetSwimState(cChunk & a_Chunk) override {}
 } ;
 
 
diff --git a/src/Mobs/Villager.cpp b/src/Mobs/Villager.cpp
index 7f89fb6cc..bbd8d6aaa 100644
--- a/src/Mobs/Villager.cpp
+++ b/src/Mobs/Villager.cpp
@@ -3,6 +3,9 @@
 
 #include "Villager.h"
 #include "../World.h"
+#include "../BlockArea.h"
+#include "../Blocks/BlockHandler.h"
+#include "../BlockInServerPluginInterface.h"
 
 
 
@@ -10,7 +13,9 @@
 
 cVillager::cVillager(eVillagerType VillagerType) :
 	super("Villager", mtVillager, "", "", 0.6, 1.8),
-	m_Type(VillagerType)
+	m_ActionCountDown(-1),
+	m_Type(VillagerType),
+	m_VillagerAction(false)
 {
 }
 
@@ -21,7 +26,7 @@ cVillager::cVillager(eVillagerType VillagerType) :
 void cVillager::DoTakeDamage(TakeDamageInfo & a_TDI)
 {
 	super::DoTakeDamage(a_TDI);
-	if (a_TDI.Attacker->IsPlayer())
+	if ((a_TDI.Attacker != NULL) && a_TDI.Attacker->IsPlayer())
 	{
 		if (m_World->GetTickRandomNumber(5) == 3)
 		{
@@ -33,3 +38,155 @@ void cVillager::DoTakeDamage(TakeDamageInfo & a_TDI)
 
 
 
+
+void cVillager::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	super::Tick(a_Dt, a_Chunk);
+
+	if (m_ActionCountDown > -1)
+	{
+		m_ActionCountDown--;
+		if (m_ActionCountDown == 0)
+		{
+			switch (m_Type)
+			{
+				case vtFarmer: 
+				{
+					HandleFarmerPlaceCrops();
+				}
+			}
+		}
+		return;
+	}
+
+	if (m_VillagerAction)
+	{
+		switch (m_Type)
+		{
+			case vtFarmer:
+			{
+				HandleFarmerTryHarvestCrops();
+			}
+		}
+		m_VillagerAction = false;
+		return;
+	}
+
+	// Don't always try to do a special action. Each tick has 1% to do a special action.
+	if (m_World->GetTickRandomNumber(99) != 0)
+	{
+		return;
+	}
+
+	switch (m_Type)
+	{
+		case vtFarmer:
+		{
+			HandleFarmerPrepareFarmCrops();
+		}
+	}
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Farmer functions.
+void cVillager::HandleFarmerPrepareFarmCrops()
+{
+	if (!m_World->VillagersShouldHarvestCrops())
+	{
+		return;
+	}
+
+	cBlockArea Surrounding;
+	/// Read a 11x7x11 area.
+	Surrounding.Read(
+		m_World,
+		(int) GetPosX() - 5,
+		(int) GetPosX() + 5,
+		(int) GetPosY() - 3,
+		(int) GetPosY() + 3,
+		(int) GetPosZ() - 5,
+		(int) GetPosZ() + 5
+	);
+
+	for (int I = 0; I < 5; I++)
+	{
+		for (int Y = 0; Y < 6; Y++)
+		{
+			// Pick random coordinates and check for crops.
+			int X = m_World->GetTickRandomNumber(11);
+			int Z = m_World->GetTickRandomNumber(11);
+
+			// A villager can't farm this.
+			if (!IsBlockFarmable(Surrounding.GetRelBlockType(X, Y, Z)))
+			{
+				continue;
+			}
+			if (Surrounding.GetRelBlockMeta(X, Y, Z) != 0x7)
+			{
+				continue;
+			}
+
+			m_VillagerAction = true;
+			m_CropsPos = Vector3i((int) GetPosX() + X - 5, (int) GetPosY() + Y - 3, (int) GetPosZ() + Z - 5);
+			MoveToPosition(Vector3f((float) (m_CropsPos.x + 0.5), (float) m_CropsPos.y, (float) (m_CropsPos.z + 0.5)));
+			return;
+		} // for Y loop.
+	} // Repeat the procces 5 times.
+}
+
+
+
+
+
+void cVillager::HandleFarmerTryHarvestCrops()
+{
+	// Harvest the crops if the villager isn't moving and if the crops are closer then 2 blocks.
+	if (!m_bMovingToDestination && (GetPosition() - m_CropsPos).Length() < 2)
+	{
+		// Check if the blocks didn't change while the villager was walking to the coordinates.
+		BLOCKTYPE CropBlock = m_World->GetBlock(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z);
+		if (IsBlockFarmable(CropBlock) && m_World->GetBlockMeta(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z) == 0x7)
+		{
+			cBlockHandler * Handler = cBlockInfo::GetHandler(CropBlock);
+			cChunkInterface ChunkInterface(m_World->GetChunkMap());
+			cBlockInServerPluginInterface PluginInterface(*m_World);
+			Handler->DropBlock(ChunkInterface, *m_World, PluginInterface, this, m_CropsPos.x, m_CropsPos.y, m_CropsPos.z);
+			m_World->SetBlock(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z, E_BLOCK_AIR, 0);
+			m_ActionCountDown = 20;
+		}
+	}
+}
+
+
+
+
+void cVillager::HandleFarmerPlaceCrops()
+{
+	// Check if there is still farmland at the spot where the crops were.
+	if (m_World->GetBlock(m_CropsPos.x, m_CropsPos.y - 1, m_CropsPos.z) == E_BLOCK_FARMLAND)
+	{
+		m_World->SetBlock(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z, E_BLOCK_CROPS, 0);
+	}
+}
+
+
+
+
+
+bool cVillager::IsBlockFarmable(BLOCKTYPE a_BlockType)
+{
+	switch (a_BlockType)
+	{
+		case E_BLOCK_CROPS:
+		case E_BLOCK_POTATOES:
+		case E_BLOCK_CARROTS:
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
diff --git a/src/Mobs/Villager.h b/src/Mobs/Villager.h
index 4cd9aaa8e..5bba4d4ba 100644
--- a/src/Mobs/Villager.h
+++ b/src/Mobs/Villager.h
@@ -29,12 +29,36 @@ public:
 
 	CLASS_PROTODEF(cVillager);
 
+	// cEntity overrides
 	virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
-	int GetVilType(void) const { return m_Type; }	
+	virtual void Tick        (float a_Dt, cChunk & a_Chunk) override;
+
+	// cVillager functions
+	/** return true if the given blocktype are: crops, potatoes or carrots.*/
+	bool IsBlockFarmable(BLOCKTYPE a_BlockType);
+
+	//////////////////////////////////////////////////////////////////
+	// Farmer functions
+	/** It searches in a 11x7x11 area for crops. If it found some it will navigate to them.*/
+	void HandleFarmerPrepareFarmCrops();
+
+	/** Looks if the farmer has reached it's destination, and if it's still crops and the destination is closer then 2 blocks it will harvest them.*/
+	void HandleFarmerTryHarvestCrops();
+
+	/** Replaces the crops he harvested.*/
+	void HandleFarmerPlaceCrops();
+
+	// Get and set functions.
+	int      GetVilType(void)              const { return m_Type; }	
+	Vector3i GetCropsPos(void)             const { return m_CropsPos; }
+	bool     DoesHaveActionActivated(void) const { return m_VillagerAction; }
 
 private:
 
+	int m_ActionCountDown;
 	int m_Type;
+	bool m_VillagerAction;
+	Vector3i m_CropsPos;
 
 } ;
 
diff --git a/src/Mobs/Witch.cpp b/src/Mobs/Witch.cpp
index 25d27041f..6956f7b7a 100644
--- a/src/Mobs/Witch.cpp
+++ b/src/Mobs/Witch.cpp
@@ -18,13 +18,28 @@ cWitch::cWitch(void) :
 
 void cWitch::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_GLASS_BOTTLE);
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_GLOWSTONE_DUST);
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_GUNPOWDER);
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_REDSTONE_DUST);
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_SPIDER_EYE);
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_STICK);
-	AddRandomDropItem(a_Drops, 0, 6, E_ITEM_SUGAR);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	MTRand r1;
+	int DropTypeCount = (r1.randInt() % 3) + 1;
+	for (int i = 0; i < DropTypeCount; i++)
+	{
+		int DropType = r1.randInt() % 7;
+		switch (DropType)
+		{
+			case 0: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GLASS_BOTTLE); break;
+			case 1: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GLOWSTONE_DUST); break;
+			case 2: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER); break;
+			case 3: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_REDSTONE_DUST); break;
+			case 4: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_SPIDER_EYE); break;
+			case 5: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STICK); break;
+			case 6: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_SUGAR); break;
+		}
+	}
+	AddRandomWeaponDropItem(a_Drops, LootingLevel);
 }
 
 
diff --git a/src/Mobs/Witch.h b/src/Mobs/Witch.h
index 4e637beea..51c63322a 100644
--- a/src/Mobs/Witch.h
+++ b/src/Mobs/Witch.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include "AggressiveMonster.h"
+#include "../MersenneTwister.h"
 
 
 
diff --git a/src/Mobs/Wither.cpp b/src/Mobs/Wither.cpp
index c46e0beab..8f5d28b68 100644
--- a/src/Mobs/Wither.cpp
+++ b/src/Mobs/Wither.cpp
@@ -2,14 +2,90 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Wither.h"
+#include "../World.h"
 
 
 
 
 
 cWither::cWither(void) :
-	super("Wither", mtWither, "mob.wither.hurt", "mob.wither.death", 0.9, 4.0)
+	super("Wither", mtWither, "mob.wither.hurt", "mob.wither.death", 0.9, 4.0),
+	m_InvulnerableTicks(220)
 {
+	SetMaxHealth(300);
+}
+
+
+
+
+
+bool cWither::IsArmored(void) const
+{
+	return GetHealth() <= (GetMaxHealth() / 2);
+}
+
+
+
+
+
+bool cWither::Initialize(cWorld * a_World)
+{
+	// Set health before BroadcastSpawnEntity()
+	SetHealth(GetMaxHealth() / 3);
+
+	return super::Initialize(a_World);
+}
+
+
+
+
+
+void cWither::DoTakeDamage(TakeDamageInfo & a_TDI)
+{
+	if (a_TDI.DamageType == dtDrowning)
+	{
+		return;
+	}
+
+	if (m_InvulnerableTicks > 0)
+	{
+		return;
+	}
+
+	if (IsArmored() && (a_TDI.DamageType == dtRangedAttack))
+	{
+		return;
+	}
+
+	super::DoTakeDamage(a_TDI);
+}
+
+
+
+
+
+void cWither::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	super::Tick(a_Dt, a_Chunk);
+
+	if (m_InvulnerableTicks > 0)
+	{
+		unsigned int NewTicks = m_InvulnerableTicks - 1;
+
+		if (NewTicks == 0)
+		{
+			m_World->DoExplosionAt(7.0, GetPosX(), GetPosY(), GetPosZ(), false, esWitherBirth, this);
+		}
+
+		m_InvulnerableTicks = NewTicks;
+
+		if ((NewTicks % 10) == 0)
+		{
+			Heal(10);
+		}
+	}
+
+	m_World->BroadcastEntityMetadata(*this);
 }
 
 
diff --git a/src/Mobs/Wither.h b/src/Mobs/Wither.h
index 56effc6bb..bc78bfaad 100644
--- a/src/Mobs/Wither.h
+++ b/src/Mobs/Wither.h
@@ -16,8 +16,25 @@ public:
 	cWither(void);
 
 	CLASS_PROTODEF(cWither);
+
+	unsigned int GetNumInvulnerableTicks(void) const { return m_InvulnerableTicks; }
+
+	void SetNumInvulnerableTicks(unsigned int a_Ticks) { m_InvulnerableTicks = a_Ticks; }
+
+	/** Returns whether the wither is invulnerable to arrows. */
+	bool IsArmored(void) const;
 	
+	// cEntity overrides
+	virtual bool Initialize(cWorld * a_World) override;
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+	virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+
+private:
+
+	/** The number of ticks of invulnerability left after being initially created. Zero once invulnerability has expired. */
+	unsigned int m_InvulnerableTicks;
+
 } ;
 
 
diff --git a/src/Mobs/Wolf.cpp b/src/Mobs/Wolf.cpp
index 3d4e97c80..0d3619166 100644
--- a/src/Mobs/Wolf.cpp
+++ b/src/Mobs/Wolf.cpp
@@ -4,6 +4,7 @@
 #include "Wolf.h"
 #include "../World.h"
 #include "../Entities/Player.h"
+#include "../Items/ItemHandler.h"
 
 
 
@@ -37,6 +38,26 @@ void cWolf::DoTakeDamage(TakeDamageInfo & a_TDI)
 
 
 
+void cWolf::Attack(float a_Dt)
+{
+	UNUSED(a_Dt);
+
+	if ((m_Target != NULL) && (m_Target->IsPlayer()))
+	{
+		if (((cPlayer *)m_Target)->GetName() != m_OwnerName)
+		{
+			super::Attack(a_Dt);
+		}
+	}
+	else
+	{
+		super::Attack(a_Dt);
+	}
+}
+
+
+
+
 
 void cWolf::OnRightClicked(cPlayer & a_Player)
 {
@@ -55,32 +76,55 @@ void cWolf::OnRightClicked(cPlayer & a_Player)
 				SetIsTame(true);
 				SetOwner(a_Player.GetName());
 				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_WOLF_TAMED);
+				m_World->BroadcastParticleEffect("heart", (float) GetPosX(), (float) GetPosY(), (float) GetPosZ(), 0, 0, 0, 0, 5);
 			}
 			else
 			{
 				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_WOLF_TAMING);
+				m_World->BroadcastParticleEffect("smoke", (float) GetPosX(), (float) GetPosY(), (float) GetPosZ(), 0, 0, 0, 0, 5);
 			}
 		}
 	}
 	else if (IsTame())
 	{
-		if (a_Player.GetName() == m_OwnerName) // Is the player the owner of the dog?
+		switch (a_Player.GetEquippedItem().m_ItemType)
 		{
-			if (a_Player.GetEquippedItem().m_ItemType == E_ITEM_DYE)
+			case E_ITEM_RAW_BEEF:
+			case E_ITEM_STEAK:
+			case E_ITEM_RAW_PORKCHOP:
+			case E_ITEM_COOKED_PORKCHOP:
+			case E_ITEM_RAW_CHICKEN:
+			case E_ITEM_COOKED_CHICKEN:
+			case E_ITEM_ROTTEN_FLESH:
 			{
-				SetCollarColor(15 - a_Player.GetEquippedItem().m_ItemDamage);
-				if (!a_Player.IsGameModeCreative())
+				if (m_Health < m_MaxHealth)
 				{
-					a_Player.GetInventory().RemoveOneEquippedItem();
+					Heal(ItemHandler(a_Player.GetEquippedItem().m_ItemType)->GetFoodInfo().FoodLevel);
+					if (!a_Player.IsGameModeCreative())
+					{
+						a_Player.GetInventory().RemoveOneEquippedItem();
+					}
 				}
-			} 
-			else if (IsSitting()) 
+				break;
+			}
+			case E_ITEM_DYE:
 			{
-				SetIsSitting(false);
+				if (a_Player.GetName() == m_OwnerName) // Is the player the owner of the dog?
+				{
+					SetCollarColor(15 - a_Player.GetEquippedItem().m_ItemDamage);
+					if (!a_Player.IsGameModeCreative())
+					{
+						a_Player.GetInventory().RemoveOneEquippedItem();
+					}
+				}
+				break;
 			}
-			else
+			default:
 			{
-				SetIsSitting(true);
+				if (a_Player.GetName() == m_OwnerName) // Is the player the owner of the dog?
+				{
+					SetIsSitting(!IsSitting());
+				}
 			}
 		}
 	}
@@ -103,12 +147,7 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
 		super::Tick(a_Dt, a_Chunk);
 	}
 
-	if (IsSitting())
-	{
-		m_bMovingToDestination = false;
-	}
-
-	cPlayer * a_Closest_Player = FindClosestPlayer();
+	cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance);
 	if (a_Closest_Player != NULL)
 	{
 		switch (a_Closest_Player->GetEquippedItem().m_ItemType)
@@ -119,16 +158,23 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
 			case E_ITEM_RAW_CHICKEN:
 			case E_ITEM_COOKED_CHICKEN:
 			case E_ITEM_ROTTEN_FLESH:
+			case E_ITEM_RAW_PORKCHOP:
+			case E_ITEM_COOKED_PORKCHOP:
 			{
 				if (!IsBegging())
 				{
 					SetIsBegging(true);
 					m_World->BroadcastEntityMetadata(*this);
 				}
-				Vector3f a_NewDestination = a_Closest_Player->GetPosition();
-				a_NewDestination.y = a_NewDestination.y + 1; // Look at the head of the player, not his feet.
-				m_Destination = Vector3f(a_NewDestination);
-				m_bMovingToDestination = false;
+
+				m_FinalDestination = a_Closest_Player->GetPosition(); // So that we will look at a player holding food
+
+				// Don't move to the player if the wolf is sitting.
+				if (!IsSitting())
+				{
+					MoveToPosition(a_Closest_Player->GetPosition());
+				}
+
 				break;
 			}
 			default:
@@ -142,10 +188,14 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
 		}
 	}
 
-	if (IsTame())
+	if (IsTame() && !IsSitting())
 	{
 		TickFollowPlayer();
 	}
+	else if (IsSitting())
+	{
+		m_bMovingToDestination = false;
+	}
 }
 
 
@@ -163,23 +213,21 @@ void cWolf::TickFollowPlayer()
 			return false;
 		}
 	public:
-		Vector3f OwnerPos;
+		Vector3d OwnerPos;
 	} Callback;
+
 	if (m_World->DoWithPlayer(m_OwnerName, Callback))
 	{
-		// The player is present in the world, follow them:
+		// The player is present in the world, follow him:
 		double Distance = (Callback.OwnerPos - GetPosition()).Length();
-		if (Distance < 3)
-		{
-			m_bMovingToDestination = false;
-		}
-		else if ((Distance > 30) && (!IsSitting()))
+		if (Distance > 30)
 		{
+			Callback.OwnerPos.y = FindFirstNonAirBlockPosition(Callback.OwnerPos.x, Callback.OwnerPos.z);
 			TeleportToCoords(Callback.OwnerPos.x, Callback.OwnerPos.y, Callback.OwnerPos.z);
 		}
 		else
 		{
-			m_Destination = Callback.OwnerPos;
+			MoveToPosition(Callback.OwnerPos);
 		}
 	}
 }
diff --git a/src/Mobs/Wolf.h b/src/Mobs/Wolf.h
index 040e2cf7a..9e5ad03c7 100644
--- a/src/Mobs/Wolf.h
+++ b/src/Mobs/Wolf.h
@@ -22,6 +22,7 @@ public:
 	virtual void OnRightClicked(cPlayer & a_Player) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void TickFollowPlayer();
+	virtual void Attack(float a_Dt) override;
 
 	// Get functions
 	bool    IsSitting     (void) const { return m_IsSitting; }
diff --git a/src/Mobs/Zombie.cpp b/src/Mobs/Zombie.cpp
index a046fcc92..f19e096ee 100644
--- a/src/Mobs/Zombie.cpp
+++ b/src/Mobs/Zombie.cpp
@@ -23,9 +23,19 @@ cZombie::cZombie(bool a_IsVillagerZombie) :
 
 void cZombie::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 2, E_ITEM_ROTTEN_FLESH);
-	
-	// TODO: Rare drops
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_ROTTEN_FLESH);
+	cItems RareDrops;
+	RareDrops.Add(cItem(E_ITEM_IRON));
+	RareDrops.Add(cItem(E_ITEM_CARROT));
+	RareDrops.Add(cItem(E_ITEM_POTATO));
+	AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel);
+	AddRandomArmorDropItem(a_Drops, LootingLevel);
+	AddRandomWeaponDropItem(a_Drops, LootingLevel);
 }
 
 
@@ -34,15 +44,18 @@ void cZombie::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 
 void cZombie::MoveToPosition(const Vector3f & a_Position)
 {
-	m_Destination = a_Position;
-
-	// If the destination is in the sun and if it is not night AND the skeleton isn't on fire then block the movement.
-	if ((m_World->GetBlockSkyLight((int) a_Position.x, (int) a_Position.y, (int) a_Position.z) == 15) && (m_World->GetTimeOfDay() < 13187) && !IsOnFire())
+	// If the destination is in the sun and if it is not night AND the zombie isn't on fire then block the movement.
+	if (
+		!IsOnFire() &&
+		(m_World->GetTimeOfDay() < 13187) &&
+		(m_World->GetBlockSkyLight((int)a_Position.x, (int)a_Position.y, (int)a_Position.z) == 15)
+		)
 	{
 		m_bMovingToDestination = false;
 		return;
 	}
-	m_bMovingToDestination = true;
+
+	super::MoveToPosition(a_Position);
 }
 
 
diff --git a/src/Mobs/Zombiepigman.cpp b/src/Mobs/Zombiepigman.cpp
index 6ac89ed4c..a0142b566 100644
--- a/src/Mobs/Zombiepigman.cpp
+++ b/src/Mobs/Zombiepigman.cpp
@@ -19,10 +19,19 @@ cZombiePigman::cZombiePigman(void) :
 
 void cZombiePigman::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 {
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_ROTTEN_FLESH);
-	AddRandomDropItem(a_Drops, 0, 1, E_ITEM_GOLD_NUGGET);
+	int LootingLevel = 0;
+	if (a_Killer != NULL)
+	{
+		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
+	}
+	AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_ROTTEN_FLESH);
+	AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_GOLD_NUGGET);
 	
-	// TODO: Rare drops
+	cItems RareDrops;
+	RareDrops.Add(cItem(E_ITEM_GOLD));
+	AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel);
+	AddRandomArmorDropItem(a_Drops, LootingLevel);
+	AddRandomWeaponDropItem(a_Drops, LootingLevel);
 }
 
 
diff --git a/src/MonsterConfig.cpp b/src/MonsterConfig.cpp
index 6165606f0..c06bd6b6f 100644
--- a/src/MonsterConfig.cpp
+++ b/src/MonsterConfig.cpp
@@ -12,9 +12,9 @@
 struct cMonsterConfig::sAttributesStruct
 {
 	AString m_Name;
-	double  m_SightDistance;
-	double  m_AttackDamage;
-	double  m_AttackRange;
+	int     m_SightDistance;
+	int     m_AttackDamage;
+	int     m_AttackRange;
 	double  m_AttackRate;
 	int     m_MaxHealth;
 };
@@ -67,9 +67,9 @@ void cMonsterConfig::Initialize()
 		sAttributesStruct Attributes;
 		AString Name = MonstersIniFile.GetKeyName(i);
 		Attributes.m_Name = Name;
-		Attributes.m_AttackDamage  = MonstersIniFile.GetValueF(Name, "AttackDamage",  0);
-		Attributes.m_AttackRange   = MonstersIniFile.GetValueF(Name, "AttackRange",   0);
-		Attributes.m_SightDistance = MonstersIniFile.GetValueF(Name, "SightDistance", 0);
+		Attributes.m_AttackDamage  = MonstersIniFile.GetValueI(Name, "AttackDamage",  0);
+		Attributes.m_AttackRange   = MonstersIniFile.GetValueI(Name, "AttackRange",   0);
+		Attributes.m_SightDistance = MonstersIniFile.GetValueI(Name, "SightDistance", 0);
 		Attributes.m_AttackRate    = MonstersIniFile.GetValueF(Name, "AttackRate",    0);
 		Attributes.m_MaxHealth     = MonstersIniFile.GetValueI(Name, "MaxHealth",     1);
 		m_pState->AttributesList.push_front(Attributes);
@@ -87,10 +87,10 @@ void cMonsterConfig::AssignAttributes(cMonster * a_Monster, const AString & a_Na
 	{
 		if (itr->m_Name.compare(a_Name) == 0)
 		{
-			a_Monster->SetAttackDamage ((float)itr->m_AttackDamage);
-			a_Monster->SetAttackRange  ((float)itr->m_AttackRange);
-			a_Monster->SetSightDistance((float)itr->m_SightDistance);
-			a_Monster->SetAttackRate   ((int)itr->m_AttackRate);
+			a_Monster->SetAttackDamage (itr->m_AttackDamage);
+			a_Monster->SetAttackRange  (itr->m_AttackRange);
+			a_Monster->SetSightDistance(itr->m_SightDistance);
+			a_Monster->SetAttackRate   ((float)itr->m_AttackRate);
 			a_Monster->SetMaxHealth    (itr->m_MaxHealth);
 			return;
 		}
diff --git a/src/Noise.cpp b/src/Noise.cpp
index 5f23a47f9..32922c8f3 100644
--- a/src/Noise.cpp
+++ b/src/Noise.cpp
@@ -3,14 +3,6 @@
 
 #include "Noise.h"
 
-
-
-
-
-#if NOISE_USE_SSE
-	#include <smmintrin.h> //_mm_mul_epi32
-#endif
-
 #define FAST_FLOOR(x) (((x) < 0) ? (((int)x) - 1) : ((int)x))
 
 
@@ -433,7 +425,7 @@ void cCubicCell3D::Move(int a_NewFloorX, int a_NewFloorY, int a_NewFloorZ)
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cNoise:
 
-cNoise::cNoise(unsigned int a_Seed) :
+cNoise::cNoise(int a_Seed) :
 	m_Seed(a_Seed)
 {
 }
diff --git a/src/Noise.h b/src/Noise.h
index ea72c64e9..62004503f 100644
--- a/src/Noise.h
+++ b/src/Noise.h
@@ -25,7 +25,7 @@
 class cNoise
 {
 public:
-	cNoise(unsigned int a_Seed);
+	cNoise(int a_Seed);
 	cNoise(const cNoise & a_Noise);
 
 	// The following functions, if not marked INLINE, are about 20 % slower
@@ -47,14 +47,14 @@ public:
 
 	NOISE_DATATYPE CubicNoise3D (NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y, NOISE_DATATYPE a_Z) const;
 
-	void SetSeed(unsigned int a_Seed) { m_Seed = a_Seed; }
+	void SetSeed(int a_Seed) { m_Seed = a_Seed; }
 
 	INLINE static NOISE_DATATYPE CubicInterpolate (NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_C, NOISE_DATATYPE a_D, NOISE_DATATYPE a_Pct);
 	INLINE static NOISE_DATATYPE CosineInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
 	INLINE static NOISE_DATATYPE LinearInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
 
 private:
-	unsigned int m_Seed;
+	int m_Seed;
 } ;
 
 
diff --git a/src/OSSupport/BlockingTCPLink.cpp b/src/OSSupport/BlockingTCPLink.cpp
index 08aec0c65..07f48b955 100644
--- a/src/OSSupport/BlockingTCPLink.cpp
+++ b/src/OSSupport/BlockingTCPLink.cpp
@@ -2,7 +2,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "BlockingTCPLink.h"
-
+#include "Errors.h"
 
 
 
@@ -70,12 +70,12 @@ bool cBlockingTCPLink::Connect(const char * iAddress, unsigned int iPort)
 		}
 	}
 
-	server.sin_addr.s_addr = *((unsigned long *)hp->h_addr);
+	memcpy(&server.sin_addr.s_addr,hp->h_addr, hp->h_length);
 	server.sin_family = AF_INET;
 	server.sin_port = htons( (unsigned short)iPort);
 	if (connect(m_Socket, (struct sockaddr *)&server, sizeof(server)))
 	{
-		LOGWARN("cTCPLink: Connection to \"%s:%d\" failed (%s)", iAddress, iPort, cSocket::GetErrorString( cSocket::GetLastError() ).c_str() );
+		LOGWARN("cTCPLink: Connection to \"%s:%d\" failed (%s)", iAddress, iPort,GetOSErrorString( cSocket::GetLastError() ).c_str() );
 		CloseSocket();
 		return false;
 	}
@@ -89,6 +89,8 @@ bool cBlockingTCPLink::Connect(const char * iAddress, unsigned int iPort)
 
 int cBlockingTCPLink::Send(char * a_Data, unsigned int a_Size, int a_Flags /* = 0 */ )
 {
+	UNUSED(a_Flags);
+	
 	ASSERT(m_Socket.IsValid());
 	if (!m_Socket.IsValid())
 	{
@@ -104,6 +106,8 @@ int cBlockingTCPLink::Send(char * a_Data, unsigned int a_Size, int a_Flags /* =
 
 int cBlockingTCPLink::SendMessage( const char* a_Message, int a_Flags /* = 0 */ )
 {
+	UNUSED(a_Flags);
+	
 	ASSERT(m_Socket.IsValid());
 	if (!m_Socket.IsValid())
 	{
diff --git a/src/OSSupport/Errors.cpp b/src/OSSupport/Errors.cpp
new file mode 100644
index 000000000..6072b6ac6
--- /dev/null
+++ b/src/OSSupport/Errors.cpp
@@ -0,0 +1,53 @@
+
+#include "Globals.h"
+
+#include "Errors.h"
+
+AString GetOSErrorString( int a_ErrNo )
+{
+	char buffer[ 1024 ];
+	AString Out;
+
+	#ifdef _WIN32
+
+	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, a_ErrNo, 0, buffer, ARRAYCOUNT(buffer), NULL);
+	Printf(Out, "%d: %s", a_ErrNo, buffer);
+	if (!Out.empty() && (Out[Out.length() - 1] == '\n'))
+	{
+		Out.erase(Out.length() - 2);
+	}
+	return Out;
+	
+	#else  // _WIN32
+	
+	// According to http://linux.die.net/man/3/strerror_r there are two versions of strerror_r():
+	
+	#if !defined(__APPLE__) && ( _GNU_SOURCE ) && !defined(ANDROID_NDK)  // GNU version of strerror_r()
+	
+	char * res = strerror_r( errno, buffer, ARRAYCOUNT(buffer) );
+	if( res != NULL )
+	{
+		Printf(Out, "%d: %s", a_ErrNo, res);
+		return Out;
+	}
+	
+	#else  // XSI version of strerror_r():
+	
+	int res = strerror_r( errno, buffer, ARRAYCOUNT(buffer) );
+	if( res == 0 )
+	{
+		Printf(Out, "%d: %s", a_ErrNo, buffer);
+		return Out;
+	}
+	
+	#endif  // strerror_r() version
+	
+	else
+	{
+		Printf(Out, "Error %d while getting error string for error #%d!", errno, a_ErrNo);
+		return Out;
+	}
+	
+	#endif  // else _WIN32
+}
+
diff --git a/src/OSSupport/Errors.h b/src/OSSupport/Errors.h
new file mode 100644
index 000000000..8ce9deb10
--- /dev/null
+++ b/src/OSSupport/Errors.h
@@ -0,0 +1,5 @@
+
+#pragma once
+
+AString GetOSErrorString(int a_ErrNo);
+
diff --git a/src/OSSupport/Event.cpp b/src/OSSupport/Event.cpp
index cbacbba17..649a0a3cf 100644
--- a/src/OSSupport/Event.cpp
+++ b/src/OSSupport/Event.cpp
@@ -7,7 +7,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Event.h"
-
+#include "Errors.h"
 
 
 
@@ -35,14 +35,16 @@ cEvent::cEvent(void)
 		m_Event = sem_open(EventName.c_str(), O_CREAT, 777, 0 );
 		if (m_Event == SEM_FAILED)
 		{
-			LOGERROR("cEvent: Cannot create event, errno = %i. Aborting server.", errno);
+			AString error = GetOSErrorString(errno);
+			LOGERROR("cEvent: Cannot create event, err = %s. Aborting server.", error.c_str());
 			abort();
 		}
 		// Unlink the semaphore immediately - it will continue to function but will not pollute the namespace
 		// We don't store the name, so can't call this in the destructor
 		if (sem_unlink(EventName.c_str()) != 0)
 		{
-			LOGWARN("ERROR: Could not unlink cEvent. (%i)", errno);
+			AString error = GetOSErrorString(errno);
+			LOGWARN("ERROR: Could not unlink cEvent. (%s)", error.c_str());
 		}
 	}
 #endif  // *nix
@@ -61,7 +63,8 @@ cEvent::~cEvent()
 	{
 		if (sem_close(m_Event) != 0)
 		{
-			LOGERROR("ERROR: Could not close cEvent. (%i)", errno);
+			AString error = GetOSErrorString(errno);
+			LOGERROR("ERROR: Could not close cEvent. (%s)", error.c_str());
 		}
 	}
 	else
@@ -88,7 +91,8 @@ void cEvent::Wait(void)
 		int res = sem_wait(m_Event);
 		if (res != 0 )
 		{
-			LOGWARN("cEvent: waiting for the event failed: %i, errno = %i. Continuing, but server may be unstable.", res, errno);
+			AString error = GetOSErrorString(errno);
+			LOGWARN("cEvent: waiting for the event failed: %i, err = %s. Continuing, but server may be unstable.", res, error.c_str());
 		}
 	#endif
 }
@@ -108,7 +112,8 @@ void cEvent::Set(void)
 		int res = sem_post(m_Event);
 		if (res != 0)
 		{
-			LOGWARN("cEvent: Could not set cEvent: %i, errno = %d", res, errno);
+			AString error = GetOSErrorString(errno);
+			LOGWARN("cEvent: Could not set cEvent: %i, err = %s", res, error.c_str());
 		}
 	#endif
 }
diff --git a/src/OSSupport/File.cpp b/src/OSSupport/File.cpp
index 9f7c0d439..7f0f0ad2f 100644
--- a/src/OSSupport/File.cpp
+++ b/src/OSSupport/File.cpp
@@ -73,14 +73,26 @@ bool cFile::Open(const AString & iFileName, eMode iMode)
 			return false;
 		}
 	}
-	m_File = fopen( (FILE_IO_PREFIX + iFileName).c_str(), Mode);
+
+#ifdef _WIN32
+	fopen_s(&m_File, (FILE_IO_PREFIX + iFileName).c_str(), Mode);
+#else
+	m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), Mode);
+#endif // _WIN32
+
 	if ((m_File == NULL) && (iMode == fmReadWrite))
 	{
 		// Fix for MS not following C spec, opening "a" mode files for writing at the end only
 		// The file open operation has been tried with "read update", fails if file not found
 		// So now we know either the file doesn't exist or we don't have rights, no need to worry about file contents.
 		// Simply re-open for read-writing, erasing existing contents:
-		m_File = fopen( (FILE_IO_PREFIX + iFileName).c_str(), "wb+");
+
+#ifdef _WIN32
+		fopen_s(&m_File, (FILE_IO_PREFIX + iFileName).c_str(), "wb+");
+#else
+		m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), "wb+");
+#endif // _WIN32
+
 	}
 	return (m_File != NULL);
 }
@@ -140,7 +152,7 @@ int cFile::Read (void * iBuffer, int iNumBytes)
 		return -1;
 	}
 	
-	return fread(iBuffer, 1, iNumBytes, m_File);  // fread() returns the portion of Count parameter actually read, so we need to send iNumBytes as Count
+	return (int)fread(iBuffer, 1, (size_t)iNumBytes, m_File);  // fread() returns the portion of Count parameter actually read, so we need to send iNumBytes as Count
 }
 
 
@@ -156,7 +168,7 @@ int cFile::Write(const void * iBuffer, int iNumBytes)
 		return -1;
 	}
 
-	int res = fwrite(iBuffer, 1, iNumBytes, m_File);  // fwrite() returns the portion of Count parameter actually written, so we need to send iNumBytes as Count
+	int res = (int)fwrite(iBuffer, 1, (size_t)iNumBytes, m_File);  // fwrite() returns the portion of Count parameter actually written, so we need to send iNumBytes as Count
 	return res;
 }
 
@@ -177,7 +189,7 @@ int cFile::Seek (int iPosition)
 	{
 		return -1;
 	}
-	return ftell(m_File);
+	return (int)ftell(m_File);
 }
 
 
@@ -194,7 +206,7 @@ int cFile::Tell (void) const
 		return -1;
 	}
 	
-	return ftell(m_File);
+	return (int)ftell(m_File);
 }
 
 
@@ -210,7 +222,7 @@ int cFile::GetSize(void) const
 		return -1;
 	}
 	
-	int CurPos = ftell(m_File);
+	int CurPos = Tell();
 	if (CurPos < 0)
 	{
 		return -1;
@@ -219,8 +231,8 @@ int cFile::GetSize(void) const
 	{
 		return -1;
 	}
-	int res = ftell(m_File);
-	if (fseek(m_File, CurPos, SEEK_SET) != 0)
+	int res = Tell();
+	if (fseek(m_File, (long)CurPos, SEEK_SET) != 0)
 	{
 		return -1;
 	}
@@ -243,7 +255,7 @@ int cFile::ReadRestOfFile(AString & a_Contents)
 	int DataSize = GetSize() - Tell();
 	
 	// HACK: This depends on the internal knowledge that AString's data() function returns the internal buffer directly
-	a_Contents.assign(DataSize, '\0');
+	a_Contents.assign((size_t)DataSize, '\0');
 	return Read((void *)a_Contents.data(), DataSize);
 }
 
@@ -338,7 +350,7 @@ int cFile::GetSize(const AString & a_FileName)
 	struct stat st;
 	if (stat(a_FileName.c_str(), &st) == 0)
 	{
-		return st.st_size;
+		return (int)st.st_size;
 	}
 	return -1;
 }
@@ -444,7 +456,16 @@ int cFile::Printf(const char * a_Fmt, ...)
 	va_start(args, a_Fmt);
 	AppendVPrintf(buf, a_Fmt, args);
 	va_end(args);
-	return Write(buf.c_str(), buf.length());
+	return Write(buf.c_str(), (int)buf.length());
+}
+
+
+
+
+
+void cFile::Flush(void)
+{
+	fflush(m_File);
 }
 
 
diff --git a/src/OSSupport/File.h b/src/OSSupport/File.h
index 01663a229..b394c5cb9 100644
--- a/src/OSSupport/File.h
+++ b/src/OSSupport/File.h
@@ -18,6 +18,8 @@ Usage:
 2, Check if the file was opened using IsOpen()
 3, Read / write
 4, Destroy the instance
+
+For reading entire files into memory, just use the static cFile::ReadWholeFile()
 */
 
 
@@ -55,7 +57,7 @@ public:
 	static const char PathSeparator = '/';
 	#endif
 	
-	/// The mode in which to open the file
+	/** The mode in which to open the file */
 	enum eMode
 	{
 		fmRead,      // Read-only. If the file doesn't exist, object will not be valid
@@ -63,13 +65,13 @@ public:
 		fmReadWrite  // Read/write. If the file already exists, it will be left intact; writing will overwrite the data from the beginning
 	} ;
 	
-	/// Simple constructor - creates an unopened file object, use Open() to open / create a real file
+	/** Simple constructor - creates an unopened file object, use Open() to open / create a real file */
 	cFile(void);
 	
-	/// Constructs and opens / creates the file specified, use IsOpen() to check for success
+	/** Constructs and opens / creates the file specified, use IsOpen() to check for success */
 	cFile(const AString & iFileName, eMode iMode);
 	
-	/// Auto-closes the file, if open
+	/** Auto-closes the file, if open */
 	~cFile();
 	
 	bool Open(const AString & iFileName, eMode iMode);
@@ -77,59 +79,62 @@ public:
 	bool IsOpen(void) const;
 	bool IsEOF(void) const;
 	
-	/// Reads  up to iNumBytes bytes into iBuffer, returns the number of bytes actually read,    or -1 on failure; asserts if not open
+	/** Reads  up to iNumBytes bytes into iBuffer, returns the number of bytes actually read,    or -1 on failure; asserts if not open */
 	int Read (void * iBuffer,       int iNumBytes);
 	
-	/// Writes up to iNumBytes bytes from iBuffer, returns the number of bytes actually written, or -1 on failure; asserts if not open
+	/** Writes up to iNumBytes bytes from iBuffer, returns the number of bytes actually written, or -1 on failure; asserts if not open */
 	int Write(const void * iBuffer, int iNumBytes);
 	
-	/// Seeks to iPosition bytes from file start, returns old position or -1 for failure; asserts if not open
+	/** Seeks to iPosition bytes from file start, returns old position or -1 for failure; asserts if not open */
 	int Seek (int iPosition);
 	
-	/// Returns the current position (bytes from file start) or -1 for failure; asserts if not open
+	/** Returns the current position (bytes from file start) or -1 for failure; asserts if not open */
 	int Tell (void) const;
 	
-	/// Returns the size of file, in bytes, or -1 for failure; asserts if not open
+	/** Returns the size of file, in bytes, or -1 for failure; asserts if not open */
 	int GetSize(void) const;
 	
-	/// Reads the file from current position till EOF into an AString; returns the number of bytes read or -1 for error
+	/** Reads the file from current position till EOF into an AString; returns the number of bytes read or -1 for error */
 	int ReadRestOfFile(AString & a_Contents);
 	
 	// tolua_begin
 	
-	/// Returns true if the file specified exists
+	/** Returns true if the file specified exists */
 	static bool Exists(const AString & a_FileName);
 	
-	/// Deletes a file, returns true if successful
+	/** Deletes a file, returns true if successful */
 	static bool Delete(const AString & a_FileName);
 	
-	/// Renames a file or folder, returns true if successful. May fail if dest already exists (libc-dependant)!
+	/** Renames a file or folder, returns true if successful. May fail if dest already exists (libc-dependant)! */
 	static bool Rename(const AString & a_OrigPath, const AString & a_NewPath);
 	
-	/// Copies a file, returns true if successful.
+	/** Copies a file, returns true if successful. */
 	static bool Copy(const AString & a_SrcFileName, const AString & a_DstFileName);
 	
-	/// Returns true if the specified path is a folder
+	/** Returns true if the specified path is a folder */
 	static bool IsFolder(const AString & a_Path);
 	
-	/// Returns true if the specified path is a regular file
+	/** Returns true if the specified path is a regular file */
 	static bool IsFile(const AString & a_Path);
 	
-	/// Returns the size of the file, or a negative number on error
+	/** Returns the size of the file, or a negative number on error */
 	static int GetSize(const AString & a_FileName);
 	
-	/// Creates a new folder with the specified name. Returns true if successful. Path may be relative or absolute
+	/** Creates a new folder with the specified name. Returns true if successful. Path may be relative or absolute */
 	static bool CreateFolder(const AString & a_FolderPath);
 	
-	/// Returns the entire contents of the specified file as a string. Returns empty string on error.
+	/** Returns the entire contents of the specified file as a string. Returns empty string on error. */
 	static AString ReadWholeFile(const AString & a_FileName);
 	
 	// tolua_end
 	
-	/// Returns the list of all items in the specified folder (files, folders, nix pipes, whatever's there).
+	/** Returns the list of all items in the specified folder (files, folders, nix pipes, whatever's there). */
 	static AStringVector GetFolderContents(const AString & a_Folder);  // Exported in ManualBindings.cpp
 
-	int Printf(const char * a_Fmt, ...);
+	int Printf(const char * a_Fmt, ...) FORMATSTRING(2, 3);
+	
+	/** Flushes all the bufferef output into the file (only when writing) */
+	void Flush(void);
 	
 private:
 	#ifdef USE_STDIO_FILE
diff --git a/src/OSSupport/GZipFile.cpp b/src/OSSupport/GZipFile.cpp
index cbf6be6c4..7a8433f4f 100644
--- a/src/OSSupport/GZipFile.cpp
+++ b/src/OSSupport/GZipFile.cpp
@@ -73,12 +73,15 @@ int cGZipFile::ReadRestOfFile(AString & a_Contents)
 	
 	// Since the gzip format doesn't really support getting the uncompressed length, we need to read incrementally. Yuck!
 	int NumBytesRead = 0;
+	int TotalBytes = 0;
 	char Buffer[64 KiB];
 	while ((NumBytesRead = gzread(m_File, Buffer, sizeof(Buffer))) > 0)
 	{
-		a_Contents.append(Buffer, NumBytesRead);
+		TotalBytes += NumBytesRead;
+		a_Contents.append(Buffer, (size_t)NumBytesRead);
 	}
-	return NumBytesRead;
+	// NumBytesRead is < 0 on error
+	return (NumBytesRead >= 0) ? TotalBytes : NumBytesRead;
 }
 
 
@@ -99,7 +102,7 @@ bool cGZipFile::Write(const char * a_Contents, int a_Size)
 		return false;
 	}
 
-	return (gzwrite(m_File, a_Contents, a_Size) != 0);
+	return (gzwrite(m_File, a_Contents, (unsigned int)a_Size) != 0);
 }
 
 
diff --git a/src/OSSupport/IsThread.h b/src/OSSupport/IsThread.h
index b8784ea33..42b8bfdda 100644
--- a/src/OSSupport/IsThread.h
+++ b/src/OSSupport/IsThread.h
@@ -34,7 +34,7 @@ protected:
 	
 public:
 	cIsThread(const AString & iThreadName);
-	~cIsThread();
+	virtual ~cIsThread();
 	
 	/// Starts the thread; returns without waiting for the actual start
 	bool Start(void);
diff --git a/src/OSSupport/ListenThread.h b/src/OSSupport/ListenThread.h
index 4e337d814..b2d806c82 100644
--- a/src/OSSupport/ListenThread.h
+++ b/src/OSSupport/ListenThread.h
@@ -29,43 +29,45 @@ class cListenThread :
 	typedef cIsThread super;
 	
 public:
-	/// Used as the callback for connection events
+	/** Used as the callback for connection events */
 	class cCallback
 	{
 	public:
-		/// This callback is called whenever a socket connection is accepted
+		virtual ~cCallback() {}
+		
+		/** This callback is called whenever a socket connection is accepted */
 		virtual void OnConnectionAccepted(cSocket & a_Socket) = 0;
 	} ;
 	
 	cListenThread(cCallback & a_Callback, cSocket::eFamily a_Family, const AString & a_ServiceName = "");
 	~cListenThread();
 	
-	/// Creates all the sockets, returns trus if successful, false if not.
+	/** Creates all the sockets, returns trus if successful, false if not. */
 	bool Initialize(const AString & a_PortsString);
 	
 	bool Start(void);
 	
 	void Stop(void);
 	
-	/// Call before Initialize() to set the "reuse" flag on the sockets
+	/** Call before Initialize() to set the "reuse" flag on the sockets */
 	void SetReuseAddr(bool a_Reuse = true);
 	
 protected:
 	typedef std::vector<cSocket> cSockets;
 
-	/// The callback which to notify of incoming connections	
+	/** The callback which to notify of incoming connections	 */
 	cCallback & m_Callback;
 	
-	/// Socket address family to use
+	/** Socket address family to use */
 	cSocket::eFamily m_Family;
 	
-	/// Sockets that are being monitored
+	/** Sockets that are being monitored */
 	cSockets m_Sockets;
 	
-	/// If set to true, the SO_REUSEADDR socket option is set to true
+	/** If set to true, the SO_REUSEADDR socket option is set to true */
 	bool m_ShouldReuseAddr;
 	
-	/// Name of the service that's listening on the ports; for logging purposes only
+	/** Name of the service that's listening on the ports; for logging purposes only */
 	AString m_ServiceName;
 	
 	
diff --git a/src/OSSupport/Queue.h b/src/OSSupport/Queue.h
index 6c3d58295..beb6a63f1 100644
--- a/src/OSSupport/Queue.h
+++ b/src/OSSupport/Queue.h
@@ -29,7 +29,11 @@ public:
 	static void Delete(T) {};
 	
 	/// Called when an Item is inserted with EnqueueItemIfNotPresent and there is another equal value already inserted
-	static void Combine(T & a_existing, const T & a_new) {};
+	static void Combine(T & a_existing, const T & a_new)
+	{
+		UNUSED(a_existing);
+		UNUSED(a_new);
+	};
 };
 
 
diff --git a/src/OSSupport/Sleep.h b/src/OSSupport/Sleep.h
index 5298c15da..0ec0adf9d 100644
--- a/src/OSSupport/Sleep.h
+++ b/src/OSSupport/Sleep.h
@@ -4,4 +4,4 @@ class cSleep
 {
 public:
 	static void MilliSleep( unsigned int a_MilliSeconds );
-};
\ No newline at end of file
+};
diff --git a/src/OSSupport/Socket.cpp b/src/OSSupport/Socket.cpp
index d80c9bb3d..c29e495c3 100644
--- a/src/OSSupport/Socket.cpp
+++ b/src/OSSupport/Socket.cpp
@@ -6,7 +6,8 @@
 #ifndef _WIN32
 	#include <netdb.h>
 	#include <unistd.h>
-	#include <arpa/inet.h>		//inet_ntoa()
+	#include <arpa/inet.h>  // inet_ntoa()
+	#include <sys/ioctl.h>  // ioctl()
 #else
 	#define socklen_t int
 #endif
@@ -105,58 +106,6 @@ void cSocket::ShutdownReadWrite(void)
 
 
 
-
-AString cSocket::GetErrorString( int a_ErrNo )
-{
-	char buffer[ 1024 ];
-	AString Out;
-
-	#ifdef _WIN32
-
-	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, a_ErrNo, 0, buffer, ARRAYCOUNT(buffer), NULL);
-	Printf(Out, "%d: %s", a_ErrNo, buffer);
-	if (!Out.empty() && (Out[Out.length() - 1] == '\n'))
-	{
-		Out.erase(Out.length() - 2);
-	}
-	return Out;
-	
-	#else  // _WIN32
-	
-	// According to http://linux.die.net/man/3/strerror_r there are two versions of strerror_r():
-	
-	#if ( _GNU_SOURCE ) && !defined(ANDROID_NDK)  // GNU version of strerror_r()
-	
-	char * res = strerror_r( errno, buffer, ARRAYCOUNT(buffer) );
-	if( res != NULL )
-	{
-		Printf(Out, "%d: %s", a_ErrNo, res);
-		return Out;
-	}
-	
-	#else  // XSI version of strerror_r():
-	
-	int res = strerror_r( errno, buffer, ARRAYCOUNT(buffer) );
-	if( res == 0 )
-	{
-		Printf(Out, "%d: %s", a_ErrNo, buffer);
-		return Out;
-	}
-	
-	#endif  // strerror_r() version
-	
-	else
-	{
-		Printf(Out, "Error %d while getting error string for error #%d!", errno, a_ErrNo);
-		return Out;
-	}
-	
-	#endif  // else _WIN32
-}
-
-
-
-
 int cSocket::GetLastError()
 {
 #ifdef _WIN32
@@ -358,7 +307,8 @@ bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Por
 			CloseSocket();
 			return false;
 		}
-		addr = *((unsigned long*)hp->h_addr);
+		// Should be optimised to a single word copy
+		memcpy(&addr, hp->h_addr, hp->h_length);
 	}
 
 	sockaddr_in server;
@@ -372,7 +322,7 @@ bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Por
 
 
 
-int cSocket::Receive(char* a_Buffer, unsigned int a_Length, unsigned int a_Flags)
+int cSocket::Receive(char * a_Buffer, unsigned int a_Length, unsigned int a_Flags)
 {
 	return recv(m_Socket, a_Buffer, a_Length, a_Flags);
 }
@@ -406,3 +356,25 @@ unsigned short cSocket::GetPort(void) const
 
 
 
+
+void cSocket::SetNonBlocking(void)
+{
+	#ifdef _WIN32
+		u_long NonBlocking = 1;
+		int res = ioctlsocket(m_Socket, FIONBIO, &NonBlocking);
+	#else
+		int NonBlocking = 1;
+		int res = ioctl(m_Socket, FIONBIO, (char *)&NonBlocking);
+	#endif
+	if (res != 0)
+	{
+		LOGERROR("Cannot set socket to non-blocking. This would make the server deadlock later on, aborting.\nErr: %d, %d, %s",
+			res, GetLastError(), GetLastErrorString().c_str()
+		);
+		abort();
+	}
+}
+
+
+
+
diff --git a/src/OSSupport/Socket.h b/src/OSSupport/Socket.h
index 91c9ca5fd..bdc2babf5 100644
--- a/src/OSSupport/Socket.h
+++ b/src/OSSupport/Socket.h
@@ -14,7 +14,7 @@
 #endif
 
 
-
+#include "Errors.h"
 
 
 class cSocket
@@ -24,6 +24,12 @@ public:
 	{
 		IPv4 = AF_INET,
 		IPv6 = AF_INET6,
+		
+		#ifdef _WIN32
+		ErrWouldBlock = WSAEWOULDBLOCK,
+		#else
+		ErrWouldBlock = EWOULDBLOCK,
+		#endif
 	} ;
 	
 #ifdef _WIN32
@@ -57,11 +63,10 @@ public:
 	/// Initializes the network stack. Returns 0 on success, or another number as an error code.
 	static int WSAStartup(void);
 
-	static AString GetErrorString(int a_ErrNo);
 	static int     GetLastError();
 	static AString GetLastErrorString(void)
 	{
-		return GetErrorString(GetLastError());
+		return GetOSErrorString(GetLastError());
 	}
 	
 	/// Creates a new socket of the specified address family
@@ -111,8 +116,11 @@ public:
 	unsigned short GetPort(void) const;  // Returns 0 on failure
 
 	const AString & GetIPString(void) const { return m_IPString; }
+	
+	/** Sets the socket into non-blocking mode */
+	void SetNonBlocking(void);
 
 private:
 	xSocket m_Socket;
 	AString m_IPString;
-};
\ No newline at end of file
+};
diff --git a/src/OSSupport/SocketThreads.cpp b/src/OSSupport/SocketThreads.cpp
index b8069cf00..0bc1d6b55 100644
--- a/src/OSSupport/SocketThreads.cpp
+++ b/src/OSSupport/SocketThreads.cpp
@@ -7,6 +7,7 @@
 
 #include "Globals.h"
 #include "SocketThreads.h"
+#include "Errors.h"
 
 
 
@@ -53,7 +54,7 @@ bool cSocketThreads::AddClient(const cSocket & a_Socket, cCallback * a_Client)
 	}
 	
 	// No thread has free space, create a new one:
-	LOGD("Creating a new cSocketThread (currently have %d)", m_Threads.size());
+	LOGD("Creating a new cSocketThread (currently have " SIZE_T_FMT ")", m_Threads.size());
 	cSocketThread * Thread = new cSocketThread(this);
 	if (!Thread->Start())
 	{
@@ -174,6 +175,7 @@ void cSocketThreads::cSocketThread::AddClient(const cSocket & a_Socket, cCallbac
 	
 	m_Slots[m_NumSlots].m_Client = a_Client;
 	m_Slots[m_NumSlots].m_Socket = a_Socket;
+	m_Slots[m_NumSlots].m_Socket.SetNonBlocking();
 	m_Slots[m_NumSlots].m_Outgoing.clear();
 	m_Slots[m_NumSlots].m_State = sSlot::ssNormal;
 	m_NumSlots++;
@@ -207,12 +209,18 @@ bool cSocketThreads::cSocketThread::RemoveClient(const cCallback * a_Client)
 		if (m_Slots[i].m_State == sSlot::ssRemoteClosed)
 		{
 			// The remote has already closed the socket, remove the slot altogether:
+			if (m_Slots[i].m_Socket.IsValid())
+			{
+				m_Slots[i].m_Socket.CloseSocket();
+			}
 			m_Slots[i] = m_Slots[--m_NumSlots];
 		}
 		else
 		{
 			// Query and queue the last batch of outgoing data:
-			m_Slots[i].m_Client->GetOutgoingData(m_Slots[i].m_Outgoing);
+			AString Data;
+			m_Slots[i].m_Client->GetOutgoingData(Data);
+			m_Slots[i].m_Outgoing.append(Data);
 			if (m_Slots[i].m_Outgoing.empty())
 			{
 				// No more outgoing data, shut the socket down immediately:
@@ -385,38 +393,28 @@ void cSocketThreads::cSocketThread::Execute(void)
 	// The main thread loop:
 	while (!m_ShouldTerminate)
 	{
-		// Put all sockets into the Read set:
+		// Read outgoing data from the clients:
+		QueueOutgoingData();
+		
+		// Put sockets into the sets
 		fd_set fdRead;
+		fd_set fdWrite;
 		cSocket::xSocket Highest = m_ControlSocket1.GetSocket();
-		
-		PrepareSet(&fdRead, Highest, false);
+		PrepareSets(&fdRead, &fdWrite, Highest);
 		
 		// Wait for the sockets:
 		timeval Timeout;
 		Timeout.tv_sec = 5;
 		Timeout.tv_usec = 0;
-		if (select(Highest + 1, &fdRead, NULL, NULL, &Timeout) == -1)
+		if (select(Highest + 1, &fdRead, &fdWrite, NULL, &Timeout) == -1)
 		{
-			LOG("select(R) call failed in cSocketThread: \"%s\"", cSocket::GetLastErrorString().c_str());
+			LOG("select() call failed in cSocketThread: \"%s\"", cSocket::GetLastErrorString().c_str());
 			continue;
 		}
 		
+		// Perform the IO:
 		ReadFromSockets(&fdRead);
-
-		// Test sockets for writing:
-		fd_set fdWrite;
-		Highest = m_ControlSocket1.GetSocket();
-		PrepareSet(&fdWrite, Highest, true);
-		Timeout.tv_sec = 0;
-		Timeout.tv_usec = 0;
-		if (select(Highest + 1, NULL, &fdWrite, NULL, &Timeout) == -1)
-		{
-			LOG("select(W) call failed in cSocketThread: \"%s\"", cSocket::GetLastErrorString().c_str());
-			continue;
-		}
-		
 		WriteToSockets(&fdWrite);
-		
 		CleanUpShutSockets();
 	}  // while (!mShouldTerminate)
 }
@@ -425,10 +423,11 @@ void cSocketThreads::cSocketThread::Execute(void)
 
 
 
-void cSocketThreads::cSocketThread::PrepareSet(fd_set * a_Set, cSocket::xSocket & a_Highest, bool a_IsForWriting)
+void cSocketThreads::cSocketThread::PrepareSets(fd_set * a_Read, fd_set * a_Write, cSocket::xSocket & a_Highest)
 {
-	FD_ZERO(a_Set);
-	FD_SET(m_ControlSocket1.GetSocket(), a_Set);
+	FD_ZERO(a_Read);
+	FD_ZERO(a_Write);
+	FD_SET(m_ControlSocket1.GetSocket(), a_Read);
 
 	cCSLock Lock(m_Parent->m_CS);
 	for (int i = m_NumSlots - 1; i >= 0; --i)
@@ -443,11 +442,16 @@ void cSocketThreads::cSocketThread::PrepareSet(fd_set * a_Set, cSocket::xSocket
 			continue;
 		}
 		cSocket::xSocket s = m_Slots[i].m_Socket.GetSocket();
-		FD_SET(s, a_Set);
+		FD_SET(s, a_Read);
 		if (s > a_Highest)
 		{
 			a_Highest = s;
 		}
+		if (!m_Slots[i].m_Outgoing.empty())
+		{
+			// There's outgoing data for the socket, put it in the Write set
+			FD_SET(s, a_Write);
+		}
 	}  // for i - m_Slots[]
 }
 
@@ -479,34 +483,38 @@ void cSocketThreads::cSocketThread::ReadFromSockets(fd_set * a_Read)
 		int Received = m_Slots[i].m_Socket.Receive(Buffer, ARRAYCOUNT(Buffer), 0);
 		if (Received <= 0)
 		{
-			// The socket has been closed by the remote party
-			switch (m_Slots[i].m_State)
+			if (cSocket::GetLastError() != cSocket::ErrWouldBlock)
 			{
-				case sSlot::ssNormal:
+				// The socket has been closed by the remote party
+				switch (m_Slots[i].m_State)
 				{
-					// Notify the callback that the remote has closed the socket; keep the slot
-					m_Slots[i].m_Client->SocketClosed();
-					m_Slots[i].m_State = sSlot::ssRemoteClosed;
-					break;
-				}
-				case sSlot::ssWritingRestOut:
-				case sSlot::ssShuttingDown:
-				case sSlot::ssShuttingDown2:
-				{
-					// Force-close the socket and remove the slot:
-					m_Slots[i].m_Socket.CloseSocket();
-					m_Slots[i] = m_Slots[--m_NumSlots];
-					break;
-				}
-				default:
-				{
-					LOG("%s: Unexpected socket state: %d (%s)",
-						__FUNCTION__, m_Slots[i].m_Socket.GetSocket(), m_Slots[i].m_Socket.GetIPString().c_str()
-					);
-					ASSERT(!"Unexpected socket state");
-					break;
-				}
-			}  // switch (m_Slots[i].m_State)
+					case sSlot::ssNormal:
+					{
+						// Notify the callback that the remote has closed the socket; keep the slot
+						m_Slots[i].m_Client->SocketClosed();
+						m_Slots[i].m_State = sSlot::ssRemoteClosed;
+						m_Slots[i].m_Socket.CloseSocket();
+						break;
+					}
+					case sSlot::ssWritingRestOut:
+					case sSlot::ssShuttingDown:
+					case sSlot::ssShuttingDown2:
+					{
+						// Force-close the socket and remove the slot:
+						m_Slots[i].m_Socket.CloseSocket();
+						m_Slots[i] = m_Slots[--m_NumSlots];
+						break;
+					}
+					default:
+					{
+						LOG("%s: Unexpected socket state: %d (%s)",
+							__FUNCTION__, m_Slots[i].m_Socket.GetSocket(), m_Slots[i].m_Socket.GetIPString().c_str()
+						);
+						ASSERT(!"Unexpected socket state");
+						break;
+					}
+				}  // switch (m_Slots[i].m_State)
+			}
 		}
 		else
 		{
@@ -538,7 +546,9 @@ void cSocketThreads::cSocketThread::WriteToSockets(fd_set * a_Write)
 			// Request another chunk of outgoing data:
 			if (m_Slots[i].m_Client != NULL)
 			{
-				m_Slots[i].m_Client->GetOutgoingData(m_Slots[i].m_Outgoing);
+				AString Data;
+				m_Slots[i].m_Client->GetOutgoingData(Data);
+				m_Slots[i].m_Outgoing.append(Data);
 			}
 			if (m_Slots[i].m_Outgoing.empty())
 			{
@@ -552,19 +562,22 @@ void cSocketThreads::cSocketThread::WriteToSockets(fd_set * a_Write)
 			}
 		}  // if (outgoing data is empty)
 		
-		int Sent = m_Slots[i].m_Socket.Send(m_Slots[i].m_Outgoing.data(), m_Slots[i].m_Outgoing.size());
-		if (Sent < 0)
+		if (m_Slots[i].m_State == sSlot::ssRemoteClosed)
+		{
+			continue;
+		}
+		
+		if (!SendDataThroughSocket(m_Slots[i].m_Socket, m_Slots[i].m_Outgoing))
 		{
 			int Err = cSocket::GetLastError();
-			LOGWARNING("Error %d while writing to client \"%s\", disconnecting. \"%s\"", Err, m_Slots[i].m_Socket.GetIPString().c_str(), cSocket::GetErrorString(Err).c_str());
+			LOGWARNING("Error %d while writing to client \"%s\", disconnecting. \"%s\"", Err, m_Slots[i].m_Socket.GetIPString().c_str(), GetOSErrorString(Err).c_str());
 			m_Slots[i].m_Socket.CloseSocket();
 			if (m_Slots[i].m_Client != NULL)
 			{
 				m_Slots[i].m_Client->SocketClosed();
 			}
-			return;
+			continue;
 		}
-		m_Slots[i].m_Outgoing.erase(0, Sent);
 		
 		if (m_Slots[i].m_Outgoing.empty() && (m_Slots[i].m_State == sSlot::ssWritingRestOut))
 		{
@@ -589,8 +602,41 @@ void cSocketThreads::cSocketThread::WriteToSockets(fd_set * a_Write)
 
 
 
+bool cSocketThreads::cSocketThread::SendDataThroughSocket(cSocket & a_Socket, AString & a_Data)
+{
+	// Send data in smaller chunks, so that the OS send buffers aren't overflown easily
+	while (!a_Data.empty())
+	{
+		size_t NumToSend = std::min(a_Data.size(), (size_t)1024);
+		int Sent = a_Socket.Send(a_Data.data(), NumToSend);
+		if (Sent < 0)
+		{
+			int Err = cSocket::GetLastError();
+			if (Err == cSocket::ErrWouldBlock)
+			{
+				// The OS send buffer is full, leave the outgoing data for the next time
+				return true;
+			}
+			// An error has occured
+			return false;
+		}
+		if (Sent == 0)
+		{
+			a_Socket.CloseSocket();
+			return true;
+		}
+		a_Data.erase(0, Sent);
+	}
+	return true;
+}
+
+
+
+
+
 void cSocketThreads::cSocketThread::CleanUpShutSockets(void)
 {
+	cCSLock Lock(m_Parent->m_CS);
 	for (int i = m_NumSlots - 1; i >= 0; i--)
 	{
 		switch (m_Slots[i].m_State)
@@ -616,3 +662,32 @@ void cSocketThreads::cSocketThread::CleanUpShutSockets(void)
 
 
 
+void cSocketThreads::cSocketThread::QueueOutgoingData(void)
+{
+	cCSLock Lock(m_Parent->m_CS);
+	for (int i = 0; i < m_NumSlots; i++)
+	{
+		if (m_Slots[i].m_Client != NULL)
+		{
+			AString Data;
+			m_Slots[i].m_Client->GetOutgoingData(Data);
+			m_Slots[i].m_Outgoing.append(Data);
+		}
+		if (m_Slots[i].m_Outgoing.empty())
+		{
+			// No outgoing data is ready
+			if (m_Slots[i].m_State == sSlot::ssWritingRestOut)
+			{
+				// The socket doesn't want to be kept alive anymore, and doesn't have any remaining data to send.
+				// Shut it down and then close it after a timeout, or when the other side agrees
+				m_Slots[i].m_State = sSlot::ssShuttingDown;
+				m_Slots[i].m_Socket.ShutdownReadWrite();
+			}
+			continue;
+		}
+	}
+}
+
+
+
+
diff --git a/src/OSSupport/SocketThreads.h b/src/OSSupport/SocketThreads.h
index 9e1947ab6..679e374e1 100644
--- a/src/OSSupport/SocketThreads.h
+++ b/src/OSSupport/SocketThreads.h
@@ -64,9 +64,10 @@ public:
 		virtual ~cCallback() {}
 		
 		/** Called when data is received from the remote party */
-		virtual void DataReceived(const char * a_Data, int a_Size) = 0;
+		virtual void DataReceived(const char * a_Data, size_t a_Size) = 0;
 		
-		/** Called when data can be sent to remote party; the function is supposed to *append* outgoing data to a_Data */
+		/** Called when data can be sent to remote party
+		The function is supposed to *set* outgoing data to a_Data (overwrite) */
 		virtual void GetOutgoingData(AString & a_Data) = 0;
 		
 		/** Called when the socket has been closed for any reason */
@@ -102,7 +103,7 @@ private:
 	public:
 	
 		cSocketThread(cSocketThreads * a_Parent);
-		~cSocketThread();
+		virtual ~cSocketThread();
 		
 		// All these methods assume parent's m_CS is locked
 		bool HasEmptySlot(void) const {return m_NumSlots < MAX_SLOTS; }
@@ -156,16 +157,27 @@ private:
 		
 		virtual void Execute(void) override;
 		
-		/** Puts all sockets into the set, along with m_ControlSocket1.
-		Only sockets that are able to send and receive data are put in the Set.
-		Is a_IsForWriting is true, the ssWritingRestOut sockets are added as well. */
-		void PrepareSet(fd_set * a_Set, cSocket::xSocket & a_Highest, bool a_IsForWriting);
+		/** Prepares the Read and Write socket sets for select()
+		Puts all sockets into the read set, along with m_ControlSocket1.
+		Only sockets that have outgoing data queued on them are put in the write set.*/
+		void PrepareSets(fd_set * a_ReadSet, fd_set * a_WriteSet, cSocket::xSocket & a_Highest);
 		
-		void ReadFromSockets(fd_set * a_Read);  // Reads from sockets indicated in a_Read
-		void WriteToSockets (fd_set * a_Write);  // Writes to sockets indicated in a_Write
+		/** Reads from sockets indicated in a_Read */
+		void ReadFromSockets(fd_set * a_Read);
 		
+		/** Writes to sockets indicated in a_Write */
+		void WriteToSockets (fd_set * a_Write);
+		
+		/** Sends data through the specified socket, trying to fill the OS send buffer in chunks.
+		Returns true if there was no error while sending, false if an error has occured.
+		Modifies a_Data to contain only the unsent data. */
+		bool SendDataThroughSocket(cSocket & a_Socket, AString & a_Data);
+
 		/** Removes those slots in ssShuttingDown2 state, sets those with ssShuttingDown state to ssShuttingDown2 */
 		void CleanUpShutSockets(void);
+		
+		/** Calls each client's callback to retrieve outgoing data for that client. */
+		void QueueOutgoingData(void);
 	} ;
 	
 	typedef std::list<cSocketThread *> cSocketThreadList;
diff --git a/src/OSSupport/Thread.h b/src/OSSupport/Thread.h
index 3c9316424..4153b2427 100644
--- a/src/OSSupport/Thread.h
+++ b/src/OSSupport/Thread.h
@@ -23,4 +23,4 @@ private:
 	cEvent* m_StopEvent;
 
 	AString m_ThreadName;
-};
\ No newline at end of file
+};
diff --git a/src/OSSupport/Timer.cpp b/src/OSSupport/Timer.cpp
index ed16f9e3a..fd838dd0d 100644
--- a/src/OSSupport/Timer.cpp
+++ b/src/OSSupport/Timer.cpp
@@ -28,7 +28,7 @@ long long cTimer::GetNowTime(void)
 	#else
 		struct timeval  now;
 		gettimeofday(&now, NULL);
-		return (long long)(now.tv_sec * 1000 + now.tv_usec / 1000);
+		return (long long)now.tv_sec * 1000 + (long long)now.tv_usec / 1000;
 	#endif
 }
 
diff --git a/src/Piston.cpp b/src/Piston.cpp
index 75eeb5e98..b21d576f3 100644
--- a/src/Piston.cpp
+++ b/src/Piston.cpp
@@ -9,6 +9,7 @@
 #include "World.h"
 #include "Server.h"
 #include "Blocks/BlockHandler.h"
+#include "BlockInServerPluginInterface.h"
 
 
 
@@ -90,7 +91,9 @@ void cPiston::ExtendPiston(int pistx, int pisty, int pistz)
 		cBlockHandler * Handler = BlockHandler(currBlock);
 		if (Handler->DoesDropOnUnsuitable())
 		{
-			Handler->DropBlock(m_World, NULL, pistx, pisty, pistz);
+			cChunkInterface ChunkInterface(m_World->GetChunkMap());
+			cBlockInServerPluginInterface PluginInterface(*m_World);
+			Handler->DropBlock(ChunkInterface, *m_World, PluginInterface, NULL, pistx, pisty, pistz);
 		}
 	}
 	
@@ -239,7 +242,7 @@ bool cPiston::CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 bool cPiston::CanBreakPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
 	UNUSED(a_BlockMeta);
-	return g_BlockPistonBreakable[a_BlockType];
+	return cBlockInfo::IsPistonBreakable(a_BlockType);
 }
 
 
diff --git a/src/Piston.h b/src/Piston.h
index 92ddf6938..9bbc8c6b9 100644
--- a/src/Piston.h
+++ b/src/Piston.h
@@ -2,7 +2,7 @@
 #pragma once
 
 
-
+#include "Defines.h"
 
 
 // fwd: World.h
@@ -54,6 +54,25 @@ public:
 			}
 		}
 	}
+	
+	static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)
+	{
+		switch (a_MetaData)
+		{
+			//case -1:  return BLOCK_FACE_NONE; //can never happen as metadata is unsigned
+			case 0x0: return BLOCK_FACE_YM;
+			case 0x1: return BLOCK_FACE_YP;
+			case 0x2: return BLOCK_FACE_ZM;
+			case 0x3: return BLOCK_FACE_ZP;
+			case 0x4: return BLOCK_FACE_XM;
+			case 0x5: return BLOCK_FACE_XP;
+			default:
+			{
+				ASSERT(!"Invalid Metadata");
+				return BLOCK_FACE_NONE;
+			}
+		}
+	}
 
 	void ExtendPiston( int, int, int );
 	void RetractPiston( int, int, int );
diff --git a/src/Protocol/ChunkDataSerializer.cpp b/src/Protocol/ChunkDataSerializer.cpp
index 78318a5ee..ebe61631b 100644
--- a/src/Protocol/ChunkDataSerializer.cpp
+++ b/src/Protocol/ChunkDataSerializer.cpp
@@ -105,7 +105,7 @@ void cChunkDataSerializer::Serialize29(AString & a_Data)
 	a_Data.append((const char *)&BitMap1, sizeof(short));
 	a_Data.append((const char *)&BitMap2, sizeof(short));
 	
-	Int32 CompressedSizeBE = htonl(CompressedSize);
+	UInt32 CompressedSizeBE = htonl((UInt32)CompressedSize);
 	a_Data.append((const char *)&CompressedSizeBE, sizeof(CompressedSizeBE));
 	
 	Int32 UnusedInt32 = 0;
@@ -163,7 +163,7 @@ void cChunkDataSerializer::Serialize39(AString & a_Data)
 	a_Data.append((const char *)&BitMap1, sizeof(short));
 	a_Data.append((const char *)&BitMap2, sizeof(short));
 	
-	Int32 CompressedSizeBE = htonl(CompressedSize);
+	UInt32 CompressedSizeBE = htonl((UInt32)CompressedSize);
 	a_Data.append((const char *)&CompressedSizeBE, sizeof(CompressedSizeBE));
 	
 	// Unlike 29, 39 doesn't have the "unused" int
diff --git a/src/Protocol/Protocol.h b/src/Protocol/Protocol.h
index 1bc5d528e..939170f0e 100644
--- a/src/Protocol/Protocol.h
+++ b/src/Protocol/Protocol.h
@@ -12,6 +12,8 @@
 
 #include "../Defines.h"
 #include "../Endianness.h"
+#include "../Scoreboard.h"
+#include "../Map.h"
 
 
 
@@ -23,10 +25,12 @@ class cWindow;
 class cInventory;
 class cPawn;
 class cPickup;
+class cPainting;
 class cWorld;
 class cMonster;
 class cChunkDataSerializer;
 class cFallingBlock;
+class cCompositeChat;
 
 
 
@@ -48,7 +52,7 @@ public:
 	virtual ~cProtocol() {}
 	
 	/// Called when client sends some data
-	virtual void DataReceived(const char * a_Data, int a_Size) = 0;
+	virtual void DataReceived(const char * a_Data, size_t a_Size) = 0;
 	
 	// Sending stuff to clients (alphabetically sorted):
 	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) = 0;
@@ -57,6 +61,7 @@ public:
 	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
 	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) = 0;
 	virtual void SendChat                (const AString & a_Message) = 0;
+	virtual void SendChat                (const cCompositeChat & a_Message) = 0;
 	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) = 0;
 	virtual void SendCollectPickup       (const cPickup & a_Pickup, const cPlayer & a_Player) = 0;
 	virtual void SendDestroyEntity       (const cEntity & a_Entity) = 0;
@@ -78,6 +83,10 @@ public:
 	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) = 0;
 	virtual void SendKeepAlive           (int a_PingID) = 0;
 	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) = 0;
+	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) = 0;
+	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) = 0;
+	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) = 0;
+	virtual void SendPaintingSpawn       (const cPainting & a_Painting) = 0;
 	virtual void SendPickupSpawn         (const cPickup & a_Pickup) = 0;
 	virtual void SendPlayerAbilities     (void) = 0;
 	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) = 0;
@@ -92,6 +101,9 @@ public:
 	virtual void SendRespawn             (void) = 0;
 	virtual void SendExperience          (void) = 0;
 	virtual void SendExperienceOrb       (const cExpOrb & a_ExpOrb) = 0;
+	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) = 0;
+	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) = 0;
+	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) = 0;
 	virtual void SendSoundEffect         (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch) = 0;  // a_Src coords are Block * 8
 	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) = 0;
 	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) = 0;
@@ -120,7 +132,7 @@ protected:
 	cCriticalSection m_CSPacket;  //< Each SendXYZ() function must acquire this CS in order to send the whole packet at once
 	
 	/// A generic data-sending routine, all outgoing packet data needs to be routed through this so that descendants may override it
-	virtual void SendData(const char * a_Data, int a_Size) = 0;
+	virtual void SendData(const char * a_Data, size_t a_Size) = 0;
 	
 	/// Called after writing each packet, enables descendants to flush their buffers
 	virtual void Flush(void) {};
@@ -131,10 +143,15 @@ protected:
 		SendData((const char *)&a_Value, 1);
 	}
 	
+	void WriteChar(char a_Value)
+	{
+		SendData(&a_Value, 1);
+	}
+	
 	void WriteShort(short a_Value)
 	{
-		a_Value = htons(a_Value);
-		SendData((const char *)&a_Value, 2);
+		u_short Value = htons((u_short)a_Value);
+		SendData((const char *)&Value, 2);
 	}
 	
 	/*
@@ -147,8 +164,8 @@ protected:
 	
 	void WriteInt(int a_Value)
 	{
-		a_Value = htonl(a_Value);
-		SendData((const char *)&a_Value, 4);
+		u_long Value = htonl((u_long)a_Value);
+		SendData((const char *)&Value, 4);
 	}
 	
 	void WriteUInt(unsigned int a_Value)
@@ -159,19 +176,19 @@ protected:
 	
 	void WriteInt64 (Int64 a_Value)
 	{
-		a_Value = HostToNetwork8(&a_Value);
-		SendData((const char *)&a_Value, 8);
+		UInt64 Value = HostToNetwork8(&a_Value);
+		SendData((const char *)&Value, 8);
 	}
 	
 	void WriteFloat (float a_Value)
 	{
-		unsigned int val = HostToNetwork4(&a_Value);
+		UInt32 val = HostToNetwork4(&a_Value);
 		SendData((const char *)&val, 4);
 	}
 	
 	void WriteDouble(double a_Value)
 	{
-		unsigned long long val = HostToNetwork8(&a_Value);
+		UInt64 val = HostToNetwork8(&a_Value);
 		SendData((const char *)&val, 8);
 	}
 	
@@ -179,7 +196,7 @@ protected:
 	{
 		AString UTF16;
 		UTF8ToRawBEUTF16(a_Value.c_str(), a_Value.length(), UTF16);
-		WriteShort((unsigned short)(UTF16.size() / 2));
+		WriteShort((short)(UTF16.size() / 2));
 		SendData(UTF16.data(), UTF16.size());
 	}
 	
@@ -199,7 +216,7 @@ protected:
 	{
 		// A 32-bit integer can be encoded by at most 5 bytes:
 		unsigned char b[5];
-		int idx = 0;
+		size_t idx = 0;
 		do
 		{
 			b[idx] = (a_Value & 0x7f) | ((a_Value > 0x7f) ? 0x80 : 0x00);
@@ -212,7 +229,7 @@ protected:
 	
 	void WriteVarUTF8String(const AString & a_String)
 	{
-		WriteVarInt(a_String.size());
+		WriteVarInt((UInt32)a_String.size());
 		SendData(a_String.data(), a_String.size());
 	}
 } ;
diff --git a/src/Protocol/Protocol125.cpp b/src/Protocol/Protocol125.cpp
index 2df2a695b..867cf3ef3 100644
--- a/src/Protocol/Protocol125.cpp
+++ b/src/Protocol/Protocol125.cpp
@@ -32,6 +32,8 @@ Documentation:
 
 #include "../Mobs/IncludeAllMonsters.h"
 
+#include "../CompositeChat.h"
+
 
 
 
@@ -96,6 +98,7 @@ enum
 	PACKET_CREATIVE_INVENTORY_ACTION = 0x6B,
 	PACKET_ENCHANT_ITEM              = 0x6C,
 	PACKET_UPDATE_SIGN               = 0x82,
+	PACKET_ITEM_DATA                 = 0x83,
 	PACKET_PLAYER_LIST_ITEM          = 0xC9,
 	PACKET_PLAYER_ABILITIES          = 0xca,
 	PACKET_PLUGIN_MESSAGE            = 0xfa,
@@ -159,8 +162,8 @@ void cProtocol125::SendBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, cha
 	WriteInt  (a_BlockX);
 	WriteShort((short)a_BlockY);
 	WriteInt  (a_BlockZ);
-	WriteByte (a_Byte1);
-	WriteByte (a_Byte2);
+	WriteChar (a_Byte1);
+	WriteChar (a_Byte2);
 	Flush();
 }
 
@@ -207,12 +210,12 @@ void cProtocol125::SendBlockChanges(int a_ChunkX, int a_ChunkZ, const sSetBlockV
 	WriteByte (PACKET_MULTI_BLOCK);
 	WriteInt  (a_ChunkX);
 	WriteInt  (a_ChunkZ);
-	WriteShort((unsigned short)a_Changes.size());
-	WriteUInt (sizeof(int) * a_Changes.size());
+	WriteShort((short)a_Changes.size());
+	WriteUInt ((UInt32)(4 * a_Changes.size()));
 	for (sSetBlockVector::const_iterator itr = a_Changes.begin(), end = a_Changes.end(); itr != end; ++itr)
 	{
-		unsigned int Coords = itr->y | (itr->z << 8) | (itr->x << 12);
-		unsigned int Blocks = itr->BlockMeta | (itr->BlockType << 4);
+		UInt32 Coords = ((UInt32)itr->y) | ((UInt32)(itr->z << 8)) | ((UInt32)(itr->x << 12));
+		UInt32 Blocks = ((UInt32)itr->BlockMeta) | ((UInt32)(itr->BlockType << 4));
 		WriteUInt(Coords << 16 | Blocks);
 	}
 	Flush();
@@ -234,6 +237,21 @@ void cProtocol125::SendChat(const AString & a_Message)
 
 
 
+void cProtocol125::SendChat(const cCompositeChat & a_Message)
+{
+	// This version doesn't support composite messages, just extract each part's text and use it:
+	
+	// Send the message:
+	cCSLock Lock(m_CSPacket);
+	WriteByte  (PACKET_CHAT);
+	WriteString(a_Message.ExtractText());
+	Flush();
+}
+
+
+
+
+
 void cProtocol125::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer)
 {
 	cCSLock Lock(m_CSPacket);
@@ -308,8 +326,8 @@ void cProtocol125::SendEntityEffect(const cEntity & a_Entity, int a_EffectID, in
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_ENTITY_EFFECT);
 	WriteInt  (a_Entity.GetUniqueID());
-	WriteByte (a_EffectID);
-	WriteByte (a_Amplifier);
+	WriteByte ((Byte)a_EffectID);
+	WriteByte ((Byte)a_Amplifier);
 	WriteShort(a_Duration);
 	Flush();
 }
@@ -340,7 +358,7 @@ void cProtocol125::SendEntityHeadLook(const cEntity & a_Entity)
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_ENT_HEAD_LOOK);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte((char)((a_Entity.GetHeadYaw() / 360.f) * 256));
+	WriteChar((char)((a_Entity.GetHeadYaw() / 360.f) * 256));
 	Flush();
 }
 
@@ -355,8 +373,8 @@ void cProtocol125::SendEntityLook(const cEntity & a_Entity)
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_ENT_LOOK);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte((char)((a_Entity.GetYaw()   / 360.f) * 256));
-	WriteByte((char)((a_Entity.GetPitch() / 360.f) * 256));
+	WriteChar((char)((a_Entity.GetYaw()   / 360.f) * 256));
+	WriteChar((char)((a_Entity.GetPitch() / 360.f) * 256));
 	Flush();
 }
 
@@ -404,9 +422,9 @@ void cProtocol125::SendEntityRelMove(const cEntity & a_Entity, char a_RelX, char
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_ENT_REL_MOVE);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte(a_RelX);
-	WriteByte(a_RelY);
-	WriteByte(a_RelZ);
+	WriteChar(a_RelX);
+	WriteChar(a_RelY);
+	WriteChar(a_RelZ);
 	Flush();
 }
 
@@ -421,11 +439,11 @@ void cProtocol125::SendEntityRelMoveLook(const cEntity & a_Entity, char a_RelX,
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_ENT_REL_MOVE_LOOK);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte(a_RelX);
-	WriteByte(a_RelY);
-	WriteByte(a_RelZ);
-	WriteByte((char)((a_Entity.GetYaw()   / 360.f) * 256));
-	WriteByte((char)((a_Entity.GetPitch() / 360.f) * 256));
+	WriteChar(a_RelX);
+	WriteChar(a_RelY);
+	WriteChar(a_RelZ);
+	WriteChar((char)((a_Entity.GetYaw()   / 360.f) * 256));
+	WriteChar((char)((a_Entity.GetPitch() / 360.f) * 256));
 	Flush();
 }
 
@@ -438,7 +456,7 @@ void cProtocol125::SendEntityStatus(const cEntity & a_Entity, char a_Status)
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_ENT_STATUS);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte(a_Status);
+	WriteChar(a_Status);
 	Flush();
 }
 
@@ -471,7 +489,7 @@ void cProtocol125::SendExplosion(double a_BlockX, double a_BlockY, double a_Bloc
 	WriteDouble (a_BlockY);
 	WriteDouble (a_BlockZ);
 	WriteFloat  (a_Radius);
-	WriteInt    (a_BlocksAffected.size());
+	WriteInt    ((Int32)a_BlocksAffected.size());
 	int BlockX = (int)a_BlockX;
 	int BlockY = (int)a_BlockY;
 	int BlockZ = (int)a_BlockZ;
@@ -496,7 +514,7 @@ void cProtocol125::SendGameMode(eGameMode a_GameMode)
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_CHANGE_GAME_STATE);
 	WriteByte(3);
-	WriteByte((char)a_GameMode);
+	WriteChar((char)a_GameMode);
 	Flush();
 }
 
@@ -521,7 +539,7 @@ void cProtocol125::SendHealth(void)
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_UPDATE_HEALTH);
 	WriteShort((short)m_Client->GetPlayer()->GetHealth());
-	WriteShort(m_Client->GetPlayer()->GetFoodLevel());
+	WriteShort((short)m_Client->GetPlayer()->GetFoodLevel());
 	WriteFloat((float)m_Client->GetPlayer()->GetFoodSaturationLevel());
 	Flush();
 }
@@ -534,7 +552,7 @@ void cProtocol125::SendInventorySlot(char a_WindowID, short a_SlotNum, const cIt
 {
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_INVENTORY_SLOT);
-	WriteByte (a_WindowID);
+	WriteChar (a_WindowID);
 	WriteShort(a_SlotNum);
 	WriteItem (a_Item);
 	Flush();
@@ -577,13 +595,61 @@ void cProtocol125::SendLogin(const cPlayer & a_Player, const cWorld & a_World)
 
 
 
+void cProtocol125::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+{
+	cCSLock Lock(m_CSPacket);
+
+	WriteByte (PACKET_ITEM_DATA);
+	WriteShort(E_ITEM_MAP);
+	WriteShort((short)a_ID);
+	WriteShort((short)(3 + a_Length));
+
+	WriteByte(0);
+	WriteChar((char)a_X);
+	WriteChar((char)a_Y);
+	
+	SendData((const char *)a_Colors, a_Length);
+
+	Flush();
+}
+
+
+
+
+
+void cProtocol125::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+{
+	cCSLock Lock(m_CSPacket);
+
+	WriteByte (PACKET_ITEM_DATA);
+	WriteShort(E_ITEM_MAP);
+	WriteShort((short)a_ID);
+	WriteShort((short)(1 + (3 * a_Decorators.size())));
+
+	WriteByte(1);
+	
+	for (cMapDecoratorList::const_iterator it = a_Decorators.begin(); it != a_Decorators.end(); ++it)
+	{
+		WriteByte((Byte)(it->GetType() << 4) | (it->GetRot() & 0xf));
+		WriteByte((Byte)it->GetPixelX());
+		WriteByte((Byte)it->GetPixelZ());
+	}
+
+	Flush();
+}
+
+
+
+
+
+
 void cProtocol125::SendPickupSpawn(const cPickup & a_Pickup)
 {
 	cCSLock Lock(m_CSPacket);
 	WriteByte   (PACKET_PICKUP_SPAWN);
 	WriteInt    (a_Pickup.GetUniqueID());
 	WriteShort  (a_Pickup.GetItem().m_ItemType);
-	WriteByte   (a_Pickup.GetItem().m_ItemCount);
+	WriteChar   (a_Pickup.GetItem().m_ItemCount);
 	WriteShort  (a_Pickup.GetItem().m_ItemDamage);
 	WriteVectorI((Vector3i)(a_Pickup.GetPosition() * 32));
 	WriteByte   ((char)(a_Pickup.GetSpeed().x * 8));
@@ -601,7 +667,7 @@ void cProtocol125::SendEntityAnimation(const cEntity & a_Entity, char a_Animatio
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_ANIMATION);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte(a_Animation);
+	WriteChar(a_Animation);
 	Flush();
 }
 
@@ -695,8 +761,8 @@ void cProtocol125::SendPlayerSpawn(const cPlayer & a_Player)
 	WriteInt   ((int)(a_Player.GetPosX() * 32));
 	WriteInt   ((int)(a_Player.GetPosY() * 32));
 	WriteInt   ((int)(a_Player.GetPosZ() * 32));
-	WriteByte  ((char)((a_Player.GetYaw()   / 360.f) * 256));
-	WriteByte  ((char)((a_Player.GetPitch() / 360.f) * 256));
+	WriteChar  ((char)((a_Player.GetYaw()   / 360.f) * 256));
+	WriteChar  ((char)((a_Player.GetPitch() / 360.f) * 256));
 	WriteShort (HeldItem.IsEmpty() ? 0 : HeldItem.m_ItemType);
 	Flush();
 }
@@ -722,9 +788,9 @@ void cProtocol125::SendPluginMessage(const AString & a_Channel, const AString &
 void cProtocol125::SendRemoveEntityEffect(const cEntity & a_Entity, int a_EffectID)
 {
 	cCSLock Lock(m_CSPacket);
-	WriteByte  (PACKET_REMOVE_ENTITY_EFFECT);
-	WriteInt   (a_Entity.GetUniqueID());
-	WriteByte  (a_EffectID);
+	WriteByte(PACKET_REMOVE_ENTITY_EFFECT);
+	WriteInt (a_Entity.GetUniqueID());
+	WriteChar((char)a_EffectID);
 	Flush();
 }
 
@@ -738,7 +804,7 @@ void cProtocol125::SendRespawn(void)
 	WriteByte  (PACKET_RESPAWN);
 	WriteInt   ((int)(m_Client->GetPlayer()->GetWorld()->GetDimension()));
 	WriteByte  (2);  // TODO: Difficulty; 2 = Normal
-	WriteByte  ((char)m_Client->GetPlayer()->GetGameMode());
+	WriteChar  ((char)m_Client->GetPlayer()->GetGameMode());
 	WriteShort (256);  // Current world height
 	WriteString("default");
 }
@@ -769,7 +835,7 @@ void cProtocol125::SendExperienceOrb(const cExpOrb & a_ExpOrb)
 	WriteInt((int) a_ExpOrb.GetPosX());
 	WriteInt((int) a_ExpOrb.GetPosY());
 	WriteInt((int) a_ExpOrb.GetPosZ());
-	WriteShort(a_ExpOrb.GetReward());
+	WriteShort((short)a_ExpOrb.GetReward());
 	Flush();
 }
 
@@ -810,7 +876,7 @@ void cProtocol125::SendSpawnMob(const cMonster & a_Mob)
 	cCSLock Lock(m_CSPacket);
 	WriteByte   (PACKET_SPAWN_MOB);
 	WriteInt    (a_Mob.GetUniqueID());
-	WriteByte   (a_Mob.GetMobType());
+	WriteByte   ((Byte)a_Mob.GetMobType());
 	WriteVectorI((Vector3i)(a_Mob.GetPosition() * 32));
 	WriteByte   (0);
 	WriteByte   (0);
@@ -835,7 +901,7 @@ void cProtocol125::SendSpawnObject(const cEntity & a_Entity, char a_ObjectType,
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_SPAWN_OBJECT);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte(a_ObjectType);
+	WriteChar(a_ObjectType);
 	WriteInt ((int)(a_Entity.GetPosX() * 32));
 	WriteInt ((int)(a_Entity.GetPosY() * 32));
 	WriteInt ((int)(a_Entity.GetPosZ() * 32));
@@ -860,7 +926,7 @@ void cProtocol125::SendSpawnVehicle(const cEntity & a_Vehicle, char a_VehicleTyp
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_SPAWN_OBJECT);
 	WriteInt  (a_Vehicle.GetUniqueID());
-	WriteByte (a_VehicleType);
+	WriteChar (a_VehicleType);
 	WriteInt  ((int)(a_Vehicle.GetPosX() * 32));
 	WriteInt  ((int)(a_Vehicle.GetPosY() * 32));
 	WriteInt  ((int)(a_Vehicle.GetPosZ() * 32));
@@ -898,8 +964,8 @@ void cProtocol125::SendTeleportEntity(const cEntity & a_Entity)
 	WriteInt    ((int)(floor(a_Entity.GetPosX() * 32)));
 	WriteInt    ((int)(floor(a_Entity.GetPosY() * 32)));
 	WriteInt    ((int)(floor(a_Entity.GetPosZ() * 32)));
-	WriteByte   ((char)((a_Entity.GetYaw() / 360.f) * 256));
-	WriteByte   ((char)((a_Entity.GetPitch() / 360.f) * 256));
+	WriteChar   ((char)((a_Entity.GetYaw() / 360.f) * 256));
+	WriteChar   ((char)((a_Entity.GetPitch() / 360.f) * 256));
 	Flush();
 }
 
@@ -974,7 +1040,7 @@ void cProtocol125::SendUseBed(const cEntity & a_Entity, int a_BlockX, int a_Bloc
 	WriteInt (a_Entity.GetUniqueID());
 	WriteByte(0);	// Unknown byte only 0 has been observed
 	WriteInt (a_BlockX);
-	WriteByte(a_BlockY);
+	WriteByte((Byte)a_BlockY);
 	WriteInt (a_BlockZ);
 	Flush();
 }
@@ -1018,7 +1084,7 @@ void cProtocol125::SendWholeInventory(const cWindow & a_Window)
 	cCSLock Lock(m_CSPacket);
 	cItems Slots;
 	a_Window.GetSlots(*(m_Client->GetPlayer()), Slots);
-	SendWindowSlots(a_Window.GetWindowID(), Slots.size(), &(Slots[0]));
+	SendWindowSlots(a_Window.GetWindowID(), (int)Slots.size(), &(Slots[0]));
 }
 
 
@@ -1035,7 +1101,7 @@ void cProtocol125::SendWindowClose(const cWindow & a_Window)
 	
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_WINDOW_CLOSE);
-	WriteByte(a_Window.GetWindowID());
+	WriteChar(a_Window.GetWindowID());
 	Flush();
 }
 
@@ -1052,10 +1118,10 @@ void cProtocol125::SendWindowOpen(const cWindow & a_Window)
 	}
 	cCSLock Lock(m_CSPacket);
 	WriteByte  (PACKET_WINDOW_OPEN);
-	WriteByte  (a_Window.GetWindowID());
-	WriteByte  (a_Window.GetWindowType());
+	WriteChar  (a_Window.GetWindowID());
+	WriteByte  ((Byte)a_Window.GetWindowType());
 	WriteString(a_Window.GetWindowTitle());
-	WriteByte  (a_Window.GetNumNonInventorySlots());
+	WriteByte  ((Byte)a_Window.GetNumNonInventorySlots());
 	Flush();
 }
 
@@ -1067,7 +1133,7 @@ void cProtocol125::SendWindowProperty(const cWindow & a_Window, short a_Property
 {
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_WINDOW_PROPERTY);
-	WriteByte (a_Window.GetWindowID());
+	WriteChar (a_Window.GetWindowID());
 	WriteShort(a_Property);
 	WriteShort(a_Value);
 	Flush();
@@ -1088,7 +1154,7 @@ AString cProtocol125::GetAuthServerID(void)
 
 
 
-void cProtocol125::SendData(const char * a_Data, int a_Size)
+void cProtocol125::SendData(const char * a_Data, size_t a_Size)
 {
 	m_Client->SendData(a_Data, a_Size);
 }
@@ -1097,7 +1163,7 @@ void cProtocol125::SendData(const char * a_Data, int a_Size)
 
 
 
-void cProtocol125::DataReceived(const char * a_Data, int a_Size)
+void cProtocol125::DataReceived(const char * a_Data, size_t a_Size)
 {
 	if (!m_ReceivedData.Write(a_Data, a_Size))
 	{
@@ -1181,19 +1247,6 @@ int cProtocol125::ParsePacket(unsigned char a_PacketType)
 
 
 
-#define HANDLE_PACKET_PARSE(Packet) \
-	{ \
-		int res = Packet.Parse(m_ReceivedData); \
-		if (res < 0) \
-		{ \
-			return res; \
-		} \
-	}
-
-
-
-
-
 int cProtocol125::ParseArmAnim(void)
 {
 	HANDLE_PACKET_READ(ReadBEInt, int,  EntityID);
@@ -1213,7 +1266,7 @@ int cProtocol125::ParseBlockDig(void)
 	HANDLE_PACKET_READ(ReadByte,	Byte, PosY);
 	HANDLE_PACKET_READ(ReadBEInt, int,  PosZ);
 	HANDLE_PACKET_READ(ReadChar,	char, BlockFace);
-	m_Client->HandleLeftClick(PosX, PosY, PosZ, BlockFace, Status);
+	m_Client->HandleLeftClick(PosX, PosY, PosZ, static_cast<eBlockFace>(BlockFace), Status);
 	return PARSE_OK;
 }
 
@@ -1236,7 +1289,7 @@ int cProtocol125::ParseBlockPlace(void)
 	}
 
 	// 1.2.5 didn't have any cursor position, so use 8, 8, 8, so that halfslabs and stairs work correctly and the special value is recognizable.
-	m_Client->HandleRightClick(PosX, PosY, PosZ, BlockFace, 8, 8, 8, HeldItem);
+	m_Client->HandleRightClick(PosX, PosY, PosZ, static_cast<eBlockFace>(BlockFace), 8, 8, 8, HeldItem);
 	return PARSE_OK;
 }
 
@@ -1287,7 +1340,16 @@ int cProtocol125::ParseEntityAction(void)
 {
 	HANDLE_PACKET_READ(ReadBEInt, int,  EntityID);
 	HANDLE_PACKET_READ(ReadChar,  char, ActionID);
-	m_Client->HandleEntityAction(EntityID, ActionID);
+
+	switch (ActionID)
+	{
+		case 1: m_Client->HandleEntityCrouch(EntityID, true);     break; // Crouch
+		case 2: m_Client->HandleEntityCrouch(EntityID, false);    break; // Uncrouch
+		case 3: m_Client->HandleEntityLeaveBed(EntityID);         break; // Leave Bed
+		case 4: m_Client->HandleEntitySprinting(EntityID, true);  break; // Start sprinting
+		case 5: m_Client->HandleEntitySprinting(EntityID, false); break; // Stop sprinting
+	}
+
 	return PARSE_OK;
 }
 
@@ -1464,7 +1526,7 @@ int cProtocol125::ParsePluginMessage(void)
 	HANDLE_PACKET_READ(ReadBEUTF16String16, AString, ChannelName);
 	HANDLE_PACKET_READ(ReadBEShort,         short,   Length);
 	AString Data;
-	if (!m_ReceivedData.ReadString(Data, Length))
+	if (!m_ReceivedData.ReadString(Data, (size_t)Length))
 	{
 		m_ReceivedData.CheckValid();
 		return PARSE_INCOMPLETE;
@@ -1641,7 +1703,7 @@ void cProtocol125::SendPreChunk(int a_ChunkX, int a_ChunkZ, bool a_ShouldLoad)
 void cProtocol125::SendWindowSlots(char a_WindowID, int a_NumItems, const cItem * a_Items)
 {
 	WriteByte (PACKET_INVENTORY_WHOLE);
-	WriteByte (a_WindowID);
+	WriteChar (a_WindowID);
 	WriteShort((short)a_NumItems);
 
 	for (int j = 0; j < a_NumItems; j++)
@@ -1671,7 +1733,7 @@ void cProtocol125::WriteItem(const cItem & a_Item)
 		return;
 	}
 	
-	WriteByte (a_Item.m_ItemCount);
+	WriteChar (a_Item.m_ItemCount);
 	WriteShort(a_Item.m_ItemDamage);
 	
 	if (cItem::IsEnchantable(a_Item.m_ItemType))
@@ -1718,7 +1780,7 @@ int cProtocol125::ParseItem(cItem & a_Item)
 	}
 		
 	// TODO: Enchantment not implemented yet!
-	if (!m_ReceivedData.SkipRead(EnchantNumBytes))
+	if (!m_ReceivedData.SkipRead((size_t)EnchantNumBytes))
 	{
 		return PARSE_INCOMPLETE;
 	}
@@ -1803,7 +1865,7 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 		case cMonster::mtCreeper:
 		{
 			WriteByte(0x10);
-			WriteByte(((const cCreeper &)a_Mob).IsBlowing() ? 1 : -1); // Blowing up?
+			WriteChar(((const cCreeper &)a_Mob).IsBlowing() ? 1 : -1); // Blowing up?
 			WriteByte(0x11);
 			WriteByte(((const cCreeper &)a_Mob).IsCharged() ? 1 : 0); // Lightning-charged?
 			break;
@@ -1873,9 +1935,9 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 
 			WriteByte(0x10);
 			Byte SheepMetadata = 0;
-			SheepMetadata = ((const cSheep &)a_Mob).GetFurColor(); // Fur colour
+			SheepMetadata = (Byte)((const cSheep &)a_Mob).GetFurColor();
 
-			if (((const cSheep &)a_Mob).IsSheared()) // Is sheared?
+			if (((const cSheep &)a_Mob).IsSheared())
 			{
 				SheepMetadata |= 0x16;
 			}
@@ -1904,17 +1966,25 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(((const cWitch &)a_Mob).IsAngry() ? 1 : 0); // Aggravated? Doesn't seem to do anything
 			break;
 		}
+		case cMonster::mtWither:
+		{
+			WriteByte(0x54); // Int at index 20
+			WriteInt((Int32)((const cWither &)a_Mob).GetNumInvulnerableTicks());
+			WriteByte(0x66); // Float at index 6
+			WriteFloat((float)(a_Mob.GetHealth()));
+			break;
+		}
 		case cMonster::mtSlime:
 		case cMonster::mtMagmaCube:
 		{
 			WriteByte(0x10);
 			if (a_Mob.GetMobType() == cMonster::mtSlime)
 			{
-				WriteByte(((const cSlime &)a_Mob).GetSize()); // Size of slime - HEWGE, meh, cute BABBY SLIME
+				WriteByte((Byte)((const cSlime &)a_Mob).GetSize()); // Size of slime - HEWGE, meh, cute BABBY SLIME
 			}
 			else
 			{
-				WriteByte(((const cMagmaCube &)a_Mob).GetSize()); // Size of slime - HEWGE, meh, cute BABBY SLIME
+				WriteByte((Byte)((const cMagmaCube &)a_Mob).GetSize()); // Size of slime - HEWGE, meh, cute BABBY SLIME
 			}
 			break;
 		}
@@ -1953,7 +2023,7 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteInt(Flags);
 
 			WriteByte(0x13);
-			WriteByte(((const cHorse &)a_Mob).GetHorseType()); // Type of horse (donkey, chestnut, etc.)
+			WriteByte((Byte)((const cHorse &)a_Mob).GetHorseType()); // Type of horse (donkey, chestnut, etc.)
 
 			WriteByte(0x54);
 			int Appearance = 0;
@@ -1965,6 +2035,10 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteInt(((const cHorse &)a_Mob).GetHorseArmour()); // Horshey armour
 			break;
 		}
+		default:
+		{
+			break;
+		}
 	}
 }
 
diff --git a/src/Protocol/Protocol125.h b/src/Protocol/Protocol125.h
index e3c8765b1..753458ebc 100644
--- a/src/Protocol/Protocol125.h
+++ b/src/Protocol/Protocol125.h
@@ -11,6 +11,7 @@
 
 #include "Protocol.h"
 #include "../ByteBuffer.h"
+#include "../Entities/Painting.h"
 
 
 
@@ -24,7 +25,7 @@ public:
 	cProtocol125(cClientHandle * a_Client);
 	
 	/// Called when client sends some data:
-	virtual void DataReceived(const char * a_Data, int a_Size) override;
+	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 	
 	/// Sending stuff to clients (alphabetically sorted):
 	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
@@ -33,6 +34,7 @@ public:
 	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
 	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
 	virtual void SendChat                (const AString & a_Message) override;
+	virtual void SendChat                (const cCompositeChat & a_Message) override;
 	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
 	virtual void SendCollectPickup       (const cPickup & a_Pickup, const cPlayer & a_Player) override;
 	virtual void SendDestroyEntity       (const cEntity & a_Entity) override;
@@ -54,7 +56,19 @@ public:
 	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
 	virtual void SendKeepAlive           (int a_PingID) override;
 	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
+	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) override;
+	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) override 
+	{
+		// This protocol doesn't support such message
+		UNUSED(a_ID);
+		UNUSED(a_Scale);
+	} 
 	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
+	virtual void SendPaintingSpawn       (const cPainting & a_Painting) override 
+	{
+		UNUSED(a_Painting);
+	};
 	virtual void SendPickupSpawn         (const cPickup & a_Pickup) override;
 	virtual void SendPlayerAbilities     (void) override {}  // This protocol doesn't support such message
 	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) override;
@@ -68,6 +82,14 @@ public:
 	virtual void SendRespawn             (void) override;
 	virtual void SendExperience          (void) override;
 	virtual void SendExperienceOrb       (const cExpOrb &  a_ExpOrb) override;
+	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)                            override 
+	{
+		UNUSED(a_Name);
+		UNUSED(a_DisplayName);
+		UNUSED(a_Mode);
+	} // This protocol doesn't support such message
+	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override {} // This protocol doesn't support such message
+	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)                              override {} // This protocol doesn't support such message
 	virtual void SendSoundEffect         (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch) override;  // a_Src coords are Block * 8
 	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
 	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) override;
@@ -83,8 +105,8 @@ public:
 	virtual void SendUpdateSign          (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
 	virtual void SendUseBed              (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ ) override;
 	virtual void SendWeather             (eWeather a_Weather) override;
-	virtual void SendWholeInventory      (const cWindow    & a_Window) override;
-	virtual void SendWindowClose         (const cWindow    & a_Window) override;
+	virtual void SendWholeInventory      (const cWindow & a_Window) override;
+	virtual void SendWindowClose         (const cWindow & a_Window) override;
 	virtual void SendWindowOpen          (const cWindow & a_Window) override;
 	virtual void SendWindowProperty      (const cWindow & a_Window, short a_Property, short a_Value) override;
 	
@@ -103,7 +125,7 @@ protected:
 	
 	AString m_Username;  ///< Stored in ParseHandshake(), compared to Login username
 	
-	virtual void SendData(const char * a_Data, int a_Size) override;
+	virtual void SendData(const char * a_Data, size_t a_Size) override;
 	
 	/// Sends the Handshake packet
 	void SendHandshake(const AString & a_ConnectionHash);
diff --git a/src/Protocol/Protocol132.cpp b/src/Protocol/Protocol132.cpp
index b4ca37d37..ce5942a5c 100644
--- a/src/Protocol/Protocol132.cpp
+++ b/src/Protocol/Protocol132.cpp
@@ -28,13 +28,14 @@
 	#pragma warning(disable:4702)
 #endif
 
-#include "cryptopp/randpool.h"
-
 #ifdef _MSC_VER
 	#pragma warning(pop)
 #endif
 
 
+
+
+
 #define HANDLE_PACKET_READ(Proc, Type, Var) \
 	Type Var; \
 	{ \
@@ -49,17 +50,6 @@
 
 
 
-typedef unsigned char Byte;
-
-
-
-
-
-using namespace CryptoPP;
-
-
-
-
 
 const int MAX_ENC_LEN = 512;  // Maximum size of the encrypted message; should be 128, but who knows...
 
@@ -93,81 +83,6 @@ enum
 
 
 
-// Converts a raw 160-bit SHA1 digest into a Java Hex representation
-// According to http://wiki.vg/wiki/index.php?title=Protocol_Encryption&oldid=2802
-static void DigestToJava(byte a_Digest[20], AString & a_Out)
-{
-	bool IsNegative = (a_Digest[0] >= 0x80);
-	if (IsNegative)
-	{
-		// Two's complement:
-		bool carry = true;  // Add one to the whole number
-		for (int i = 19; i >= 0; i--)
-		{
-			a_Digest[i] = ~a_Digest[i];
-			if (carry)
-			{
-				carry = (a_Digest[i] == 0xff);
-				a_Digest[i]++;
-			}
-		}
-	}
-	a_Out.clear();
-	a_Out.reserve(40);
-	for (int i = 0; i < 20; i++)
-	{
-		AppendPrintf(a_Out, "%02x", a_Digest[i]);
-	}
-	while ((a_Out.length() > 0) && (a_Out[0] == '0'))
-	{
-		a_Out.erase(0, 1);
-	}
-	if (IsNegative)
-	{
-		a_Out.insert(0, "-");
-	}
-}
-
-
-
-
-
-/*
-// Self-test the hash formatting for known values:
-// sha1(Notch) : 4ed1f46bbe04bc756bcb17c0c7ce3e4632f06a48
-// sha1(jeb_)  : -7c9d5b0044c130109a5d7b5fb5c317c02b4e28c1
-// sha1(simon) : 88e16a1019277b15d58faf0541e11910eb756f6
-
-class Test
-{
-public:
-	Test(void)
-	{
-		AString DigestNotch, DigestJeb, DigestSimon;
-		byte Digest[20];
-		CryptoPP::SHA1 Checksum;
-		Checksum.Update((const byte *)"Notch", 5);
-		Checksum.Final(Digest);
-		DigestToJava(Digest, DigestNotch);
-		Checksum.Restart();
-		Checksum.Update((const byte *)"jeb_", 4);
-		Checksum.Final(Digest);
-		DigestToJava(Digest, DigestJeb);
-		Checksum.Restart();
-		Checksum.Update((const byte *)"simon", 5);
-		Checksum.Final(Digest);
-		DigestToJava(Digest, DigestSimon);
-		printf("Notch: \"%s\"", DigestNotch.c_str());
-		printf("jeb_: \"%s\"",  DigestJeb.c_str());
-		printf("simon: \"%s\"", DigestSimon.c_str());
-	}
-} test;
-*/
-
-
-
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cProtocol132:
 
@@ -185,7 +100,7 @@ cProtocol132::~cProtocol132()
 {
 	if (!m_DataToSend.empty())
 	{
-		LOGD("There are %d unsent bytes while deleting cProtocol132", m_DataToSend.size());
+		LOGD("There are " SIZE_T_FMT " unsent bytes while deleting cProtocol132", m_DataToSend.size());
 	}
 }
 
@@ -193,15 +108,15 @@ cProtocol132::~cProtocol132()
 
 
 
-void cProtocol132::DataReceived(const char * a_Data, int a_Size)
+void cProtocol132::DataReceived(const char * a_Data, size_t a_Size)
 {
 	if (m_IsEncrypted)
 	{
-		byte Decrypted[512];
+		Byte Decrypted[512];
 		while (a_Size > 0)
 		{
-			int NumBytes = (a_Size > (int)sizeof(Decrypted)) ? (int)sizeof(Decrypted) : a_Size;
-			m_Decryptor.ProcessData(Decrypted, (byte *)a_Data, NumBytes);
+			size_t NumBytes = (a_Size > sizeof(Decrypted)) ? sizeof(Decrypted) : a_Size;
+			m_Decryptor.ProcessData(Decrypted, (Byte *)a_Data, NumBytes);
 			super::DataReceived((const char *)Decrypted, NumBytes);
 			a_Size -= NumBytes;
 			a_Data += NumBytes;
@@ -224,8 +139,8 @@ void cProtocol132::SendBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, cha
 	WriteInt  (a_BlockX);
 	WriteShort((short)a_BlockY);
 	WriteInt  (a_BlockZ);
-	WriteByte (a_Byte1);
-	WriteByte (a_Byte2);
+	WriteChar (a_Byte1);
+	WriteChar (a_Byte2);
 	WriteShort(a_BlockType);
 	Flush();
 }
@@ -242,7 +157,7 @@ void cProtocol132::SendBlockBreakAnim(int a_entityID, int a_BlockX, int a_BlockY
 	WriteInt    (a_BlockX);
 	WriteInt    (a_BlockY);
 	WriteInt    (a_BlockZ);
-	WriteByte   (stage);
+	WriteChar   (stage);
 	Flush();
 }
 
@@ -344,7 +259,7 @@ void cProtocol132::SendLogin(const cPlayer & a_Player, const cWorld & a_World)
 	WriteByte  (PACKET_LOGIN);
 	WriteInt   (a_Player.GetUniqueID());  // EntityID of the player
 	WriteString("default");  // Level type
-	WriteByte  ((int)a_Player.GetGameMode());
+	WriteByte  ((Byte)a_Player.GetGameMode());
 	WriteByte  ((Byte)(a_World.GetDimension()));
 	WriteByte  (2);  // TODO: Difficulty
 	WriteByte  (0);  // Unused, used to be world height
@@ -368,8 +283,8 @@ void cProtocol132::SendPlayerSpawn(const cPlayer & a_Player)
 	WriteInt   ((int)(a_Player.GetPosX() * 32));
 	WriteInt   ((int)(a_Player.GetPosY() * 32));
 	WriteInt   ((int)(a_Player.GetPosZ() * 32));
-	WriteByte  ((char)((a_Player.GetYaw()   / 360.f) * 256));
-	WriteByte  ((char)((a_Player.GetPitch() / 360.f) * 256));
+	WriteChar  ((char)((a_Player.GetYaw()   / 360.f) * 256));
+	WriteChar  ((char)((a_Player.GetPitch() / 360.f) * 256));
 	WriteShort (HeldItem.IsEmpty() ? 0 : HeldItem.m_ItemType);
 	// Player metadata: just use a default metadata value, since the client doesn't like starting without any metadata:
 	WriteByte  (0);  // Index 0, byte (flags)
@@ -391,7 +306,7 @@ void cProtocol132::SendSoundEffect(const AString & a_SoundName, int a_SrcX, int
 	WriteInt    (a_SrcY);
 	WriteInt    (a_SrcZ);
 	WriteFloat  (a_Volume);
-	WriteByte   ((char)(a_Pitch * 63.0f));
+	WriteChar   ((char)(a_Pitch * 63.0f));
 	Flush();
 }
 
@@ -405,7 +320,7 @@ void cProtocol132::SendSoundParticleEffect(int a_EffectID, int a_SrcX, int a_Src
 	WriteByte(PACKET_SOUND_PARTICLE_EFFECT);
 	WriteInt (a_EffectID);
 	WriteInt (a_SrcX);
-	WriteByte(a_SrcY);
+	WriteByte((Byte)a_SrcY);
 	WriteInt (a_SrcZ);
 	WriteInt (a_Data);
 	Flush();
@@ -420,7 +335,7 @@ void cProtocol132::SendSpawnMob(const cMonster & a_Mob)
 	cCSLock Lock(m_CSPacket);
 	WriteByte   (PACKET_SPAWN_MOB);
 	WriteInt    (a_Mob.GetUniqueID());
-	WriteByte   (a_Mob.GetMobType());
+	WriteByte   ((Byte)a_Mob.GetMobType());
 	WriteVectorI((Vector3i)(a_Mob.GetPosition() * 32));
 	WriteByte   ((Byte)((a_Mob.GetYaw()     / 360.f) * 256));
 	WriteByte   ((Byte)((a_Mob.GetPitch()   / 360.f) * 256));
@@ -496,12 +411,12 @@ void cProtocol132::SendWholeInventory(const cWindow & a_Window)
 	const cInventory & Inventory = m_Client->GetPlayer()->GetInventory();
 	int BaseOffset = a_Window.GetNumSlots() - (cInventory::invNumSlots - cInventory::invInventoryOffset);  // Number of non-inventory slots
 	char WindowID = a_Window.GetWindowID();
-	for (int i = 0; i < cInventory::invInventoryCount; i++)
+	for (short i = 0; i < cInventory::invInventoryCount; i++)
 	{
 		SendInventorySlot(WindowID, BaseOffset + i, Inventory.GetInventorySlot(i));
 	}  // for i - Inventory[]
 	BaseOffset += cInventory::invInventoryCount;
-	for (int i = 0; i < cInventory::invHotbarCount; i++)
+	for (short i = 0; i < cInventory::invHotbarCount; i++)
 	{
 		SendInventorySlot(WindowID, BaseOffset + i, Inventory.GetHotbarSlot(i));
 	}  // for i - Hotbar[]
@@ -561,7 +476,7 @@ int cProtocol132::ParseBlockPlace(void)
 	HANDLE_PACKET_READ(ReadChar, char, CursorY);
 	HANDLE_PACKET_READ(ReadChar, char, CursorZ);
 
-	m_Client->HandleRightClick(PosX, PosY, PosZ, BlockFace, CursorX, CursorY, CursorZ, HeldItem);
+	m_Client->HandleRightClick(PosX, PosY, PosZ, static_cast<eBlockFace>(BlockFace), CursorX, CursorY, CursorZ, HeldItem);
 	return PARSE_OK;
 }
 
@@ -582,9 +497,7 @@ int cProtocol132::ParseHandshake(void)
 		return PARSE_OK; // Player is not allowed into the server
 	}
 
-	// Send a 0xFD Encryption Key Request http://wiki.vg/Protocol#0xFD
-	CryptoPP::StringSink sink(m_ServerPublicKey);  // GCC won't allow inline instantiation in the following line, damned temporary refs
-	cRoot::Get()->GetServer()->GetPublicKey().Save(sink);
+	// Send a 0xfd Encryption Key Request http://wiki.vg/Protocol#0xFD
 	SendEncryptionKeyRequest();
 
 	return PARSE_OK;
@@ -596,7 +509,7 @@ int cProtocol132::ParseHandshake(void)
 
 int cProtocol132::ParseClientStatuses(void)
 {
-	HANDLE_PACKET_READ(ReadByte, byte, Status);
+	HANDLE_PACKET_READ(ReadByte, Byte, Status);
 	if ((Status & 1) == 0)
 	{
 		m_Client->HandleLogin(39, m_Username);
@@ -614,21 +527,30 @@ int cProtocol132::ParseClientStatuses(void)
 
 int cProtocol132::ParseEncryptionKeyResponse(void)
 {
+	// Read the encryption key:
 	HANDLE_PACKET_READ(ReadBEShort, short, EncKeyLength);
+	if (EncKeyLength > MAX_ENC_LEN)
+	{
+		LOGD("Too long encryption key");
+		m_Client->Kick("Hacked client");
+		return PARSE_OK;
+	}
 	AString EncKey;
-	if (!m_ReceivedData.ReadString(EncKey, EncKeyLength))
+	if (!m_ReceivedData.ReadString(EncKey, (size_t)EncKeyLength))
 	{
 		return PARSE_INCOMPLETE;
 	}
+	
+	// Read the encryption nonce:
 	HANDLE_PACKET_READ(ReadBEShort, short, EncNonceLength);
 	AString EncNonce;
-	if (!m_ReceivedData.ReadString(EncNonce, EncNonceLength))
+	if (!m_ReceivedData.ReadString(EncNonce, (size_t)EncNonceLength))
 	{
 		return PARSE_INCOMPLETE;
 	}
-	if ((EncKeyLength > MAX_ENC_LEN) || (EncNonceLength > MAX_ENC_LEN))
+	if (EncNonceLength > MAX_ENC_LEN)
 	{
-		LOGD("Too long encryption");
+		LOGD("Too long encryption nonce");
 		m_Client->Kick("Hacked client");
 		return PARSE_OK;
 	}
@@ -647,7 +569,7 @@ int cProtocol132::ParseLocaleViewDistance(void)
 	HANDLE_PACKET_READ(ReadChar,            char,    ViewDistance);
 	HANDLE_PACKET_READ(ReadChar,            char,    ChatFlags);
 	HANDLE_PACKET_READ(ReadChar,            char,    ClientDifficulty);
-	// TODO: m_Client->HandleLocale(Locale);
+	m_Client->SetLocale(Locale);
 	// TODO: m_Client->HandleViewDistance(ViewDistance);
 	// TODO: m_Client->HandleChatFlags(ChatFlags);
 	// Ignoring client difficulty
@@ -692,7 +614,7 @@ int cProtocol132::ParseTabCompletion(void)
 
 
 
-void cProtocol132::SendData(const char * a_Data, int a_Size)
+void cProtocol132::SendData(const char * a_Data, size_t a_Size)
 {
 	m_DataToSend.append(a_Data, a_Size);
 }
@@ -710,23 +632,23 @@ void cProtocol132::Flush(void)
 		LOGD("Flushing empty");
 		return;
 	}
-	const char * a_Data = m_DataToSend.data();
-	int a_Size = m_DataToSend.size();
+	const char * Data = m_DataToSend.data();
+	size_t Size = m_DataToSend.size();
 	if (m_IsEncrypted)
 	{
-		byte Encrypted[8192];  // Larger buffer, we may be sending lots of data (chunks)
-		while (a_Size > 0)
+		Byte Encrypted[8192];  // Larger buffer, we may be sending lots of data (chunks)
+		while (Size > 0)
 		{
-			int NumBytes = (a_Size > (int)sizeof(Encrypted)) ? (int)sizeof(Encrypted) : a_Size;
-			m_Encryptor.ProcessData(Encrypted, (byte *)a_Data, NumBytes);
+			size_t NumBytes = (Size > sizeof(Encrypted)) ? sizeof(Encrypted) : Size;
+			m_Encryptor.ProcessData(Encrypted, (Byte *)Data, NumBytes);
 			super::SendData((const char *)Encrypted, NumBytes);
-			a_Size -= NumBytes;
-			a_Data += NumBytes;
+			Size -= NumBytes;
+			Data += NumBytes;
 		}
 	}
 	else
 	{
-		super::SendData(a_Data, a_Size);
+		super::SendData(Data, Size);
 	}
 	m_DataToSend.clear();
 }
@@ -752,7 +674,7 @@ void cProtocol132::WriteItem(const cItem & a_Item)
 	}
 	
 	WriteShort(ItemType);
-	WriteByte (a_Item.m_ItemCount);
+	WriteChar (a_Item.m_ItemCount);
 	WriteShort(a_Item.m_ItemDamage);
 	
 	if (a_Item.m_Enchantments.IsEmpty())
@@ -768,7 +690,7 @@ void cProtocol132::WriteItem(const cItem & a_Item)
 	Writer.Finish();
 	AString Compressed;
 	CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
-	WriteShort(Compressed.size());
+	WriteShort((short)Compressed.size());
 	SendData(Compressed.data(), Compressed.size());
 }
 
@@ -804,8 +726,8 @@ int cProtocol132::ParseItem(cItem & a_Item)
 		
 	// Read the metadata
 	AString Metadata;
-	Metadata.resize(MetadataLength);
-	if (!m_ReceivedData.ReadBuf((void *)Metadata.data(), MetadataLength))
+	Metadata.resize((size_t)MetadataLength);
+	if (!m_ReceivedData.ReadBuf((void *)Metadata.data(), (size_t)MetadataLength))
 	{
 		return PARSE_INCOMPLETE;
 	}
@@ -880,8 +802,8 @@ void cProtocol132::SendEncryptionKeyRequest(void)
 	cCSLock Lock(m_CSPacket);
 	WriteByte(0xfd);
 	WriteString(cRoot::Get()->GetServer()->GetServerID());
-	WriteShort((short)m_ServerPublicKey.size());
-	SendData(m_ServerPublicKey.data(), m_ServerPublicKey.size());
+	WriteShort((short)(cRoot::Get()->GetServer()->GetPublicKeyDER().size()));
+	SendData(cRoot::Get()->GetServer()->GetPublicKeyDER().data(), cRoot::Get()->GetServer()->GetPublicKeyDER().size());
 	WriteShort(4);
 	WriteInt((int)(intptr_t)this);  // Using 'this' as the cryptographic nonce, so that we don't have to generate one each time :)
 	Flush();
@@ -894,13 +816,11 @@ void cProtocol132::SendEncryptionKeyRequest(void)
 void cProtocol132::HandleEncryptionKeyResponse(const AString & a_EncKey, const AString & a_EncNonce)
 {
 	// Decrypt EncNonce using privkey
-	RSAES<PKCS1v15>::Decryptor rsaDecryptor(cRoot::Get()->GetServer()->GetPrivateKey());
-	time_t CurTime = time(NULL);
-	CryptoPP::RandomPool rng;
-	rng.Put((const byte *)&CurTime, sizeof(CurTime));
+	cRSAPrivateKey & rsaDecryptor = cRoot::Get()->GetServer()->GetPrivateKey();
+
 	Int32 DecryptedNonce[MAX_ENC_LEN / sizeof(Int32)];
-	DecodingResult res = rsaDecryptor.Decrypt(rng, (const byte *)a_EncNonce.data(), a_EncNonce.size(), (byte *)DecryptedNonce);
-	if (!res.isValidCoding || (res.messageLength != 4))
+	int res = rsaDecryptor.Decrypt((const Byte *)a_EncNonce.data(), a_EncNonce.size(), (Byte *)DecryptedNonce, sizeof(DecryptedNonce));
+	if (res != 4)
 	{
 		LOGD("Bad nonce length");
 		m_Client->Kick("Hacked client");
@@ -914,9 +834,9 @@ void cProtocol132::HandleEncryptionKeyResponse(const AString & a_EncKey, const A
 	}
 	
 	// Decrypt the symmetric encryption key using privkey:
-	byte DecryptedKey[MAX_ENC_LEN];
-	res = rsaDecryptor.Decrypt(rng, (const byte *)a_EncKey.data(), a_EncKey.size(), DecryptedKey);
-	if (!res.isValidCoding || (res.messageLength != 16))
+	Byte DecryptedKey[MAX_ENC_LEN];
+	res = rsaDecryptor.Decrypt((const Byte *)a_EncKey.data(), a_EncKey.size(), DecryptedKey, sizeof(DecryptedKey));
+	if (res != 16)
 	{
 		LOGD("Bad key length");
 		m_Client->Kick("Hacked client");
@@ -932,6 +852,12 @@ void cProtocol132::HandleEncryptionKeyResponse(const AString & a_EncKey, const A
 		Flush();
 	}
 	
+	#ifdef _DEBUG
+	AString DecryptedKeyHex;
+	CreateHexDump(DecryptedKeyHex, DecryptedKey, res, 16);
+	LOGD("Received encryption key, %d bytes:\n%s", res, DecryptedKeyHex.c_str());
+	#endif
+	
 	StartEncryption(DecryptedKey);
 	return;
 }
@@ -940,21 +866,21 @@ void cProtocol132::HandleEncryptionKeyResponse(const AString & a_EncKey, const A
 
 
 
-void cProtocol132::StartEncryption(const byte * a_Key)
+void cProtocol132::StartEncryption(const Byte * a_Key)
 {
-	m_Encryptor.SetKey(a_Key, 16, MakeParameters(Name::IV(), ConstByteArrayParameter(a_Key, 16))(Name::FeedbackSize(), 1));
-	m_Decryptor.SetKey(a_Key, 16, MakeParameters(Name::IV(), ConstByteArrayParameter(a_Key, 16))(Name::FeedbackSize(), 1));
+	m_Encryptor.Init(a_Key, a_Key);
+	m_Decryptor.Init(a_Key, a_Key);
 	m_IsEncrypted = true;
 	
 	// Prepare the m_AuthServerID:
-	CryptoPP::SHA1 Checksum;
+	cSHA1Checksum Checksum;
 	AString ServerID = cRoot::Get()->GetServer()->GetServerID();
-	Checksum.Update((const byte *)ServerID.c_str(), ServerID.length());
+	Checksum.Update((const Byte *)ServerID.c_str(), ServerID.length());
 	Checksum.Update(a_Key, 16);
-	Checksum.Update((const byte *)m_ServerPublicKey.c_str(), m_ServerPublicKey.length());
-	byte Digest[20];
-	Checksum.Final(Digest);
-	DigestToJava(Digest, m_AuthServerID);
+	Checksum.Update((const Byte *)cRoot::Get()->GetServer()->GetPublicKeyDER().data(), cRoot::Get()->GetServer()->GetPublicKeyDER().size());
+	Byte Digest[20];
+	Checksum.Finalize(Digest);
+	cSHA1Checksum::DigestToJava(Digest, m_AuthServerID);
 }
 
 
diff --git a/src/Protocol/Protocol132.h b/src/Protocol/Protocol132.h
index 80fc8740a..b280c8a41 100644
--- a/src/Protocol/Protocol132.h
+++ b/src/Protocol/Protocol132.h
@@ -20,13 +20,12 @@
 	#pragma warning(disable:4702)
 #endif
 
-#include "cryptopp/modes.h"
-#include "cryptopp/aes.h"
-
 #ifdef _MSC_VER
 	#pragma warning(pop)
 #endif
 
+#include "../Crypto.h"
+
 
 
 
@@ -41,7 +40,7 @@ public:
 	virtual ~cProtocol132();
 
 	/// Called when client sends some data:
-	virtual void DataReceived(const char * a_Data, int a_Size) override;
+	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 	
 	// Sending commands (alphabetically sorted):
 	virtual void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
@@ -79,17 +78,16 @@ public:
 	
 protected:
 	bool m_IsEncrypted;
-	CryptoPP::CFB_Mode<CryptoPP::AES>::Decryption m_Decryptor;
-	CryptoPP::CFB_Mode<CryptoPP::AES>::Encryption m_Encryptor;
+	
+	cAESCFBDecryptor m_Decryptor;
+	cAESCFBEncryptor m_Encryptor;
+	
 	AString m_DataToSend;
 	
 	/// The ServerID used for session authentication; set in StartEncryption(), used in GetAuthServerID()
 	AString m_AuthServerID;
 	
-	/// The server's public key, as used by SendEncryptionKeyRequest() and StartEncryption()
-	AString m_ServerPublicKey;
-	
-	virtual void SendData(const char * a_Data, int a_Size) override;
+	virtual void SendData(const char * a_Data, size_t a_Size) override;
 	
 	// DEBUG:
 	virtual void Flush(void) override;
@@ -108,7 +106,7 @@ protected:
 	void HandleEncryptionKeyResponse(const AString & a_EncKey, const AString & a_EncNonce);
 	
 	/// Starts the symmetric encryption with the specified key; also sets m_AuthServerID
-	void StartEncryption(const byte * a_Key);
+	void StartEncryption(const Byte * a_Key);
 } ;
 
 
diff --git a/src/Protocol/Protocol14x.cpp b/src/Protocol/Protocol14x.cpp
index 127ce9d4b..f694af1eb 100644
--- a/src/Protocol/Protocol14x.cpp
+++ b/src/Protocol/Protocol14x.cpp
@@ -33,8 +33,6 @@ Implements the 1.4.x protocol classes representing these protocols:
 	#pragma warning(disable:4702)
 #endif
 
-#include "cryptopp/randpool.h"
-
 #ifdef _MSC_VER
 	#pragma warning(pop)
 #endif
@@ -87,7 +85,7 @@ int cProtocol142::ParseLocaleViewDistance(void)
 	HANDLE_PACKET_READ(ReadChar,            char,    ChatFlags);
 	HANDLE_PACKET_READ(ReadChar,            char,    ClientDifficulty);
 	HANDLE_PACKET_READ(ReadChar,            char,    ShouldShowCape);  // <-- new in 1.4.2
-	// TODO: m_Client->HandleLocale(Locale);
+	m_Client->SetLocale(Locale);
 	// TODO: m_Client->HandleViewDistance(ViewDistance);
 	// TODO: m_Client->HandleChatFlags(ChatFlags);
 	// Ignoring client difficulty
@@ -105,9 +103,9 @@ void cProtocol142::SendPickupSpawn(const cPickup & a_Pickup)
 	WriteInt    (a_Pickup.GetUniqueID());
 	WriteItem   (a_Pickup.GetItem());
 	WriteVectorI((Vector3i)(a_Pickup.GetPosition() * 32));
-	WriteByte   ((char)(a_Pickup.GetSpeed().x * 8));
-	WriteByte   ((char)(a_Pickup.GetSpeed().y * 8));
-	WriteByte   ((char)(a_Pickup.GetSpeed().z * 8));
+	WriteChar   ((char)(a_Pickup.GetSpeed().x * 8));
+	WriteChar   ((char)(a_Pickup.GetSpeed().y * 8));
+	WriteChar   ((char)(a_Pickup.GetSpeed().z * 8));
 	Flush();
 }
 
@@ -121,7 +119,7 @@ void cProtocol142::SendSoundParticleEffect(int a_EffectID, int a_SrcX, int a_Src
 	WriteByte(PACKET_SOUND_PARTICLE_EFFECT);
 	WriteInt (a_EffectID);
 	WriteInt (a_SrcX);
-	WriteByte(a_SrcY);
+	WriteByte((Byte)a_SrcY);
 	WriteInt (a_SrcZ);
 	WriteInt (a_Data);
 	WriteBool(0);
@@ -220,7 +218,7 @@ void cProtocol146::SendSpawnObject(const cEntity & a_Entity, char a_ObjectType,
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_SPAWN_OBJECT);
 	WriteInt (a_Entity.GetUniqueID());
-	WriteByte(a_ObjectType);
+	WriteChar(a_ObjectType);
 	WriteInt ((int)(a_Entity.GetPosX() * 32));
 	WriteInt ((int)(a_Entity.GetPosY() * 32));
 	WriteInt ((int)(a_Entity.GetPosZ() * 32));
@@ -245,7 +243,7 @@ void cProtocol146::SendSpawnVehicle(const cEntity & a_Vehicle, char a_VehicleTyp
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_SPAWN_OBJECT);
 	WriteInt  (a_Vehicle.GetUniqueID());
-	WriteByte (a_VehicleType);
+	WriteChar (a_VehicleType);
 	WriteInt  ((int)(a_Vehicle.GetPosX() * 32));
 	WriteInt  ((int)(a_Vehicle.GetPosY() * 32));
 	WriteInt  ((int)(a_Vehicle.GetPosZ() * 32));
diff --git a/src/Protocol/Protocol15x.cpp b/src/Protocol/Protocol15x.cpp
index 0f1e59f10..264a596b9 100644
--- a/src/Protocol/Protocol15x.cpp
+++ b/src/Protocol/Protocol15x.cpp
@@ -35,8 +35,11 @@ Implements the 1.5.x protocol classes:
 
 enum
 {
-	PACKET_WINDOW_OPEN = 0x64,
-	PACKET_PARTICLE_EFFECT = 0x3F,
+	PACKET_WINDOW_OPEN          = 0x64,
+	PACKET_PARTICLE_EFFECT      = 0x3F,
+	PACKET_SCOREBOARD_OBJECTIVE = 0xCE,
+	PACKET_SCORE_UPDATE         = 0xCF,
+	PACKET_DISPLAY_OBJECTIVE    = 0xD0
 } ;
 
 
@@ -97,6 +100,53 @@ void cProtocol150::SendParticleEffect(const AString & a_ParticleName, float a_Sr
 
 
 
+void cProtocol150::SendScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
+{
+	cCSLock Lock(m_CSPacket);
+	WriteByte(PACKET_SCOREBOARD_OBJECTIVE);
+	WriteString(a_Name);
+	WriteString(a_DisplayName);
+	WriteByte(a_Mode);
+	Flush();
+}
+
+
+
+
+
+void cProtocol150::SendScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
+{
+	cCSLock Lock(m_CSPacket);
+	WriteByte(PACKET_SCORE_UPDATE);
+	WriteString(a_Player);
+	WriteByte(a_Mode);
+
+	if (a_Mode != 1)
+	{
+		WriteString(a_Objective);
+		WriteInt((int) a_Score);
+	}
+
+	Flush();
+}
+
+
+
+
+
+void cProtocol150::SendDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
+{
+	cCSLock Lock(m_CSPacket);
+	WriteByte(PACKET_DISPLAY_OBJECTIVE);
+	WriteByte((int) a_Display);
+	WriteString(a_Objective);
+	Flush();
+}
+
+
+
+
+
 int cProtocol150::ParseWindowClick(void)
 {
 	HANDLE_PACKET_READ(ReadChar,    char,  WindowID);
diff --git a/src/Protocol/Protocol15x.h b/src/Protocol/Protocol15x.h
index 0074b3a83..0d171a67c 100644
--- a/src/Protocol/Protocol15x.h
+++ b/src/Protocol/Protocol15x.h
@@ -30,6 +30,9 @@ public:
 	
 	virtual void SendWindowOpen          (const cWindow & a_Window) override;
 	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
+	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
+	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
 
 	virtual int ParseWindowClick(void);
 } ;
diff --git a/src/Protocol/Protocol16x.cpp b/src/Protocol/Protocol16x.cpp
index cfa27b3c4..3da23a1dc 100644
--- a/src/Protocol/Protocol16x.cpp
+++ b/src/Protocol/Protocol16x.cpp
@@ -18,6 +18,7 @@ Implements the 1.6.x protocol classes:
 #include "../Entities/Entity.h"
 #include "../Entities/Player.h"
 #include "../UI/Window.h"
+#include "../CompositeChat.h"
 
 
 
@@ -89,6 +90,18 @@ void cProtocol161::SendChat(const AString & a_Message)
 
 
 
+void cProtocol161::SendChat(const cCompositeChat & a_Message)
+{
+	// This protocol version doesn't support composite messages to the full
+	// Just extract each part's text and use it:
+	
+	super::SendChat(Printf("{\"text\":\"%s\"}", EscapeString(a_Message.ExtractText()).c_str()));
+}
+
+
+
+
+
 void cProtocol161::SendEditSign(int a_BlockX, int a_BlockY, int a_BlockZ)
 {
 	cCSLock Lock(m_CSPacket);
@@ -119,7 +132,7 @@ void cProtocol161::SendHealth(void)
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_UPDATE_HEALTH);
 	WriteFloat((float)m_Client->GetPlayer()->GetHealth());
-	WriteShort(m_Client->GetPlayer()->GetFoodLevel());
+	WriteShort((short)m_Client->GetPlayer()->GetFoodLevel());
 	WriteFloat((float)m_Client->GetPlayer()->GetFoodSaturationLevel());
 	Flush();
 }
@@ -135,7 +148,7 @@ void cProtocol161::SendPlayerMaxSpeed(void)
 	WriteInt(m_Client->GetPlayer()->GetUniqueID());
 	WriteInt(1);
 	WriteString("generic.movementSpeed");
-	WriteDouble(m_Client->GetPlayer()->GetMaxSpeed());
+	WriteDouble(0.1 * m_Client->GetPlayer()->GetMaxSpeed());
 	Flush();
 }
 
@@ -163,10 +176,10 @@ void cProtocol161::SendWindowOpen(const cWindow & a_Window)
 	}
 	cCSLock Lock(m_CSPacket);
 	WriteByte  (PACKET_WINDOW_OPEN);
-	WriteByte  (a_Window.GetWindowID());
-	WriteByte  (a_Window.GetWindowType());
+	WriteChar  (a_Window.GetWindowID());
+	WriteByte  ((Byte)a_Window.GetWindowType());
 	WriteString(a_Window.GetWindowTitle());
-	WriteByte  (a_Window.GetNumNonInventorySlots());
+	WriteByte  ((Byte)a_Window.GetNumNonInventorySlots());
 	WriteByte  (1);  // Use title
 	if (a_Window.GetWindowType() == cWindow::wtAnimalChest)
 	{
@@ -184,7 +197,16 @@ int cProtocol161::ParseEntityAction(void)
 	HANDLE_PACKET_READ(ReadBEInt, int,  EntityID);
 	HANDLE_PACKET_READ(ReadChar,  char, ActionID);
 	HANDLE_PACKET_READ(ReadBEInt, int,  UnknownHorseVal);
-	m_Client->HandleEntityAction(EntityID, ActionID);
+	
+	switch (ActionID)
+	{
+		case 1: m_Client->HandleEntityCrouch(EntityID, true);     break; // Crouch
+		case 2: m_Client->HandleEntityCrouch(EntityID, false);    break; // Uncrouch
+		case 3: m_Client->HandleEntityLeaveBed(EntityID);         break; // Leave Bed
+		case 4: m_Client->HandleEntitySprinting(EntityID, true);  break; // Start sprinting
+		case 5: m_Client->HandleEntitySprinting(EntityID, false); break; // Stop sprinting
+	}
+
 	return PARSE_OK;
 }
 
@@ -258,7 +280,7 @@ void cProtocol162::SendPlayerMaxSpeed(void)
 	WriteInt(m_Client->GetPlayer()->GetUniqueID());
 	WriteInt(1);
 	WriteString("generic.movementSpeed");
-	WriteDouble(m_Client->GetPlayer()->GetMaxSpeed());
+	WriteDouble(0.1 * m_Client->GetPlayer()->GetMaxSpeed());
 	WriteShort(0);
 	Flush();
 }
diff --git a/src/Protocol/Protocol16x.h b/src/Protocol/Protocol16x.h
index 325e41c5a..ae1388649 100644
--- a/src/Protocol/Protocol16x.h
+++ b/src/Protocol/Protocol16x.h
@@ -37,6 +37,7 @@ protected:
 	// cProtocol150 overrides:
 	virtual void SendAttachEntity  (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
 	virtual void SendChat          (const AString & a_Message) override;
+	virtual void SendChat          (const cCompositeChat & a_Message) override;
 	virtual void SendEditSign      (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
 	virtual void SendGameMode      (eGameMode a_GameMode) override;
 	virtual void SendHealth        (void) override;
diff --git a/src/Protocol/Protocol17x.cpp b/src/Protocol/Protocol17x.cpp
index 05b7ebd45..785dbf935 100644
--- a/src/Protocol/Protocol17x.cpp
+++ b/src/Protocol/Protocol17x.cpp
@@ -1,4 +1,3 @@
-
 // Protocol17x.cpp
 
 /*
@@ -9,6 +8,7 @@ Implements the 1.7.x protocol classes:
 */
 
 #include "Globals.h"
+#include "json/json.h"
 #include "Protocol17x.h"
 #include "ChunkDataSerializer.h"
 #include "../ClientHandle.h"
@@ -21,11 +21,16 @@ Implements the 1.7.x protocol classes:
 #include "../Entities/ExpOrb.h"
 #include "../Entities/Minecart.h"
 #include "../Entities/FallingBlock.h"
+#include "../Entities/Painting.h"
 #include "../Entities/Pickup.h"
 #include "../Entities/Player.h"
+#include "../Entities/ItemFrame.h"
 #include "../Mobs/IncludeAllMonsters.h"
 #include "../UI/Window.h"
 #include "../BlockEntities/CommandBlockEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
+#include "../CompositeChat.h"
 
 
 
@@ -54,6 +59,22 @@ Implements the 1.7.x protocol classes:
 
 
 
+const int MAX_ENC_LEN = 512;  // Maximum size of the encrypted message; should be 128, but who knows...
+
+
+
+
+
+// fwd: main.cpp:
+extern bool g_ShouldLogCommIn, g_ShouldLogCommOut;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cProtocol172:
+
 cProtocol172::cProtocol172(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State) :
 	super(a_Client),
 	m_ServerAddress(a_ServerAddress),
@@ -64,21 +85,28 @@ cProtocol172::cProtocol172(cClientHandle * a_Client, const AString & a_ServerAdd
 	m_OutPacketLenBuffer(20),  // 20 bytes is more than enough for one VarInt
 	m_IsEncrypted(false)
 {
+	// Create the comm log file, if so requested:
+	if (g_ShouldLogCommIn || g_ShouldLogCommOut)
+	{
+		cFile::CreateFolder("CommLogs");
+		AString FileName = Printf("CommLogs/%x__%s.log", (unsigned)time(NULL), a_Client->GetIPString().c_str());
+		m_CommLogFile.Open(FileName, cFile::fmWrite);
+	}
 }
 
 
 
 
 
-void cProtocol172::DataReceived(const char * a_Data, int a_Size)
+void cProtocol172::DataReceived(const char * a_Data, size_t a_Size)
 {
 	if (m_IsEncrypted)
 	{
-		byte Decrypted[512];
+		Byte Decrypted[512];
 		while (a_Size > 0)
 		{
-			int NumBytes = (a_Size > sizeof(Decrypted)) ? sizeof(Decrypted) : a_Size;
-			m_Decryptor.ProcessData(Decrypted, (byte *)a_Data, NumBytes);
+			size_t NumBytes = (a_Size > sizeof(Decrypted)) ? sizeof(Decrypted) : a_Size;
+			m_Decryptor.ProcessData(Decrypted, (Byte *)a_Data, NumBytes);
 			AddReceivedData((const char *)Decrypted, NumBytes);
 			a_Size -= NumBytes;
 			a_Data += NumBytes;
@@ -124,7 +152,7 @@ void cProtocol172::SendBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, cha
 void cProtocol172::SendBlockBreakAnim(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage)
 {
 	cPacketizer Pkt(*this, 0x25);  // Block Break Animation packet
-	Pkt.WriteInt(a_EntityID);
+	Pkt.WriteVarInt(a_EntityID);
 	Pkt.WriteInt(a_BlockX);
 	Pkt.WriteInt(a_BlockY);
 	Pkt.WriteInt(a_BlockZ);
@@ -178,6 +206,78 @@ void cProtocol172::SendChat(const AString & a_Message)
 
 
 
+void cProtocol172::SendChat(const cCompositeChat & a_Message)
+{
+	// Compose the complete Json string to send:
+	Json::Value msg;
+	msg["text"] = "";  // The client crashes without this
+	const cCompositeChat::cParts & Parts = a_Message.GetParts();
+	for (cCompositeChat::cParts::const_iterator itr = Parts.begin(), end = Parts.end(); itr != end; ++itr)
+	{
+		Json::Value Part;
+		switch ((*itr)->m_PartType)
+		{
+			case cCompositeChat::ptText:
+			{
+				Part["text"] = (*itr)->m_Text;
+				AddChatPartStyle(Part, (*itr)->m_Style);
+				break;
+			}
+			
+			case cCompositeChat::ptClientTranslated:
+			{
+				const cCompositeChat::cClientTranslatedPart & p = (const cCompositeChat::cClientTranslatedPart &)**itr;
+				Part["translate"] = p.m_Text;
+				Json::Value With;
+				for (AStringVector::const_iterator itrW = p.m_Parameters.begin(), endW = p.m_Parameters.end(); itrW != endW; ++itr)
+				{
+					With.append(*itrW);
+				}
+				if (!p.m_Parameters.empty())
+				{
+					Part["with"] = With;
+				}
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+			
+			case cCompositeChat::ptUrl:
+			{
+				const cCompositeChat::cUrlPart & p = (const cCompositeChat::cUrlPart &)**itr;
+				Part["text"] = p.m_Text;
+				Json::Value Url;
+				Url["action"] = "open_url";
+				Url["value"] = p.m_Url;
+				Part["clickEvent"] = Url;
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+			
+			case cCompositeChat::ptSuggestCommand:
+			case cCompositeChat::ptRunCommand:
+			{
+				const cCompositeChat::cCommandPart & p = (const cCompositeChat::cCommandPart &)**itr;
+				Part["text"] = p.m_Text;
+				Json::Value Cmd;
+				Cmd["action"] = (p.m_PartType == cCompositeChat::ptRunCommand) ? "run_command" : "suggest_command";
+				Cmd["value"] = p.m_Command;
+				Part["clickEvent"] = Cmd;
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+		}
+		msg["extra"].append(Part);
+	}  // for itr - Parts[]
+	
+	// Send the message to the client:
+	cPacketizer Pkt(*this, 0x02);
+	Pkt.WriteString(msg.toStyledString());
+}
+
+
+
+
+
 void cProtocol172::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer)
 {
 	// Serialize first, before creating the Packetizer (the packetizer locks a CS)
@@ -454,7 +554,7 @@ void cProtocol172::SendLogin(const cPlayer & a_Player, const cWorld & a_World)
 		Pkt.WriteByte((Byte)a_Player.GetEffectiveGameMode() | (cRoot::Get()->GetServer()->IsHardcore() ? 0x08 : 0)); // Hardcore flag bit 4
 		Pkt.WriteChar((char)a_World.GetDimension());
 		Pkt.WriteByte(2);  // TODO: Difficulty (set to Normal)
-		Pkt.WriteByte(cRoot::Get()->GetServer()->GetMaxPlayers());
+		Pkt.WriteByte(std::min(cRoot::Get()->GetServer()->GetMaxPlayers(), 60));
 		Pkt.WriteString("default");  // Level type - wtf?
 	}
 	
@@ -473,6 +573,75 @@ void cProtocol172::SendLogin(const cPlayer & a_Player, const cWorld & a_World)
 
 
 
+void cProtocol172::SendPaintingSpawn(const cPainting & a_Painting)
+{
+	cPacketizer Pkt(*this, 0x10);  // Spawn Painting packet
+	Pkt.WriteVarInt(a_Painting.GetUniqueID());
+	Pkt.WriteString(a_Painting.GetName().c_str());
+	Pkt.WriteInt((int)a_Painting.GetPosX());
+	Pkt.WriteInt((int)a_Painting.GetPosY());
+	Pkt.WriteInt((int)a_Painting.GetPosZ());
+	Pkt.WriteInt(a_Painting.GetDirection());
+}
+
+
+
+
+
+void cProtocol172::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+{
+	cPacketizer Pkt(*this, 0x34);
+	Pkt.WriteVarInt(a_ID);
+	Pkt.WriteShort (3 + a_Length);
+
+	Pkt.WriteByte(0);
+	Pkt.WriteByte(a_X);
+	Pkt.WriteByte(a_Y);
+	
+	for (unsigned int i = 0; i < a_Length; ++i)
+	{
+		Pkt.WriteByte(a_Colors[i]);
+	}
+}
+
+
+
+
+
+void cProtocol172::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+{
+	cPacketizer Pkt(*this, 0x34);
+	Pkt.WriteVarInt(a_ID);
+	Pkt.WriteShort (1 + (3 * a_Decorators.size()));
+
+	Pkt.WriteByte(1);
+	
+	for (cMapDecoratorList::const_iterator it = a_Decorators.begin(); it != a_Decorators.end(); ++it)
+	{
+		Pkt.WriteByte((it->GetType() << 4) | (it->GetRot() & 0xf));
+		Pkt.WriteByte(it->GetPixelX());
+		Pkt.WriteByte(it->GetPixelZ());
+	}
+}
+
+
+
+
+
+void cProtocol172::SendMapInfo(int a_ID, unsigned int a_Scale)
+{
+	cPacketizer Pkt(*this, 0x34);
+	Pkt.WriteVarInt(a_ID);
+	Pkt.WriteShort (2);
+
+	Pkt.WriteByte(2);
+	Pkt.WriteByte(a_Scale);
+}
+
+
+
+
+
 
 void cProtocol172::SendPickupSpawn(const cPickup & a_Pickup)
 {
@@ -518,9 +687,8 @@ void cProtocol172::SendPlayerAbilities(void)
 		Flags |= 0x04;
 	}
 	Pkt.WriteByte(Flags);
-	// TODO: Pkt.WriteFloat(m_Client->GetPlayer()->GetMaxFlyingSpeed());
-	Pkt.WriteFloat(0.05f);
-	Pkt.WriteFloat((float)m_Client->GetPlayer()->GetMaxSpeed());
+	Pkt.WriteFloat((float)(0.05 * m_Client->GetPlayer()->GetFlyingMaxSpeed()));
+	Pkt.WriteFloat((float)(0.1 * m_Client->GetPlayer()->GetMaxSpeed()));
 }
 
 
@@ -574,13 +742,14 @@ void cProtocol172::SendPlayerMaxSpeed(void)
 	Pkt.WriteInt(m_Client->GetPlayer()->GetUniqueID());
 	Pkt.WriteInt(1);  // Count
 	Pkt.WriteString("generic.movementSpeed");
-	Pkt.WriteDouble(0.1);
+	// The default game speed is 0.1, multiply that value by the relative speed:
+	Pkt.WriteDouble(0.1 * m_Client->GetPlayer()->GetNormalMaxSpeed());
 	if (m_Client->GetPlayer()->IsSprinting())
 	{
 		Pkt.WriteShort(1);  // Modifier count
 		Pkt.WriteInt64(0x662a6b8dda3e4c1c);
 		Pkt.WriteInt64(0x881396ea6097278d);  // UUID of the modifier
-		Pkt.WriteDouble(0.3);
+		Pkt.WriteDouble(m_Client->GetPlayer()->GetSprintingMaxSpeed() - m_Client->GetPlayer()->GetNormalMaxSpeed());
 		Pkt.WriteByte(2);
 	}
 	else
@@ -707,6 +876,46 @@ void cProtocol172::SendExperienceOrb(const cExpOrb & a_ExpOrb)
 
 
 
+void cProtocol172::SendScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
+{
+	cPacketizer Pkt(*this, 0x3B);
+	Pkt.WriteString(a_Name);
+	Pkt.WriteString(a_DisplayName);
+	Pkt.WriteByte(a_Mode);
+}
+
+
+
+
+
+void cProtocol172::SendScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
+{
+	cPacketizer Pkt(*this, 0x3C);
+	Pkt.WriteString(a_Player);
+	Pkt.WriteByte(a_Mode);
+
+	if (a_Mode != 1)
+	{
+		Pkt.WriteString(a_Objective);
+		Pkt.WriteInt((int) a_Score);
+	}
+}
+
+
+
+
+
+void cProtocol172::SendDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
+{
+	cPacketizer Pkt(*this, 0x3D);
+	Pkt.WriteByte((int) a_Display);
+	Pkt.WriteString(a_Objective);
+}
+
+
+
+
+
 void cProtocol172::SendSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch)  // a_Src coords are Block * 8
 {
 	cPacketizer Pkt(*this, 0x29);  // Sound Effect packet
@@ -787,8 +996,8 @@ void cProtocol172::SendSpawnObject(const cEntity & a_Entity, char a_ObjectType,
 	Pkt.WriteFPInt(a_Entity.GetPosX());
 	Pkt.WriteFPInt(a_Entity.GetPosY());
 	Pkt.WriteFPInt(a_Entity.GetPosZ());
-	Pkt.WriteByteAngle(a_Entity.GetYaw());
 	Pkt.WriteByteAngle(a_Entity.GetPitch());
+	Pkt.WriteByteAngle(a_Entity.GetYaw());
 	Pkt.WriteInt(a_ObjectData);
 	if (a_ObjectData != 0)
 	{
@@ -810,8 +1019,8 @@ void cProtocol172::SendSpawnVehicle(const cEntity & a_Vehicle, char a_VehicleTyp
 	Pkt.WriteFPInt(a_Vehicle.GetPosX());
 	Pkt.WriteFPInt(a_Vehicle.GetPosY());
 	Pkt.WriteFPInt(a_Vehicle.GetPosZ());
-	Pkt.WriteByteAngle(a_Vehicle.GetYaw());
 	Pkt.WriteByteAngle(a_Vehicle.GetPitch());
+	Pkt.WriteByteAngle(a_Vehicle.GetYaw());
 	Pkt.WriteInt(a_VehicleSubType);
 	if (a_VehicleSubType != 0)
 	{
@@ -906,6 +1115,8 @@ void cProtocol172::SendUpdateBlockEntity(cBlockEntity & a_BlockEntity)
 	{
 		case E_BLOCK_MOB_SPAWNER:   Action = 1; break; // Update mob spawner spinny mob thing
 		case E_BLOCK_COMMAND_BLOCK: Action = 2; break; // Update command block text
+		case E_BLOCK_HEAD:          Action = 4; break; // Update Mobhead entity
+		case E_BLOCK_FLOWER_POT:    Action = 5; break; // Update flower pot
 		default: ASSERT(!"Unhandled or unimplemented BlockEntity update request!"); break;
 	}
 	Pkt.WriteByte(Action);
@@ -923,10 +1134,11 @@ void cProtocol172::SendUpdateSign(int a_BlockX, int a_BlockY, int a_BlockZ, cons
 	Pkt.WriteInt(a_BlockX);
 	Pkt.WriteShort((short)a_BlockY);
 	Pkt.WriteInt(a_BlockZ);
-	Pkt.WriteString(a_Line1);
-	Pkt.WriteString(a_Line2);
-	Pkt.WriteString(a_Line3);
-	Pkt.WriteString(a_Line4);
+	// Need to send only up to 15 chars, otherwise the client crashes (#598)
+	Pkt.WriteString(a_Line1.substr(0, 15));
+	Pkt.WriteString(a_Line2.substr(0, 15));
+	Pkt.WriteString(a_Line3.substr(0, 15));
+	Pkt.WriteString(a_Line4.substr(0, 15));
 }
 
 
@@ -1024,8 +1236,33 @@ void cProtocol172::SendWindowProperty(const cWindow & a_Window, short a_Property
 
 
 
-void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
+void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 {
+	// Write the incoming data into the comm log file:
+	if (g_ShouldLogCommIn)
+	{
+		if (m_ReceivedData.GetReadableSpace() > 0)
+		{
+			AString AllData;
+			size_t OldReadableSpace = m_ReceivedData.GetReadableSpace();
+			m_ReceivedData.ReadAll(AllData);
+			m_ReceivedData.ResetRead();
+			m_ReceivedData.SkipRead(m_ReceivedData.GetReadableSpace() - OldReadableSpace);
+			ASSERT(m_ReceivedData.GetReadableSpace() == OldReadableSpace);
+			AString Hex;
+			CreateHexDump(Hex, AllData.data(), AllData.size(), 16);
+			m_CommLogFile.Printf("Incoming data, " SIZE_T_FMT " (0x" SIZE_T_FMT_HEX ") unparsed bytes already present in buffer:\n%s\n",
+				AllData.size(), AllData.size(), Hex.c_str()
+			);
+		}
+		AString Hex;
+		CreateHexDump(Hex, a_Data, a_Size, 16);
+		m_CommLogFile.Printf("Incoming data: %d (0x%x) bytes: \n%s\n",
+			(unsigned)a_Size, (unsigned)a_Size, Hex.c_str()
+		);
+		m_CommLogFile.Flush();
+	}
+	
 	if (!m_ReceivedData.Write(a_Data, a_Size))
 	{
 		// Too much data in the incoming queue, report to caller:
@@ -1040,12 +1277,14 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
 		if (!m_ReceivedData.ReadVarInt(PacketLen))
 		{
 			// Not enough data
-			return;
+			m_ReceivedData.ResetRead();
+			break;
 		}
 		if (!m_ReceivedData.CanReadBytes(PacketLen))
 		{
 			// The full packet hasn't been received yet
-			return;
+			m_ReceivedData.ResetRead();
+			break;
 		}
 		cByteBuffer bb(PacketLen + 1);
 		VERIFY(m_ReceivedData.ReadToByteBuffer(bb, (int)PacketLen));
@@ -1058,9 +1297,25 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
 		if (!bb.ReadVarInt(PacketType))
 		{
 			// Not enough data
-			return;
+			break;
 		}
 
+		// Log the packet info into the comm log file:
+		if (g_ShouldLogCommIn)
+		{
+			AString PacketData;
+			bb.ReadAll(PacketData);
+			bb.ResetRead();
+			bb.ReadVarInt(PacketType);
+			ASSERT(PacketData.size() > 0);
+			PacketData.resize(PacketData.size() - 1);
+			AString PacketDataHex;
+			CreateHexDump(PacketDataHex, PacketData.data(), PacketData.size(), 16);
+			m_CommLogFile.Printf("Next incoming packet is type %u (0x%x), length %u (0x%x) at state %d. Payload:\n%s\n",
+				PacketType, PacketType, PacketLen, PacketLen, m_State, PacketDataHex.c_str()
+			);
+		}
+		
 		if (!HandlePacket(bb, PacketType))
 		{
 			// Unknown packet, already been reported, but without the length. Log the length here:
@@ -1077,19 +1332,52 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
 				LOGD("Packet contents:\n%s", Out.c_str());
 			#endif  // _DEBUG
 			
+			// Put a message in the comm log:
+			if (g_ShouldLogCommIn)
+			{
+				m_CommLogFile.Printf("^^^^^^ Unhandled packet ^^^^^^\n\n\n");
+			}
+			
 			return;
 		}
 		
 		if (bb.GetReadableSpace() != 1)
 		{
 			// Read more or less than packet length, report as error
-			LOGWARNING("Protocol 1.7: Wrong number of bytes read for packet 0x%x, state %d. Read %u bytes, packet contained %u bytes",
+			LOGWARNING("Protocol 1.7: Wrong number of bytes read for packet 0x%x, state %d. Read " SIZE_T_FMT " bytes, packet contained %u bytes",
 				PacketType, m_State, bb.GetUsedSpace() - bb.GetReadableSpace(), PacketLen
 			);
+
+			// Put a message in the comm log:
+			if (g_ShouldLogCommIn)
+			{
+				m_CommLogFile.Printf("^^^^^^ Wrong number of bytes read for this packet (exp %d left, got " SIZE_T_FMT " left) ^^^^^^\n\n\n",
+					1, bb.GetReadableSpace()
+				);
+				m_CommLogFile.Flush();
+			}
+
 			ASSERT(!"Read wrong number of bytes!");
 			m_Client->PacketError(PacketType);
 		}
-	}  // while (true)
+	}  // for(ever)
+	
+	// Log any leftover bytes into the logfile:
+	if (g_ShouldLogCommIn && (m_ReceivedData.GetReadableSpace() > 0))
+	{
+		AString AllData;
+		size_t OldReadableSpace = m_ReceivedData.GetReadableSpace();
+		m_ReceivedData.ReadAll(AllData);
+		m_ReceivedData.ResetRead();
+		m_ReceivedData.SkipRead(m_ReceivedData.GetReadableSpace() - OldReadableSpace);
+		ASSERT(m_ReceivedData.GetReadableSpace() == OldReadableSpace);
+		AString Hex;
+		CreateHexDump(Hex, AllData.data(), AllData.size(), 16);
+		m_CommLogFile.Printf("There are " SIZE_T_FMT " (0x" SIZE_T_FMT_HEX ") bytes of non-parse-able data left in the buffer:\n%s",
+			m_ReceivedData.GetReadableSpace(), m_ReceivedData.GetReadableSpace(), Hex.c_str()
+		);
+		m_CommLogFile.Flush();
+	}
 }
 
 
@@ -1220,7 +1508,64 @@ void cProtocol172::HandlePacketStatusRequest(cByteBuffer & a_ByteBuffer)
 
 void cProtocol172::HandlePacketLoginEncryptionResponse(cByteBuffer & a_ByteBuffer)
 {
-	// TODO: Add protocol encryption
+	short EncKeyLength, EncNonceLength;
+	a_ByteBuffer.ReadBEShort(EncKeyLength);
+	AString EncKey;
+	if (!a_ByteBuffer.ReadString(EncKey, EncKeyLength))
+	{
+		return;
+	}
+	a_ByteBuffer.ReadBEShort(EncNonceLength);
+	AString EncNonce;
+	if (!a_ByteBuffer.ReadString(EncNonce, EncNonceLength))
+	{
+		return;
+	}
+	if ((EncKeyLength > MAX_ENC_LEN) || (EncNonceLength > MAX_ENC_LEN))
+	{
+		LOGD("Too long encryption");
+		m_Client->Kick("Hacked client");
+		return;
+	}
+
+	// Decrypt EncNonce using privkey
+	cRSAPrivateKey & rsaDecryptor = cRoot::Get()->GetServer()->GetPrivateKey();
+	Int32 DecryptedNonce[MAX_ENC_LEN / sizeof(Int32)];
+	int res = rsaDecryptor.Decrypt((const Byte *)EncNonce.data(), EncNonce.size(), (Byte *)DecryptedNonce, sizeof(DecryptedNonce));
+	if (res != 4)
+	{
+		LOGD("Bad nonce length: got %d, exp %d", res, 4);
+		m_Client->Kick("Hacked client");
+		return;
+	}
+	if (ntohl(DecryptedNonce[0]) != (unsigned)(uintptr_t)this)
+	{
+		LOGD("Bad nonce value");
+		m_Client->Kick("Hacked client");
+		return;
+	}
+	
+	// Decrypt the symmetric encryption key using privkey:
+	Byte DecryptedKey[MAX_ENC_LEN];
+	res = rsaDecryptor.Decrypt((const Byte *)EncKey.data(), EncKey.size(), DecryptedKey, sizeof(DecryptedKey));
+	if (res != 16)
+	{
+		LOGD("Bad key length");
+		m_Client->Kick("Hacked client");
+		return;
+	}
+	
+	StartEncryption(DecryptedKey);
+
+	// Send login success:
+	{
+		cPacketizer Pkt(*this, 0x02);  // Login success packet
+		Pkt.WriteString(Printf("%d", m_Client->GetUniqueID()));  // TODO: proper UUID
+		Pkt.WriteString(m_Client->GetUsername());
+	}
+
+	m_State = 3;  // State = Game
+	m_Client->HandleLogin(4, m_Client->GetUsername());
 }
 
 
@@ -1232,14 +1577,26 @@ void cProtocol172::HandlePacketLoginStart(cByteBuffer & a_ByteBuffer)
 	AString Username;
 	a_ByteBuffer.ReadVarUTF8String(Username);
 	
-	// TODO: Protocol encryption should be set up here if not localhost / auth
-	
 	if (!m_Client->HandleHandshake(Username))
 	{
 		// The client is not welcome here, they have been sent a Kick packet already
 		return;
 	}
 	
+	// If auth is required, then send the encryption request:
+	if (cRoot::Get()->GetServer()->ShouldAuthenticate())
+	{
+		cPacketizer Pkt(*this, 0x01);
+		Pkt.WriteString(cRoot::Get()->GetServer()->GetServerID());
+		const AString & PubKeyDer = cRoot::Get()->GetServer()->GetPublicKeyDER();
+		Pkt.WriteShort(PubKeyDer.size());
+		Pkt.WriteBuf(PubKeyDer.data(), PubKeyDer.size());
+		Pkt.WriteShort(4);
+		Pkt.WriteInt((int)(intptr_t)this);  // Using 'this' as the cryptographic nonce, so that we don't have to generate one each time :)
+		m_Client->SetUsername(Username);
+		return;
+	}
+	
 	// Send login success:
 	{
 		cPacketizer Pkt(*this, 0x02);  // Login success packet
@@ -1272,8 +1629,8 @@ void cProtocol172::HandlePacketBlockDig(cByteBuffer & a_ByteBuffer)
 	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  BlockX);
 	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, BlockY);
 	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  BlockZ);
-	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Face);
-	m_Client->HandleLeftClick(BlockX, BlockY, BlockZ, Face, Status);
+	HANDLE_READ(a_ByteBuffer, ReadChar,  char, Face);
+	m_Client->HandleLeftClick(BlockX, BlockY, BlockZ, static_cast<eBlockFace>(Face), Status);
 }
 
 
@@ -1285,14 +1642,14 @@ void cProtocol172::HandlePacketBlockPlace(cByteBuffer & a_ByteBuffer)
 	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  BlockX);
 	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, BlockY);
 	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  BlockZ);
-	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Face);
+	HANDLE_READ(a_ByteBuffer, ReadChar,  char, Face);
 	cItem Item;
 	ReadItem(a_ByteBuffer, Item);
 
 	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, CursorX);
 	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, CursorY);
 	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, CursorZ);
-	m_Client->HandleRightClick(BlockX, BlockY, BlockZ, Face, CursorX, CursorY, CursorZ, m_Client->GetPlayer()->GetEquippedItem());
+	m_Client->HandleRightClick(BlockX, BlockY, BlockZ, static_cast<eBlockFace>(Face), CursorX, CursorY, CursorZ, m_Client->GetPlayer()->GetEquippedItem());
 }
 
 
@@ -1317,6 +1674,8 @@ void cProtocol172::HandlePacketClientSettings(cByteBuffer & a_ByteBuffer)
 	HANDLE_READ(a_ByteBuffer, ReadByte,          Byte,    ChatColors);
 	HANDLE_READ(a_ByteBuffer, ReadByte,          Byte,    Difficulty);
 	HANDLE_READ(a_ByteBuffer, ReadByte,          Byte,    ShowCape);
+	
+	m_Client->SetLocale(Locale);
 	// TODO: handle in m_Client
 }
 
@@ -1374,7 +1733,15 @@ void cProtocol172::HandlePacketEntityAction(cByteBuffer & a_ByteBuffer)
 	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  PlayerID);
 	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Action);
 	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  JumpBoost);
-	m_Client->HandleEntityAction(PlayerID, Action);
+
+	switch (Action)
+	{
+		case 1: m_Client->HandleEntityCrouch(PlayerID, true);     break; // Crouch
+		case 2: m_Client->HandleEntityCrouch(PlayerID, false);    break; // Uncrouch
+		case 3: m_Client->HandleEntityLeaveBed(PlayerID);         break; // Leave Bed
+		case 4: m_Client->HandleEntitySprinting(PlayerID, true);  break; // Start sprinting
+		case 5: m_Client->HandleEntitySprinting(PlayerID, false); break; // Stop sprinting
+	}
 }
 
 
@@ -1637,15 +2004,15 @@ void cProtocol172::WritePacket(cByteBuffer & a_Packet)
 
 
 
-void cProtocol172::SendData(const char * a_Data, int a_Size)
+void cProtocol172::SendData(const char * a_Data, size_t a_Size)
 {
 	if (m_IsEncrypted)
 	{
-		byte Encrypted[8192];  // Larger buffer, we may be sending lots of data (chunks)
+		Byte Encrypted[8192];  // Larger buffer, we may be sending lots of data (chunks)
 		while (a_Size > 0)
 		{
-			int NumBytes = (a_Size > sizeof(Encrypted)) ? sizeof(Encrypted) : a_Size;
-			m_Encryptor.ProcessData(Encrypted, (byte *)a_Data, NumBytes);
+			size_t NumBytes = (a_Size > sizeof(Encrypted)) ? sizeof(Encrypted) : a_Size;
+			m_Encryptor.ProcessData(Encrypted, (Byte *)a_Data, NumBytes);
 			m_Client->SendData((const char *)Encrypted, NumBytes);
 			a_Size -= NumBytes;
 			a_Data += NumBytes;
@@ -1711,7 +2078,7 @@ void cProtocol172::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
 	{
 		AString HexDump;
 		CreateHexDump(HexDump, a_Metadata.data(), a_Metadata.size(), 16);
-		LOGWARNING("Cannot unGZIP item metadata (%u bytes):\n%s", a_Metadata.size(), HexDump.c_str());
+		LOGWARNING("Cannot unGZIP item metadata (" SIZE_T_FMT " bytes):\n%s", a_Metadata.size(), HexDump.c_str());
 		return;
 	}
 	
@@ -1721,43 +2088,54 @@ void cProtocol172::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
 	{
 		AString HexDump;
 		CreateHexDump(HexDump, Uncompressed.data(), Uncompressed.size(), 16);
-		LOGWARNING("Cannot parse NBT item metadata: (%u bytes)\n%s", Uncompressed.size(), HexDump.c_str());
+		LOGWARNING("Cannot parse NBT item metadata: (" SIZE_T_FMT " bytes)\n%s", Uncompressed.size(), HexDump.c_str());
 		return;
 	}
 	
 	// Load enchantments and custom display names from the NBT data:
 	for (int tag = NBT.GetFirstChild(NBT.GetRoot()); tag >= 0; tag = NBT.GetNextSibling(tag))
 	{
-		if (
-			(NBT.GetType(tag) == TAG_List) &&
-			(
-				(NBT.GetName(tag) == "ench") ||
-				(NBT.GetName(tag) == "StoredEnchantments")
-			)
-		)
-		{
-			EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, NBT, tag);
-		}
-		else if ((NBT.GetType(tag) == TAG_Compound) && (NBT.GetName(tag) == "display")) // Custom name and lore tag
+		AString TagName = NBT.GetName(tag);
+		switch (NBT.GetType(tag))
 		{
-			for (int displaytag = NBT.GetFirstChild(tag); displaytag >= 0; displaytag = NBT.GetNextSibling(displaytag))
+			case TAG_List:
 			{
-				if ((NBT.GetType(displaytag) == TAG_String) && (NBT.GetName(displaytag) == "Name")) // Custon name tag
+				if ((TagName == "ench") || (TagName == "StoredEnchantments")) // Enchantments tags
 				{
-					a_Item.m_CustomName = NBT.GetString(displaytag);
+					EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, NBT, tag);
 				}
-				else if ((NBT.GetType(displaytag) == TAG_List) && (NBT.GetName(displaytag) == "Lore")) // Lore tag
+				break;
+			}
+			case TAG_Compound:
+			{
+				if (TagName == "display") // Custom name and lore tag
 				{
-					AString Lore;
-
-					for (int loretag = NBT.GetFirstChild(displaytag); loretag >= 0; loretag = NBT.GetNextSibling(loretag)) // Loop through array of strings
+					for (int displaytag = NBT.GetFirstChild(tag); displaytag >= 0; displaytag = NBT.GetNextSibling(displaytag))
 					{
-						AppendPrintf(Lore, "%s`", NBT.GetString(loretag).c_str()); // Append the lore with a newline, used internally by MCS to display a new line in the client; don't forget to c_str ;)
+						if ((NBT.GetType(displaytag) == TAG_String) && (NBT.GetName(displaytag) == "Name")) // Custon name tag
+						{
+							a_Item.m_CustomName = NBT.GetString(displaytag);
+						}
+						else if ((NBT.GetType(displaytag) == TAG_List) && (NBT.GetName(displaytag) == "Lore")) // Lore tag
+						{
+							AString Lore;
+
+							for (int loretag = NBT.GetFirstChild(displaytag); loretag >= 0; loretag = NBT.GetNextSibling(loretag)) // Loop through array of strings
+							{
+								AppendPrintf(Lore, "%s`", NBT.GetString(loretag).c_str()); // Append the lore with a newline, used internally by MCS to display a new line in the client; don't forget to c_str ;)
+							}
+
+							a_Item.m_Lore = Lore;
+						}
 					}
-
-					a_Item.m_Lore = Lore;
 				}
+				else if ((TagName == "Fireworks") || (TagName == "Explosion"))
+				{
+					cFireworkItem::ParseFromNBT(a_Item.m_FireworkItem, NBT, tag, (ENUM_ITEM_ID)a_Item.m_ItemType);
+				}
+				break;
 			}
+			default: LOGD("Unimplemented NBT data when parsing!"); break;
 		}
 	}
 }
@@ -1766,6 +2144,106 @@ void cProtocol172::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
 
 
 
+void cProtocol172::StartEncryption(const Byte * a_Key)
+{
+	m_Encryptor.Init(a_Key, a_Key);
+	m_Decryptor.Init(a_Key, a_Key);
+	m_IsEncrypted = true;
+	
+	// Prepare the m_AuthServerID:
+	cSHA1Checksum Checksum;
+	const AString & ServerID = cRoot::Get()->GetServer()->GetServerID();
+	Checksum.Update((const Byte *)ServerID.c_str(), ServerID.length());
+	Checksum.Update(a_Key, 16);
+	Checksum.Update((const Byte *)cRoot::Get()->GetServer()->GetPublicKeyDER().data(), cRoot::Get()->GetServer()->GetPublicKeyDER().size());
+	Byte Digest[20];
+	Checksum.Finalize(Digest);
+	cSHA1Checksum::DigestToJava(Digest, m_AuthServerID);
+}
+
+
+
+
+
+void cProtocol172::AddChatPartStyle(Json::Value & a_Value, const AString & a_PartStyle)
+{
+	size_t len = a_PartStyle.length();
+	for (size_t i = 0; i < len; i++)
+	{
+		switch (a_PartStyle[i])
+		{
+			case 'b':
+			{
+				// bold
+				a_Value["bold"] = Json::Value(true);
+				break;
+			}
+			
+			case 'i':
+			{
+				// italic
+				a_Value["italic"] = Json::Value(true);
+				break;
+			}
+			
+			case 'u':
+			{
+				// Underlined
+				a_Value["underlined"] = Json::Value(true);
+				break;
+			}
+			
+			case 's':
+			{
+				// strikethrough
+				a_Value["strikethrough"] = Json::Value(true);
+				break;
+			}
+			
+			case 'o':
+			{
+				// obfuscated
+				a_Value["obfuscated"] = Json::Value(true);
+				break;
+			}
+			
+			case '@':
+			{
+				// Color, specified by the next char:
+				i++;
+				if (i >= len)
+				{
+					// String too short, didn't contain a color
+					break;
+				}
+				switch (a_PartStyle[i])
+				{
+					case '0': a_Value["color"] = Json::Value("black");        break;
+					case '1': a_Value["color"] = Json::Value("dark_blue");    break;
+					case '2': a_Value["color"] = Json::Value("dark_green");   break;
+					case '3': a_Value["color"] = Json::Value("dark_aqua");    break;
+					case '4': a_Value["color"] = Json::Value("dark_red");     break;
+					case '5': a_Value["color"] = Json::Value("dark_purple");  break;
+					case '6': a_Value["color"] = Json::Value("gold");         break;
+					case '7': a_Value["color"] = Json::Value("gray");         break;
+					case '8': a_Value["color"] = Json::Value("dark_gray");    break;
+					case '9': a_Value["color"] = Json::Value("blue");         break;
+					case 'a': a_Value["color"] = Json::Value("green");        break;
+					case 'b': a_Value["color"] = Json::Value("aqua");         break;
+					case 'c': a_Value["color"] = Json::Value("red");          break;
+					case 'd': a_Value["color"] = Json::Value("light_purple"); break;
+					case 'e': a_Value["color"] = Json::Value("yellow");       break;
+					case 'f': a_Value["color"] = Json::Value("white");        break;
+				}  // switch (color)
+			}  // case '@'
+		}  // switch (Style[i])
+	}  // for i - a_PartStyle[]
+}
+
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cProtocol172::cPacketizer:
 
@@ -1784,6 +2262,17 @@ cProtocol172::cPacketizer::~cPacketizer()
 	m_Out.ReadAll(DataToSend);
 	m_Protocol.SendData(DataToSend.data(), DataToSend.size());
 	m_Out.CommitRead();
+	
+	// Log the comm into logfile:
+	if (g_ShouldLogCommOut)
+	{
+		AString Hex;
+		ASSERT(DataToSend.size() > 0);
+		CreateHexDump(Hex, DataToSend.data() + 1, DataToSend.size() - 1, 16);
+		m_Protocol.m_CommLogFile.Printf("Outgoing packet: type %d (0x%x), length %u (0x%x), state %d. Payload:\n%s\n",
+			DataToSend[0], DataToSend[0], PacketLen, PacketLen, m_Protocol.m_State, Hex.c_str()
+		);
+	}
 }
 
 
@@ -1810,7 +2299,7 @@ void cProtocol172::cPacketizer::WriteItem(const cItem & a_Item)
 	WriteByte (a_Item.m_ItemCount);
 	WriteShort(a_Item.m_ItemDamage);
 	
-	if (a_Item.m_Enchantments.IsEmpty() && a_Item.IsBothNameAndLoreEmpty())
+	if (a_Item.m_Enchantments.IsEmpty() && a_Item.IsBothNameAndLoreEmpty() && (a_Item.m_ItemType != E_ITEM_FIREWORK_ROCKET) && (a_Item.m_ItemType != E_ITEM_FIREWORK_STAR))
 	{
 		WriteShort(-1);
 		return;
@@ -1849,6 +2338,10 @@ void cProtocol172::cPacketizer::WriteItem(const cItem & a_Item)
 		}
 		Writer.EndCompound();
 	}
+	if ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR))
+	{
+		cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
+	}
 	Writer.Finish();
 	AString Compressed;
 	CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
@@ -1890,6 +2383,31 @@ void cProtocol172::cPacketizer::WriteBlockEntity(const cBlockEntity & a_BlockEnt
 			}
 			break;
 		}
+		case E_BLOCK_HEAD:
+		{
+			cMobHeadEntity & MobHeadEntity = (cMobHeadEntity &)a_BlockEntity;
+
+			Writer.AddInt("x", MobHeadEntity.GetPosX());
+			Writer.AddInt("y", MobHeadEntity.GetPosY());
+			Writer.AddInt("z", MobHeadEntity.GetPosZ());
+			Writer.AddByte("SkullType", MobHeadEntity.GetType() & 0xFF);
+			Writer.AddByte("Rot", MobHeadEntity.GetRotation() & 0xFF);
+			Writer.AddString("ExtraType", MobHeadEntity.GetOwner().c_str());
+			Writer.AddString("id", "Skull"); // "Tile Entity ID" - MC wiki; vanilla server always seems to send this though
+			break;
+		}
+		case E_BLOCK_FLOWER_POT:
+		{
+			cFlowerPotEntity & FlowerPotEntity = (cFlowerPotEntity &)a_BlockEntity;
+
+			Writer.AddInt("x", FlowerPotEntity.GetPosX());
+			Writer.AddInt("y", FlowerPotEntity.GetPosY());
+			Writer.AddInt("z", FlowerPotEntity.GetPosZ());
+			Writer.AddInt("Item", (Int32) FlowerPotEntity.GetItem().m_ItemType);
+			Writer.AddInt("Data", (Int32) FlowerPotEntity.GetItem().m_ItemDamage);
+			Writer.AddString("id", "FlowerPot"); // "Tile Entity ID" - MC wiki; vanilla server always seems to send this though
+			break;
+		}
 		default: break;
 	}
 
@@ -2000,10 +2518,22 @@ void cProtocol172::cPacketizer::WriteEntityMetadata(const cEntity & a_Entity)
 		}
 		case cEntity::etProjectile:
 		{
-			if (((cProjectileEntity &)a_Entity).GetProjectileKind() == cProjectileEntity::pkArrow)
+			cProjectileEntity & Projectile = (cProjectileEntity &)a_Entity;
+			switch (Projectile.GetProjectileKind())
 			{
-				WriteByte(0x10);
-				WriteByte(((const cArrowEntity &)a_Entity).IsCritical() ? 1 : 0);
+				case cProjectileEntity::pkArrow:
+				{
+					WriteByte(0x10);
+					WriteByte(((const cArrowEntity &)a_Entity).IsCritical() ? 1 : 0);
+					break;
+				}
+				case cProjectileEntity::pkFirework:
+				{
+					WriteByte(0xA8);
+					WriteItem(((const cFireworkEntity &)a_Entity).GetItem());
+					break;
+				}
+				default: break;
 			}
 			break;
 		}
@@ -2012,6 +2542,16 @@ void cProtocol172::cPacketizer::WriteEntityMetadata(const cEntity & a_Entity)
 			WriteMobMetadata((const cMonster &)a_Entity);
 			break;
 		}
+		case cEntity::etItemFrame:
+		{
+			cItemFrame & Frame = (cItemFrame &)a_Entity;
+			WriteByte(0xA2);
+			WriteItem(Frame.GetItem());
+			WriteByte(0x3);
+			WriteByte(Frame.GetRotation());
+			break;
+		}
+		default: break;
 	}
 }
 
@@ -2136,6 +2676,15 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(((const cWitch &)a_Mob).IsAngry() ? 1 : 0);
 			break;
 		}
+
+		case cMonster::mtWither:
+		{
+			WriteByte(0x54); // Int at index 20
+			WriteInt(((const cWither &)a_Mob).GetNumInvulnerableTicks());
+			WriteByte(0x66); // Float at index 6
+			WriteFloat((float)(a_Mob.GetHealth()));
+			break;
+		}
 		
 		case cMonster::mtSlime:
 		{
@@ -2211,7 +2760,8 @@ void cProtocol172::cPacketizer::WriteEntityProperties(const cEntity & a_Entity)
 		WriteInt(0);
 		return;
 	}
-	const cMonster & Mob = (const cMonster &)a_Entity;
+
+	//const cMonster & Mob = (const cMonster &)a_Entity;
 
 	// TODO: Send properties and modifiers based on the mob type
 	
diff --git a/src/Protocol/Protocol17x.h b/src/Protocol/Protocol17x.h
index 1f3039edb..a1ad1f049 100644
--- a/src/Protocol/Protocol17x.h
+++ b/src/Protocol/Protocol17x.h
@@ -26,36 +26,46 @@ Declares the 1.7.x protocol classes:
 	#pragma warning(disable:4702)
 #endif
 
-#include "cryptopp/modes.h"
-#include "cryptopp/aes.h"
-
 #ifdef _MSC_VER
 	#pragma warning(pop)
 #endif
 
+#include "../Crypto.h"
+
+
+
+
+
+// fwd:
+namespace Json
+{
+	class Value;
+}
+
 
 
 
 
 class cProtocol172 :
-	public cProtocol  // TODO
+	public cProtocol
 {
-	typedef cProtocol super;  // TODO
+	typedef cProtocol super;
 	
 public:
 
 	cProtocol172(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State);
 	
-	/// Called when client sends some data:
-	virtual void DataReceived(const char * a_Data, int a_Size) override;
+	/** Called when client sends some data: */
+	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 
-	/// Sending stuff to clients (alphabetically sorted):
+	/** Sending stuff to clients (alphabetically sorted): */
 	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
 	virtual void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
 	virtual void SendBlockBreakAnim	     (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
 	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
 	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
 	virtual void SendChat                (const AString & a_Message) override;
+	virtual void SendChat                (const cCompositeChat & a_Message) override;
 	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
 	virtual void SendCollectPickup       (const cPickup & a_Pickup, const cPlayer & a_Player) override;
 	virtual void SendDestroyEntity       (const cEntity & a_Entity) override;
@@ -77,6 +87,10 @@ public:
 	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
 	virtual void SendKeepAlive           (int a_PingID) override;
 	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
+	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) override;
+	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) override;
+	virtual void SendPaintingSpawn       (const cPainting & a_Painting) override;
 	virtual void SendPickupSpawn         (const cPickup & a_Pickup) override;
 	virtual void SendPlayerAbilities     (void) override;
 	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) override;
@@ -92,6 +106,9 @@ public:
 	virtual void SendSoundEffect         (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch) override;  // a_Src coords are Block * 8
 	virtual void SendExperience          (void) override;
 	virtual void SendExperienceOrb       (const cExpOrb & a_ExpOrb) override;
+	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
+	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
 	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
 	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) override;
 	virtual void SendSpawnMob            (const cMonster & a_Mob) override;
@@ -115,7 +132,7 @@ public:
 
 protected:
 
-	/// Composes individual packets in the protocol's m_OutPacketBuffer; sends them upon being destructed
+	/** Composes individual packets in the protocol's m_OutPacketBuffer; sends them upon being destructed */
 	class cPacketizer
 	{
 	public:
@@ -179,7 +196,7 @@ protected:
 			m_Out.WriteVarUTF8String(a_Value);
 		}
 		
-		void WriteBuf(const char * a_Data, int a_Size)
+		void WriteBuf(const char * a_Data, size_t a_Size)
 		{
 			m_Out.Write(a_Data, a_Size);
 		}
@@ -204,25 +221,29 @@ protected:
 	
 	AString m_AuthServerID;
 	
-	/// State of the protocol. 1 = status, 2 = login, 3 = game
+	/** State of the protocol. 1 = status, 2 = login, 3 = game */
 	UInt32 m_State;
 
-	/// Buffer for the received data
+	/** Buffer for the received data */
 	cByteBuffer m_ReceivedData;
 	
-	/// Buffer for composing the outgoing packets, through cPacketizer
+	/** Buffer for composing the outgoing packets, through cPacketizer */
 	cByteBuffer m_OutPacketBuffer;
 	
-	/// Buffer for composing packet length (so that each cPacketizer instance doesn't allocate a new cPacketBuffer)
+	/** Buffer for composing packet length (so that each cPacketizer instance doesn't allocate a new cPacketBuffer) */
 	cByteBuffer m_OutPacketLenBuffer;
 	
 	bool m_IsEncrypted;
-	CryptoPP::CFB_Mode<CryptoPP::AES>::Decryption m_Decryptor;
-	CryptoPP::CFB_Mode<CryptoPP::AES>::Encryption m_Encryptor;
+	
+	cAESCFBDecryptor m_Decryptor;
+	cAESCFBEncryptor m_Encryptor;
+
+	/** The logfile where the comm is logged, when g_ShouldLogComm is true */
+	cFile m_CommLogFile;
 	
 	
-	/// Adds the received (unencrypted) data to m_ReceivedData, parses complete packets
-	void AddReceivedData(const char * a_Data, int a_Size);
+	/** Adds the received (unencrypted) data to m_ReceivedData, parses complete packets */
+	void AddReceivedData(const char * a_Data, size_t a_Size);
 	
 	/** Reads and handles the packet. The packet length and type have already been read.
 	Returns true if the packet was understood, false if it was an unknown packet
@@ -263,19 +284,24 @@ protected:
 	void HandlePacketWindowClose            (cByteBuffer & a_ByteBuffer);
 	
 	
-	/// Writes an entire packet into the output stream. a_Packet is expected to start with the packet type; data length is prepended here.
+	/** Writes an entire packet into the output stream. a_Packet is expected to start with the packet type; data length is prepended here. */
 	void WritePacket(cByteBuffer & a_Packet);
 
-	/// Sends the data to the client, encrypting them if needed.
-	virtual void SendData(const char * a_Data, int a_Size) override;
+	/** Sends the data to the client, encrypting them if needed. */
+	virtual void SendData(const char * a_Data, size_t a_Size) override;
 
 	void SendCompass(const cWorld & a_World);
 	
-	/// Reads an item out of the received data, sets a_Item to the values read. Returns false if not enough received data
+	/** Reads an item out of the received data, sets a_Item to the values read. Returns false if not enough received data */
 	bool ReadItem(cByteBuffer & a_ByteBuffer, cItem & a_Item);
 	
-	/// Parses item metadata as read by ReadItem(), into the item enchantments.
+	/** Parses item metadata as read by ReadItem(), into the item enchantments. */
 	void ParseItemMetadata(cItem & a_Item, const AString & a_Metadata);
+	
+	void StartEncryption(const Byte * a_Key);
+	
+	/** Adds the chat part's style (represented by the part's stylestring) into the Json object. */
+	void AddChatPartStyle(Json::Value & a_Value, const AString & a_PartStyle);
 } ;
 
 
diff --git a/src/Protocol/ProtocolRecognizer.cpp b/src/Protocol/ProtocolRecognizer.cpp
index 5524af136..3f7d7b254 100644
--- a/src/Protocol/ProtocolRecognizer.cpp
+++ b/src/Protocol/ProtocolRecognizer.cpp
@@ -68,7 +68,7 @@ AString cProtocolRecognizer::GetVersionTextFromInt(int a_ProtocolVersion)
 
 
 
-void cProtocolRecognizer::DataReceived(const char * a_Data, int a_Size)
+void cProtocolRecognizer::DataReceived(const char * a_Data, size_t a_Size)
 {
 	if (m_Protocol == NULL)
 	{
@@ -159,6 +159,16 @@ void cProtocolRecognizer::SendChat(const AString & a_Message)
 
 
 
+void cProtocolRecognizer::SendChat(const cCompositeChat & a_Message)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendChat(a_Message);
+}
+
+
+
+
+
 void cProtocolRecognizer::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer)
 {
 	ASSERT(m_Protocol != NULL);
@@ -386,6 +396,36 @@ void cProtocolRecognizer::SendLogin(const cPlayer & a_Player, const cWorld & a_W
 
 
 
+void cProtocolRecognizer::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendMapDecorators(a_ID, a_Decorators);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendMapInfo(int a_ID, unsigned int a_Scale)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendMapInfo(a_ID, a_Scale);
+}
+
+
+
+
+
 void cProtocolRecognizer::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
 {
 	ASSERT(m_Protocol != NULL);
@@ -395,6 +435,14 @@ void cProtocolRecognizer::SendParticleEffect(const AString & a_ParticleName, flo
 
 
 
+void cProtocolRecognizer::SendPaintingSpawn(const cPainting & a_Painting)
+{
+	m_Protocol->SendPaintingSpawn(a_Painting);
+}
+
+
+
+
 
 void cProtocolRecognizer::SendPickupSpawn(const cPickup & a_Pickup)
 {
@@ -526,6 +574,36 @@ void cProtocolRecognizer::SendExperienceOrb(const cExpOrb & a_ExpOrb)
 
 
 
+void cProtocolRecognizer::SendScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendScoreboardObjective(a_Name, a_DisplayName, a_Mode);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendScoreUpdate(a_Objective, a_Player, a_Score, a_Mode);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendDisplayObjective(a_Objective, a_Display);
+}
+
+
+
+
+
 void cProtocolRecognizer::SendSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch)
 {
 	ASSERT(m_Protocol != NULL);
@@ -716,7 +794,7 @@ AString cProtocolRecognizer::GetAuthServerID(void)
 
 
 
-void cProtocolRecognizer::SendData(const char * a_Data, int a_Size)
+void cProtocolRecognizer::SendData(const char * a_Data, size_t a_Size)
 {
 	// This is used only when handling the server ping
 	m_Client->SendData(a_Data, a_Size);
@@ -776,7 +854,7 @@ bool cProtocolRecognizer::TryRecognizeProtocol(void)
 	// This must be a lengthed protocol, try if it has the entire initial handshake packet:
 	m_Buffer.ResetRead();
 	UInt32 PacketLen;
-	UInt32 ReadSoFar = m_Buffer.GetReadableSpace();
+	UInt32 ReadSoFar = (UInt32)m_Buffer.GetReadableSpace();
 	if (!m_Buffer.ReadVarInt(PacketLen))
 	{
 		// Not enough bytes for the packet length, keep waiting
@@ -807,7 +885,7 @@ bool cProtocolRecognizer::TryRecognizeLengthlessProtocol(void)
 	}
 	switch (ch)
 	{
-	 case PROTO_VERSION_1_3_2:
+		case PROTO_VERSION_1_3_2:
 		{
 			m_Protocol = new cProtocol132(m_Client);
 			return true;
@@ -853,7 +931,7 @@ bool cProtocolRecognizer::TryRecognizeLengthlessProtocol(void)
 bool cProtocolRecognizer::TryRecognizeLengthedProtocol(UInt32 a_PacketLengthRemaining)
 {
 	UInt32 PacketType;
-	UInt32 NumBytesRead = m_Buffer.GetReadableSpace();
+	UInt32 NumBytesRead = (UInt32)m_Buffer.GetReadableSpace();
 	if (!m_Buffer.ReadVarInt(PacketType))
 	{
 		return false;
@@ -884,7 +962,7 @@ bool cProtocolRecognizer::TryRecognizeLengthedProtocol(UInt32 a_PacketLengthRema
 			m_Buffer.ReadBEShort(ServerPort);
 			m_Buffer.ReadVarInt(NextState);
 			m_Buffer.CommitRead();
-			m_Protocol = new cProtocol172(m_Client, ServerAddress, ServerPort, NextState);
+			m_Protocol = new cProtocol172(m_Client, ServerAddress, (UInt16)ServerPort, NextState);
 			return true;
 		}
 	}
@@ -935,7 +1013,7 @@ void cProtocolRecognizer::SendLengthlessServerPing(void)
 			m_Buffer.ResetRead();
 			if (m_Buffer.CanReadBytes(2))
 			{
-				byte val;
+				Byte val;
 				m_Buffer.ReadByte(val);  // Packet type - Serverlist ping
 				m_Buffer.ReadByte(val);  // 0x01 magic value
 				ASSERT(val == 0x01);
diff --git a/src/Protocol/ProtocolRecognizer.h b/src/Protocol/ProtocolRecognizer.h
index 2dccace6e..072d7c2d2 100644
--- a/src/Protocol/ProtocolRecognizer.h
+++ b/src/Protocol/ProtocolRecognizer.h
@@ -18,7 +18,7 @@
 
 
 // Adjust these if a new protocol is added or an old one is removed:
-#define MCS_CLIENT_VERSIONS "1.2.4, 1.2.5, 1.3.1, 1.3.2, 1.4.2, 1.4.4, 1.4.5, 1.4.6, 1.4.7, 1.5, 1.5.1, 1.5.2, 1.6.1, 1.6.2, 1.6.3, 1.6.4, 1.7.2"
+#define MCS_CLIENT_VERSIONS "1.2.4, 1.2.5, 1.3.1, 1.3.2, 1.4.2, 1.4.4, 1.4.5, 1.4.6, 1.4.7, 1.5, 1.5.1, 1.5.2, 1.6.1, 1.6.2, 1.6.3, 1.6.4, 1.7.2, 1.7.4"
 #define MCS_PROTOCOL_VERSIONS "29, 39, 47, 49, 51, 60, 61, 73, 74, 77, 78, 4"
 
 
@@ -59,7 +59,7 @@ public:
 	static AString GetVersionTextFromInt(int a_ProtocolVersion);
 	
 	/// Called when client sends some data:
-	virtual void DataReceived(const char * a_Data, int a_Size) override;
+	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 	
 	/// Sending stuff to clients (alphabetically sorted):
 	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
@@ -68,6 +68,7 @@ public:
 	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
 	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
 	virtual void SendChat                (const AString & a_Message) override;
+	virtual void SendChat                (const cCompositeChat & a_Message) override;
 	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
 	virtual void SendCollectPickup       (const cPickup & a_Pickup, const cPlayer & a_Player) override;
 	virtual void SendDestroyEntity       (const cEntity & a_Entity) override;
@@ -89,7 +90,11 @@ public:
 	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
 	virtual void SendKeepAlive           (int a_PingID) override;
 	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
+	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) override;
+	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) override;
 	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
+	virtual void SendPaintingSpawn       (const cPainting & a_Painting) override;
 	virtual void SendPickupSpawn         (const cPickup & a_Pickup) override;
 	virtual void SendPlayerAbilities     (void) override;
 	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) override;
@@ -103,6 +108,9 @@ public:
 	virtual void SendRespawn             (void) override;
 	virtual void SendExperience          (void) override;
 	virtual void SendExperienceOrb       (const cExpOrb & a_ExpOrb) override;
+	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
+	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
 	virtual void SendSoundEffect         (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch) override;
 	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
 	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) override;
@@ -125,7 +133,7 @@ public:
 	
 	virtual AString GetAuthServerID(void) override;
 
-	virtual void SendData(const char * a_Data, int a_Size) override;
+	virtual void SendData(const char * a_Data, size_t a_Size) override;
 
 protected:
 	cProtocol * m_Protocol;  //< The recognized protocol
diff --git a/src/RCONServer.cpp b/src/RCONServer.cpp
index 72f2d9ba9..d7083ff2b 100644
--- a/src/RCONServer.cpp
+++ b/src/RCONServer.cpp
@@ -169,7 +169,7 @@ cRCONServer::cConnection::cConnection(cRCONServer & a_RCONServer, cSocket & a_So
 
 
 
-void cRCONServer::cConnection::DataReceived(const char * a_Data, int a_Size)
+void cRCONServer::cConnection::DataReceived(const char * a_Data, size_t a_Size)
 {
 	// Append data to the buffer:
 	m_Buffer.append(a_Data, a_Size);
diff --git a/src/RCONServer.h b/src/RCONServer.h
index 0e89800a2..b964852ab 100644
--- a/src/RCONServer.h
+++ b/src/RCONServer.h
@@ -29,7 +29,7 @@ class cRCONServer :
 {
 public:
 	cRCONServer(cServer & a_Server);
-	~cRCONServer();
+	virtual ~cRCONServer();
 	
 	void Initialize(cIniFile & a_IniFile);
 	
@@ -65,7 +65,7 @@ protected:
 		
 
 		// cSocketThreads::cCallback overrides:
-		virtual void DataReceived(const char * a_Data, int a_Size) override;
+		virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 		virtual void GetOutgoingData(AString & a_Data) override;
 		virtual void SocketClosed(void) override;
 		
diff --git a/src/ReferenceManager.cpp b/src/ReferenceManager.cpp
deleted file mode 100644
index 6a9ed0e43..000000000
--- a/src/ReferenceManager.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "ReferenceManager.h"
-#include "Entities/Entity.h"
-
-
-
-
-
-cReferenceManager::cReferenceManager( ENUM_REFERENCE_MANAGER_TYPE a_Type )
-	: m_Type( a_Type )
-{
-}
-
-cReferenceManager::~cReferenceManager()
-{
-	if( m_Type == RFMNGR_REFERENCERS )
-	{
-		for( std::list< cEntity** >::iterator itr = m_References.begin(); itr != m_References.end(); ++itr )
-		{
-			*(*itr) = 0; // Set referenced pointer to 0
-		}
-	}
-	else
-	{
-		for( std::list< cEntity** >::iterator itr = m_References.begin(); itr != m_References.end(); ++itr )
-		{
-			cEntity* Ptr = (*(*itr));
-			if( Ptr ) Ptr->Dereference( *(*itr) );
-		}
-	}
-}
-
-void cReferenceManager::AddReference( cEntity*& a_EntityPtr )
-{
-	m_References.push_back( &a_EntityPtr );
-}
-
-void cReferenceManager::Dereference( cEntity*& a_EntityPtr )
-{
-	m_References.remove( &a_EntityPtr );
-}
\ No newline at end of file
diff --git a/src/ReferenceManager.h b/src/ReferenceManager.h
deleted file mode 100644
index bcd451f72..000000000
--- a/src/ReferenceManager.h
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#pragma once
-
-
-
-
-
-class cEntity;
-
-
-
-
-
-class cReferenceManager
-{
-public:
-	enum ENUM_REFERENCE_MANAGER_TYPE
-	{	
-		RFMNGR_REFERENCERS,
-		RFMNGR_REFERENCES,
-	};
-	cReferenceManager( ENUM_REFERENCE_MANAGER_TYPE a_Type );
-	~cReferenceManager();
-
-	void AddReference( cEntity*& a_EntityPtr );
-	void Dereference( cEntity*& a_EntityPtr );
-private:
-	ENUM_REFERENCE_MANAGER_TYPE m_Type;
-	std::list< cEntity** > m_References;
-};
-
-
-
-
diff --git a/src/Root.cpp b/src/Root.cpp
index fa1fdb37a..ba4398b35 100644
--- a/src/Root.cpp
+++ b/src/Root.cpp
@@ -132,7 +132,7 @@ void cRoot::Start(void)
 			LOGWARN("Regenerating settings.ini, all settings will be reset");
 			IniFile.AddHeaderComment(" This is the main server configuration");
 			IniFile.AddHeaderComment(" Most of the settings here can be configured using the webadmin interface, if enabled in webadmin.ini");
-			IniFile.AddHeaderComment(" See: http://www.mc-server.org/wiki/doku.php?id=configure:settings.ini for further configuration help");
+			IniFile.AddHeaderComment(" See: http://wiki.mc-server.org/doku.php?id=configure:settings.ini for further configuration help");
 		}
 
 		m_PrimaryServerVersion = IniFile.GetValueI("Server", "PrimaryServerVersion", 0);
@@ -194,13 +194,13 @@ void cRoot::Start(void)
 		#if !defined(ANDROID_NDK)
 		LOGD("Starting InputThread...");
 		m_InputThread = new cThread( InputThread, this, "cRoot::InputThread" );
-		m_InputThread->Start( false );	// We should NOT wait? Otherwise we can´t stop the server from other threads than the input thread
+		m_InputThread->Start( false );	// We should NOT wait? Otherwise we can't stop the server from other threads than the input thread
 		#endif
 
 		long long finishmseconds = Time.GetNowTime();
 		finishmseconds -= mseconds;
 
-		LOG("Startup complete, took %i ms!", finishmseconds);
+		LOG("Startup complete, took %lld ms!", finishmseconds);
 		#ifdef _WIN32
 		EnableMenuItem(hmenu, SC_CLOSE, MF_ENABLED); // Re-enable close button
 		#endif
@@ -219,16 +219,14 @@ void cRoot::Start(void)
 		delete m_InputThread; m_InputThread = NULL;
 		#endif
 
-		// Deallocate stuffs
+		// Stop the server:
+		m_WebAdmin->Stop();
 		LOG("Shutting down server...");
 		m_Server->Shutdown();
-		
 		LOGD("Shutting down deadlock detector...");
 		dd.Stop();
-		
 		LOGD("Stopping world threads...");
 		StopWorlds();
-		
 		LOGD("Stopping authenticator...");
 		m_Authenticator.Stop();
 
@@ -247,7 +245,6 @@ void cRoot::Start(void)
 		delete m_PluginManager; m_PluginManager = NULL;
 
 		cItemHandler::Deinit();
-		cBlockHandler::Deinit();
 
 		LOG("Cleaning up...");
 		delete m_Server; m_Server = NULL;
@@ -307,6 +304,7 @@ void cRoot::LoadWorlds(cIniFile & IniFile)
 	{
 		if (IniFile.GetKeyComment("Worlds", 0) != " World=secondworld")
 		{
+			IniFile.DeleteKeyComment("Worlds", 0);
 			IniFile.AddKeyComment("Worlds", " World=secondworld");
 		}
 	}
@@ -536,7 +534,30 @@ void cRoot::SaveAllChunks(void)
 
 
 
-void cRoot::BroadcastChat(const AString & a_Message)
+void cRoot::ReloadGroups(void)
+{
+	LOG("Reload groups ...");
+	m_GroupManager->LoadGroups();
+	m_GroupManager->CheckUsers();
+}
+
+
+
+
+
+void cRoot::BroadcastChat(const AString & a_Message, eMessageType a_ChatPrefix)
+{
+	for (WorldMap::iterator itr = m_WorldsByName.begin(), end = m_WorldsByName.end(); itr != end; ++itr)
+	{
+		itr->second->BroadcastChat(a_Message, NULL, a_ChatPrefix);
+	}  // for itr - m_WorldsByName[]
+}
+
+
+
+
+
+void cRoot::BroadcastChat(const cCompositeChat & a_Message)
 {
 	for (WorldMap::iterator itr = m_WorldsByName.begin(), end = m_WorldsByName.end(); itr != end; ++itr)
 	{
@@ -573,7 +594,6 @@ bool cRoot::FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallbac
 		unsigned      m_NameLength;
 		const AString m_PlayerName;
 
-		cPlayerListCallback & m_Callback;
 		virtual bool Item (cPlayer * a_pPlayer)
 		{
 			unsigned int Rating = RateCompareString (m_PlayerName, a_pPlayer->GetName());
@@ -595,18 +615,17 @@ bool cRoot::FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallbac
 		}
 
 	public:
-		cCallback (const AString & a_PlayerName, cPlayerListCallback & a_Callback) :
+		cCallback (const AString & a_PlayerName) :
 			m_BestRating(0),
 			m_NameLength(a_PlayerName.length()),
 			m_PlayerName(a_PlayerName),
-			m_Callback(a_Callback),
 			m_BestMatch(NULL),
 			m_NumMatches(0)
 		{}
 
 		cPlayer * m_BestMatch;
 		unsigned  m_NumMatches;
-	} Callback (a_PlayerName, a_Callback);
+	} Callback (a_PlayerName);
 	ForEachPlayer( Callback );
 
 	if (Callback.m_NumMatches == 1)
@@ -760,11 +779,11 @@ void cRoot::LogChunkStats(cCommandOutputCallback & a_Output)
 		int Mem = NumValid * sizeof(cChunk);
 		a_Output.Out("  Memory used by chunks: %d KiB (%d MiB)", (Mem + 1023) / 1024, (Mem + 1024 * 1024 - 1) / (1024 * 1024));
 		a_Output.Out("  Per-chunk memory size breakdown:");
-		a_Output.Out("    block types:    %6d bytes (%3d KiB)", sizeof(cChunkDef::BlockTypes), (sizeof(cChunkDef::BlockTypes) + 1023) / 1024);
-		a_Output.Out("    block metadata: %6d bytes (%3d KiB)", sizeof(cChunkDef::BlockNibbles), (sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
-		a_Output.Out("    block lighting: %6d bytes (%3d KiB)", 2 * sizeof(cChunkDef::BlockNibbles), (2 * sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
-		a_Output.Out("    heightmap:      %6d bytes (%3d KiB)", sizeof(cChunkDef::HeightMap), (sizeof(cChunkDef::HeightMap) + 1023) / 1024);
-		a_Output.Out("    biomemap:       %6d bytes (%3d KiB)", sizeof(cChunkDef::BiomeMap), (sizeof(cChunkDef::BiomeMap) + 1023) / 1024);
+		a_Output.Out("    block types:    " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::BlockTypes), (sizeof(cChunkDef::BlockTypes) + 1023) / 1024);
+		a_Output.Out("    block metadata: " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::BlockNibbles), (sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
+		a_Output.Out("    block lighting: " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", 2 * sizeof(cChunkDef::BlockNibbles), (2 * sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
+		a_Output.Out("    heightmap:      " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::HeightMap), (sizeof(cChunkDef::HeightMap) + 1023) / 1024);
+		a_Output.Out("    biomemap:       " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::BiomeMap), (sizeof(cChunkDef::BiomeMap) + 1023) / 1024);
 		int Rest = sizeof(cChunk) - sizeof(cChunkDef::BlockTypes) - 3 * sizeof(cChunkDef::BlockNibbles) - sizeof(cChunkDef::HeightMap) - sizeof(cChunkDef::BiomeMap);
 		a_Output.Out("    other:          %6d bytes (%3d KiB)", Rest, (Rest + 1023) / 1024);
 		SumNumValid += NumValid;
diff --git a/src/Root.h b/src/Root.h
index c59afc810..4bbd7586f 100644
--- a/src/Root.h
+++ b/src/Root.h
@@ -3,6 +3,7 @@
 
 #include "Authenticator.h"
 #include "HTTPServer/HTTPServer.h"
+#include "Defines.h"
 
 
 
@@ -19,7 +20,8 @@ class cPluginManager;
 class cServer;
 class cWorld;
 class cPlayer;
-class cCommandOutputCallback ;
+class cCommandOutputCallback;
+class cCompositeChat;
 
 typedef cItemCallback<cPlayer> cPlayerListCallback;
 typedef cItemCallback<cWorld>  cWorldListCallback;
@@ -98,17 +100,29 @@ public:
 	/// Saves all chunks in all worlds
 	void SaveAllChunks(void);  // tolua_export
 	
-	/// Sends a chat message to all connected clients (in all worlds)
-	void BroadcastChat(const AString & a_Message);  // tolua_export
+	/// Reloads all the groups
+	void ReloadGroups(void); // tolua_export
 	
 	/// Calls the callback for each player in all worlds
 	bool ForEachPlayer(cPlayerListCallback & a_Callback);	// >> EXPORTED IN MANUALBINDINGS <<
 
 	/// Finds a player from a partial or complete player name and calls the callback - case-insensitive
 	bool FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallback & a_Callback);	// >> EXPORTED IN MANUALBINDINGS <<
-	
+
 	// tolua_begin
 	
+	/// Sends a chat message to all connected clients (in all worlds)
+	void BroadcastChat       (const AString & a_Message, eMessageType a_ChatPrefix = mtCustom);
+	void BroadcastChatInfo   (const AString & a_Message) { BroadcastChat(a_Message, mtInformation); }
+	void BroadcastChatFailure(const AString & a_Message) { BroadcastChat(a_Message, mtFailure); }
+	void BroadcastChatSuccess(const AString & a_Message) { BroadcastChat(a_Message, mtSuccess); }
+	void BroadcastChatWarning(const AString & a_Message) { BroadcastChat(a_Message, mtWarning); }
+	void BroadcastChatFatal  (const AString & a_Message) { BroadcastChat(a_Message, mtFailure); }
+	void BroadcastChatJoin   (const AString & a_Message) { BroadcastChat(a_Message, mtJoin); }
+	void BroadcastChatLeave  (const AString & a_Message) { BroadcastChat(a_Message, mtLeave); }
+	void BroadcastChatDeath  (const AString & a_Message) { BroadcastChat(a_Message, mtDeath); }
+	void BroadcastChat       (const cCompositeChat & a_Message);
+	
 	/// Returns the textual description of the protocol version: 49 -> "1.4.4". Provided specifically for Lua API
 	static AString GetProtocolVersionTextFromInt(int a_ProtocolVersionNum);
 	
diff --git a/src/Scoreboard.cpp b/src/Scoreboard.cpp
new file mode 100644
index 000000000..4c89ce265
--- /dev/null
+++ b/src/Scoreboard.cpp
@@ -0,0 +1,589 @@
+
+// Scoreboard.cpp
+
+// Implementation of a scoreboard that keeps track of specified objectives
+
+#include "Globals.h"
+
+#include "Scoreboard.h"
+#include "World.h"
+#include "ClientHandle.h"
+
+
+
+
+
+AString cObjective::TypeToString(eType a_Type)
+{
+	switch (a_Type)
+	{
+		case otDummy:              return "dummy";
+		case otDeathCount:         return "deathCount";
+		case otPlayerKillCount:    return "playerKillCount";
+		case otTotalKillCount:     return "totalKillCount";
+		case otHealth:             return "health";
+		case otAchievement:        return "achievement";
+		case otStat:               return "stat";
+		case otStatItemCraft:      return "stat.craftItem";
+		case otStatItemUse:        return "stat.useItem";
+		case otStatItemBreak:      return "stat.breakItem";
+		case otStatBlockMine:      return "stat.mineBlock";
+		case otStatEntityKill:     return "stat.killEntity";
+		case otStatEntityKilledBy: return "stat.entityKilledBy";
+		
+		// clang optimisises this line away then warns that it has done so.
+		#if !defined(__clang__)
+		default: return "";
+		#endif
+	}
+	
+}
+
+
+
+
+
+cObjective::eType cObjective::StringToType(const AString & a_Name)
+{
+	static struct {
+		eType m_Type;
+		const char * m_String;
+	} TypeMap [] =
+	{
+		{otDummy,              "dummy"              },
+		{otDeathCount,         "deathCount"         },
+		{otPlayerKillCount,    "playerKillCount"    },
+		{otTotalKillCount,     "totalKillCount"     },
+		{otHealth,             "health"             },
+		{otAchievement,        "achievement"        },
+		{otStat,               "stat"               },
+		{otStatItemCraft,      "stat.craftItem"     },
+		{otStatItemUse,        "stat.useItem"       },
+		{otStatItemBreak,      "stat.breakItem"     },
+		{otStatBlockMine,      "stat.mineBlock"     },
+		{otStatEntityKill,     "stat.killEntity"    },
+		{otStatEntityKilledBy, "stat.entityKilledBy"}
+	};
+	for (size_t i = 0; i < ARRAYCOUNT(TypeMap); i++)
+	{
+		if (NoCaseCompare(TypeMap[i].m_String, a_Name) == 0)
+		{
+			return TypeMap[i].m_Type;
+		}
+	}  // for i - TypeMap[]
+	return otDummy;
+}
+
+
+
+
+
+cObjective::cObjective(const AString & a_Name, const AString & a_DisplayName, cObjective::eType a_Type, cWorld * a_World)
+	: m_DisplayName(a_DisplayName)
+	, m_Name(a_Name)
+	, m_Type(a_Type)
+	, m_World(a_World)
+{
+}
+
+
+
+
+
+void cObjective::Reset(void)
+{
+	for (cScoreMap::iterator it = m_Scores.begin(); it != m_Scores.end(); ++it)
+	{
+		m_World->BroadcastScoreUpdate(m_Name, it->first, 0, 1);
+	}
+
+	m_Scores.clear();
+}
+
+
+
+
+
+cObjective::Score cObjective::GetScore(const AString & a_Name) const
+{
+	cScoreMap::const_iterator it = m_Scores.find(a_Name);
+
+	if (it == m_Scores.end())
+	{
+		return 0;
+	}
+	else
+	{
+		return it->second;
+	}
+}
+
+
+
+
+
+void cObjective::SetScore(const AString & a_Name, cObjective::Score a_Score)
+{
+	m_Scores[a_Name] = a_Score;
+
+	m_World->BroadcastScoreUpdate(m_Name, a_Name, a_Score, 0);
+}
+
+
+
+
+
+void cObjective::ResetScore(const AString & a_Name)
+{
+	m_Scores.erase(a_Name);
+
+	m_World->BroadcastScoreUpdate(m_Name, a_Name, 0, 1);
+}
+
+
+
+
+
+cObjective::Score cObjective::AddScore(const AString & a_Name, cObjective::Score a_Delta)
+{
+	// TODO 2014-01-19 xdot: Potential optimization - Reuse iterator
+	Score NewScore = m_Scores[a_Name] + a_Delta;
+
+	SetScore(a_Name, NewScore);
+
+	return NewScore;
+}
+
+
+
+
+
+cObjective::Score cObjective::SubScore(const AString & a_Name, cObjective::Score a_Delta)
+{
+	// TODO 2014-01-19 xdot: Potential optimization - Reuse iterator
+	Score NewScore = m_Scores[a_Name] - a_Delta;
+
+	SetScore(a_Name, NewScore);
+
+	return NewScore;
+}
+
+
+
+
+
+void cObjective::SetDisplayName(const AString & a_Name)
+{
+	m_DisplayName = a_Name;
+
+	m_World->BroadcastScoreboardObjective(m_Name, m_DisplayName, 2);
+}
+
+
+
+
+
+void cObjective::SendTo(cClientHandle & a_Client)
+{
+	a_Client.SendScoreboardObjective(m_Name, m_DisplayName, 0);
+
+	for (cScoreMap::const_iterator it = m_Scores.begin(); it != m_Scores.end(); ++it)
+	{
+		a_Client.SendScoreUpdate(m_Name, it->first, it->second, 0);
+	}
+}
+
+
+
+
+
+cTeam::cTeam(const AString & a_Name, const AString & a_DisplayName,
+	     const AString & a_Prefix, const AString & a_Suffix)
+	: m_AllowsFriendlyFire(true)
+	, m_CanSeeFriendlyInvisible(false)
+	, m_DisplayName(a_DisplayName)
+	, m_Name(a_Name)
+	, m_Prefix(a_Prefix)
+	, m_Suffix(a_Suffix)
+{}
+
+
+
+
+
+bool cTeam::AddPlayer(const AString & a_Name)
+{
+	return m_Players.insert(a_Name).second;
+}
+
+
+
+
+
+bool cTeam::RemovePlayer(const AString & a_Name)
+{
+	return m_Players.erase(a_Name) > 0;
+}
+
+
+
+
+
+bool cTeam::HasPlayer(const AString & a_Name) const
+{
+	cPlayerNameSet::const_iterator it = m_Players.find(a_Name);
+
+	return it != m_Players.end();
+}
+
+
+
+
+
+void cTeam::Reset(void)
+{
+	// TODO 2014-01-22 xdot: Inform online players
+
+	m_Players.clear();
+}
+
+
+
+
+void cTeam::SetDisplayName(const AString & a_Name)
+{
+	m_DisplayName = a_Name;
+
+	// TODO 2014-03-01 xdot: Update clients
+}
+
+
+
+
+
+unsigned int cTeam::GetNumPlayers(void) const
+{
+	return m_Players.size();
+}
+
+
+
+
+
+cScoreboard::cScoreboard(cWorld * a_World) : m_World(a_World)
+{
+	for (int i = 0; i < (int) dsCount; ++i)
+	{
+		m_Display[i] = NULL;
+	}
+}
+
+
+
+
+
+cObjective* cScoreboard::RegisterObjective(const AString & a_Name, const AString & a_DisplayName, cObjective::eType a_Type)
+{
+	cObjective Objective(a_Name, a_DisplayName, a_Type, m_World);
+
+	std::pair<cObjectiveMap::iterator, bool> Status = m_Objectives.insert(cNamedObjective(a_Name, Objective));
+
+	if (Status.second)
+	{
+		ASSERT(m_World != NULL);
+		m_World->BroadcastScoreboardObjective(a_Name, a_DisplayName, 0);
+
+		return &Status.first->second;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+
+
+
+
+bool cScoreboard::RemoveObjective(const AString & a_Name)
+{
+	cCSLock Lock(m_CSObjectives);
+
+	cObjectiveMap::iterator it = m_Objectives.find(a_Name);
+
+	if (it == m_Objectives.end())
+	{
+		return false;
+	}
+
+	ASSERT(m_World != NULL);
+	m_World->BroadcastScoreboardObjective(it->second.GetName(), it->second.GetDisplayName(), 1);
+
+	for (unsigned int i = 0; i < (unsigned int) dsCount; ++i)
+	{
+		if (m_Display[i] == &it->second)
+		{
+			SetDisplay(NULL, (eDisplaySlot) i);
+		}
+	}
+
+	m_Objectives.erase(it);
+
+	return true;
+}
+
+
+
+
+
+cObjective * cScoreboard::GetObjective(const AString & a_Name)
+{
+	cCSLock Lock(m_CSObjectives);
+
+	cObjectiveMap::iterator it = m_Objectives.find(a_Name);
+
+	if (it == m_Objectives.end())
+	{
+		return NULL;
+	}
+	else
+	{
+		return &it->second;
+	}
+}
+
+
+
+
+
+cTeam * cScoreboard::RegisterTeam(
+	const AString & a_Name, const AString & a_DisplayName,
+	const AString & a_Prefix, const AString & a_Suffix
+)
+{
+	cTeam Team(a_Name, a_DisplayName, a_Prefix, a_Suffix);
+
+	std::pair<cTeamMap::iterator, bool> Status = m_Teams.insert(cNamedTeam(a_Name, Team));
+
+	return Status.second ? &Status.first->second : NULL;
+}
+
+
+
+
+
+bool cScoreboard::RemoveTeam(const AString & a_Name)
+{
+	cCSLock Lock(m_CSTeams);
+
+	cTeamMap::iterator it = m_Teams.find(a_Name);
+
+	if (it == m_Teams.end())
+	{
+		return false;
+	}
+
+	m_Teams.erase(it);
+
+	return true;
+}
+
+
+
+
+
+cTeam * cScoreboard::GetTeam(const AString & a_Name)
+{
+	cCSLock Lock(m_CSTeams);
+
+	cTeamMap::iterator it = m_Teams.find(a_Name);
+
+	if (it == m_Teams.end())
+	{
+		return NULL;
+	}
+	else
+	{
+		return &it->second;
+	}
+}
+
+
+
+
+
+cTeam * cScoreboard::QueryPlayerTeam(const AString & a_Name)
+{
+	cCSLock Lock(m_CSTeams);
+
+	for (cTeamMap::iterator it = m_Teams.begin(); it != m_Teams.end(); ++it)
+	{
+		if (it->second.HasPlayer(a_Name))
+		{
+			return &it->second;
+		}
+	}
+
+	return NULL;
+}
+
+
+
+
+
+void cScoreboard::SetDisplay(const AString & a_Objective, eDisplaySlot a_Slot)
+{
+	ASSERT(a_Slot < dsCount);
+
+	cObjective * Objective = GetObjective(a_Objective);
+
+	SetDisplay(Objective, a_Slot);
+}
+
+
+
+
+
+void cScoreboard::SetDisplay(cObjective * a_Objective, eDisplaySlot a_Slot)
+{
+	m_Display[a_Slot] = a_Objective;
+
+	ASSERT(m_World != NULL);
+	m_World->BroadcastDisplayObjective(a_Objective ? a_Objective->GetName() : "", a_Slot);
+}
+
+
+
+
+
+cObjective * cScoreboard::GetObjectiveIn(eDisplaySlot a_Slot)
+{
+	ASSERT(a_Slot < dsCount);
+
+	return m_Display[a_Slot];
+}
+
+
+
+
+
+bool cScoreboard::ForEachObjectiveWith(cObjective::eType a_Type, cObjectiveCallback& a_Callback)
+{
+	cCSLock Lock(m_CSObjectives);
+
+	for (cObjectiveMap::iterator it = m_Objectives.begin(); it != m_Objectives.end(); ++it)
+	{
+		if (it->second.GetType() == a_Type)
+		{
+			// Call callback
+			if (a_Callback.Item(&it->second))
+			{
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+
+
+
+
+bool cScoreboard::ForEachObjective(cObjectiveCallback& a_Callback)
+{
+	cCSLock Lock(m_CSObjectives);
+
+	for (cObjectiveMap::iterator it = m_Objectives.begin(); it != m_Objectives.end(); ++it)
+	{
+		// Call callback
+		if (a_Callback.Item(&it->second))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+
+
+
+bool cScoreboard::ForEachTeam(cTeamCallback& a_Callback)
+{
+	cCSLock Lock(m_CSTeams);
+
+	for (cTeamMap::iterator it = m_Teams.begin(); it != m_Teams.end(); ++it)
+	{
+		// Call callback
+		if (a_Callback.Item(&it->second))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+
+
+
+void cScoreboard::AddPlayerScore(const AString & a_Name, cObjective::eType a_Type, cObjective::Score a_Value)
+{
+	cCSLock Lock(m_CSObjectives);
+
+	for (cObjectiveMap::iterator it = m_Objectives.begin(); it != m_Objectives.end(); ++it)
+	{
+		if (it->second.GetType() == a_Type)
+		{
+			it->second.AddScore(a_Name, a_Value);
+		}
+	}
+}
+
+
+
+
+
+void cScoreboard::SendTo(cClientHandle & a_Client)
+{
+	cCSLock Lock(m_CSObjectives);
+
+	for (cObjectiveMap::iterator it = m_Objectives.begin(); it != m_Objectives.end(); ++it)
+	{
+		it->second.SendTo(a_Client);
+	}
+
+	for (int i = 0; i < (int) dsCount; ++i)
+	{
+		// Avoid race conditions
+		cObjective * Objective = m_Display[i];
+
+		if (Objective)
+		{
+			a_Client.SendDisplayObjective(Objective->GetName(), (eDisplaySlot) i);
+		}
+	}
+}
+
+
+
+
+
+unsigned int cScoreboard::GetNumObjectives(void) const
+{
+	return m_Objectives.size();
+}
+
+
+
+
+
+unsigned int cScoreboard::GetNumTeams(void) const
+{
+	return m_Teams.size();
+}
+
+
+
+
+
diff --git a/src/Scoreboard.h b/src/Scoreboard.h
new file mode 100644
index 000000000..2fae5e499
--- /dev/null
+++ b/src/Scoreboard.h
@@ -0,0 +1,311 @@
+
+// Scoreboard.h
+
+// Implementation of a scoreboard that keeps track of specified objectives
+
+
+
+
+
+#pragma once
+
+
+
+
+
+class cObjective;
+class cTeam;
+class cWorld;
+
+typedef cItemCallback<cObjective> cObjectiveCallback;
+typedef cItemCallback<cTeam>      cTeamCallback;
+
+
+
+
+
+// tolua_begin
+class cObjective
+{
+public:
+
+	typedef int Score;
+
+	enum eType
+	{
+		otDummy,
+
+		otDeathCount,
+		otPlayerKillCount,
+		otTotalKillCount,
+		otHealth,
+
+		otAchievement,
+
+		otStat,
+		otStatItemCraft,
+		otStatItemUse,
+		otStatItemBreak,
+
+		otStatBlockMine,
+		otStatEntityKill,
+		otStatEntityKilledBy
+	};
+
+	// tolua_end
+
+	static AString TypeToString(eType a_Type);
+
+	static eType StringToType(const AString & a_Name);
+
+public:
+
+	cObjective(const AString & a_Name, const AString & a_DisplayName, eType a_Type, cWorld * a_World);
+
+	// tolua_begin
+
+	eType GetType(void) const { return m_Type; }
+
+	const AString & GetName(void)        const { return m_Name; }
+	const AString & GetDisplayName(void) const { return m_DisplayName; }
+
+	/** Resets the objective */
+	void Reset(void);
+
+	/** Returns the score of the specified player */
+	Score GetScore(const AString & a_Name) const;
+
+	/** Sets the score of the specified player */
+	void SetScore(const AString & a_Name, Score a_Score);
+
+	/** Resets the score of the specified player */
+	void ResetScore(const AString & a_Name);
+
+	/** Adds a_Delta and returns the new score */
+	Score AddScore(const AString & a_Name, Score a_Delta);
+
+	/** Subtracts a_Delta and returns the new score */
+	Score SubScore(const AString & a_Name, Score a_Delta);
+
+	void SetDisplayName(const AString & a_Name);
+
+	// tolua_end
+
+	/** Send this objective to the specified client */
+	void SendTo(cClientHandle & a_Client);
+
+	static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
+	{
+		return "cObjective";
+	}
+
+
+private:
+
+	typedef std::pair<AString, Score> cTrackedPlayer;
+
+	typedef std::map<AString, Score> cScoreMap;
+
+	cScoreMap m_Scores;
+
+	AString m_DisplayName;
+	AString m_Name;
+
+	eType m_Type;
+
+	cWorld * m_World;
+
+	friend class cScoreboardSerializer;
+
+
+}; // tolua_export
+
+
+
+
+
+// tolua_begin
+class cTeam
+{
+public:
+
+	// tolua_end
+
+	cTeam(
+		const AString & a_Name, const AString & a_DisplayName,
+		const AString & a_Prefix, const AString & a_Suffix
+	);
+
+	// tolua_begin
+
+	/** Adds a new player to the team */
+	bool AddPlayer(const AString & a_Name);
+
+	/** Removes a player from the team */
+	bool RemovePlayer(const AString & a_Name);
+
+	/** Returns whether the specified player is in this team */
+	bool HasPlayer(const AString & a_Name) const;
+
+	/** Removes all registered players */
+	void Reset(void);
+
+	// tolua_begin
+
+	/** Returns the number of registered players */
+	unsigned int GetNumPlayers(void) const;
+
+	bool AllowsFriendlyFire(void)      const { return m_AllowsFriendlyFire; }
+	bool CanSeeFriendlyInvisible(void) const { return m_CanSeeFriendlyInvisible; }
+
+	const AString & GetDisplayName(void) const { return m_DisplayName; }
+	const AString & GetName(void)        const { return m_DisplayName; }
+
+	const AString & GetPrefix(void) const { return m_Prefix; }
+	const AString & GetSuffix(void) const { return m_Suffix; }
+
+	void SetFriendlyFire(bool a_Flag)            { m_AllowsFriendlyFire      = a_Flag; }
+	void SetCanSeeFriendlyInvisible(bool a_Flag) { m_CanSeeFriendlyInvisible = a_Flag; }
+
+	void SetDisplayName(const AString & a_Name);
+
+	void SetPrefix(const AString & a_Prefix) { m_Prefix = a_Prefix; }
+	void SetSuffix(const AString & a_Suffix) { m_Suffix = a_Suffix; }
+
+	// tolua_end
+
+	static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
+	{
+		return "cTeam";
+	}
+
+private:
+
+	typedef std::set<AString> cPlayerNameSet;
+
+	bool m_AllowsFriendlyFire;
+	bool m_CanSeeFriendlyInvisible;
+
+	AString m_DisplayName;
+	AString m_Name;
+
+	AString m_Prefix;
+	AString m_Suffix;
+
+	cPlayerNameSet m_Players;
+
+	friend class cScoreboardSerializer;
+
+
+}; // tolua_export
+
+
+
+
+
+// tolua_begin
+class cScoreboard
+{
+public:
+
+	enum eDisplaySlot
+	{
+		dsList = 0,
+		dsSidebar,
+		dsName,
+
+		dsCount
+	};
+
+	// tolua_end
+
+
+public:
+
+	cScoreboard(cWorld * a_World);
+
+	// tolua_begin
+
+	/** Registers a new scoreboard objective, returns the cObjective instance, NULL on name collision */
+	cObjective * RegisterObjective(const AString & a_Name, const AString & a_DisplayName, cObjective::eType a_Type);
+
+	/** Removes a registered objective, returns true if operation was successful */
+	bool RemoveObjective(const AString & a_Name);
+
+	/** Retrieves the objective with the specified name, NULL if not found */
+	cObjective * GetObjective(const AString & a_Name);
+
+	/** Registers a new team, returns the cTeam instance, NULL on name collision */
+	cTeam * RegisterTeam(const AString & a_Name, const AString & a_DisplayName, const AString & a_Prefix, const AString & a_Suffix);
+
+	/** Removes a registered team, returns true if operation was successful */
+	bool RemoveTeam(const AString & a_Name);
+
+	/** Retrieves the team with the specified name, NULL if not found */
+	cTeam * GetTeam(const AString & a_Name);
+
+	void SetDisplay(const AString & a_Objective, eDisplaySlot a_Slot);
+
+	cObjective * GetObjectiveIn(eDisplaySlot a_Slot);
+
+	unsigned int GetNumObjectives(void) const;
+
+	unsigned int GetNumTeams(void) const;
+
+	void AddPlayerScore(const AString & a_Name, cObjective::eType a_Type, cObjective::Score a_Value = 1);
+
+	// tolua_end
+
+	/** Send this scoreboard to the specified client */
+	void SendTo(cClientHandle & a_Client);
+
+	cTeam * QueryPlayerTeam(const AString & a_Name); // WARNING: O(n logn)
+
+	/** Execute callback for each objective with the specified type 
+	 *
+	 * Returns true if all objectives processed, false if the callback aborted by returning true.
+	 */
+	bool ForEachObjectiveWith(cObjective::eType a_Type, cObjectiveCallback& a_Callback);
+
+	/** Execute callback for each objective.
+	 *
+	 * Returns true if all objectives have been processed, false if the callback aborted by returning true.
+	 */
+	bool ForEachObjective(cObjectiveCallback& a_Callback); // Exported in ManualBindings.cpp
+
+	/** Execute callback for each team.
+	 *
+	 * Returns true if all teams have been processed, false if the callback aborted by returning true.
+	 */
+	bool ForEachTeam(cTeamCallback& a_Callback); // Exported in ManualBindings.cpp
+
+	void SetDisplay(cObjective * a_Objective, eDisplaySlot a_Slot);
+
+
+private:
+
+	typedef std::pair<AString, cObjective> cNamedObjective;
+	typedef std::pair<AString, cTeam>      cNamedTeam;
+
+	typedef std::map<AString, cObjective> cObjectiveMap;
+	typedef std::map<AString, cTeam>      cTeamMap;
+
+	// TODO 2014-01-19 xdot: Potential optimization - Sort objectives based on type
+	cCriticalSection m_CSObjectives;
+	cObjectiveMap m_Objectives;
+
+	cCriticalSection m_CSTeams;
+	cTeamMap m_Teams;
+
+	cWorld * m_World;
+
+	cObjective * m_Display[dsCount];
+
+	friend class cScoreboardSerializer;
+
+
+}; // tolua_export
+
+
+
+
diff --git a/src/Server.cpp b/src/Server.cpp
index 4d551e164..d1e53bfff 100644
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -24,7 +24,7 @@
 #include "MersenneTwister.h"
 
 #include "inifile/iniFile.h"
-#include "Vector3f.h"
+#include "Vector3.h"
 
 #include <fstream>
 #include <sstream>
@@ -39,7 +39,9 @@ extern "C" {
 
 // For the "dumpmem" server command:
 /// Synchronize this with main.cpp - the leak finder needs initialization before it can be used to dump memory
-#define ENABLE_LEAK_FINDER
+// _X 2014_02_20: Disabled for canon repo, it makes the debug version too slow in MSVC2013
+// and we haven't had a memory leak for over a year anyway.
+// #define ENABLE_LEAK_FINDER
 
 #if defined(_MSC_VER) && defined(_DEBUG) && defined(ENABLE_LEAK_FINDER)
 	#pragma warning(push)
@@ -194,7 +196,7 @@ bool cServer::InitServer(cIniFile & a_SettingsIni)
 	m_PlayerCount = 0;
 	m_PlayerCountDiff = 0;
 
-	m_FaviconData = Base64Encode(cFile::ReadWholeFile("favicon.png")); // Will return empty string if file nonexistant; client doesn't mind
+	m_FaviconData = Base64Encode(cFile::ReadWholeFile(FILE_IO_PREFIX + AString("favicon.png"))); // Will return empty string if file nonexistant; client doesn't mind
 
 	if (m_bIsConnected)
 	{
@@ -237,7 +239,8 @@ bool cServer::InitServer(cIniFile & a_SettingsIni)
 	m_bIsConnected = true;
 
 	m_ServerID = "-";
-	if (a_SettingsIni.GetValueSetB("Authentication", "Authenticate", true))
+	m_ShouldAuthenticate = a_SettingsIni.GetValueSetB("Authentication", "Authenticate", true);
+	if (m_ShouldAuthenticate)
 	{
 		MTRand mtrand1;
 		unsigned int r1 = (mtrand1.randInt() % 1147483647) + 1000000000;
@@ -284,17 +287,9 @@ int cServer::GetNumPlayers(void)
 
 void cServer::PrepareKeys(void)
 {
-	// TODO: Save and load key for persistence across sessions
-	// But generating the key takes only a moment, do we even need that?
-	
 	LOGD("Generating protocol encryption keypair...");
-	
-	time_t CurTime = time(NULL);
-	CryptoPP::RandomPool rng;
-	rng.Put((const byte *)&CurTime, sizeof(CurTime));
-	m_PrivateKey.GenerateRandomWithKeySize(rng, 1024);
-	CryptoPP::RSA::PublicKey pk(m_PrivateKey);
-	m_PublicKey = pk;
+	VERIFY(m_PrivateKey.Generate(1024));
+	m_PublicKeyDER = m_PrivateKey.GetPubKeyDER();
 }
 
 
@@ -466,6 +461,19 @@ void cServer::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallbac
 	if (split[0] == "reload")
 	{
 		cPluginManager::Get()->ReloadPlugins();
+		cRoot::Get()->ReloadGroups();
+		return;
+	}
+	if (split[0] == "reloadplugins")
+	{
+		cPluginManager::Get()->ReloadPlugins();
+		return;
+	}
+	if (split[0] == "reloadgroups")
+	{
+		cRoot::Get()->ReloadGroups();
+		a_Output.Out("Groups reloaded!");
+		a_Output.Finished();
 		return;
 	}
 	
@@ -492,7 +500,7 @@ void cServer::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallbac
 		}
 	}
 	#endif
-	
+
 	if (cPluginManager::Get()->ExecuteConsoleCommand(split, a_Output))
 	{
 		a_Output.Finished();
@@ -542,7 +550,7 @@ void cServer::PrintHelp(const AStringVector & a_Split, cCommandOutputCallback &
 	for (AStringPairs::const_iterator itr = Callback.m_Commands.begin(), end = Callback.m_Commands.end(); itr != end; ++itr)
 	{
 		const AStringPair & cmd = *itr;
-		a_Output.Out(Printf("%-*s%s\n", Callback.m_MaxLen, cmd.first.c_str(), cmd.second.c_str()));
+		a_Output.Out(Printf("%-*s%s\n", static_cast<int>(Callback.m_MaxLen), cmd.first.c_str(), cmd.second.c_str()));
 	}  // for itr - Callback.m_Commands[]
 	a_Output.Finished();
 }
diff --git a/src/Server.h b/src/Server.h
index bb55e81b6..b5280c59d 100644
--- a/src/Server.h
+++ b/src/Server.h
@@ -23,8 +23,7 @@
 	#pragma warning(disable:4702)
 #endif
 
-#include "cryptopp/rsa.h"
-#include "cryptopp/randpool.h"
+#include "Crypto.h"
 
 #ifdef _MSC_VER
 	#pragma warning(pop)
@@ -72,13 +71,13 @@ public:												// tolua_export
 
 	bool Command(cClientHandle & a_Client, AString & a_Cmd);
 	
-	/// Executes the console command, sends output through the specified callback
+	/** Executes the console command, sends output through the specified callback */
 	void ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
 	
-	/// Lists all available console commands and their helpstrings
+	/** Lists all available console commands and their helpstrings */
 	void PrintHelp(const AStringVector & a_Split, cCommandOutputCallback & a_Output);
 
-	/// Binds the built-in console commands with the plugin manager
+	/** Binds the built-in console commands with the plugin manager */
 	static void BindBuiltInConsoleCommands(void);
 	
 	void Shutdown(void);
@@ -98,26 +97,28 @@ public:												// tolua_export
 	
 	void RemoveClient(const cClientHandle * a_Client);  // Removes the clienthandle from m_SocketThreads
 	
-	/// Don't tick a_Client anymore, it will be ticked from its cPlayer instead
+	/** Don't tick a_Client anymore, it will be ticked from its cPlayer instead */
 	void ClientMovedToWorld(const cClientHandle * a_Client);
 	
-	/// Notifies the server that a player was created; the server uses this to adjust the number of players
+	/** Notifies the server that a player was created; the server uses this to adjust the number of players */
 	void PlayerCreated(const cPlayer * a_Player);
 	
-	/// Notifies the server that a player is being destroyed; the server uses this to adjust the number of players
+	/** Notifies the server that a player is being destroyed; the server uses this to adjust the number of players */
 	void PlayerDestroying(const cPlayer * a_Player);
 
 	/** Returns base64 encoded favicon data (obtained from favicon.png) */
 	const AString & GetFaviconData(void) const { return m_FaviconData; }
 	
-	CryptoPP::RSA::PrivateKey & GetPrivateKey(void) { return m_PrivateKey; }
-	CryptoPP::RSA::PublicKey  & GetPublicKey (void) { return m_PublicKey; }
+	cRSAPrivateKey & GetPrivateKey(void) { return m_PrivateKey; }
+	const AString & GetPublicKeyDER(void) const { return m_PublicKeyDER; }
+	
+	bool ShouldAuthenticate(void) const { return m_ShouldAuthenticate; }
 	
 private:
 
 	friend class cRoot; // so cRoot can create and destroy cServer
 	
-	/// When NotifyClientWrite() is called, it is queued for this thread to process (to avoid deadlocks between cSocketThreads, cClientHandle and cChunkMap)
+	/** When NotifyClientWrite() is called, it is queued for this thread to process (to avoid deadlocks between cSocketThreads, cClientHandle and cChunkMap) */
 	class cNotifyWriteThread :
 		public cIsThread
 	{
@@ -141,7 +142,7 @@ private:
 		void NotifyClientWrite(const cClientHandle * a_Client);
 	} ;
 	
-	/// The server tick thread takes care of the players who aren't yet spawned in a world
+	/** The server tick thread takes care of the players who aren't yet spawned in a world */
 	class cTickThread :
 		public cIsThread
 	{
@@ -180,8 +181,11 @@ private:
 
 	bool m_bRestarting;
 	
-	CryptoPP::RSA::PrivateKey m_PrivateKey;
-	CryptoPP::RSA::PublicKey  m_PublicKey;
+	/** The private key used for the assymetric encryption start in the protocols */
+	cRSAPrivateKey m_PrivateKey;
+	
+	/** Public key for m_PrivateKey, ASN1-DER-encoded */
+	AString m_PublicKeyDER;
 	
 	cRCONServer m_RCONServer;
 	
@@ -193,18 +197,22 @@ private:
 	cTickThread m_TickThread;
 	cEvent m_RestartEvent;
 	
-	/// The server ID used for client authentication
+	/** The server ID used for client authentication */
 	AString m_ServerID;
 	
+	/** If true, players will be online-authenticated agains Mojang servers.
+	This setting is the same as the "online-mode" setting in Vanilla. */
+	bool m_ShouldAuthenticate;
+	
 
 	cServer(void);
 
-	/// Loads, or generates, if missing, RSA keys for protocol encryption
+	/** Loads, or generates, if missing, RSA keys for protocol encryption */
 	void PrepareKeys(void);
 	
 	bool Tick(float a_Dt);
 	
-	/// Ticks the clients in m_Clients, manages the list in respect to removing clients
+	/** Ticks the clients in m_Clients, manages the list in respect to removing clients */
 	void TickClients(float a_Dt);
 
 	// cListenThread::cCallback overrides:
diff --git a/src/Simulator/DelayedFluidSimulator.cpp b/src/Simulator/DelayedFluidSimulator.cpp
index 3d2170e44..bc5158d95 100644
--- a/src/Simulator/DelayedFluidSimulator.cpp
+++ b/src/Simulator/DelayedFluidSimulator.cpp
@@ -20,7 +20,7 @@
 bool cDelayedFluidSimulatorChunkData::cSlot::Add(int a_RelX, int a_RelY, int a_RelZ)
 {
 	ASSERT(a_RelZ >= 0);
-	ASSERT(a_RelZ < ARRAYCOUNT(m_Blocks));
+	ASSERT(a_RelZ < static_cast<int>(ARRAYCOUNT(m_Blocks)));
 	
 	cCoordWithIntVector & Blocks = m_Blocks[a_RelZ];
 	int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY, a_RelZ);
diff --git a/src/Simulator/FireSimulator.cpp b/src/Simulator/FireSimulator.cpp
index d7c5ab3b4..470dfc791 100644
--- a/src/Simulator/FireSimulator.cpp
+++ b/src/Simulator/FireSimulator.cpp
@@ -6,6 +6,8 @@
 #include "../BlockID.h"
 #include "../Defines.h"
 #include "../Chunk.h"
+#include "Root.h"
+#include "../Bindings/PluginManager.h"
 
 
 
@@ -162,13 +164,27 @@ bool cFireSimulator::IsFuel(BLOCKTYPE a_BlockType)
 	switch (a_BlockType)
 	{
 		case E_BLOCK_PLANKS:
+		case E_BLOCK_DOUBLE_WOODEN_SLAB:
+		case E_BLOCK_WOODEN_SLAB:
+		case E_BLOCK_WOODEN_STAIRS:
+		case E_BLOCK_SPRUCE_WOOD_STAIRS:
+		case E_BLOCK_BIRCH_WOOD_STAIRS:
+		case E_BLOCK_JUNGLE_WOOD_STAIRS:
 		case E_BLOCK_LEAVES:
+		case E_BLOCK_NEW_LEAVES:
 		case E_BLOCK_LOG:
+		case E_BLOCK_NEW_LOG:
 		case E_BLOCK_WOOL:
 		case E_BLOCK_BOOKCASE:
 		case E_BLOCK_FENCE:
 		case E_BLOCK_TNT:
 		case E_BLOCK_VINES:
+		case E_BLOCK_HAY_BALE:
+		case E_BLOCK_TALL_GRASS:
+		case E_BLOCK_BIG_FLOWER:
+		case E_BLOCK_DANDELION:
+		case E_BLOCK_FLOWER:
+		case E_BLOCK_CARPET:
 		{
 			return true;
 		}
@@ -238,7 +254,7 @@ int cFireSimulator::GetBurnStepTime(cChunk * a_Chunk, int a_RelX, int a_RelY, in
 		{
 			return m_BurnStepTimeFuel;
 		}
-		IsBlockBelowSolid = g_BlockIsSolid[BlockBelow];
+		IsBlockBelowSolid = cBlockInfo::IsSolid(BlockBelow);
 	}
 	
 	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
@@ -301,9 +317,15 @@ void cFireSimulator::TrySpreadFire(cChunk * a_Chunk, int a_RelX, int a_RelY, int
 				*/
 				if (CanStartFireInBlock(a_Chunk, x, y, z))
 				{
-					FLOG("FS: Starting new fire at {%d, %d, %d}.", 
-						x + a_Chunk->GetPosX() * cChunkDef::Width, y, z + a_Chunk->GetPosZ() * cChunkDef::Width
-					);
+					int a_PosX = x + a_Chunk->GetPosX() * cChunkDef::Width;
+					int a_PosZ = z + a_Chunk->GetPosZ() * cChunkDef::Width;
+					
+					if (cRoot::Get()->GetPluginManager()->CallHookBlockSpread(&m_World, a_PosX, y, a_PosZ, ssFireSpread))
+					{
+						return;
+					}
+					
+					FLOG("FS: Starting new fire at {%d, %d, %d}.", a_PosX, y, a_PosZ);
 					a_Chunk->UnboundedRelSetBlock(x, y, z, E_BLOCK_FIRE, 0);
 				}
 			}  // for y
@@ -320,21 +342,33 @@ void cFireSimulator::RemoveFuelNeighbors(cChunk * a_Chunk, int a_RelX, int a_Rel
 	for (size_t i = 0; i < ARRAYCOUNT(gNeighborCoords); i++)
 	{
 		BLOCKTYPE  BlockType;
-		NIBBLETYPE BlockMeta;
-		if (!a_Chunk->UnboundedRelGetBlock(a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z, BlockType, BlockMeta))
+		int X = a_RelX + gNeighborCoords[i].x;
+		int Z = a_RelZ + gNeighborCoords[i].z;
+
+		cChunkPtr Neighbour = a_Chunk->GetRelNeighborChunkAdjustCoords(X, Z);
+		if (Neighbour == NULL)
 		{
-			// Neighbor not accessible, ignore it
 			continue;
 		}
+		BlockType = Neighbour->GetBlock(X, a_RelY + gCrossCoords[i].y, Z);
+
 		if (!IsFuel(BlockType))
 		{
 			continue;
 		}
+
+		if (BlockType == E_BLOCK_TNT)
+		{
+			int AbsX = X + Neighbour->GetPosX() * cChunkDef::Width;
+			int AbsZ = Z + Neighbour->GetPosZ() * cChunkDef::Width;
+
+			m_World.SpawnPrimedTNT(AbsX, a_RelY + gNeighborCoords[i].y, AbsZ, 0);
+			Neighbour->SetBlock(X, a_RelY + gNeighborCoords[i].y, Z, E_BLOCK_AIR, 0);
+			return;
+		}
+
 		bool ShouldReplaceFuel = (m_World.GetTickRandomNumber(MAX_CHANCE_REPLACE_FUEL) < m_ReplaceFuelChance);
-		a_Chunk->UnboundedRelSetBlock(
-			a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z,
-			ShouldReplaceFuel ? E_BLOCK_FIRE : E_BLOCK_AIR, 0
-		);
+		Neighbour->SetBlock(X, a_RelY + gNeighborCoords[i].y, Z, ShouldReplaceFuel ? E_BLOCK_FIRE : E_BLOCK_AIR, 0);
 	}  // for i - Coords[]
 }
 
diff --git a/src/Simulator/FloodyFluidSimulator.cpp b/src/Simulator/FloodyFluidSimulator.cpp
index fdc4643a8..03e94e791 100644
--- a/src/Simulator/FloodyFluidSimulator.cpp
+++ b/src/Simulator/FloodyFluidSimulator.cpp
@@ -11,6 +11,7 @@
 #include "../Chunk.h"
 #include "../BlockArea.h"
 #include "../Blocks/BlockHandler.h"
+#include "../BlockInServerPluginInterface.h"
 
 
 
@@ -53,14 +54,23 @@ void cFloodyFluidSimulator::SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_Re
 		a_Chunk->GetMeta(a_RelX, a_RelY, a_RelZ)
 	);
 	
-	NIBBLETYPE MyMeta = a_Chunk->GetMeta(a_RelX, a_RelY, a_RelZ);
-	if (!IsAnyFluidBlock(a_Chunk->GetBlock(a_RelX, a_RelY, a_RelZ)))
+	BLOCKTYPE MyBlock; NIBBLETYPE MyMeta;
+	a_Chunk->GetBlockTypeMeta(a_RelX, a_RelY, a_RelZ, MyBlock, MyMeta);
+
+	if (!IsAnyFluidBlock(MyBlock))
 	{
 		// Can happen - if a block is scheduled for simulating and gets replaced in the meantime.
 		FLOG("  BadBlockType exit");
 		return;
 	}
 
+	// When in contact with water, lava should harden
+	if (HardenBlock(a_Chunk, a_RelX, a_RelY, a_RelZ, MyBlock, MyMeta))
+	{
+		// Block was changed, bail out
+		return;
+	}
+
 	if (MyMeta != 0)
 	{
 		// Source blocks aren't checked for tributaries, others are.
@@ -85,7 +95,12 @@ void cFloodyFluidSimulator::SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_Re
 		{
 			// Spread only down, possibly washing away what's there or turning lava to stone / cobble / obsidian:
 			SpreadToNeighbor(a_Chunk, a_RelX, a_RelY - 1, a_RelZ, 8);
-			SpreadFurther = false;
+
+			// Source blocks spread both downwards and sideways
+			if (MyMeta != 0)
+			{
+				SpreadFurther = false;
+			}
 		}
 		// If source creation is on, check for it here:
 		else if (
@@ -104,10 +119,7 @@ void cFloodyFluidSimulator::SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_Re
 	if (SpreadFurther && (NewMeta < 8))
 	{
 		// Spread to the neighbors:
-		SpreadToNeighbor(a_Chunk, a_RelX - 1, a_RelY, a_RelZ,     NewMeta);
-		SpreadToNeighbor(a_Chunk, a_RelX + 1, a_RelY, a_RelZ,     NewMeta);
-		SpreadToNeighbor(a_Chunk, a_RelX,     a_RelY, a_RelZ - 1, NewMeta);
-		SpreadToNeighbor(a_Chunk, a_RelX,     a_RelY, a_RelZ + 1, NewMeta);
+		Spread(a_Chunk, a_RelX, a_RelY, a_RelZ, NewMeta);
 	}
 	
 	// Mark as processed:
@@ -118,6 +130,17 @@ void cFloodyFluidSimulator::SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_Re
 
 
 
+void cFloodyFluidSimulator::Spread(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_NewMeta)
+{
+	SpreadToNeighbor(a_Chunk, a_RelX - 1, a_RelY, a_RelZ,     a_NewMeta);
+	SpreadToNeighbor(a_Chunk, a_RelX + 1, a_RelY, a_RelZ,     a_NewMeta);
+	SpreadToNeighbor(a_Chunk, a_RelX,     a_RelY, a_RelZ - 1, a_NewMeta);
+	SpreadToNeighbor(a_Chunk, a_RelX,     a_RelY, a_RelZ + 1, a_NewMeta);
+}
+
+
+
+
 bool cFloodyFluidSimulator::CheckTributaries(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_MyMeta)
 {
 	// If we have a section above, check if there's fluid above this block that would feed it:
@@ -273,8 +296,13 @@ void cFloodyFluidSimulator::SpreadToNeighbor(cChunk * a_NearChunk, int a_RelX, i
 		cBlockHandler * Handler = BlockHandler(BlockType);
 		if (Handler->DoesDropOnUnsuitable())
 		{
+			cChunkInterface ChunkInterface(m_World.GetChunkMap());
+			cBlockInServerPluginInterface PluginInterface(m_World);
 			Handler->DropBlock(
-				&m_World, NULL, 
+				ChunkInterface,
+				m_World,
+				PluginInterface,
+				NULL, 
 				a_NearChunk->GetPosX() * cChunkDef::Width + a_RelX, 
 				a_RelY,
 				a_NearChunk->GetPosZ() * cChunkDef::Width + a_RelZ
@@ -290,6 +318,8 @@ void cFloodyFluidSimulator::SpreadToNeighbor(cChunk * a_NearChunk, int a_RelX, i
 		a_NewMeta
 	);
 	a_NearChunk->UnboundedRelSetBlock(a_RelX, a_RelY, a_RelZ, m_FluidBlock, a_NewMeta);
+
+	HardenBlock(a_NearChunk, a_RelX, a_RelY, a_RelZ, m_FluidBlock, a_NewMeta);
 }
 
 
@@ -342,3 +372,56 @@ bool cFloodyFluidSimulator::CheckNeighborsForSource(cChunk * a_Chunk, int a_RelX
 
 
 
+
+bool cFloodyFluidSimulator::HardenBlock(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta)
+{
+	// Only lava blocks can harden
+	if (!IsBlockLava(a_BlockType))
+	{
+		return false;
+	}
+
+	bool ShouldHarden = false;
+
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+	static const Vector3i Coords[] =
+	{
+		Vector3i( 1, 0,  0),
+		Vector3i(-1, 0,  0),
+		Vector3i( 0, 0,  1),
+		Vector3i( 0, 0, -1),
+	};
+	for (size_t i = 0; i < ARRAYCOUNT(Coords); i++)
+	{
+		if (!a_Chunk->UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta))
+		{
+			continue;
+		}
+		if (IsBlockWater(BlockType))
+		{
+			ShouldHarden = true;
+		}
+	}  // for i - Coords[]
+
+	if (ShouldHarden)
+	{
+		if (a_Meta == 0)
+		{
+			// Source lava block
+			a_Chunk->UnboundedRelSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_OBSIDIAN, 0);
+			return true;
+		}
+		// Ignore last lava level
+		else if (a_Meta <= 4)
+		{
+			a_Chunk->UnboundedRelSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_COBBLESTONE, 0);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
diff --git a/src/Simulator/FloodyFluidSimulator.h b/src/Simulator/FloodyFluidSimulator.h
index c4af2e246..632de3bb2 100644
--- a/src/Simulator/FloodyFluidSimulator.h
+++ b/src/Simulator/FloodyFluidSimulator.h
@@ -38,14 +38,26 @@ protected:
 	// cDelayedFluidSimulator overrides:
 	virtual void SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override;
 	
-	/// Checks tributaries, if not fed, decreases the block's level and returns true
+	/** Checks tributaries, if not fed, decreases the block's level and returns true. */
 	bool CheckTributaries(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_MyMeta);
 
-	/// Spreads into the specified block, if the blocktype there allows. a_Area is for checking.
+	/** Spreads into the specified block, if the blocktype there allows. a_Area is for checking. */
 	void SpreadToNeighbor(cChunk * a_NearChunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_NewMeta);
 	
-	/// Checks if there are enough neighbors to create a source at the coords specified; turns into source and returns true if so
+	/** Checks if there are enough neighbors to create a source at the coords specified; turns into source and returns true if so. */
 	bool CheckNeighborsForSource(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ);
+
+	/** Checks if the specified block should harden (Water/Lava interaction) and if so, converts it to a suitable block.
+	 *
+	 * Returns whether the block was changed or not.
+	 */
+	bool HardenBlock(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta);
+
+	/** Spread water to neighbors.
+	 *
+	 * May be overridden to provide more sophisticated algorithms.
+	 */
+	virtual void Spread(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_NewMeta);
 } ;
 
 
diff --git a/src/Simulator/FluidSimulator.cpp b/src/Simulator/FluidSimulator.cpp
index 72b2eb628..7779573d7 100644
--- a/src/Simulator/FluidSimulator.cpp
+++ b/src/Simulator/FluidSimulator.cpp
@@ -36,6 +36,7 @@ bool cFluidSimulator::CanWashAway(BLOCKTYPE a_BlockType)
 		case E_BLOCK_COBWEB:
 		case E_BLOCK_CROPS:
 		case E_BLOCK_DEAD_BUSH:
+		case E_BLOCK_LILY_PAD:
 		case E_BLOCK_RAIL:
 		case E_BLOCK_REDSTONE_TORCH_OFF:
 		case E_BLOCK_REDSTONE_TORCH_ON:
@@ -166,14 +167,12 @@ Direction cFluidSimulator::GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a
 			{
 				LowestPoint = Meta;
 				X = Pos->x;
-				Pos->y; //Remove if no side effects
 				Z = Pos->z;
 			}
 		}else if(BlockID == E_BLOCK_AIR)
 		{
 			LowestPoint = 9;		//This always dominates
 			X = Pos->x;
-			Pos->y; //Remove if no side effects
 			Z = Pos->z;
 		
 		}
diff --git a/src/Simulator/IncrementalRedstoneSimulator.cpp b/src/Simulator/IncrementalRedstoneSimulator.cpp
new file mode 100644
index 000000000..f12c29211
--- /dev/null
+++ b/src/Simulator/IncrementalRedstoneSimulator.cpp
@@ -0,0 +1,1704 @@
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "IncrementalRedstoneSimulator.h"
+#include "../BlockEntities/DropSpenserEntity.h"
+#include "../BlockEntities/NoteEntity.h"
+#include "../BlockEntities/CommandBlockEntity.h"
+#include "../Entities/TNTEntity.h"
+#include "../Entities/Pickup.h"
+#include "../Blocks/BlockTorch.h"
+#include "../Blocks/BlockDoor.h"
+#include "../Piston.h"
+
+
+
+
+
+cIncrementalRedstoneSimulator::cIncrementalRedstoneSimulator(cWorld & a_World)
+	: super(a_World)
+{
+}
+
+
+
+
+
+cIncrementalRedstoneSimulator::~cIncrementalRedstoneSimulator()
+{
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::RedstoneAddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk, cChunk * a_OtherChunk)
+{
+	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
+	{
+		return;
+	}
+	else if ((a_BlockY < 0) || (a_BlockY > cChunkDef::Height))
+	{
+		return;
+	}
+
+	// We may be called with coordinates in a chunk that is not the first chunk parameter
+	// In that case, the actual chunk (which the coordinates are in), will be passed as the second parameter
+	// Use that Chunk pointer to get a relative position
+
+	int RelX = 0;
+	int RelZ = 0;	
+	BLOCKTYPE Block;
+	NIBBLETYPE Meta;
+
+	if (a_OtherChunk != NULL)
+	{
+		RelX = a_BlockX - a_OtherChunk->GetPosX() * cChunkDef::Width;
+		RelZ = a_BlockZ - a_OtherChunk->GetPosZ() * cChunkDef::Width;
+		a_OtherChunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
+	}
+	else
+	{
+		RelX = a_BlockX - a_Chunk->GetPosX() * cChunkDef::Width;
+		RelZ = a_BlockZ - a_Chunk->GetPosZ() * cChunkDef::Width;
+		a_Chunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
+	}
+
+	// Every time a block is changed (AddBlock called), we want to go through all lists and check to see if the coordiantes stored within are still valid
+	// Checking only when a block is changed, as opposed to every tick, also improves performance
+
+	PoweredBlocksList * PoweredBlocks = a_Chunk->GetRedstoneSimulatorPoweredBlocksList();
+	for (PoweredBlocksList::iterator itr = PoweredBlocks->begin(); itr != PoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			continue;
+		}
+
+		if (!IsPotentialSource(Block))
+		{
+			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list as it no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+			PoweredBlocks->erase(itr);
+			break;
+		}
+		else if (
+			// Changeable sources
+			((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
+			((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
+			((Block == E_BLOCK_DETECTOR_RAIL) && (Meta & 0x08) == 0) ||
+			(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta))) ||
+			(((Block == E_BLOCK_STONE_PRESSURE_PLATE) || (Block == E_BLOCK_WOODEN_PRESSURE_PLATE)) && (Meta == 0)) ||
+			(((Block == E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE) || (Block == E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE)) && (Meta == 0))
+			)
+		{
+			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+			PoweredBlocks->erase(itr);
+			break;
+		}
+		else if (Block == E_BLOCK_DAYLIGHT_SENSOR)
+		{
+			if (!a_Chunk->IsLightValid())
+			{
+				m_World.QueueLightChunk(a_Chunk->GetPosX(), a_Chunk->GetPosZ());
+				break;
+			}
+			else
+			{
+				NIBBLETYPE SkyLight;
+				a_Chunk->UnboundedRelGetBlockSkyLight(RelX, itr->a_SourcePos.y + 1, RelZ, SkyLight);
+
+				if (a_Chunk->GetTimeAlteredLight(SkyLight) <= 8) // Could use SkyLight - m_World.GetSkyDarkness();
+				{
+					LOGD("cIncrementalRedstoneSimulator: Erased daylight sensor from powered blocks list due to insufficient light level");
+					PoweredBlocks->erase(itr);
+					break;
+				}
+			}
+		}
+	}
+
+	LinkedBlocksList * LinkedPoweredBlocks = a_Chunk->GetRedstoneSimulatorLinkedBlocksList();
+	// We loop through all values (insteading of breaking out at the first) to make sure everything is gone, as there can be multiple SourceBlock entries for one AddBlock coordinate
+	for (LinkedBlocksList::iterator itr = LinkedPoweredBlocks->begin(); itr != LinkedPoweredBlocks->end();)
+	{
+		if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			if (!IsPotentialSource(Block))
+			{
+				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+				itr = LinkedPoweredBlocks->erase(itr);
+				continue;
+			}
+			else if (
+				// Things that can send power through a block but which depends on meta
+				((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
+				((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
+				(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta)))
+				)
+			{
+				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+				itr = LinkedPoweredBlocks->erase(itr);
+				continue;
+			}
+		}
+		else if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			if (!IsViableMiddleBlock(Block))
+			{
+				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer powered through a valid middle block", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+				itr = LinkedPoweredBlocks->erase(itr);
+				continue;
+			}
+		}
+		++itr;
+	}
+
+	SimulatedPlayerToggleableList * SimulatedPlayerToggleableBlocks = a_Chunk->GetRedstoneSimulatorSimulatedPlayerToggleableList();
+	for (SimulatedPlayerToggleableList::iterator itr = SimulatedPlayerToggleableBlocks->begin(); itr != SimulatedPlayerToggleableBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			continue;
+		}
+
+		if (!IsAllowedBlock(Block))
+		{
+			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from toggleable simulated list as it is no longer redstone", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+			SimulatedPlayerToggleableBlocks->erase(itr);
+			break;
+		}
+	}
+
+	RepeatersDelayList * RepeatersDelayList = a_Chunk->GetRedstoneSimulatorRepeatersDelayList();
+	for (RepeatersDelayList::iterator itr = RepeatersDelayList->begin(); itr != RepeatersDelayList->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			continue;
+		}
+
+		if ((Block != E_BLOCK_REDSTONE_REPEATER_ON) && (Block != E_BLOCK_REDSTONE_REPEATER_OFF))
+		{
+			RepeatersDelayList->erase(itr);
+			break;
+		}
+	}
+
+	if (a_OtherChunk != NULL)
+	{
+		// DO NOT touch our chunk's data structure if we are being called with coordinates from another chunk - this one caused me massive grief :P
+		return;
+	}
+
+	cRedstoneSimulatorChunkData * RedstoneSimulatorChunkData = a_Chunk->GetRedstoneSimulatorData();
+	for (cRedstoneSimulatorChunkData::iterator itr = RedstoneSimulatorChunkData->begin(); itr != RedstoneSimulatorChunkData->end(); ++itr)
+	{
+		if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == RelZ)) // We are at an entry matching the current (changed) block
+		{
+			if (!IsAllowedBlock(Block))
+			{
+				itr->DataTwo = true; // The new blocktype is not redstone; it must be queued to be removed from this list
+			}
+			else
+			{
+				itr->Data = Block; // Update block information
+			}
+			return;
+		}
+	}
+
+	if (!IsAllowedBlock(Block))
+	{
+		return;
+	}
+
+	RedstoneSimulatorChunkData->push_back(cCoordWithBlockAndBool(RelX, a_BlockY, RelZ, Block, false));
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk)
+{
+	// We still attempt to simulate all blocks in the chunk every tick, because of outside influence that needs to be taken into account
+	// For example, repeaters need to be ticked, pressure plates checked for entities, daylight sensor checked for light changes, etc.
+	// The easiest way to make this more efficient is probably just to reduce code within the handlers that put too much strain on server, like getting or setting blocks
+	// A marking dirty system might be a TODO for later on, perhaps
+
+	m_RedstoneSimulatorChunkData = a_Chunk->GetRedstoneSimulatorData();
+	if (m_RedstoneSimulatorChunkData->empty())
+	{
+		return;
+	}
+
+	m_PoweredBlocks = a_Chunk->GetRedstoneSimulatorPoweredBlocksList();
+	m_RepeatersDelayList = a_Chunk->GetRedstoneSimulatorRepeatersDelayList();
+	m_SimulatedPlayerToggleableBlocks = a_Chunk->GetRedstoneSimulatorSimulatedPlayerToggleableList();
+	m_LinkedPoweredBlocks = a_Chunk->GetRedstoneSimulatorLinkedBlocksList();
+	m_Chunk = a_Chunk;
+
+	int BaseX = a_Chunk->GetPosX() * cChunkDef::Width;
+	int BaseZ = a_Chunk->GetPosZ() * cChunkDef::Width;
+
+	for (cRedstoneSimulatorChunkData::iterator dataitr = m_RedstoneSimulatorChunkData->begin(); dataitr != m_RedstoneSimulatorChunkData->end();)
+	{
+		if (dataitr->DataTwo)
+		{
+			dataitr = m_RedstoneSimulatorChunkData->erase(dataitr);
+			continue;
+		}
+
+		int a_X = BaseX + dataitr->x;
+		int a_Z = BaseZ + dataitr->z;
+		switch (dataitr->Data)
+		{
+			case E_BLOCK_BLOCK_OF_REDSTONE:     HandleRedstoneBlock(a_X, dataitr->y, a_Z);	break;
+			case E_BLOCK_LEVER:                 HandleRedstoneLever(a_X, dataitr->y, a_Z);	break;
+			case E_BLOCK_FENCE_GATE:            HandleFenceGate(a_X, dataitr->y, a_Z);      break;
+			case E_BLOCK_TNT:                   HandleTNT(a_X, dataitr->y, a_Z);            break;
+			case E_BLOCK_TRAPDOOR:              HandleTrapdoor(a_X, dataitr->y, a_Z);       break;
+			case E_BLOCK_REDSTONE_WIRE:         HandleRedstoneWire(a_X, dataitr->y, a_Z);	break;
+			case E_BLOCK_NOTE_BLOCK:            HandleNoteBlock(a_X, dataitr->y, a_Z);      break;
+			case E_BLOCK_DAYLIGHT_SENSOR:       HandleDaylightSensor(a_X, dataitr->y, a_Z); break;
+			case E_BLOCK_COMMAND_BLOCK:         HandleCommandBlock(a_X, dataitr->y, a_Z);   break;
+
+			case E_BLOCK_REDSTONE_TORCH_OFF:
+			case E_BLOCK_REDSTONE_TORCH_ON:
+			{
+				HandleRedstoneTorch(a_X, dataitr->y, a_Z, dataitr->Data);
+				break;
+			}
+			case E_BLOCK_STONE_BUTTON:
+			case E_BLOCK_WOODEN_BUTTON:
+			{
+				HandleRedstoneButton(a_X, dataitr->y, a_Z, dataitr->Data);
+				break;
+			}
+			case E_BLOCK_REDSTONE_REPEATER_OFF:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			{
+				HandleRedstoneRepeater(a_X, dataitr->y, a_Z, dataitr->Data);
+				break;
+			}
+			case E_BLOCK_PISTON:
+			case E_BLOCK_STICKY_PISTON:
+			{
+				HandlePiston(a_X, dataitr->y, a_Z);
+				break;
+			}
+			case E_BLOCK_REDSTONE_LAMP_OFF:
+			case E_BLOCK_REDSTONE_LAMP_ON:
+			{
+				HandleRedstoneLamp(a_X, dataitr->y, a_Z, dataitr->Data);
+				break;
+			}
+			case E_BLOCK_DISPENSER:
+			case E_BLOCK_DROPPER:
+			{
+				HandleDropSpenser(a_X, dataitr->y, a_Z);
+				break;
+			}
+			case E_BLOCK_WOODEN_DOOR:
+			case E_BLOCK_IRON_DOOR:
+			{
+				HandleDoor(a_X, dataitr->y, a_Z);
+				break;
+			}
+			case E_BLOCK_ACTIVATOR_RAIL:
+			case E_BLOCK_DETECTOR_RAIL:
+			case E_BLOCK_POWERED_RAIL:
+			{
+				HandleRail(a_X, dataitr->y, a_Z, dataitr->Data);
+				break;
+			}
+			case E_BLOCK_WOODEN_PRESSURE_PLATE:
+			case E_BLOCK_STONE_PRESSURE_PLATE:
+			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+			{
+				HandlePressurePlate(a_X, dataitr->y, a_Z, dataitr->Data);
+				break;
+			}
+			default: LOGD("Unhandled block (!) or unimplemented redstone block: %s", ItemToString(dataitr->Data).c_str()); break;
+		}
+		++dataitr;
+	}
+}
+
+
+
+
+void cIncrementalRedstoneSimulator::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
+{
+	if (
+		((a_BlockX % cChunkDef::Width) <= 1) ||
+		((a_BlockX % cChunkDef::Width) >= 14) ||
+		((a_BlockZ % cChunkDef::Width) <= 1) ||
+		((a_BlockZ % cChunkDef::Width) >= 14)
+		) // Are we on a chunk boundary? +- 2 because of LinkedPowered blocks
+	{
+		// On a chunk boundary, alert all four sides (i.e. at least one neighbouring chunk)
+		AddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk);
+
+		// Pass the original coordinates, because when adding things to our simulator lists, we get the chunk that they are in, and therefore any updates need to preseve their position
+		// RedstoneAddBlock to pass both the neighbouring chunk and the chunk which the coordiantes are in and +- 2 in GetNeighbour() to accomodate for LinkedPowered blocks being 2 away from chunk boundaries
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX - 2, a_BlockZ), a_Chunk);
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX + 2, a_BlockZ), a_Chunk);
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ - 2), a_Chunk);
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ + 2), a_Chunk);
+
+		return;
+	}
+
+	// Not on boundary, just alert this chunk for speed
+	AddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk);
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneTorch(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState)
+{
+	static const struct // Define which directions the torch can power
+	{
+		int x, y, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0,  0},
+		{-1, 0,  0},
+		{ 0, 0,  1},
+		{ 0, 0, -1},
+		{ 0, 1,  0},
+	} ;
+
+	if (a_MyState == E_BLOCK_REDSTONE_TORCH_ON)
+	{
+		// Check if the block the torch is on is powered		
+		int X = a_BlockX; int Y = a_BlockY; int Z = a_BlockZ;
+		AddFaceDirection(X, Y, Z, cBlockTorchHandler::MetaDataToDirection(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)), true); // Inverse true to get the block torch is on
+
+		if (AreCoordsDirectlyPowered(X, Y, Z))
+		{
+			// There was a match, torch goes off
+			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_OFF, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ));
+			return;
+		}
+
+		// Torch still on, make all 4(X, Z) + 1(Y) sides powered
+		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
+		{
+			BLOCKTYPE Type = m_World.GetBlock(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z);
+			if (i + 1 < ARRAYCOUNT(gCrossCoords)) // Sides of torch, not top (top is last)
+			{
+				if (
+					((IsMechanism(Type)) || (Type == E_BLOCK_REDSTONE_WIRE)) && // Is it a mechanism or wire? Not block/other torch etc.
+					(!Vector3i(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z).Equals(Vector3i(X, Y, Z))) // CAN'T power block is that it is on
+					)
+				{
+					SetBlockPowered(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON);
+				}
+			}
+			else
+			{
+				// Top side, power whatever is there, including blocks
+				SetBlockPowered(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON);
+				// Power all blocks surrounding block above torch
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, E_BLOCK_REDSTONE_TORCH_ON);
+			}
+		}
+
+		if (m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) != 0x5) // Is torch standing on ground? If NOT (i.e. on wall), power block beneath
+		{
+			BLOCKTYPE Type = m_World.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
+
+			if ((IsMechanism(Type)) || (Type == E_BLOCK_REDSTONE_WIRE)) // Still can't make a normal block powered though!
+			{
+				SetBlockPowered(a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON);
+			}
+		}
+	}
+	else
+	{
+		// Check if the block the torch is on is powered		
+		int X = a_BlockX; int Y = a_BlockY; int Z = a_BlockZ;
+		AddFaceDirection(X, Y, Z, cBlockTorchHandler::MetaDataToDirection(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)), true); // Inverse true to get the block torch is on
+
+		// See if off state torch can be turned on again
+		if (AreCoordsDirectlyPowered(X, Y, Z))
+		{
+			return; // Something matches, torch still powered
+		}
+
+		// Block torch on not powered, can be turned on again!
+		m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ));
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_BLOCK_OF_REDSTONE);
+	SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_BLOCK_OF_REDSTONE); // Set self as powered
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneLever(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	if (IsLeverOn(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)))
+	{
+		SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_LEVER);
+
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_LEVER);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_LEVER);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, E_BLOCK_LEVER);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, E_BLOCK_LEVER);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_LEVER);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_LEVER);
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleFenceGate(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	cChunkInterface ChunkInterface(m_World.GetChunkMap());
+	NIBBLETYPE MetaData = ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
+		{
+			m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, MetaData | 0x4);
+			m_World.BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
+		{
+			m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, MetaData & 0xFFFFFFFB);
+			m_World.BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneButton(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType)
+{
+	if (IsButtonOn(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)))
+	{
+		SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, a_BlockType);
+
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, a_BlockType);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, a_BlockType);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, a_BlockType);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, a_BlockType);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, a_BlockType);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, a_BlockType);
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneWire(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	static const struct // Define which directions the wire can receive power from
+	{
+		int x, y, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0,  0}, /* Wires on same level start */
+		{-1, 0,  0},
+		{ 0, 0,  1},
+		{ 0, 0, -1}, /* Wires on same level stop */
+		{ 1, 1,  0}, /* Wires one higher, surrounding self start */
+		{-1, 1,  0},
+		{ 0, 1,  1},
+		{ 0, 1, -1}, /* Wires one higher, surrounding self stop */
+		{ 1,-1,  0}, /* Wires one lower, surrounding self start */
+		{-1,-1,  0},
+		{ 0,-1,  1},
+		{ 0,-1, -1}, /* Wires one lower, surrounding self stop */
+	} ;
+
+	static const struct // Define which directions the wire will check for repeater prescence
+	{
+		int x, y, z;
+	} gSideCoords[] =
+	{
+		{ 1, 0, 0 },
+		{-1, 0, 0 },
+		{ 0, 0, 1 },
+		{ 0, 0,-1 },
+		{ 0, 1, 0 },
+	};
+
+	// Check to see if directly beside a power source
+	if (IsWirePowered(a_BlockX, a_BlockY, a_BlockZ))
+	{
+		m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 15); // Maximum power
+	}
+	else
+	{
+		NIBBLETYPE MetaToSet = 0;
+		NIBBLETYPE MyMeta = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		int TimesMetaSmaller = 0, TimesFoundAWire = 0;
+
+		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++) // Loop through all directions to transfer or receive power
+		{
+			if ((i >= 4) && (i <= 7)) // If we are currently checking for wire surrounding ourself one block above...
+			{
+				if (cBlockInfo::IsSolid(m_World.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ))) // If there is something solid above us (wire cut off)...
+				{
+					continue; // We don't receive power from that wire
+				}
+			}
+			else if ((i >= 8) && (i <= 11)) // See above, but this is for wire below us
+			{
+				if (cBlockInfo::IsSolid(m_World.GetBlock(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y + 1, a_BlockZ + gCrossCoords[i].z)))
+				{
+					continue;
+				}
+			}
+
+			BLOCKTYPE SurroundType;
+			NIBBLETYPE SurroundMeta;
+			m_World.GetBlockTypeMeta(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, SurroundType, SurroundMeta);
+
+			if (SurroundType == E_BLOCK_REDSTONE_WIRE)
+			{
+				TimesFoundAWire++;
+
+				if (SurroundMeta > 1) // Wires of power 1 or 0 cannot transfer power TO ME, don't bother checking
+				{
+					// Does surrounding wire have a higher power level than self?
+					// >= to fix a bug where wires bordering each other with the same power level will appear (in terms of meta) to power each other, when they aren't actually in the powered list
+					if (SurroundMeta >= MyMeta)
+					{
+						MetaToSet = SurroundMeta - 1; // To improve performance
+					}
+				}
+				
+				if (SurroundMeta < MyMeta) // Go through all surroundings to see if self power is larger than everyone else's
+				{
+					TimesMetaSmaller++;
+				}
+			}			
+		}
+
+		if ((TimesMetaSmaller == TimesFoundAWire) && (MyMeta != 0))
+		{
+			// All surrounding metas were smaller - self must have been a wire that was
+			// transferring power to other wires around.
+			// However, self not directly powered anymore, so source must have been removed,
+			// therefore, self must be set to meta zero
+			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE, 0); // SetMeta & WakeUpSims doesn't seem to work here, so SetBlock
+			return; // No need to process block power sets because self not powered
+		}
+		else if (MyMeta != MetaToSet)
+		{
+			m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, MetaToSet);
+		}
+	}
+
+	if (m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) != 0) // A powered wire
+	{
+		for (size_t i = 0; i < ARRAYCOUNT(gSideCoords); i++) // Look for repeaters immediately surrounding self and try to power them
+		{
+			if (m_World.GetBlock(a_BlockX + gSideCoords[i].x, a_BlockY + gSideCoords[i].y, a_BlockZ + gSideCoords[i].z) == E_BLOCK_REDSTONE_REPEATER_OFF)
+			{
+				SetBlockPowered(a_BlockX + gSideCoords[i].x, a_BlockY + gSideCoords[i].y, a_BlockZ + gSideCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+			}
+		}
+
+		// Wire still powered, power blocks beneath
+		SetBlockPowered(a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, E_BLOCK_REDSTONE_WIRE);
+
+		switch (GetWireDirection(a_BlockX, a_BlockY, a_BlockZ))
+		{
+			case REDSTONE_NONE:
+			{
+				SetBlockPowered(a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetBlockPowered(a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetBlockPowered(a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_REDSTONE_WIRE);
+				break;
+			}
+			case REDSTONE_X_POS:
+			{
+				SetBlockPowered(a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_REDSTONE_WIRE);
+				break;
+			}
+			case REDSTONE_X_NEG:
+			{
+				SetBlockPowered(a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_REDSTONE_WIRE);
+				break;
+			}
+			case REDSTONE_Z_POS:
+			{
+				SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_REDSTONE_WIRE);
+				break;
+			}
+			case REDSTONE_Z_NEG:
+			{
+				SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
+				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_REDSTONE_WIRE);
+				break;
+			}
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneRepeater(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState)
+{
+	// Create a variable holding my meta to avoid multiple lookups.
+	NIBBLETYPE a_Meta = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+	// Do the same for being on, self powered or locked.
+	bool IsOn = (a_MyState == E_BLOCK_REDSTONE_REPEATER_ON);
+	bool IsSelfPowered = IsRepeaterPowered(a_BlockX, a_BlockY, a_BlockZ, a_Meta);
+	bool IsLocked = IsRepeaterLocked(a_BlockX, a_BlockY, a_BlockZ, a_Meta);
+
+	if (IsSelfPowered && !IsOn && !IsLocked) // Queue a power change if powered, but not on and not locked.
+	{
+		QueueRepeaterPowerChange(a_BlockX, a_BlockY, a_BlockZ, a_Meta, true);
+	}
+	else if (!IsSelfPowered && IsOn && !IsLocked) // Queue a power change if unpowered, on, and not locked.
+	{
+		QueueRepeaterPowerChange(a_BlockX, a_BlockY, a_BlockZ, a_Meta, false);
+	}
+
+	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList->begin(); itr != m_RepeatersDelayList->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			continue;
+		}
+
+		if (itr->a_ElapsedTicks >= itr->a_DelayTicks) // Has the elapsed ticks reached the target ticks?
+		{
+			if (itr->ShouldPowerOn)
+			{
+				if (!IsOn)
+				{
+					m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON, a_Meta); // For performance
+				}
+
+				switch (a_Meta & 0x3) // We only want the direction (bottom) bits
+				{
+					case 0x0:
+					{
+						SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
+						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_REDSTONE_REPEATER_ON);
+						break;
+					}
+					case 0x1:
+					{
+						SetBlockPowered(a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
+						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_REDSTONE_REPEATER_ON);
+						break;
+					}
+					case 0x2:
+					{
+						SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
+						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_REDSTONE_REPEATER_ON);
+						break;
+					}
+					case 0x3:
+					{
+						SetBlockPowered(a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
+						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_REDSTONE_REPEATER_ON);
+						break;
+					}
+				}
+
+				// Removal of the data entry will be handled in SimChunk - we still want to continue trying to power blocks, even if our delay time has reached
+				// Otherwise, the power state of blocks in front won't update after we have powered on
+				return;
+			}
+			else
+			{
+				if (IsOn)
+				{
+					m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_OFF, a_Meta);
+				}
+				m_RepeatersDelayList->erase(itr); // We can remove off repeaters which don't need further updating
+				return;
+			}
+		}
+		else
+		{
+			// Apparently, incrementing ticks only works reliably here, and not in SimChunk;
+			// With a world with lots of redstone, the repeaters simply do not delay
+			// I am confounded to say why. Perhaps optimisation failure.
+			LOGD("Incremented a repeater @ {%i %i %i} | Elapsed ticks: %i | Target delay: %i", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z, itr->a_ElapsedTicks, itr->a_DelayTicks);
+			itr->a_ElapsedTicks++;
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandlePiston(int a_BlockX, int a_BlockY, int a_BlockZ)
+{	
+	cPiston Piston(&m_World);
+	if (IsPistonPowered(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x7)) // We only want the bottom three bits (4th controls extended-ness)
+	{
+		Piston.ExtendPiston(a_BlockX, a_BlockY, a_BlockZ);
+	}
+	else
+	{
+		Piston.RetractPiston(a_BlockX, a_BlockY, a_BlockZ);
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleDropSpenser(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	class cSetPowerToDropSpenser :
+		public cDropSpenserCallback
+	{
+		bool m_IsPowered;
+	public:
+		cSetPowerToDropSpenser(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
+				
+		virtual bool Item(cDropSpenserEntity * a_DropSpenser) override
+		{
+			a_DropSpenser->SetRedstonePower(m_IsPowered);
+			return false;
+		}
+	} DrSpSP (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ));
+
+	m_World.DoWithDropSpenserAt(a_BlockX, a_BlockY, a_BlockZ, DrSpSP);
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRedstoneLamp(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState)
+{
+	if (a_MyState == E_BLOCK_REDSTONE_LAMP_OFF)
+	{
+		if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+		{
+			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_LAMP_ON, 0);
+		}
+	}
+	else
+	{
+		if (!AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+		{
+			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_LAMP_OFF, 0);
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleTNT(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+	{
+		m_World.BroadcastSoundEffect("game.tnt.primed", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.6f);
+		m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+		m_World.SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5);  // 80 ticks to boom
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleDoor(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
+		{
+			cChunkInterface ChunkInterface(m_World.GetChunkMap());
+			cBlockDoorHandler::ChangeDoor(ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
+			m_World.BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
+		{
+			cChunkInterface ChunkInterface(m_World.GetChunkMap());
+			cBlockDoorHandler::ChangeDoor(ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
+			m_World.BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleCommandBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	class cSetPowerToCommandBlock :
+		public cCommandBlockCallback
+	{
+		bool m_IsPowered;
+	public:
+		cSetPowerToCommandBlock(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
+				
+		virtual bool Item(cCommandBlockEntity * a_CommandBlock) override
+		{
+			a_CommandBlock->SetRedstonePower(m_IsPowered);
+			return false;
+		}
+	} CmdBlockSP (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ));
+
+	m_World.DoWithCommandBlockAt(a_BlockX, a_BlockY, a_BlockZ, CmdBlockSP);
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleRail(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType)
+{
+	switch (a_MyType)
+	{
+		case E_BLOCK_DETECTOR_RAIL:
+		{
+			if ((m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x08) == 0x08)
+			{
+				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, a_MyType);
+			}
+			break;
+		}
+		case E_BLOCK_ACTIVATOR_RAIL:
+		case E_BLOCK_POWERED_RAIL:
+		{
+			if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+			{
+				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) | 0x08);
+			}
+			else
+			{
+				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x07);
+			}
+			break;
+		}
+		default: LOGD("Unhandled type of rail in %s", __FUNCTION__);
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleTrapdoor(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
+		{
+			m_World.SetTrapdoorOpen(a_BlockX, a_BlockY, a_BlockZ, true);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
+		{
+			m_World.SetTrapdoorOpen(a_BlockX, a_BlockY, a_BlockZ, false);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleNoteBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	bool m_bAreCoordsPowered = AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ);
+
+	if (m_bAreCoordsPowered)
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
+		{
+			class cSetPowerToNoteBlock :
+				public cNoteBlockCallback
+			{
+				bool m_IsPowered;
+			public:
+				cSetPowerToNoteBlock(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
+
+				virtual bool Item(cNoteEntity * a_NoteBlock) override
+				{
+					if (m_IsPowered)
+					{
+						a_NoteBlock->MakeSound();
+					}
+					return false;
+				}
+			} NoteBlockSP(m_bAreCoordsPowered);
+
+			m_World.DoWithNoteBlockAt(a_BlockX, a_BlockY, a_BlockZ, NoteBlockSP);
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
+		{
+			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandleDaylightSensor(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	int a_ChunkX, a_ChunkZ;
+	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, a_ChunkX, a_ChunkZ);
+
+	if (!m_World.IsChunkLighted(a_ChunkX, a_ChunkZ))
+	{
+		m_World.QueueLightChunk(a_ChunkX, a_ChunkZ);
+	}
+	else
+	{
+		NIBBLETYPE SkyLight = m_World.GetBlockSkyLight(a_BlockX, a_BlockY + 1, a_BlockZ) - m_World.GetSkyDarkness();
+		if (SkyLight > 8)
+		{
+			SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_DAYLIGHT_SENSOR);
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::HandlePressurePlate(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType)
+{
+	switch (a_MyType)
+	{
+		case E_BLOCK_STONE_PRESSURE_PLATE:
+		{
+			// MCS feature - stone pressure plates can only be triggered by players :D
+			cPlayer * a_Player = m_World.FindClosestPlayer(Vector3f(a_BlockX + 0.5f, (float)a_BlockY, a_BlockZ + 0.5f), 0.5f, false);
+
+			if (a_Player != NULL)
+			{
+				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x1);
+				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_STONE_PRESSURE_PLATE);
+			}
+			else
+			{
+				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x0);
+				m_World.WakeUpSimulators(a_BlockX, a_BlockY, a_BlockZ);
+			}
+			break;
+		}
+		case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+		case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+		case E_BLOCK_WOODEN_PRESSURE_PLATE:
+		{
+			class cPressurePlateCallback :
+				public cEntityCallback
+			{
+			public:
+				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) :
+					m_Entity(NULL),
+					m_World(a_World),
+					m_X(a_BlockX),
+					m_Y(a_BlockY),
+					m_Z(a_BlockZ)
+				{
+				}
+
+				virtual bool Item(cEntity * a_Entity) override
+				{
+					Vector3f EntityPos = a_Entity->GetPosition();
+					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
+					double Distance = (EntityPos - BlockPos).Length();
+
+					if (Distance <= 0.7)
+					{
+						m_Entity = a_Entity;
+						return true; // Break out, we only need to know for plates that at least one entity is on top
+					}
+					return false;
+				}
+
+				bool FoundEntity(void) const
+				{
+					return m_Entity != NULL;
+				}
+
+			protected:
+				cEntity * m_Entity;
+				cWorld * m_World;
+
+				int m_X;
+				int m_Y;
+				int m_Z;
+			} ;
+
+			cPressurePlateCallback PressurePlateCallback(a_BlockX, a_BlockY, a_BlockZ, &m_World);
+			m_World.ForEachEntity(PressurePlateCallback);
+
+			NIBBLETYPE Meta = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+			if (PressurePlateCallback.FoundEntity())
+			{
+				if (Meta == 0x0)
+				{
+					m_World.BroadcastSoundEffect("random.click", (int) ((a_BlockX + 0.5) * 8.0), (int) ((a_BlockY + 0.1) * 8.0), (int) ((a_BlockZ + 0.5) * 8.0), 0.3F, 0.5F);
+				}
+				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x1);
+				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, a_MyType);
+			}
+			else
+			{
+				if (Meta == 0x1)
+				{
+					m_World.BroadcastSoundEffect("random.click", (int) ((a_BlockX + 0.5) * 8.0), (int) ((a_BlockY + 0.1) * 8.0), (int) ((a_BlockZ + 0.5) * 8.0), 0.3F, 0.6F);
+				}
+				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x0);
+				m_World.WakeUpSimulators(a_BlockX, a_BlockY, a_BlockZ);
+			}
+			break;
+		}
+		default:
+			LOGD("Unimplemented pressure plate type %s in cRedstoneSimulator", ItemToFullString(a_MyType).c_str());
+			break;
+	}
+}
+
+
+
+
+
+bool cIncrementalRedstoneSimulator::AreCoordsDirectlyPowered(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr) // Check powered list
+	{
+		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			return true;
+		}
+	}
+	return false;	
+}
+
+
+
+
+
+bool cIncrementalRedstoneSimulator::AreCoordsLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr) // Check linked powered list
+	{
+		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+// IsRepeaterPowered tests if a repeater should be powered by testing for power sources behind the repeater.
+// It takes the coordinates of the repeater the the meta value.
+bool cIncrementalRedstoneSimulator::IsRepeaterPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta)
+{
+	// Repeaters cannot be powered by any face except their back; verify that this is true for a source
+
+	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
+
+		switch (a_Meta & 0x3)
+		{
+			case 0x0:
+			{
+				// Flip the coords to check the back of the repeater
+				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ + 1))) { return true; }
+				break;
+			}
+			case 0x1:
+			{
+				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX - 1, a_BlockY, a_BlockZ))) { return true; }
+				break;
+			}
+			case 0x2:
+			{
+				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ - 1))) { return true; }
+				break;
+			}
+			case 0x3:
+			{
+				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX + 1, a_BlockY, a_BlockZ))) { return true; }
+				break;
+			}
+		}
+	}
+
+	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
+
+		switch (a_Meta & 0x3)
+		{
+			case 0x0:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ + 1))) { return true; }
+				break;
+			}
+			case 0x1:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX - 1, a_BlockY, a_BlockZ))) { return true; }
+				break;
+			}
+			case 0x2:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ - 1))) { return true; }
+				break;
+			}
+			case 0x3:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX + 1, a_BlockY, a_BlockZ))) { return true; }
+				break;
+			}
+		}
+	}
+	return false; // Couldn't find power source behind repeater
+}
+
+
+
+
+
+bool cIncrementalRedstoneSimulator::IsRepeaterLocked(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta)
+{
+	// Change checking direction according to meta rotation.
+	switch (a_Meta & 0x3) //compare my direction to my neighbor's
+	{
+
+		// If the repeater is facing one direction, do one thing.
+		case 0x0: 
+		case 0x2:
+		{
+			if (m_World.GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ) == E_BLOCK_REDSTONE_REPEATER_ON) // Is right neighbor a
+			{ 
+				NIBBLETYPE otherRepeaterDir = m_World.GetBlockMeta(a_BlockX + 1, a_BlockY, a_BlockZ) & 0x3;
+				if (otherRepeaterDir == 0x1) { return true; }
+			}
+	  
+	  		if (m_World.GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ) == E_BLOCK_REDSTONE_REPEATER_ON) 
+			{ 
+				NIBBLETYPE otherRepeaterDir = m_World.GetBlockMeta(a_BlockX -1, a_BlockY, a_BlockZ) & 0x3;
+				if (otherRepeaterDir == 0x3) { return true; }
+			}
+	  
+			break;
+		}
+	  
+		// If another, do the other.
+		case 0x1:
+		case 0x3:
+		{
+			if (m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1) == E_BLOCK_REDSTONE_REPEATER_ON) 
+			{ 
+				NIBBLETYPE otherRepeaterDir = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ + 1) & 0x3;
+				if (otherRepeaterDir == 0x0) { return true; }
+			}
+			
+			if (m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ -1) == E_BLOCK_REDSTONE_REPEATER_ON) 
+			{ 
+				NIBBLETYPE otherRepeaterDir = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ - 1) & 0x3;
+				if (otherRepeaterDir == 0x2) { return true; }
+			}
+
+			break;
+		}
+	}
+
+	return false;
+}
+
+
+
+
+bool cIncrementalRedstoneSimulator::IsPistonPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta)
+{
+	// Pistons cannot be powered through their front face; this function verifies that a source meets this requirement
+
+	int OldX = a_BlockX, OldY = a_BlockY, OldZ = a_BlockZ;
+	eBlockFace Face = cPiston::MetaDataToDirection(a_Meta);
+
+	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
+
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, Face);
+
+		if (!itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			return true;
+		}
+
+		a_BlockX = OldX;
+		a_BlockY = OldY;
+		a_BlockZ = OldZ;
+	}
+
+	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
+
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, Face);
+
+		if (!itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			return true;
+		}
+
+		a_BlockX = OldX;
+		a_BlockY = OldY;
+		a_BlockZ = OldZ;
+	}
+	return false; // Source was in front of the piston's front face
+}
+
+
+
+
+bool cIncrementalRedstoneSimulator::IsWirePowered(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
+
+		if (m_World.GetBlock(itr->a_SourcePos) != E_BLOCK_REDSTONE_WIRE)
+		{
+			return true;
+		}
+	}
+
+	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
+
+		if (m_World.GetBlock(itr->a_SourcePos) != E_BLOCK_REDSTONE_WIRE)
+		{
+			return true;
+		}
+	}
+	return false; // Source was in front of the piston's front face
+}
+
+
+
+
+
+bool cIncrementalRedstoneSimulator::AreCoordsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool IsCurrentStatePowered)
+{
+	for (SimulatedPlayerToggleableList::const_iterator itr = m_SimulatedPlayerToggleableBlocks->begin(); itr != m_SimulatedPlayerToggleableBlocks->end(); ++itr)
+	{
+		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			if (itr->WasLastStatePowered != IsCurrentStatePowered) // Was the last power state different to the current?
+			{
+				return false; // It was, coordinates are no longer simulated
+			}
+			else
+			{
+				return true; // It wasn't, don't resimulate block, and allow players to toggle
+			}
+		}
+	}
+	return false; // Block wasn't even in the list, not simulated
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::SetDirectionLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Direction, BLOCKTYPE a_SourceType)
+{
+	switch (a_Direction)
+	{
+		case BLOCK_FACE_XM:
+		{
+			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ);
+
+			SetBlockLinkedPowered(a_BlockX - 2, a_BlockY, a_BlockZ, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY + 1, a_BlockZ, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY - 1, a_BlockZ, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ + 1, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ - 1, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+
+			break;
+		}
+		case BLOCK_FACE_XP:
+		{
+			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ);
+
+			SetBlockLinkedPowered(a_BlockX + 2, a_BlockY, a_BlockZ, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY + 1, a_BlockZ, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY - 1, a_BlockZ, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ + 1, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ - 1, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+
+			break;
+		}
+		case BLOCK_FACE_YM:
+		{
+			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
+
+			SetBlockLinkedPowered(a_BlockX, a_BlockY - 2, a_BlockZ, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ + 1, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ - 1, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+
+			break;
+		}
+		case BLOCK_FACE_YP:
+		{
+			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ);
+
+			SetBlockLinkedPowered(a_BlockX, a_BlockY + 2, a_BlockZ, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ + 1, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ - 1, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+
+			break;
+		}
+		case BLOCK_FACE_ZM:
+		{
+			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ - 1);
+						
+			SetBlockLinkedPowered(a_BlockX, a_BlockY, a_BlockZ - 2, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+
+			break;
+		}
+		case BLOCK_FACE_ZP:
+		{
+			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1);
+			
+			SetBlockLinkedPowered(a_BlockX, a_BlockY, a_BlockZ + 2, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
+
+			break;
+		}
+		default:
+		{
+			ASSERT(!"Unhandled face direction when attempting to set blocks as linked powered!"); // Zombies, that wasn't supposed to happen...
+			break;
+		}
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::SetAllDirsAsPowered(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_SourceBlock)
+{
+	static const struct
+	{
+		int x, y, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0, 0 },
+		{-1, 0, 0 },
+		{ 0, 0, 1 },
+		{ 0, 0,-1 },
+		{ 0, 1, 0 },
+		{ 0,-1, 0 }
+	};
+
+	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++) // Loop through struct to power all directions
+	{
+		SetBlockPowered(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, a_SourceBlock);
+	}
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::SetBlockPowered(int a_BlockX, int a_BlockY, int a_BlockZ, int a_SourceX, int a_SourceY, int a_SourceZ, BLOCKTYPE a_SourceBlock)
+{
+	BLOCKTYPE Block = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+	if (Block == E_BLOCK_AIR)
+	{
+		// Don't set air, fixes some bugs (wires powering themselves)
+		return;
+	}
+
+	PoweredBlocksList * Powered = m_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ)->GetRedstoneSimulatorPoweredBlocksList();
+
+	for (PoweredBlocksList::const_iterator itr = Powered->begin(); itr != Powered->end(); ++itr) // Check powered list
+	{
+		if (
+			itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)) &&
+			itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ))
+			)
+		{
+			// Check for duplicates
+			return;
+		}
+	}
+
+	sPoweredBlocks RC;
+	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
+	RC.a_SourcePos = Vector3i(a_SourceX, a_SourceY, a_SourceZ);
+	Powered->push_back(RC);
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::SetBlockLinkedPowered(
+	int a_BlockX,  int a_BlockY,  int a_BlockZ,
+	int a_MiddleX, int a_MiddleY, int a_MiddleZ,
+	int a_SourceX, int a_SourceY, int a_SourceZ,
+	BLOCKTYPE a_SourceBlock, BLOCKTYPE a_MiddleBlock
+)
+{
+	BLOCKTYPE DestBlock = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+	if (DestBlock == E_BLOCK_AIR)
+	{
+		// Don't set air, fixes some bugs (wires powering themselves)
+		return;
+	}
+	if (!IsViableMiddleBlock(a_MiddleBlock))
+	{
+		return;
+	}
+
+	LinkedBlocksList * Linked = m_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ)->GetRedstoneSimulatorLinkedBlocksList();
+
+	for (LinkedBlocksList::const_iterator itr = Linked->begin(); itr != Linked->end(); ++itr) // Check linked powered list
+	{
+		if (
+			itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)) &&
+			itr->a_MiddlePos.Equals(Vector3i(a_MiddleX, a_MiddleY, a_MiddleZ)) &&
+			itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ))
+			)
+		{
+			// Check for duplicates
+			return;
+		}
+	}
+
+	sLinkedPoweredBlocks RC;
+	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
+	RC.a_MiddlePos = Vector3i(a_MiddleX, a_MiddleY, a_MiddleZ);
+	RC.a_SourcePos = Vector3i(a_SourceX, a_SourceY, a_SourceZ);
+	Linked->push_back(RC);
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::SetPlayerToggleableBlockAsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool WasLastStatePowered)
+{
+	for (SimulatedPlayerToggleableList::iterator itr = m_SimulatedPlayerToggleableBlocks->begin(); itr != m_SimulatedPlayerToggleableBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			continue;
+		}
+
+		if (itr->WasLastStatePowered != WasLastStatePowered)
+		{
+			// If power states different, update listing
+			itr->WasLastStatePowered = WasLastStatePowered;
+			return;
+		}
+		else
+		{
+			// If states the same, just ignore
+			return;
+		}
+	}
+
+	// We have arrive here; no block must be in list - add one
+	sSimulatedPlayerToggleableList RC;
+	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
+	RC.WasLastStatePowered = WasLastStatePowered;
+	m_SimulatedPlayerToggleableBlocks->push_back(RC);
+}
+
+
+
+
+
+void cIncrementalRedstoneSimulator::QueueRepeaterPowerChange(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta, bool ShouldPowerOn)
+{
+	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList->begin(); itr != m_RepeatersDelayList->end(); ++itr)
+	{
+		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			if (ShouldPowerOn == itr->ShouldPowerOn) // We are queued already for the same thing, don't replace entry
+			{
+				return;
+			}
+
+			// Already in here (normal to allow repeater to continue on powering and updating blocks in front) - just update info and quit
+			itr->a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + 1) * 2; // See below for description
+			itr->a_ElapsedTicks = 0;
+			itr->ShouldPowerOn = ShouldPowerOn;
+			return;
+		}
+	}
+
+	// Self not in list, add self to list
+	sRepeatersDelayList RC;	
+	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
+	
+	// Gets the top two bits (delay time), shifts them into the lower two bits, and adds one (meta 0 = 1 tick; 1 = 2 etc.)
+	// * 2 because apparently, MCS ticks are way faster than vanilla ticks, so repeater aren't noticeably delayed
+	RC.a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + 1) * 2;
+
+	RC.a_ElapsedTicks = 0;
+	RC.ShouldPowerOn = ShouldPowerOn;
+	m_RepeatersDelayList->push_back(RC);
+	return;
+}
+
+
+
+
+
+cIncrementalRedstoneSimulator::eRedstoneDirection cIncrementalRedstoneSimulator::GetWireDirection(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	int Dir = REDSTONE_NONE;
+
+	BLOCKTYPE NegX = m_World.GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ);
+	if (IsPotentialSource(NegX))
+	{
+		Dir |= (REDSTONE_X_POS);
+	}
+	
+	BLOCKTYPE PosX = m_World.GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ);
+	if (IsPotentialSource(PosX))
+	{
+		Dir |= (REDSTONE_X_NEG);
+	}
+	
+	BLOCKTYPE NegZ = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ - 1);
+	if (IsPotentialSource(NegZ))
+	{
+		if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
+		{
+			Dir ^= REDSTONE_X_POS;
+			Dir |= REDSTONE_X_NEG;
+		}
+		if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
+		{
+			Dir ^= REDSTONE_X_NEG;
+			Dir |= REDSTONE_X_POS;
+		}
+		Dir |= REDSTONE_Z_POS;
+	}
+	
+	BLOCKTYPE PosZ = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1);
+	if (IsPotentialSource(PosZ))
+	{
+		if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
+		{
+			Dir ^= REDSTONE_X_POS;
+			Dir |= REDSTONE_X_NEG;
+		}
+		if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
+		{
+			Dir ^= REDSTONE_X_NEG;
+			Dir |= REDSTONE_X_POS;
+		}
+		Dir |= REDSTONE_Z_NEG;
+	}
+	return (eRedstoneDirection)Dir;
+}
+
+
+
+
+
+bool cIncrementalRedstoneSimulator::IsLeverOn(NIBBLETYPE a_BlockMeta)
+{
+	// Extract the ON bit from metadata and return if true if it is set:
+	return ((a_BlockMeta & 0x8) == 0x8);
+}
+
+
+
+
+
+bool cIncrementalRedstoneSimulator::IsButtonOn(NIBBLETYPE a_BlockMeta)
+{
+	return IsLeverOn(a_BlockMeta);
+}
+
+
+
+
diff --git a/src/Simulator/IncrementalRedstoneSimulator.h b/src/Simulator/IncrementalRedstoneSimulator.h
new file mode 100644
index 000000000..f93f86898
--- /dev/null
+++ b/src/Simulator/IncrementalRedstoneSimulator.h
@@ -0,0 +1,283 @@
+
+#pragma once
+
+#include "RedstoneSimulator.h"
+
+/// Per-chunk data for the simulator, specified individual chunks to simulate
+typedef cCoordWithBlockAndBoolVector cRedstoneSimulatorChunkData;
+
+
+
+
+
+class cIncrementalRedstoneSimulator :
+	public cRedstoneSimulator
+{
+	typedef cRedstoneSimulator super;
+public:
+
+	cIncrementalRedstoneSimulator(cWorld & a_World);
+	~cIncrementalRedstoneSimulator();
+
+	virtual void Simulate(float a_Dt) override { UNUSED(a_Dt);}  // not used
+	virtual void SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk) override;
+	virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) override { return IsRedstone(a_BlockType); }
+	virtual void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override;
+
+	enum eRedstoneDirection
+	{
+		REDSTONE_NONE =  0,
+		REDSTONE_X_POS = 0x1,
+		REDSTONE_X_NEG = 0x2,
+		REDSTONE_Z_POS = 0x4,
+		REDSTONE_Z_NEG = 0x8,
+	};
+	eRedstoneDirection GetWireDirection(int a_BlockX, int a_BlockY, int a_BlockZ);
+
+private:
+
+	struct sPoweredBlocks // Define structure of the directly powered blocks list
+	{
+		Vector3i a_BlockPos; // Position of powered block
+		Vector3i a_SourcePos; // Position of source powering the block at a_BlockPos
+	};
+
+	struct sLinkedPoweredBlocks // Define structure of the indirectly powered blocks list (i.e. repeaters powering through a block to the block at the other side)
+	{
+		Vector3i a_BlockPos;
+		Vector3i a_MiddlePos;
+		Vector3i a_SourcePos;
+	};
+
+	struct sSimulatedPlayerToggleableList
+	{
+		Vector3i a_BlockPos;
+		bool WasLastStatePowered;
+	};
+
+	struct sRepeatersDelayList
+	{
+		Vector3i a_BlockPos;
+		unsigned char a_DelayTicks;
+		unsigned char a_ElapsedTicks;
+		bool ShouldPowerOn;
+	};
+
+public:
+
+	typedef std::vector <sPoweredBlocks> PoweredBlocksList;
+	typedef std::vector <sLinkedPoweredBlocks> LinkedBlocksList;
+	typedef std::vector <sSimulatedPlayerToggleableList> SimulatedPlayerToggleableList;
+	typedef std::vector <sRepeatersDelayList> RepeatersDelayList;
+
+private:
+
+	cRedstoneSimulatorChunkData * m_RedstoneSimulatorChunkData;
+	PoweredBlocksList * m_PoweredBlocks;
+	LinkedBlocksList * m_LinkedPoweredBlocks;
+	SimulatedPlayerToggleableList * m_SimulatedPlayerToggleableBlocks;
+	RepeatersDelayList * m_RepeatersDelayList;
+
+	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override { RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk); }
+	void RedstoneAddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk, cChunk * a_OtherChunk = NULL);
+	cChunk * m_Chunk;
+
+	// We want a_MyState for devices needing a full FastSetBlock (as opposed to meta) because with our simulation model, we cannot keep setting the block if it is already set correctly
+	// In addition to being non-performant, it would stop the player from actually breaking said device
+
+	/* ====== SOURCES ====== */
+	/** Handles the redstone torch */
+	void HandleRedstoneTorch(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState);
+	/** Handles the redstone block */
+	void HandleRedstoneBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles levers */
+	void HandleRedstoneLever(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles buttons */
+	void HandleRedstoneButton(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType);
+	/** Handles daylight sensors */
+	void HandleDaylightSensor(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles pressure plates */
+	void HandlePressurePlate(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType);
+	/* ==================== */
+
+	/* ====== CARRIERS ====== */
+	/** Handles redstone wire */
+	void HandleRedstoneWire(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles repeaters */
+	void HandleRedstoneRepeater(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState);
+	/* ====================== */
+
+	/* ====== DEVICES ====== */
+	/** Handles pistons */
+	void HandlePiston(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles dispensers and droppers */
+	void HandleDropSpenser(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles TNT (exploding) */
+	void HandleTNT(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles redstone lamps */
+	void HandleRedstoneLamp(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState);
+	/** Handles doords */
+	void HandleDoor(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles command blocks */
+	void HandleCommandBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles activator, detector, and powered rails */
+	void HandleRail(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType);
+	/** Handles trapdoors */
+	void HandleTrapdoor(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles fence gates */
+	void HandleFenceGate(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Handles noteblocks */
+	void HandleNoteBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/* ===================== */
+
+	/* ====== Helper functions ====== */
+	/** Marks a block as powered */
+	void SetBlockPowered(int a_BlockX, int a_BlockY, int a_BlockZ, int a_SourceX, int a_SourceY, int a_SourceZ, BLOCKTYPE a_SourceBlock);
+	/** Marks a block as being powered through another block */
+	void SetBlockLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MiddleX, int a_MiddleY, int a_MiddleZ, int a_SourceX, int a_SourceY, int a_SourceZ, BLOCKTYPE a_SourceBlock, BLOCKTYPE a_MiddeBlock);
+	/** Marks a block as simulated, who should not be simulated further unless their power state changes, to accomodate a player manually toggling the block without triggering the simulator toggling it back */
+	void SetPlayerToggleableBlockAsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool WasLastStatePowered);
+	/** Marks the second block in a direction as linked powered */
+	void SetDirectionLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Direction, BLOCKTYPE a_SourceBlock);
+	/** Marks all blocks immediately surrounding a coordinate as powered */
+	void SetAllDirsAsPowered(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_SourceBlock);
+	/** Queues a repeater to be powered or unpowered */
+	void QueueRepeaterPowerChange(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta, bool ShouldPowerOn);
+
+	/** Returns if a coordinate is powered or linked powered */
+	bool AreCoordsPowered(int a_BlockX, int a_BlockY, int a_BlockZ) { return AreCoordsDirectlyPowered(a_BlockX, a_BlockY, a_BlockZ) || AreCoordsLinkedPowered(a_BlockX, a_BlockY, a_BlockZ); }
+	/** Returns if a coordinate is in the directly powered blocks list */
+	bool AreCoordsDirectlyPowered(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Returns if a coordinate is in the indirectly powered blocks list */
+	bool AreCoordsLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ);
+	/** Returns if a coordinate was marked as simulated (for blocks toggleable by players) */
+	bool AreCoordsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool IsCurrentStatePowered);
+	/** Returns if a repeater is powered */
+	bool IsRepeaterPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta);
+	/** Returns if a repeater is locked */
+	bool IsRepeaterLocked(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta);
+	/** Returns if a piston is powered */
+	bool IsPistonPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta);
+	/** Returns if a wire is powered
+		The only diffence between this and a normal AreCoordsPowered is that this function checks for a wire powering another wire
+	*/
+	bool IsWirePowered(int a_BlockX, int a_BlockY, int a_BlockZ);
+
+
+	/** Returns if lever metadata marks it as emitting power */
+	bool IsLeverOn(NIBBLETYPE a_BlockMeta);
+	/** Returns if button metadata marks it as emitting power */
+	bool IsButtonOn(NIBBLETYPE a_BlockMeta);
+	/* ============================== */
+
+	/* ====== Misc Functions ====== */
+	/** Returns if a block is viable to be the MiddleBlock of a SetLinkedPowered operation */
+	inline static bool IsViableMiddleBlock(BLOCKTYPE Block) { return cBlockInfo::FullyOccupiesVoxel(Block); }
+
+	/** Returns if a block is a mechanism (something that accepts power and does something) */
+	inline static bool IsMechanism(BLOCKTYPE Block)
+	{
+		switch (Block)
+		{
+			case E_BLOCK_ACTIVATOR_RAIL:
+			case E_BLOCK_COMMAND_BLOCK:
+			case E_BLOCK_PISTON:
+			case E_BLOCK_STICKY_PISTON:
+			case E_BLOCK_DISPENSER:
+			case E_BLOCK_DROPPER:
+			case E_BLOCK_FENCE_GATE:
+			case E_BLOCK_HOPPER:
+			case E_BLOCK_NOTE_BLOCK:
+			case E_BLOCK_TNT:
+			case E_BLOCK_TRAPDOOR:
+			case E_BLOCK_REDSTONE_LAMP_OFF:
+			case E_BLOCK_REDSTONE_LAMP_ON:
+			case E_BLOCK_WOODEN_DOOR:
+			case E_BLOCK_IRON_DOOR:
+			case E_BLOCK_REDSTONE_REPEATER_OFF:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			case E_BLOCK_POWERED_RAIL:
+			{
+				return true;
+			}
+			default: return false;
+		}
+	}
+
+	/** Returns if a block has the potential to output power */
+	inline static bool IsPotentialSource(BLOCKTYPE Block)
+	{
+		switch (Block)
+		{
+			case E_BLOCK_DETECTOR_RAIL:
+			case E_BLOCK_DAYLIGHT_SENSOR:
+			case E_BLOCK_WOODEN_BUTTON:
+			case E_BLOCK_STONE_BUTTON:
+			case E_BLOCK_REDSTONE_WIRE:
+			case E_BLOCK_REDSTONE_TORCH_ON:
+			case E_BLOCK_LEVER:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			case E_BLOCK_BLOCK_OF_REDSTONE:
+			case E_BLOCK_ACTIVE_COMPARATOR:
+			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_STONE_PRESSURE_PLATE:
+			case E_BLOCK_WOODEN_PRESSURE_PLATE:
+			{
+				return true;
+			}
+			default: return false;
+		}
+	}
+
+	/** Returns if a block is any sort of redstone device */
+	inline static bool IsRedstone(BLOCKTYPE Block)
+	{
+		switch (Block)
+		{
+			// All redstone devices, please alpha sort
+			case E_BLOCK_ACTIVATOR_RAIL:
+			case E_BLOCK_ACTIVE_COMPARATOR:
+			case E_BLOCK_BLOCK_OF_REDSTONE:
+			case E_BLOCK_COMMAND_BLOCK:
+			case E_BLOCK_DETECTOR_RAIL:
+			case E_BLOCK_DISPENSER:
+			case E_BLOCK_DAYLIGHT_SENSOR:
+			case E_BLOCK_DROPPER:
+			case E_BLOCK_FENCE_GATE:
+			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_HOPPER:
+			case E_BLOCK_INACTIVE_COMPARATOR:
+			case E_BLOCK_IRON_DOOR:
+			case E_BLOCK_LEVER:
+			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_NOTE_BLOCK:
+			case E_BLOCK_POWERED_RAIL:
+			case E_BLOCK_REDSTONE_LAMP_OFF:
+			case E_BLOCK_REDSTONE_LAMP_ON:
+			case E_BLOCK_REDSTONE_REPEATER_OFF:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			case E_BLOCK_REDSTONE_TORCH_OFF:
+			case E_BLOCK_REDSTONE_TORCH_ON:
+			case E_BLOCK_REDSTONE_WIRE:
+			case E_BLOCK_STICKY_PISTON:
+			case E_BLOCK_STONE_BUTTON:
+			case E_BLOCK_STONE_PRESSURE_PLATE:
+			case E_BLOCK_TNT:
+			case E_BLOCK_TRAPDOOR:
+			case E_BLOCK_TRIPWIRE_HOOK:
+			case E_BLOCK_WOODEN_BUTTON:
+			case E_BLOCK_WOODEN_DOOR:
+			case E_BLOCK_WOODEN_PRESSURE_PLATE:
+			case E_BLOCK_PISTON:
+			{
+				 return true;
+			}
+			default: return false;
+		}
+	}
+};
+
+
+
+
diff --git a/src/Simulator/NoopRedstoneSimulator.h b/src/Simulator/NoopRedstoneSimulator.h
new file mode 100644
index 000000000..fe3949198
--- /dev/null
+++ b/src/Simulator/NoopRedstoneSimulator.h
@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include "RedstoneSimulator.h"
+
+
+
+
+
+class cRedstoneNoopSimulator :
+	public cRedstoneSimulator
+{
+	typedef cRedstoneSimulator super;
+public:
+
+	cRedstoneNoopSimulator(cWorld & a_World) :
+		super(a_World)
+	{
+	}
+
+	//~cRedstoneNoopSimulator();
+
+	virtual void Simulate(float a_Dt) override { UNUSED(a_Dt);}  // not used
+	virtual void SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk) override 
+	{
+		UNUSED(a_Dt);
+		UNUSED(a_ChunkX);
+		UNUSED(a_ChunkZ);
+		UNUSED(a_Chunk);
+	}
+	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override { return false; }
+	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override
+	{
+		UNUSED(a_BlockX);
+		UNUSED(a_BlockY);
+		UNUSED(a_BlockZ);
+		UNUSED(a_Chunk);
+	}
+
+} ;
diff --git a/src/Simulator/RedstoneSimulator.cpp b/src/Simulator/RedstoneSimulator.cpp
index e361cbf49..a83f21106 100644
--- a/src/Simulator/RedstoneSimulator.cpp
+++ b/src/Simulator/RedstoneSimulator.cpp
@@ -1,22 +1,15 @@
 
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+#include "Globals.h"
 
 #include "RedstoneSimulator.h"
-#include "../BlockEntities/DropSpenserEntity.h"
-#include "../BlockEntities/NoteEntity.h"
-#include "../BlockEntities/CommandBlockEntity.h"
-#include "../Entities/TNTEntity.h"
-#include "../Blocks/BlockTorch.h"
-#include "../Blocks/BlockDoor.h"
-#include "../Piston.h"
-#include "../Tracer.h"
+#include "../World.h"
 
 
 
 
 
-cRedstoneSimulator::cRedstoneSimulator(cWorld & a_World)
-	: super(a_World)
+cRedstoneSimulator::cRedstoneSimulator(cWorld & a_World) :
+	super(a_World)
 {
 }
 
@@ -24,1507 +17,3 @@ cRedstoneSimulator::cRedstoneSimulator(cWorld & a_World)
 
 
 
-cRedstoneSimulator::~cRedstoneSimulator()
-{
-}
-
-
-
-
-
-void cRedstoneSimulator::AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
-{
-	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
-	{
-		return;
-	}
-	else if ((a_BlockY < 0) || (a_BlockY > cChunkDef::Height))
-	{
-		return;
-	}
-
-	int RelX = a_BlockX - a_Chunk->GetPosX() * cChunkDef::Width;
-	int RelZ = a_BlockZ - a_Chunk->GetPosZ() * cChunkDef::Width;
-	
-	BLOCKTYPE Block;
-	NIBBLETYPE Meta;
-	a_Chunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
-
-	// Every time a block is changed (AddBlock called), we want to go through all lists and check to see if the coordiantes stored within are still valid
-	// Checking only when a block is changed, as opposed to every tick, also improves performance
-
-	for (PoweredBlocksList::iterator itr = m_PoweredBlocks.begin(); itr != m_PoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			continue;
-		}
-
-		if (!IsPotentialSource(Block))
-		{
-			LOGD("cRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list as it no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-			m_PoweredBlocks.erase(itr);
-			break;
-		}
-		else if (
-			// Changeable sources
-			((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
-			((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
-			((Block == E_BLOCK_DETECTOR_RAIL) && (Meta & 0x08) == 0) ||
-			(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta))) ||
-			(((Block == E_BLOCK_STONE_PRESSURE_PLATE) || (Block == E_BLOCK_WOODEN_PRESSURE_PLATE)) && (Meta == 0))
-			)
-		{
-			LOGD("cRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-			m_PoweredBlocks.erase(itr);
-			break;
-		}
-		else if (Block == E_BLOCK_DAYLIGHT_SENSOR)
-		{
-			if (!a_Chunk->IsLightValid())
-			{
-				m_World.QueueLightChunk(a_Chunk->GetPosX(), a_Chunk->GetPosZ());
-				break;
-			}
-			else
-			{
-				NIBBLETYPE SkyLight;
-				a_Chunk->UnboundedRelGetBlockSkyLight(RelX, itr->a_SourcePos.y + 1, RelZ, SkyLight);
-
-				if (a_Chunk->GetTimeAlteredLight(SkyLight) <= 8) // Could use SkyLight - m_World.GetSkyDarkness();
-				{
-					LOGD("cRedstoneSimulator: Erased daylight sensor from powered blocks list due to insufficient light level");
-					m_PoweredBlocks.erase(itr);
-					break;
-				}
-			}
-		}
-	}
-
-	for (LinkedBlocksList::iterator itr = m_LinkedPoweredBlocks.begin(); itr != m_LinkedPoweredBlocks.end(); ++itr)
-	{
-		if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			if (!IsPotentialSource(Block))
-			{
-				LOGD("cRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-				m_LinkedPoweredBlocks.erase(itr);
-				break;
-			}
-			else if (
-				// Things that can send power through a block but which depends on meta
-				((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
-				((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
-				(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta)))
-				)
-			{
-				LOGD("cRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-				m_LinkedPoweredBlocks.erase(itr);
-				break;
-			}
-		}
-		else if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			if (!IsViableMiddleBlock(Block))
-			{
-				LOGD("cRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer powered through a valid middle block", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-				m_LinkedPoweredBlocks.erase(itr);
-				break;
-			}
-		}
-	}
-
-	for (SimulatedPlayerToggleableList::iterator itr = m_SimulatedPlayerToggleableBlocks.begin(); itr != m_SimulatedPlayerToggleableBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			continue;
-		}
-
-		if (!IsAllowedBlock(Block))
-		{
-			LOGD("cRedstoneSimulator: Erased block @ {%i, %i, %i} from toggleable simulated list as it is no longer redstone", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-			m_SimulatedPlayerToggleableBlocks.erase(itr);
-			break;
-		}
-	}
-
-	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList.begin(); itr != m_RepeatersDelayList.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			continue;
-		}
-
-		if ((Block != E_BLOCK_REDSTONE_REPEATER_ON) && (Block != E_BLOCK_REDSTONE_REPEATER_OFF))
-		{
-			m_RepeatersDelayList.erase(itr);
-			break;
-		}
-	}
-
-	cRedstoneSimulatorChunkData & ChunkData = a_Chunk->GetRedstoneSimulatorData();
-	for (cRedstoneSimulatorChunkData::iterator itr = ChunkData.begin(); itr != ChunkData.end(); ++itr)
-	{
-		if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == RelZ)) // We are at an entry matching the current (changed) block
-		{
-			if (!IsAllowedBlock(Block))
-			{
-				ChunkData.erase(itr); // The new blocktype is not redstone; it must be removed from this list
-			}
-			else
-			{
-				itr->Data = Block; // Update block information
-			}
-			return;
-		}
-	}
-
-	if (!IsAllowedBlock(Block))
-	{
-		return;
-	}
-
-	ChunkData.push_back(cCoordWithBlock(RelX, a_BlockY, RelZ, Block));
-}
-
-
-
-
-
-void cRedstoneSimulator::SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk)
-{
-	// We still attempt to simulate all blocks in the chunk every tick, because of outside influence that needs to be taken into account
-	// For example, repeaters need to be ticked, pressure plates checked for entities, daylight sensor checked for light changes, etc.
-	// The easiest way to make this more efficient is probably just to reduce code within the handlers that put too much strain on server, like getting or setting blocks
-	// A marking dirty system might be a TODO for later on, perhaps
-
-	cRedstoneSimulatorChunkData & ChunkData = a_Chunk->GetRedstoneSimulatorData();
-	if (ChunkData.empty())
-	{
-		return;
-	}
-
-	int BaseX = a_Chunk->GetPosX() * cChunkDef::Width;
-	int BaseZ = a_Chunk->GetPosZ() * cChunkDef::Width;
-
-	for (cRedstoneSimulatorChunkData::const_iterator dataitr = ChunkData.begin(); dataitr != ChunkData.end(); ++dataitr)
-	{
-		int a_X = BaseX + dataitr->x;
-		int a_Z = BaseZ + dataitr->z;
-		switch (dataitr->Data)
-		{
-			case E_BLOCK_BLOCK_OF_REDSTONE:     HandleRedstoneBlock(a_X, dataitr->y, a_Z);	break;
-			case E_BLOCK_LEVER:                 HandleRedstoneLever(a_X, dataitr->y, a_Z);	break;
-			case E_BLOCK_TNT:                   HandleTNT(a_X, dataitr->y, a_Z);            break;
-			case E_BLOCK_TRAPDOOR:              HandleTrapdoor(a_X, dataitr->y, a_Z);       break;
-			case E_BLOCK_REDSTONE_WIRE:         HandleRedstoneWire(a_X, dataitr->y, a_Z);	break;
-			case E_BLOCK_NOTE_BLOCK:            HandleNoteBlock(a_X, dataitr->y, a_Z);      break;
-			case E_BLOCK_DAYLIGHT_SENSOR:       HandleDaylightSensor(a_X, dataitr->y, a_Z); break;
-			case E_BLOCK_COMMAND_BLOCK:         HandleCommandBlock(a_X, dataitr->y, a_Z);   break;
-
-			case E_BLOCK_REDSTONE_TORCH_OFF:
-			case E_BLOCK_REDSTONE_TORCH_ON:
-			{
-				HandleRedstoneTorch(a_X, dataitr->y, a_Z, dataitr->Data);
-				break;
-			}
-			case E_BLOCK_STONE_BUTTON:
-			case E_BLOCK_WOODEN_BUTTON:
-			{
-				HandleRedstoneButton(a_X, dataitr->y, a_Z, dataitr->Data);
-				break;
-			}
-			case E_BLOCK_REDSTONE_REPEATER_OFF:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			{
-				HandleRedstoneRepeater(a_X, dataitr->y, a_Z, dataitr->Data);
-				break;
-			}
-			case E_BLOCK_PISTON:
-			case E_BLOCK_STICKY_PISTON:
-			{
-				HandlePiston(a_X, dataitr->y, a_Z);
-				break;
-			}
-			case E_BLOCK_REDSTONE_LAMP_OFF:
-			case E_BLOCK_REDSTONE_LAMP_ON:
-			{
-				HandleRedstoneLamp(a_X, dataitr->y, a_Z, dataitr->Data);
-				break;
-			}
-			case E_BLOCK_DISPENSER:
-			case E_BLOCK_DROPPER:
-			{
-				HandleDropSpenser(a_X, dataitr->y, a_Z);
-				break;
-			}
-			case E_BLOCK_WOODEN_DOOR:
-			case E_BLOCK_IRON_DOOR:
-			{
-				HandleDoor(a_X, dataitr->y, a_Z);
-				break;
-			}
-			case E_BLOCK_ACTIVATOR_RAIL:
-			case E_BLOCK_DETECTOR_RAIL:
-			case E_BLOCK_POWERED_RAIL:
-			{
-				HandleRail(a_X, dataitr->y, a_Z, dataitr->Data);
-				break;
-			}
-			case E_BLOCK_WOODEN_PRESSURE_PLATE:
-			case E_BLOCK_STONE_PRESSURE_PLATE:
-			{
-				HandlePressurePlate(a_X, dataitr->y, a_Z, dataitr->Data);
-				break;
-			}
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneTorch(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState)
-{
-	static const struct // Define which directions the torch can power
-	{
-		int x, y, z;
-	} gCrossCoords[] =
-	{
-		{ 1, 0,  0},
-		{-1, 0,  0},
-		{ 0, 0,  1},
-		{ 0, 0, -1},
-		{ 0, 1,  0},
-	} ;
-
-	if (a_MyState == E_BLOCK_REDSTONE_TORCH_ON)
-	{
-		// Check if the block the torch is on is powered		
-		int X = a_BlockX; int Y = a_BlockY; int Z = a_BlockZ;
-		AddFaceDirection(X, Y, Z, cBlockTorchHandler::MetaDataToDirection(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)), true); // Inverse true to get the block torch is on
-
-		if (AreCoordsDirectlyPowered(X, Y, Z))
-		{
-			// There was a match, torch goes off
-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_OFF, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ));
-			return;
-		}
-
-		// Torch still on, make all 4(X, Z) + 1(Y) sides powered
-		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
-		{
-			BLOCKTYPE Type = m_World.GetBlock(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z);
-			if (i + 1 < ARRAYCOUNT(gCrossCoords)) // Sides of torch, not top (top is last)
-			{
-				if (
-					((IsMechanism(Type)) || (Type == E_BLOCK_REDSTONE_WIRE)) && // Is it a mechanism or wire? Not block/other torch etc.
-					(!Vector3i(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z).Equals(Vector3i(X, Y, Z))) // CAN'T power block is that it is on
-					)
-				{
-					SetBlockPowered(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON);
-				}
-			}
-			else
-			{
-				// Top side, power whatever is there, including blocks
-				SetBlockPowered(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON);
-				// Power all blocks surrounding block above torch
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, E_BLOCK_REDSTONE_TORCH_ON);
-			}
-		}
-
-		if (m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) != 0x5) // Is torch standing on ground? If NOT (i.e. on wall), power block beneath
-		{
-			BLOCKTYPE Type = m_World.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
-
-			if ((IsMechanism(Type)) || (Type == E_BLOCK_REDSTONE_WIRE)) // Still can't make a normal block powered though!
-			{
-				SetBlockPowered(a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON);
-			}
-		}
-	}
-	else
-	{
-		// Check if the block the torch is on is powered		
-		int X = a_BlockX; int Y = a_BlockY; int Z = a_BlockZ;
-		AddFaceDirection(X, Y, Z, cBlockTorchHandler::MetaDataToDirection(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)), true); // Inverse true to get the block torch is on
-
-		// See if off state torch can be turned on again
-		if (AreCoordsDirectlyPowered(X, Y, Z))
-		{
-			return; // Something matches, torch still powered
-		}
-
-		// Block torch on not powered, can be turned on again!
-		m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_TORCH_ON, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ));
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_BLOCK_OF_REDSTONE);
-	SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_BLOCK_OF_REDSTONE); // Set self as powered
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneLever(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	if (IsLeverOn(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)))
-	{
-		SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_LEVER);
-
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_LEVER);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_LEVER);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, E_BLOCK_LEVER);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, E_BLOCK_LEVER);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_LEVER);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_LEVER);
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneButton(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType)
-{
-	if (IsButtonOn(m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ)))
-	{
-		SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, a_BlockType);
-
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, a_BlockType);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, a_BlockType);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, a_BlockType);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, a_BlockType);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, a_BlockType);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, a_BlockType);
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneWire(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	static const struct // Define which directions the wire can receive power from
-	{
-		int x, y, z;
-	} gCrossCoords[] =
-	{
-		{ 1, 0,  0}, /* Wires on same level start */
-		{-1, 0,  0},
-		{ 0, 0,  1},
-		{ 0, 0, -1}, /* Wires on same level stop */
-		{ 1, 1,  0}, /* Wires one higher, surrounding self start */
-		{-1, 1,  0},
-		{ 0, 1,  1},
-		{ 0, 1, -1}, /* Wires one higher, surrounding self stop */
-		{ 1,-1,  0}, /* Wires one lower, surrounding self start */
-		{-1,-1,  0},
-		{ 0,-1,  1},
-		{ 0,-1, -1}, /* Wires one lower, surrounding self stop */
-	} ;
-
-	static const struct // Define which directions the wire will check for repeater prescence
-	{
-		int x, y, z;
-	} gSideCoords[] =
-	{
-		{ 1, 0, 0 },
-		{-1, 0, 0 },
-		{ 0, 0, 1 },
-		{ 0, 0,-1 },
-		{ 0, 1, 0 },
-	};
-
-	// Check to see if directly beside a power source
-	if (IsWirePowered(a_BlockX, a_BlockY, a_BlockZ))
-	{
-		m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 15); // Maximum power
-	}
-	else
-	{
-		NIBBLETYPE MetaToSet = 0;
-		NIBBLETYPE MyMeta = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-		int TimesMetaSmaller = 0, TimesFoundAWire = 0;
-
-		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++) // Loop through all directions to transfer or receive power
-		{
-			if ((i >= 4) && (i <= 7)) // If we are currently checking for wire surrounding ourself one block above...
-			{
-				if (g_BlockIsSolid[m_World.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ)]) // If there is something solid above us (wire cut off)...
-				{
-					continue; // We don't receive power from that wire
-				}
-			}
-			else if ((i >= 8) && (i <= 11)) // See above, but this is for wire below us
-			{
-				if (g_BlockIsSolid[m_World.GetBlock(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y + 1, a_BlockZ + gCrossCoords[i].z)])
-				{
-					continue;
-				}
-			}
-
-			BLOCKTYPE SurroundType;
-			NIBBLETYPE SurroundMeta;
-			m_World.GetBlockTypeMeta(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, SurroundType, SurroundMeta);
-
-			if (SurroundType == E_BLOCK_REDSTONE_WIRE)
-			{
-				TimesFoundAWire++;
-
-				if (SurroundMeta > 1) // Wires of power 1 or 0 cannot transfer power TO ME, don't bother checking
-				{
-					// Does surrounding wire have a higher power level than self?
-					// >= to fix a bug where wires bordering each other with the same power level will appear (in terms of meta) to power each other, when they aren't actually in the powered list
-					if (SurroundMeta >= MyMeta)
-					{
-						MetaToSet = SurroundMeta - 1; // To improve performance
-					}
-				}
-				
-				if (SurroundMeta < MyMeta) // Go through all surroundings to see if self power is larger than everyone else's
-				{
-					TimesMetaSmaller++;
-				}
-			}			
-		}
-
-		if (TimesMetaSmaller == TimesFoundAWire)
-		{
-			// All surrounding metas were smaller - self must have been a wire that was
-			// transferring power to other wires around.
-			// However, self not directly powered anymore, so source must have been removed,
-			// therefore, self must be set to meta zero
-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE, 0); // SetMeta & WakeUpSims doesn't seem to work here, so SetBlock
-			return; // No need to process block power sets because self not powered
-		}
-		else
-		{
-			m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, MetaToSet);
-		}
-	}
-
-	if (m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) != 0) // A powered wire
-	{
-		for (size_t i = 0; i < ARRAYCOUNT(gSideCoords); i++) // Look for repeaters immediately surrounding self and try to power them
-		{
-			if (m_World.GetBlock(a_BlockX + gSideCoords[i].x, a_BlockY + gSideCoords[i].y, a_BlockZ + gSideCoords[i].z) == E_BLOCK_REDSTONE_REPEATER_OFF)
-			{
-				SetBlockPowered(a_BlockX + gSideCoords[i].x, a_BlockY + gSideCoords[i].y, a_BlockZ + gSideCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-			}
-		}
-
-		// Wire still powered, power blocks beneath
-		SetBlockPowered(a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-		SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, E_BLOCK_REDSTONE_WIRE);
-
-		switch (GetWireDirection(a_BlockX, a_BlockY, a_BlockZ))
-		{
-			case REDSTONE_NONE:
-			{
-				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YM, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_YP, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_REDSTONE_WIRE);
-				break;
-			}
-			case REDSTONE_X_POS:
-			{
-				SetBlockPowered(a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_REDSTONE_WIRE);
-				break;
-			}
-			case REDSTONE_X_NEG:
-			{
-				SetBlockPowered(a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_REDSTONE_WIRE);
-				break;
-			}
-			case REDSTONE_Z_POS:
-			{
-				SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_REDSTONE_WIRE);
-				break;
-			}
-			case REDSTONE_Z_NEG:
-			{
-				SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_WIRE);
-				SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_REDSTONE_WIRE);
-				break;
-			}
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneRepeater(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState)
-{
-	NIBBLETYPE a_Meta = m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-
-	bool IsOn = ((a_MyState == E_BLOCK_REDSTONE_REPEATER_ON) ? true : false); // Cache if repeater is on
-	bool IsSelfPowered = IsRepeaterPowered(a_BlockX, a_BlockY, a_BlockZ, a_Meta & 0x3); // Cache if repeater is pwoered
-
-	if (IsSelfPowered && !IsOn) // Queue a power change if I am receiving power but not on
-	{
-		QueueRepeaterPowerChange(a_BlockX, a_BlockY, a_BlockZ, a_Meta, 0, true);
-	}
-	else if (!IsSelfPowered && IsOn) // Queue a power change if I am not receiving power but on
-	{
-		QueueRepeaterPowerChange(a_BlockX, a_BlockY, a_BlockZ, a_Meta, 0, false);
-	}
-
-	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList.begin(); itr != m_RepeatersDelayList.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			continue;
-		}
-
-		if (itr->a_ElapsedTicks >= itr->a_DelayTicks) // Has the elapsed ticks reached the target ticks?
-		{
-			if (itr->ShouldPowerOn)
-			{
-				if (!IsOn)
-				{
-					m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON, a_Meta); // For performance
-				}
-
-				switch (a_Meta & 0x3) // We only want the direction (bottom) bits
-				{
-					case 0x0:
-					{
-						SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
-						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZM, E_BLOCK_REDSTONE_REPEATER_ON);
-						break;
-					}
-					case 0x1:
-					{
-						SetBlockPowered(a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
-						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XP, E_BLOCK_REDSTONE_REPEATER_ON);
-						break;
-					}
-					case 0x2:
-					{
-						SetBlockPowered(a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
-						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_ZP, E_BLOCK_REDSTONE_REPEATER_ON);
-						break;
-					}
-					case 0x3:
-					{
-						SetBlockPowered(a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_ON);
-						SetDirectionLinkedPowered(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_XM, E_BLOCK_REDSTONE_REPEATER_ON);
-						break;
-					}
-				}
-
-				// Removal of the data entry will be handled in SimChunk - we still want to continue trying to power blocks, even if our delay time has reached
-				// Otherwise, the power state of blocks in front won't update after we have powered on
-				return;
-			}
-			else
-			{
-				if (IsOn)
-				{
-					m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_REPEATER_OFF, a_Meta);
-				}
-				m_RepeatersDelayList.erase(itr); // We can remove off repeaters which don't need further updating
-				return;
-			}
-		}
-		else
-		{
-			// Apparently, incrementing ticks only works reliably here, and not in SimChunk;
-			// With a world with lots of redstone, the repeaters simply do not delay
-			// I am confounded to say why. Perhaps optimisation failure.
-			LOGD("Incremented a repeater @ {%i %i %i} | Elapsed ticks: %i | Target delay: %i", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z, itr->a_ElapsedTicks, itr->a_DelayTicks);
-			itr->a_ElapsedTicks++;
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandlePiston(int a_BlockX, int a_BlockY, int a_BlockZ)
-{	
-	cPiston Piston(&m_World);
-	if (IsPistonPowered(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x7)) // We only want the bottom three bits (4th controls extended-ness)
-	{
-		Piston.ExtendPiston(a_BlockX, a_BlockY, a_BlockZ);
-	}
-	else
-	{
-		Piston.RetractPiston(a_BlockX, a_BlockY, a_BlockZ);
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleDropSpenser(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	class cSetPowerToDropSpenser :
-		public cDropSpenserCallback
-	{
-		bool m_IsPowered;
-	public:
-		cSetPowerToDropSpenser(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
-				
-		virtual bool Item(cDropSpenserEntity * a_DropSpenser) override
-		{
-			a_DropSpenser->SetRedstonePower(m_IsPowered);
-			return false;
-		}
-	} DrSpSP (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ));
-
-	m_World.DoWithDropSpenserAt(a_BlockX, a_BlockY, a_BlockZ, DrSpSP);
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRedstoneLamp(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState)
-{
-	if (a_MyState == E_BLOCK_REDSTONE_LAMP_OFF)
-	{
-		if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
-		{
-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_LAMP_ON, 0);
-		}
-	}
-	else
-	{
-		if (!AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
-		{
-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_REDSTONE_LAMP_OFF, 0);
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleTNT(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
-	{
-		m_World.BroadcastSoundEffect("random.fuse", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.6f);
-		m_World.SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5, 4);  // 4 seconds to boom
-		m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleDoor(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
-	{
-		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
-		{
-			cBlockDoorHandler::ChangeDoor(&m_World, a_BlockX, a_BlockY, a_BlockZ);
-			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
-		}
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
-		{
-			cBlockDoorHandler::ChangeDoor(&m_World, a_BlockX, a_BlockY, a_BlockZ);
-			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleCommandBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	class cSetPowerToCommandBlock :
-		public cCommandBlockCallback
-	{
-		bool m_IsPowered;
-	public:
-		cSetPowerToCommandBlock(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
-				
-		virtual bool Item(cCommandBlockEntity * a_CommandBlock) override
-		{
-			a_CommandBlock->SetRedstonePower(m_IsPowered);
-			return false;
-		}
-	} CmdBlockSP (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ));
-
-	m_World.DoWithCommandBlockAt(a_BlockX, a_BlockY, a_BlockZ, CmdBlockSP);
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleRail(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType)
-{
-	switch (a_MyType)
-	{
-		case E_BLOCK_DETECTOR_RAIL:
-		{
-			if ((m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x08) == 0x08)
-			{
-				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, a_MyType);
-			}
-			break;
-		}
-		case E_BLOCK_ACTIVATOR_RAIL:
-		case E_BLOCK_POWERED_RAIL:
-		{
-			if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
-			{
-				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) | 0x08);
-			}
-			else
-			{
-				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x07);
-			}
-			break;
-		}
-		default: LOGD("Unhandled type of rail in %s", __FUNCTION__);
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleTrapdoor(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
-	{
-		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
-		{
-			m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) | 0x4);
-			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
-		}		
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
-		{
-			m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, m_World.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0xB); // Take into account that the fourth bit is needed for trapdoors too
-			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleNoteBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	bool m_bAreCoordsPowered = AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ);
-
-	if (m_bAreCoordsPowered)
-	{
-		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, true))
-		{
-			class cSetPowerToNoteBlock :
-				public cNoteBlockCallback
-			{
-				bool m_IsPowered;
-			public:
-				cSetPowerToNoteBlock(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
-
-				virtual bool Item(cNoteEntity * a_NoteBlock) override
-				{
-					if (m_IsPowered)
-					{
-						a_NoteBlock->MakeSound();
-					}
-					return false;
-				}
-			} NoteBlockSP(m_bAreCoordsPowered);
-
-			m_World.DoWithNoteBlockAt(a_BlockX, a_BlockY, a_BlockZ, NoteBlockSP);
-			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, true);
-		}
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_BlockX, a_BlockY, a_BlockZ, false))
-		{
-			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandleDaylightSensor(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	int a_ChunkX, a_ChunkZ;
-	cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, a_ChunkX, a_ChunkZ);
-
-	if (!m_World.IsChunkLighted(a_ChunkX, a_ChunkZ))
-	{
-		m_World.QueueLightChunk(a_ChunkX, a_ChunkZ);
-	}
-	else
-	{
-		NIBBLETYPE SkyLight = m_World.GetBlockSkyLight(a_BlockX, a_BlockY + 1, a_BlockZ) - m_World.GetSkyDarkness();
-		if (SkyLight > 8)
-		{
-			SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_DAYLIGHT_SENSOR);
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::HandlePressurePlate(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType)
-{
-	switch (a_MyType)
-	{
-		case E_BLOCK_STONE_PRESSURE_PLATE:
-		{
-			// MCS feature - stone pressure plates can only be triggered by players :D
-			cPlayer * a_Player = m_World.FindClosestPlayer(Vector3f(a_BlockX + 0.5f, (float)a_BlockY, a_BlockZ + 0.5f), 0.5f);
-
-			if (a_Player != NULL)
-			{
-				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x1);
-				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_STONE_PRESSURE_PLATE);
-			}
-			else
-			{
-				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x0);
-				m_World.WakeUpSimulators(a_BlockX, a_BlockY, a_BlockZ);
-			}
-			break;
-		}
-		case E_BLOCK_WOODEN_PRESSURE_PLATE:
-		{
-			class cWoodenPressurePlateCallback :
-				public cEntityCallback
-			{
-			public:
-				cWoodenPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) :
-					m_X(a_BlockX),
-					m_Y(a_BlockY),
-					m_Z(a_BlockZ),
-					m_World(a_World),
-					m_Entity(NULL)
-				{
-				}
-
-				virtual bool Item(cEntity * a_Entity) override
-				{
-					cTracer LineOfSight(m_World);
-
-					Vector3f EntityPos = a_Entity->GetPosition();
-					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
-					float Distance = (EntityPos - BlockPos).Length();
-
-					if (Distance < 0.5)
-					{
-						if (!LineOfSight.Trace(BlockPos, (EntityPos - BlockPos), (int)(EntityPos - BlockPos).Length()))
-						{
-							m_Entity = a_Entity;
-							return true; // Break out, we only need to know for wooden plates that at least one entity is on top
-						}
-					}
-					return false;
-				}
-
-				bool FoundEntity(void) const
-				{
-					return m_Entity != NULL;
-				}
-
-			protected:
-				cEntity * m_Entity;
-				cWorld * m_World;
-
-				int m_X;
-				int m_Y;
-				int m_Z;
-			} ;
-
-			cWoodenPressurePlateCallback WoodenPressurePlateCallback(a_BlockX, a_BlockY, a_BlockZ, &m_World);
-			m_World.ForEachEntity(WoodenPressurePlateCallback);
-
-			if (WoodenPressurePlateCallback.FoundEntity())
-			{
-				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x1);
-				SetAllDirsAsPowered(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_WOODEN_PRESSURE_PLATE);
-			}
-			else
-			{
-				m_World.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, 0x0);
-				m_World.WakeUpSimulators(a_BlockX, a_BlockY, a_BlockZ);
-			}
-			break;
-		}
-		default:
-			LOGD("Unimplemented pressure plate type %s in cRedstoneSimulator", ItemToFullString(a_MyType).c_str());
-			break;
-	}
-}
-
-
-
-
-
-bool cRedstoneSimulator::AreCoordsDirectlyPowered(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks.begin(); itr != m_PoweredBlocks.end(); ++itr) // Check powered list
-	{
-		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			return true;
-		}
-	}
-	return false;	
-}
-
-
-
-
-
-bool cRedstoneSimulator::AreCoordsLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks.begin(); itr != m_LinkedPoweredBlocks.end(); ++itr) // Check linked powered list
-	{
-		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-
-
-
-
-bool cRedstoneSimulator::IsRepeaterPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta)
-{
-	// Repeaters cannot be powered by any face except their back; verify that this is true for a source
-
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks.begin(); itr != m_PoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
-
-		switch (a_Meta)
-		{
-			case 0x0:
-			{
-				// Flip the coords to check the back of the repeater
-				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ + 1))) { return true; }
-				break;
-			}
-			case 0x1:
-			{
-				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX - 1, a_BlockY, a_BlockZ))) { return true; }
-				break;
-			}
-			case 0x2:
-			{
-				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ - 1))) { return true; }
-				break;
-			}
-			case 0x3:
-			{
-				if (itr->a_SourcePos.Equals(Vector3i(a_BlockX + 1, a_BlockY, a_BlockZ))) { return true; }
-				break;
-			}
-		}
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks.begin(); itr != m_LinkedPoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
-
-		switch (a_Meta)
-		{
-			case 0x0:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ + 1))) { return true; }
-				break;
-			}
-			case 0x1:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX - 1, a_BlockY, a_BlockZ))) { return true; }
-				break;
-			}
-			case 0x2:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ - 1))) { return true; }
-				break;
-			}
-			case 0x3:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX + 1, a_BlockY, a_BlockZ))) { return true; }
-				break;
-			}
-		}
-	}
-	return false; // Couldn't find power source behind repeater
-}
-
-
-
-
-bool cRedstoneSimulator::IsPistonPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta)
-{
-	// Pistons cannot be powered through their front face; this function verifies that a source meets this requirement
-
-	int OldX = a_BlockX, OldY = a_BlockY, OldZ = a_BlockZ;
-
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks.begin(); itr != m_PoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
-
-		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_Meta); // Piston meta is based on what direction they face, so we can do this
-
-		if (!itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			return true;
-		}
-
-		a_BlockX = OldX;
-		a_BlockY = OldY;
-		a_BlockZ = OldZ;
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks.begin(); itr != m_LinkedPoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
-
-		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_Meta);
-
-		if (!itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			return true;
-		}
-
-		a_BlockX = OldX;
-		a_BlockY = OldY;
-		a_BlockZ = OldZ;
-	}
-	return false; // Source was in front of the piston's front face
-}
-
-
-
-
-bool cRedstoneSimulator::IsWirePowered(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks.begin(); itr != m_PoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
-
-		if (m_World.GetBlock(itr->a_SourcePos) != E_BLOCK_REDSTONE_WIRE)
-		{
-			return true;
-		}
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks.begin(); itr != m_LinkedPoweredBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ))) { continue; }
-
-		if (m_World.GetBlock(itr->a_SourcePos) != E_BLOCK_REDSTONE_WIRE)
-		{
-			return true;
-		}
-	}
-	return false; // Source was in front of the piston's front face
-}
-
-
-
-
-
-bool cRedstoneSimulator::AreCoordsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool IsCurrentStatePowered)
-{
-	for (SimulatedPlayerToggleableList::const_iterator itr = m_SimulatedPlayerToggleableBlocks.begin(); itr != m_SimulatedPlayerToggleableBlocks.end(); ++itr)
-	{
-		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			if (itr->WasLastStatePowered != IsCurrentStatePowered) // Was the last power state different to the current?
-			{
-				return false; // It was, coordinates are no longer simulated
-			}
-			else
-			{
-				return true; // It wasn't, don't resimulate block, and allow players to toggle
-			}
-		}
-	}
-	return false; // Block wasn't even in the list, not simulated
-}
-
-
-
-
-
-void cRedstoneSimulator::SetDirectionLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Direction, BLOCKTYPE a_SourceType)
-{
-	switch (a_Direction)
-	{
-		case BLOCK_FACE_XM:
-		{
-			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ);
-
-			SetBlockLinkedPowered(a_BlockX - 2, a_BlockY, a_BlockZ, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY + 1, a_BlockZ, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY - 1, a_BlockZ, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ + 1, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ - 1, a_BlockX - 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-
-			break;
-		}
-		case BLOCK_FACE_XP:
-		{
-			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ);
-
-			SetBlockLinkedPowered(a_BlockX + 2, a_BlockY, a_BlockZ, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY + 1, a_BlockZ, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY - 1, a_BlockZ, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ + 1, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ - 1, a_BlockX + 1, a_BlockY, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-
-			break;
-		}
-		case BLOCK_FACE_YM:
-		{
-			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
-
-			SetBlockLinkedPowered(a_BlockX, a_BlockY - 2, a_BlockZ, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ + 1, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ - 1, a_BlockX, a_BlockY - 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-
-			break;
-		}
-		case BLOCK_FACE_YP:
-		{
-			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ);
-
-			SetBlockLinkedPowered(a_BlockX, a_BlockY + 2, a_BlockZ, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ + 1, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ - 1, a_BlockX, a_BlockY + 1, a_BlockZ, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-
-			break;
-		}
-		case BLOCK_FACE_ZM:
-		{
-			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ - 1);
-						
-			SetBlockLinkedPowered(a_BlockX, a_BlockY, a_BlockZ - 2, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ - 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-
-			break;
-		}
-		case BLOCK_FACE_ZP:
-		{
-			BLOCKTYPE MiddleBlock = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1);
-			
-			SetBlockLinkedPowered(a_BlockX, a_BlockY, a_BlockZ + 2, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX + 1, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX - 1, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY + 1, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-			SetBlockLinkedPowered(a_BlockX, a_BlockY - 1, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ + 1, a_BlockX, a_BlockY, a_BlockZ, a_SourceType, MiddleBlock);
-
-			break;
-		}
-		default:
-		{
-			ASSERT(!"Unhandled face direction when attempting to set blocks as linked powered!"); // Zombies, that wasn't supposed to happen...
-			break;
-		}
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::SetAllDirsAsPowered(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_SourceBlock)
-{
-	static const struct
-	{
-		int x, y, z;
-	} gCrossCoords[] =
-	{
-		{ 1, 0, 0 },
-		{-1, 0, 0 },
-		{ 0, 0, 1 },
-		{ 0, 0,-1 },
-		{ 0, 1, 0 },
-		{ 0,-1, 0 }
-	};
-
-	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++) // Loop through struct to power all directions
-	{
-		SetBlockPowered(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y, a_BlockZ + gCrossCoords[i].z, a_BlockX, a_BlockY, a_BlockZ, a_SourceBlock);
-	}
-}
-
-
-
-
-
-void cRedstoneSimulator::SetBlockPowered(int a_BlockX, int a_BlockY, int a_BlockZ, int a_SourceX, int a_SourceY, int a_SourceZ, BLOCKTYPE a_SourceBlock)
-{
-	BLOCKTYPE Block = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-	if (Block == E_BLOCK_AIR)
-	{
-		// Don't set air, fixes some bugs (wires powering themselves)
-		return;
-	}
-
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks.begin(); itr != m_PoweredBlocks.end(); ++itr) // Check powered list
-	{
-		if (
-			itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)) &&
-			itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ))
-			)
-		{
-			// Check for duplicates
-			return;
-		}
-	}
-
-	sPoweredBlocks RC;
-	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
-	RC.a_SourcePos = Vector3i(a_SourceX, a_SourceY, a_SourceZ);
-	m_PoweredBlocks.push_back(RC);
-}
-
-
-
-
-
-void cRedstoneSimulator::SetBlockLinkedPowered(
-	int a_BlockX,  int a_BlockY,  int a_BlockZ,
-	int a_MiddleX, int a_MiddleY, int a_MiddleZ,
-	int a_SourceX, int a_SourceY, int a_SourceZ,
-	BLOCKTYPE a_SourceBlock, BLOCKTYPE a_MiddleBlock
-)
-{
-	BLOCKTYPE DestBlock = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-	if (DestBlock == E_BLOCK_AIR)
-	{
-		// Don't set air, fixes some bugs (wires powering themselves)
-		return;
-	}
-	if (!IsViableMiddleBlock(a_MiddleBlock))
-	{
-		return;
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks.begin(); itr != m_LinkedPoweredBlocks.end(); ++itr) // Check linked powered list
-	{
-		if (
-			itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)) &&
-			itr->a_MiddlePos.Equals(Vector3i(a_MiddleX, a_MiddleY, a_MiddleZ)) &&
-			itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ))
-			)
-		{
-			// Check for duplicates
-			return;
-		}
-	}
-
-	sLinkedPoweredBlocks RC;
-	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
-	RC.a_MiddlePos = Vector3i(a_MiddleX, a_MiddleY, a_MiddleZ);
-	RC.a_SourcePos = Vector3i(a_SourceX, a_SourceY, a_SourceZ);
-	m_LinkedPoweredBlocks.push_back(RC);
-}
-
-
-
-
-
-void cRedstoneSimulator::SetPlayerToggleableBlockAsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool WasLastStatePowered)
-{
-	for (SimulatedPlayerToggleableList::iterator itr = m_SimulatedPlayerToggleableBlocks.begin(); itr != m_SimulatedPlayerToggleableBlocks.end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			continue;
-		}
-
-		if (itr->WasLastStatePowered != WasLastStatePowered)
-		{
-			// If power states different, update listing
-			itr->WasLastStatePowered = WasLastStatePowered;
-			return;
-		}
-		else
-		{
-			// If states the same, just ignore
-			return;
-		}
-	}
-
-	// We have arrive here; no block must be in list - add one
-	sSimulatedPlayerToggleableList RC;
-	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
-	RC.WasLastStatePowered = WasLastStatePowered;
-	m_SimulatedPlayerToggleableBlocks.push_back(RC);
-}
-
-
-
-
-
-void cRedstoneSimulator::QueueRepeaterPowerChange(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta, short a_ElapsedTicks, bool ShouldPowerOn)
-{
-	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList.begin(); itr != m_RepeatersDelayList.end(); ++itr)
-	{
-		if (itr->a_BlockPos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			if (ShouldPowerOn == itr->ShouldPowerOn) // We are queued already for the same thing, don't replace entry
-			{
-				return;
-			}
-
-			// Already in here (normal to allow repeater to continue on powering and updating blocks in front) - just update info and quit
-			itr->a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + (ShouldPowerOn ? 1 : 0)) * 2; // See below for description
-			itr->a_ElapsedTicks = 0;
-			itr->ShouldPowerOn = ShouldPowerOn;
-			return;
-		}
-	}
-
-	// Self not in list, add self to list
-	sRepeatersDelayList RC;
-	RC.a_BlockPos = Vector3i(a_BlockX, a_BlockY, a_BlockZ);
-	
-	// Gets the top two bits (delay time), shifts them into the lower two bits, and adds one (meta 0 = 1 tick; 1 = 2 etc.)
-	// * 2 because apparently, MCS ticks are way faster than vanilla ticks, so repeater aren't noticeably delayed
-	// We don't +1 when powering off because everything seems to already delay a tick when powering off, why? No idea :P
-	RC.a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + (ShouldPowerOn ? 1 : 0)) * 2;
-
-
-	RC.a_ElapsedTicks = 0;
-	RC.ShouldPowerOn = ShouldPowerOn;
-	m_RepeatersDelayList.push_back(RC);
-	return;
-}
-
-
-
-
-
-cRedstoneSimulator::eRedstoneDirection cRedstoneSimulator::GetWireDirection(int a_BlockX, int a_BlockY, int a_BlockZ)
-{
-	int Dir = REDSTONE_NONE;
-
-	BLOCKTYPE NegX = m_World.GetBlock(a_BlockX - 1, a_BlockY, a_BlockZ);
-	if (IsPotentialSource(NegX))
-	{
-		Dir |= (REDSTONE_X_POS);
-	}
-	
-	BLOCKTYPE PosX = m_World.GetBlock(a_BlockX + 1, a_BlockY, a_BlockZ);
-	if (IsPotentialSource(PosX))
-	{
-		Dir |= (REDSTONE_X_NEG);
-	}
-	
-	BLOCKTYPE NegZ = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ - 1);
-	if (IsPotentialSource(NegZ))
-	{
-		if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
-		{
-			Dir ^= REDSTONE_X_POS;
-			Dir |= REDSTONE_X_NEG;
-		}
-		if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
-		{
-			Dir ^= REDSTONE_X_NEG;
-			Dir |= REDSTONE_X_POS;
-		}
-		Dir |= REDSTONE_Z_POS;
-	}
-	
-	BLOCKTYPE PosZ = m_World.GetBlock(a_BlockX, a_BlockY, a_BlockZ + 1);
-	if (IsPotentialSource(PosZ))
-	{
-		if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
-		{
-			Dir ^= REDSTONE_X_POS;
-			Dir |= REDSTONE_X_NEG;
-		}
-		if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
-		{
-			Dir ^= REDSTONE_X_NEG;
-			Dir |= REDSTONE_X_POS;
-		}
-		Dir |= REDSTONE_Z_NEG;
-	}
-	return (eRedstoneDirection)Dir;
-}
-
-
-
-
-
-bool cRedstoneSimulator::IsLeverOn(NIBBLETYPE a_BlockMeta)
-{
-	// Extract the ON bit from metadata and return if true if it is set:
-	return ((a_BlockMeta & 0x8) == 0x8);
-}
-
-
-
-
-
-bool cRedstoneSimulator::IsButtonOn(NIBBLETYPE a_BlockMeta)
-{
-	return IsLeverOn(a_BlockMeta);
-}
-
-
-
-
diff --git a/src/Simulator/RedstoneSimulator.h b/src/Simulator/RedstoneSimulator.h
index bb2efeb8a..b3e20c9a5 100644
--- a/src/Simulator/RedstoneSimulator.h
+++ b/src/Simulator/RedstoneSimulator.h
@@ -3,10 +3,6 @@
 
 #include "Simulator.h"
 
-/// Per-chunk data for the simulator, specified individual chunks to simulate; 'Data' is not used
-typedef cCoordWithBlockVector cRedstoneSimulatorChunkData;
-
-
 
 
 
@@ -14,250 +10,8 @@ class cRedstoneSimulator :
 	public cSimulator
 {
 	typedef cSimulator super;
+	
 public:
-
 	cRedstoneSimulator(cWorld & a_World);
-	~cRedstoneSimulator();
-
-	virtual void Simulate(float a_Dt) override { UNUSED(a_Dt);}  // not used
-	virtual void SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk) override;
-	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override { return IsRedstone(a_BlockType); }
-
-	enum eRedstoneDirection
-	{
-		REDSTONE_NONE =  0,
-		REDSTONE_X_POS = 0x1,
-		REDSTONE_X_NEG = 0x2,
-		REDSTONE_Z_POS = 0x4,
-		REDSTONE_Z_NEG = 0x8,
-	};
-	eRedstoneDirection GetWireDirection(int a_BlockX, int a_BlockY, int a_BlockZ);
-
-private:
-
-	struct sPoweredBlocks // Define structure of the directly powered blocks list
-	{
-		Vector3i a_BlockPos; // Position of powered block
-		Vector3i a_SourcePos; // Position of source powering the block at a_BlockPos
-	};
-
-	struct sLinkedPoweredBlocks // Define structure of the indirectly powered blocks list (i.e. repeaters powering through a block to the block at the other side)
-	{
-		Vector3i a_BlockPos;
-		Vector3i a_MiddlePos;
-		Vector3i a_SourcePos;
-	};
-
-	struct sSimulatedPlayerToggleableList
-	{
-		Vector3i a_BlockPos;
-		bool WasLastStatePowered;
-	};
-
-	struct sRepeatersDelayList
-	{
-		Vector3i a_BlockPos;
-		short a_DelayTicks;
-		short a_ElapsedTicks;
-		bool ShouldPowerOn;
-	};
-	
-	typedef std::vector <sPoweredBlocks> PoweredBlocksList;
-	typedef std::vector <sLinkedPoweredBlocks> LinkedBlocksList;
-	typedef std::vector <sSimulatedPlayerToggleableList> SimulatedPlayerToggleableList;
-	typedef std::vector <sRepeatersDelayList> RepeatersDelayList;
-
-	PoweredBlocksList m_PoweredBlocks;
-	LinkedBlocksList m_LinkedPoweredBlocks;
-	SimulatedPlayerToggleableList m_SimulatedPlayerToggleableBlocks;
-	RepeatersDelayList m_RepeatersDelayList;
-
-	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override;
-
-	// We want a_MyState for devices needing a full FastSetBlock (as opposed to meta) because with our simulation model, we cannot keep setting the block if it is already set correctly
-	// In addition to being non-performant, it would stop the player from actually breaking said device
-
-	/* ====== SOURCES ====== */
-	/** Handles the redstone torch */
-	void HandleRedstoneTorch(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState);
-	/** Handles the redstone block */
-	void HandleRedstoneBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles levers */
-	void HandleRedstoneLever(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles buttons */
-	void HandleRedstoneButton(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType);
-	/** Handles daylight sensors */
-	void HandleDaylightSensor(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles pressure plates */
-	void HandlePressurePlate(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType);
-	/* ==================== */
-
-	/* ====== CARRIERS ====== */
-	/** Handles redstone wire */
-	void HandleRedstoneWire(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles repeaters */
-	void HandleRedstoneRepeater(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState);
-	/* ====================== */
-
-	/* ====== DEVICES ====== */
-	/** Handles pistons */
-	void HandlePiston(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles dispensers and droppers */
-	void HandleDropSpenser(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles TNT (exploding) */
-	void HandleTNT(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles redstone lamps */
-	void HandleRedstoneLamp(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyState);
-	/** Handles doords */
-	void HandleDoor(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles command blocks */
-	void HandleCommandBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles activator, detector, and powered rails */
-	void HandleRail(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_MyType);
-	/** Handles trapdoors */
-	void HandleTrapdoor(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Handles noteblocks */
-	void HandleNoteBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/* ===================== */
-
-	/* ====== Helper functions ====== */
-	/** Marks a block as powered */
-	void SetBlockPowered(int a_BlockX, int a_BlockY, int a_BlockZ, int a_SourceX, int a_SourceY, int a_SourceZ, BLOCKTYPE a_SourceBlock);
-	/** Marks a block as being powered through another block */
-	void SetBlockLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MiddleX, int a_MiddleY, int a_MiddleZ, int a_SourceX, int a_SourceY, int a_SourceZ, BLOCKTYPE a_SourceBlock, BLOCKTYPE a_MiddeBlock);
-	/** Marks a block as simulated, who should not be simulated further unless their power state changes, to accomodate a player manually toggling the block without triggering the simulator toggling it back */
-	void SetPlayerToggleableBlockAsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool WasLastStatePowered);
-	/** Marks the second block in a direction as linked powered */
-	void SetDirectionLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Direction, BLOCKTYPE a_SourceBlock);
-	/** Marks all blocks immediately surrounding a coordinate as powered */
-	void SetAllDirsAsPowered(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_SourceBlock);
-	/** Queues a repeater to be powered or unpowered */
-	void QueueRepeaterPowerChange(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta, short a_ElapsedTicks, bool ShouldPowerOn);
-
-	/** Returns if a coordinate is powered or linked powered */
-	bool AreCoordsPowered(int a_BlockX, int a_BlockY, int a_BlockZ) { return AreCoordsDirectlyPowered(a_BlockX, a_BlockY, a_BlockZ) || AreCoordsLinkedPowered(a_BlockX, a_BlockY, a_BlockZ); }
-	/** Returns if a coordinate is in the directly powered blocks list */
-	bool AreCoordsDirectlyPowered(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Returns if a coordinate is in the indirectly powered blocks list */
-	bool AreCoordsLinkedPowered(int a_BlockX, int a_BlockY, int a_BlockZ);
-	/** Returns if a coordinate was marked as simulated (for blocks toggleable by players) */
-	bool AreCoordsSimulated(int a_BlockX, int a_BlockY, int a_BlockZ, bool IsCurrentStatePowered);
-	/** Returns if a repeater is powered */
-	bool IsRepeaterPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta);
-	/** Returns if a piston is powered */
-	bool IsPistonPowered(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Meta);
-	/** Returns if a wire is powered
-		The only diffence between this and a normal AreCoordsPowered is that this function checks for a wire powering another wire
-	*/
-	bool IsWirePowered(int a_BlockX, int a_BlockY, int a_BlockZ);
-
-
-	/** Returns if lever metadata marks it as emitting power */
-	bool IsLeverOn(NIBBLETYPE a_BlockMeta);
-	/** Returns if button metadata marks it as emitting power */
-	bool IsButtonOn(NIBBLETYPE a_BlockMeta);
-	/* ============================== */
-
-	/* ====== Misc Functions ====== */
-	/** Returns if a block is viable to be the MiddleBlock of a SetLinkedPowered operation */
-	inline static bool IsViableMiddleBlock(BLOCKTYPE Block) { return g_BlockFullyOccupiesVoxel[Block]; }
-
-	/** Returns if a block is a mechanism (something that accepts power and does something) */
-	inline static bool IsMechanism(BLOCKTYPE Block)
-	{
-		switch (Block)
-		{
-			case E_BLOCK_ACTIVATOR_RAIL:
-			case E_BLOCK_COMMAND_BLOCK:
-			case E_BLOCK_PISTON:
-			case E_BLOCK_STICKY_PISTON:
-			case E_BLOCK_DISPENSER:
-			case E_BLOCK_DROPPER:
-			case E_BLOCK_FENCE_GATE:
-			case E_BLOCK_HOPPER:
-			case E_BLOCK_NOTE_BLOCK:
-			case E_BLOCK_TNT:
-			case E_BLOCK_TRAPDOOR:
-			case E_BLOCK_REDSTONE_LAMP_OFF:
-			case E_BLOCK_REDSTONE_LAMP_ON:
-			case E_BLOCK_WOODEN_DOOR:
-			case E_BLOCK_IRON_DOOR:
-			case E_BLOCK_REDSTONE_REPEATER_OFF:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			case E_BLOCK_POWERED_RAIL:
-			{
-				return true;
-			}
-			default: return false;
-		}
-	}
-
-	/** Returns if a block has the potential to output power */
-	inline static bool IsPotentialSource(BLOCKTYPE Block)
-	{
-		switch (Block)
-		{
-			case E_BLOCK_DETECTOR_RAIL:
-			case E_BLOCK_DAYLIGHT_SENSOR:
-			case E_BLOCK_WOODEN_BUTTON:
-			case E_BLOCK_STONE_BUTTON:
-			case E_BLOCK_REDSTONE_WIRE:
-			case E_BLOCK_REDSTONE_TORCH_ON:
-			case E_BLOCK_LEVER:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			case E_BLOCK_BLOCK_OF_REDSTONE:
-			case E_BLOCK_ACTIVE_COMPARATOR:
-			{
-				return true;
-			}
-			default: return false;
-		}
-	}
 
-	/** Returns if a block is any sort of redstone device */
-	inline static bool IsRedstone(BLOCKTYPE Block)
-	{
-		switch (Block)
-		{
-			// All redstone devices, please alpha sort
-			case E_BLOCK_ACTIVATOR_RAIL:
-			case E_BLOCK_ACTIVE_COMPARATOR:
-			case E_BLOCK_BLOCK_OF_REDSTONE:
-			case E_BLOCK_COMMAND_BLOCK:
-			case E_BLOCK_DETECTOR_RAIL:
-			case E_BLOCK_DISPENSER:
-			case E_BLOCK_DAYLIGHT_SENSOR:
-			case E_BLOCK_DROPPER:
-			case E_BLOCK_FENCE_GATE:
-			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_HOPPER:
-			case E_BLOCK_INACTIVE_COMPARATOR:
-			case E_BLOCK_IRON_DOOR:
-			case E_BLOCK_LEVER:
-			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_NOTE_BLOCK:
-			case E_BLOCK_POWERED_RAIL:
-			case E_BLOCK_REDSTONE_LAMP_OFF:
-			case E_BLOCK_REDSTONE_LAMP_ON:
-			case E_BLOCK_REDSTONE_REPEATER_OFF:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			case E_BLOCK_REDSTONE_TORCH_OFF:
-			case E_BLOCK_REDSTONE_TORCH_ON:
-			case E_BLOCK_REDSTONE_WIRE:
-			case E_BLOCK_STICKY_PISTON:
-			case E_BLOCK_STONE_BUTTON:
-			case E_BLOCK_STONE_PRESSURE_PLATE:
-			case E_BLOCK_TNT:
-			case E_BLOCK_TRAPDOOR:
-			case E_BLOCK_TRIPWIRE_HOOK:
-			case E_BLOCK_WOODEN_BUTTON:
-			case E_BLOCK_WOODEN_DOOR:
-			case E_BLOCK_WOODEN_PRESSURE_PLATE:
-			case E_BLOCK_PISTON:
-			{
-				 return true;
-			}
-			default: return false;
-		}
-	}
-};
+} ;
diff --git a/src/Simulator/SandSimulator.cpp b/src/Simulator/SandSimulator.cpp
index 87fb83357..f305ba61a 100644
--- a/src/Simulator/SandSimulator.cpp
+++ b/src/Simulator/SandSimulator.cpp
@@ -158,8 +158,10 @@ bool cSandSimulator::CanContinueFallThrough(BLOCKTYPE a_BlockType)
 		case E_BLOCK_DETECTOR_RAIL:
 		case E_BLOCK_FIRE:
 		case E_BLOCK_FLOWER_POT:
+		case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
 		case E_BLOCK_LAVA:
 		case E_BLOCK_LEVER:
+		case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
 		case E_BLOCK_MINECART_TRACKS:
 		case E_BLOCK_MELON_STEM:
 		case E_BLOCK_POWERED_RAIL:
diff --git a/src/Simulator/Simulator.cpp b/src/Simulator/Simulator.cpp
index 06fd0f858..0739f0187 100644
--- a/src/Simulator/Simulator.cpp
+++ b/src/Simulator/Simulator.cpp
@@ -3,7 +3,6 @@
 
 #include "Simulator.h"
 #include "../World.h"
-#include "../Vector3i.h"
 #include "../BlockID.h"
 #include "../Defines.h"
 #include "../Chunk.h"
diff --git a/src/Simulator/Simulator.h b/src/Simulator/Simulator.h
index a25b7f1b6..a2e2a5742 100644
--- a/src/Simulator/Simulator.h
+++ b/src/Simulator/Simulator.h
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include "../Vector3i.h"
+#include "../Vector3.h"
 #include "inifile/iniFile.h"
 
 
diff --git a/src/Simulator/VanillaFluidSimulator.cpp b/src/Simulator/VanillaFluidSimulator.cpp
new file mode 100644
index 000000000..78aff9d68
--- /dev/null
+++ b/src/Simulator/VanillaFluidSimulator.cpp
@@ -0,0 +1,150 @@
+
+// VanillaFluidSimulator.cpp
+
+#include "Globals.h"
+
+#include "VanillaFluidSimulator.h"
+#include "../World.h"
+#include "../Chunk.h"
+#include "../BlockArea.h"
+#include "../Blocks/BlockHandler.h"
+#include "../BlockInServerPluginInterface.h"
+
+
+
+
+
+static const int InfiniteCost = 100;
+
+
+
+
+
+cVanillaFluidSimulator::cVanillaFluidSimulator(
+	cWorld & a_World,
+	BLOCKTYPE a_Fluid,
+	BLOCKTYPE a_StationaryFluid,
+	NIBBLETYPE a_Falloff,
+	int a_TickDelay,
+	int a_NumNeighborsForSource
+) : super(a_World, a_Fluid, a_StationaryFluid, a_Falloff, a_TickDelay, a_NumNeighborsForSource)
+{
+}
+
+
+
+
+
+void cVanillaFluidSimulator::Spread(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_NewMeta)
+{
+	int Cost[4];
+	Cost[0] = CalculateFlowCost(a_Chunk, a_RelX + 1, a_RelY, a_RelZ,     X_PLUS);
+	Cost[1] = CalculateFlowCost(a_Chunk, a_RelX - 1, a_RelY, a_RelZ,     X_MINUS);
+	Cost[2] = CalculateFlowCost(a_Chunk, a_RelX,     a_RelY, a_RelZ + 1, Z_PLUS);
+	Cost[3] = CalculateFlowCost(a_Chunk, a_RelX,     a_RelY, a_RelZ - 1, Z_MINUS);
+
+	int MinCost = InfiniteCost;
+	for (unsigned int i = 0; i < ARRAYCOUNT(Cost); ++i)
+	{
+		if (Cost[i] < MinCost)
+		{
+			MinCost = Cost[i];
+		}
+	}
+
+	if (Cost[0] == MinCost)
+	{
+		SpreadToNeighbor(a_Chunk, a_RelX + 1, a_RelY, a_RelZ, a_NewMeta);
+	}
+	if (Cost[1] == MinCost)
+	{
+		SpreadToNeighbor(a_Chunk, a_RelX - 1, a_RelY, a_RelZ, a_NewMeta);
+	}
+	if (Cost[2] == MinCost)
+	{
+		SpreadToNeighbor(a_Chunk, a_RelX, a_RelY, a_RelZ + 1, a_NewMeta);
+	}
+	if (Cost[3] == MinCost)
+	{
+		SpreadToNeighbor(a_Chunk, a_RelX, a_RelY, a_RelZ - 1, a_NewMeta);
+	}
+}
+
+
+
+
+
+int cVanillaFluidSimulator::CalculateFlowCost(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, Direction a_Dir, unsigned a_Iteration)
+{
+	int Cost = InfiniteCost;
+
+	BLOCKTYPE BlockType;
+	NIBBLETYPE BlockMeta;
+
+	// Check if block is passable
+	if (!a_Chunk->UnboundedRelGetBlock(a_RelX, a_RelY, a_RelZ, BlockType, BlockMeta))
+	{
+		return Cost;
+	}
+	if (!IsPassableForFluid(BlockType) && !IsBlockLiquid(BlockType))
+	{
+		return Cost;
+	}
+
+	// Check if block below is passable
+	if (!a_Chunk->UnboundedRelGetBlock(a_RelX, a_RelY - 1, a_RelZ, BlockType, BlockMeta))
+	{
+		return Cost;
+	}
+	if (IsPassableForFluid(BlockType) || IsBlockLiquid(BlockType))
+	{
+		// Path found, exit
+		return a_Iteration;
+	}
+
+	// 5 blocks away, bail out
+	if (a_Iteration > 3)
+	{
+		return Cost;
+	}
+
+	// Recurse
+	if (a_Dir != X_MINUS)
+	{
+		int NextCost = CalculateFlowCost(a_Chunk, a_RelX + 1, a_RelY, a_RelZ, X_PLUS, a_Iteration + 1);
+		if (NextCost < Cost)
+		{
+			Cost = NextCost;
+		}
+	}
+	if (a_Dir != X_PLUS)
+	{
+		int NextCost = CalculateFlowCost(a_Chunk, a_RelX - 1, a_RelY, a_RelZ, X_MINUS, a_Iteration + 1);
+		if (NextCost < Cost)
+		{
+			Cost = NextCost;
+		}
+	}
+	if (a_Dir != Z_MINUS)
+	{
+		int NextCost = CalculateFlowCost(a_Chunk, a_RelX, a_RelY, a_RelZ + 1, Z_PLUS, a_Iteration + 1);
+		if (NextCost < Cost)
+		{
+			Cost = NextCost;
+		}
+	}
+	if (a_Dir != Z_PLUS)
+	{
+		int NextCost = CalculateFlowCost(a_Chunk, a_RelX, a_RelY, a_RelZ - 1, Z_MINUS, a_Iteration + 1);
+		if (NextCost < Cost)
+		{
+			Cost = NextCost;
+		}
+	}
+
+	return Cost;
+}
+
+
+
+
diff --git a/src/Simulator/VanillaFluidSimulator.h b/src/Simulator/VanillaFluidSimulator.h
new file mode 100644
index 000000000..a9ea98b5a
--- /dev/null
+++ b/src/Simulator/VanillaFluidSimulator.h
@@ -0,0 +1,42 @@
+
+// VanillaFluidSimulator.h
+
+
+
+
+
+#pragma once
+
+#include "FloodyFluidSimulator.h"
+
+
+
+
+
+// fwd:
+class cBlockArea;
+
+
+
+
+
+class cVanillaFluidSimulator :
+	public cFloodyFluidSimulator
+{
+	typedef cFloodyFluidSimulator super;
+	
+public:
+	cVanillaFluidSimulator(cWorld & a_World, BLOCKTYPE a_Fluid, BLOCKTYPE a_StationaryFluid, NIBBLETYPE a_Falloff, int a_TickDelay, int a_NumNeighborsForSource);
+	
+protected:
+	// cFloodyFluidSimulator overrides:
+	virtual void Spread(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_NewMeta) override;
+
+	/** Recursively calculates the minimum number of blocks needed to descend a level. */
+	int CalculateFlowCost(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, Direction a_Dir, unsigned a_Iteration = 0);
+
+} ;
+
+
+
+
diff --git a/src/StringCompression.cpp b/src/StringCompression.cpp
index 5b9a3bb0a..2a85649a1 100644
--- a/src/StringCompression.cpp
+++ b/src/StringCompression.cpp
@@ -53,7 +53,7 @@ int UncompressString(const char * a_Data, int a_Length, AString & a_Uncompressed
 
 
 
-int CompressStringGZIP(const char * a_Data, int a_Length, AString & a_Compressed)
+int CompressStringGZIP(const char * a_Data, size_t a_Length, AString & a_Compressed)
 {
 	// Compress a_Data into a_Compressed using GZIP; return Z_XXX error constants same as zlib's compress2()
 
@@ -83,6 +83,7 @@ int CompressStringGZIP(const char * a_Data, int a_Length, AString & a_Compressed
 			{
 				// Some data has been compressed. Consume the buffer and continue compressing
 				a_Compressed.append(Buffer, sizeof(Buffer) - strm.avail_out);
+				strm.next_out = (Bytef *)Buffer;
 				strm.avail_out = sizeof(Buffer);
 				if (strm.avail_in == 0)
 				{
@@ -116,7 +117,7 @@ int CompressStringGZIP(const char * a_Data, int a_Length, AString & a_Compressed
 
 
 
-extern int UncompressStringGZIP(const char * a_Data, int a_Length, AString & a_Uncompressed)
+extern int UncompressStringGZIP(const char * a_Data, size_t a_Length, AString & a_Uncompressed)
 {
 	// Uncompresses a_Data into a_Uncompressed using GZIP; returns Z_OK for success or Z_XXX error constants same as zlib
 
@@ -139,13 +140,14 @@ extern int UncompressStringGZIP(const char * a_Data, int a_Length, AString & a_U
 	
 	for (;;)
 	{
-		res = inflate(&strm, Z_FINISH);
+		res = inflate(&strm, Z_NO_FLUSH);
 		switch (res)
 		{
 			case Z_OK:
 			{
 				// Some data has been uncompressed. Consume the buffer and continue uncompressing
 				a_Uncompressed.append(Buffer, sizeof(Buffer) - strm.avail_out);
+				strm.next_out = (Bytef *)Buffer;
 				strm.avail_out = sizeof(Buffer);
 				if (strm.avail_in == 0)
 				{
diff --git a/src/StringCompression.h b/src/StringCompression.h
index 3f4e12d2d..c3a9eca91 100644
--- a/src/StringCompression.h
+++ b/src/StringCompression.h
@@ -16,10 +16,10 @@ extern int CompressString(const char * a_Data, int a_Length, AString & a_Compres
 extern int UncompressString(const char * a_Data, int a_Length, AString & a_Uncompressed, int a_UncompressedSize);
 
 /// Compresses a_Data into a_Compressed using GZIP; returns Z_OK for success or Z_XXX error constants same as zlib
-extern int CompressStringGZIP(const char * a_Data, int a_Length, AString & a_Compressed);
+extern int CompressStringGZIP(const char * a_Data, size_t a_Length, AString & a_Compressed);
 
 /// Uncompresses a_Data into a_Uncompressed using GZIP; returns Z_OK for success or Z_XXX error constants same as zlib
-extern int UncompressStringGZIP(const char * a_Data, int a_Length, AString & a_Uncompressed);
+extern int UncompressStringGZIP(const char * a_Data, size_t a_Length, AString & a_Uncompressed);
 
 
 
diff --git a/src/StringUtils.cpp b/src/StringUtils.cpp
index 0dbd41c12..33b04505f 100644
--- a/src/StringUtils.cpp
+++ b/src/StringUtils.cpp
@@ -288,13 +288,13 @@ void ReplaceString(AString & iHayStack, const AString & iNeedle, const AString &
 
 
 // Converts a stream of BE shorts into UTF-8 string; returns a ref to a_UTF8
-AString & RawBEToUTF8(short * a_RawData, int a_NumShorts, AString & a_UTF8)
+AString & RawBEToUTF8(const char * a_RawData, int a_NumShorts, AString & a_UTF8)
 {
 	a_UTF8.clear();
 	a_UTF8.reserve(3 * a_NumShorts / 2);  // a quick guess of the resulting size
 	for (int i = 0; i < a_NumShorts; i++)
 	{
-		int c = ntohs(*(a_RawData + i));
+		int c = GetBEShort(&a_RawData[i * 2]);
 		if (c < 0x80)
 		{
 			a_UTF8.push_back((char)c);
@@ -364,10 +364,7 @@ Notice from the original file:
 
 #define UNI_MAX_BMP         0x0000FFFF
 #define UNI_MAX_UTF16       0x0010FFFF
-#define UNI_MAX_UTF32       0x7FFFFFFF
-#define UNI_MAX_LEGAL_UTF32 0x0010FFFF
 #define UNI_SUR_HIGH_START  0xD800
-#define UNI_SUR_HIGH_END    0xDBFF
 #define UNI_SUR_LOW_START   0xDC00
 #define UNI_SUR_LOW_END     0xDFFF
 
@@ -457,7 +454,6 @@ AString & UTF8ToRawBEUTF16(const char * a_UTF8, size_t a_UTF8Length, AString & a
 		if (!isLegalUTF8(source, extraBytesToRead + 1))
 		{
 			return a_UTF16;
-			break;
 		}
 		
 		// The cases all fall through. See "Note A" below.
@@ -535,32 +531,32 @@ AString & UTF8ToRawBEUTF16(const char * a_UTF8, size_t a_UTF8Length, AString & a
 format binary data this way:
 00001234: 31 32 33 34 35 36 37 38 39 30 61 62 63 64 65 66    1234567890abcdef
 */
-AString & CreateHexDump(AString & a_Out, const void * a_Data, int a_Size, int a_LineLength)
+AString & CreateHexDump(AString & a_Out, const void * a_Data, size_t a_Size, size_t a_BytesPerLine)
 {
-	ASSERT(a_LineLength <= 120);  // Due to using a fixed size line buffer; increase line[]'s size to lift this max
+	ASSERT(a_BytesPerLine <= 120);  // Due to using a fixed size line buffer; increase line[]'s size to lift this max
 	char line[512];
 	char * p;
 	char * q;
 	
-	a_Out.reserve(a_Size / a_LineLength * (18 + 6 * a_LineLength));
-	for (int i = 0; i < a_Size; i += a_LineLength)
+	a_Out.reserve(a_Size / a_BytesPerLine * (18 + 6 * a_BytesPerLine));
+	for (size_t i = 0; i < a_Size; i += a_BytesPerLine)
 	{
-		int k = a_Size - i;
-		if (k > a_LineLength)
+		size_t k = a_Size - i;
+		if (k > a_BytesPerLine)
 		{
-			k = a_LineLength;
+			k = a_BytesPerLine;
 		}
 		#ifdef _MSC_VER
 		// MSVC provides a "secure" version of sprintf()
-		int Count = sprintf_s(line, sizeof(line), "%08x:", i);
+		int Count = sprintf_s(line, sizeof(line), "%08x:", (unsigned)i);
 		#else
-		int Count = sprintf(line, "%08x:", i);
+		int Count = sprintf(line, "%08x:", (unsigned)i);
 		#endif
 		// Remove the terminating NULL / leftover garbage in line, after the sprintf-ed value
 		memset(line + Count, 32, sizeof(line) - Count);
 		p = line + 10;
-		q = p + 2 + a_LineLength * 3 + 1;
-		for (int j = 0; j < k; j++)
+		q = p + 2 + a_BytesPerLine * 3 + 1;
+		for (size_t j = 0; j < k; j++)
 		{
 			unsigned char c = ((unsigned char *)a_Data)[i + j];
 			p[0] = HEX(c >> 4);
@@ -833,7 +829,8 @@ AString Base64Encode(const AString & a_Input)
 
 short GetBEShort(const char * a_Mem)
 {
-	return (((short)a_Mem[0]) << 8) | a_Mem[1];
+	const Byte * Bytes = (const Byte *)a_Mem;
+	return (Bytes[0] << 8) | Bytes[1];
 }
 
 
@@ -842,7 +839,8 @@ short GetBEShort(const char * a_Mem)
 
 int GetBEInt(const char * a_Mem)
 {
-	return (((int)a_Mem[0]) << 24) | (((int)a_Mem[1]) << 16) | (((int)a_Mem[2]) << 8) | a_Mem[3];
+	const Byte * Bytes = (const Byte *)a_Mem;
+	return (Bytes[0] << 24) | (Bytes[1] << 16) | (Bytes[2] << 8) | Bytes[3];
 }
 
 
diff --git a/src/StringUtils.h b/src/StringUtils.h
index dfbfc2a75..b69e47d3c 100644
--- a/src/StringUtils.h
+++ b/src/StringUtils.h
@@ -22,16 +22,16 @@ typedef std::list<AString>   AStringList;
 
 
 /** Add the formated string to the existing data in the string */
-extern AString & AppendVPrintf(AString & str, const char * format, va_list args);
+extern AString & AppendVPrintf(AString & str, const char * format, va_list args) FORMATSTRING(2, 0);
 
 /// Output the formatted text into the string
-extern AString & Printf       (AString & str, const char * format, ...);
+extern AString & Printf       (AString & str, const char * format, ...) FORMATSTRING(2, 3);
 
 /// Output the formatted text into string, return string by value
-extern AString Printf(const char * format, ...);
+extern AString Printf(const char * format, ...) FORMATSTRING(1, 2);
 
 /// Add the formatted string to the existing data in the string
-extern AString & AppendPrintf (AString & str, const char * format, ...);
+extern AString & AppendPrintf (AString & str, const char * format, ...) FORMATSTRING(2, 3);
 
 /// Split the string at any of the listed delimiters, return as a stringvector
 extern AStringVector StringSplit(const AString & str, const AString & delim);
@@ -58,13 +58,13 @@ extern unsigned int RateCompareString(const AString & s1, const AString & s2 );
 extern void ReplaceString(AString & iHayStack, const AString & iNeedle, const AString & iReplaceWith);  // tolua_export
 
 /// Converts a stream of BE shorts into UTF-8 string; returns a ref to a_UTF8
-extern AString & RawBEToUTF8(short * a_RawData, int a_NumShorts, AString & a_UTF8);
+extern AString & RawBEToUTF8(const char * a_RawData, int a_NumShorts, AString & a_UTF8);
 
 /// Converts a UTF-8 string into a UTF-16 BE string, packing that back into AString; return a ref to a_UTF16
 extern AString & UTF8ToRawBEUTF16(const char * a_UTF8, size_t a_UTF8Length, AString & a_UTF16);
 
 /// Creates a nicely formatted HEX dump of the given memory block. Max a_BytesPerLine is 120
-extern AString & CreateHexDump(AString & a_Out, const void * a_Data, int a_Size, int a_BytesPerLine);
+extern AString & CreateHexDump(AString & a_Out, const void * a_Data, size_t a_Size, size_t a_BytesPerLine);
 
 /// Returns a copy of a_Message with all quotes and backslashes escaped by a backslash
 extern AString EscapeString(const AString & a_Message);  // tolua_export
@@ -79,10 +79,10 @@ extern AString URLDecode(const AString & a_String);  // Cannot export to Lua aut
 extern AString ReplaceAllCharOccurrences(const AString & a_String, char a_From, char a_To);  // Needn't export to Lua, since Lua doesn't have chars anyway
 
 /// Decodes a Base64-encoded string into the raw data
-extern AString Base64Decode(const AString & a_Base64String);
+extern AString Base64Decode(const AString & a_Base64String);  // Exported manually due to embedded NULs and extra parameter
 
 /// Encodes a string into Base64
-extern AString Base64Encode(const AString & a_Input);
+extern AString Base64Encode(const AString & a_Input);  // Exported manually due to embedded NULs and extra parameter
 
 /// Reads two bytes from the specified memory location and interprets them as BigEndian short
 extern short GetBEShort(const char * a_Mem);
diff --git a/src/Tracer.cpp b/src/Tracer.cpp
index ef136302f..6da6b2ad7 100644
--- a/src/Tracer.cpp
+++ b/src/Tracer.cpp
@@ -4,10 +4,6 @@
 #include "Tracer.h"
 #include "World.h"
 
-#include "Vector3f.h"
-#include "Vector3i.h"
-#include "Vector3d.h"
-
 #include "Entities/Entity.h"
 
 #ifndef _WIN32
@@ -226,7 +222,7 @@ bool cTracer::Trace( const Vector3f & a_Start, const Vector3f & a_Direction, int
 		BLOCKTYPE BlockID = m_World->GetBlock(pos.x, pos.y, pos.z);
 		// Block is counted as a collision if we are not doing a line of sight and it is solid,
 		// or if the block is not air and not water. That way mobs can still see underwater.
-		if ((!a_LineOfSight && g_BlockIsSolid[BlockID]) || (a_LineOfSight && (BlockID != E_BLOCK_AIR) && !IsBlockWater(BlockID)))
+		if ((!a_LineOfSight && cBlockInfo::IsSolid(BlockID)) || (a_LineOfSight && (BlockID != E_BLOCK_AIR) && !IsBlockWater(BlockID)))
 		{
 			BlockHitPosition = pos;
 			int Normal = GetHitNormal(a_Start, End, pos );
diff --git a/src/Tracer.h b/src/Tracer.h
index 6c2ab6792..bdb080f0d 100644
--- a/src/Tracer.h
+++ b/src/Tracer.h
@@ -1,8 +1,7 @@
 
 #pragma once
 
-#include "Vector3i.h"
-#include "Vector3f.h"
+#include "Vector3.h"
 
 
 
diff --git a/src/UI/SlotArea.cpp b/src/UI/SlotArea.cpp
index 03bfd275a..9463bc593 100644
--- a/src/UI/SlotArea.cpp
+++ b/src/UI/SlotArea.cpp
@@ -226,6 +226,24 @@ void cSlotArea::DblClicked(cPlayer & a_Player, int a_SlotNum)
 
 
 
+void cSlotArea::OnPlayerAdded(cPlayer & a_Player)
+{
+	UNUSED(a_Player);
+}
+
+
+
+
+
+void cSlotArea::OnPlayerRemoved(cPlayer & a_Player)
+{
+	UNUSED(a_Player);
+}
+
+
+
+
+
 void cSlotArea::DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_Apply, bool a_KeepEmptySlots)
 {
 	for (int i = 0; i < m_NumSlots; i++)
@@ -449,6 +467,18 @@ void cSlotAreaCrafting::OnPlayerRemoved(cPlayer & a_Player)
 
 
 
+
+void cSlotAreaCrafting::DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots)
+{
+	UNUSED(a_ItemStack);
+	UNUSED(a_Player);
+	UNUSED(a_ShouldApply);
+	UNUSED(a_KeepEmptySlots);
+}
+
+
+
+
 void cSlotAreaCrafting::ClickedResult(cPlayer & a_Player)
 {
 	cItem & DraggingItem = a_Player.GetDraggingItem();
diff --git a/src/UI/SlotArea.h b/src/UI/SlotArea.h
index bd5c66c77..82360ffbe 100644
--- a/src/UI/SlotArea.h
+++ b/src/UI/SlotArea.h
@@ -48,10 +48,10 @@ public:
 	virtual void DblClicked(cPlayer & a_Player, int a_SlotNum);
 	
 	/// Called when a new player opens the same parent window. The window already tracks the player. CS-locked.
-	virtual void OnPlayerAdded(cPlayer & a_Player) {} ;
+	virtual void OnPlayerAdded(cPlayer & a_Player);
 	
 	/// Called when one of the players closes the parent window. The window already doesn't track the player. CS-locked.
-	virtual void OnPlayerRemoved(cPlayer & a_Player) {} ;
+	virtual void OnPlayerRemoved(cPlayer & a_Player);
 	
 	/** Called to store as much of a_ItemStack in the area as possible. a_ItemStack is modified to reflect the change.
 	The default implementation searches each slot for available space and distributes the stack there.
@@ -226,7 +226,7 @@ public:
 	virtual void OnPlayerRemoved(cPlayer & a_Player) override;
 	
 	// Distributing items into this area is completely disabled
-	virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots) override {}
+	virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots) override;
 
 protected:
 	/// Maps player's EntityID -> current recipe; not a std::map because cCraftingGrid needs proper constructor params
diff --git a/src/UI/Window.cpp b/src/UI/Window.cpp
index 9188b47a7..5d89534dd 100644
--- a/src/UI/Window.cpp
+++ b/src/UI/Window.cpp
@@ -13,7 +13,8 @@
 #include "../BlockEntities/DropSpenserEntity.h"
 #include "../BlockEntities/EnderChestEntity.h"
 #include "../BlockEntities/HopperEntity.h"
-
+#include "../Root.h"
+#include "../Bindings/PluginManager.h"
 
 
 
@@ -169,6 +170,7 @@ void cWindow::Clicked(
 	const cItem & a_ClickedItem
 )
 {
+    	cPluginManager * PlgMgr = cRoot::Get()->GetPluginManager();
 	if (a_WindowID != m_WindowID)
 	{
 		LOGWARNING("%s: Wrong window ID (exp %d, got %d) received from \"%s\"; ignoring click.", __FUNCTION__, m_WindowID, a_WindowID, a_Player.GetName().c_str());
@@ -179,14 +181,35 @@ void cWindow::Clicked(
 	{
 		case caRightClickOutside:
 		{
+			if (PlgMgr->CallHookPlayerTossingItem(a_Player))
+			{
+				// A plugin doesn't agree with the tossing. The plugin itself is responsible for handling the consequences (possible inventory mismatch)
+				return;
+			}
+			if (a_Player.IsGameModeCreative())
+			{
+				a_Player.TossPickup(a_ClickedItem);
+			}
+
 			// Toss one of the dragged items:
-			a_Player.TossItem(true);
+			a_Player.TossHeldItem();
 			return;
 		}
 		case caLeftClickOutside:
 		{
+			if (PlgMgr->CallHookPlayerTossingItem(a_Player))
+			{
+				// A plugin doesn't agree with the tossing. The plugin itself is responsible for handling the consequences (possible inventory mismatch)
+				return;
+			}
+
+			if (a_Player.IsGameModeCreative())
+			{
+				a_Player.TossPickup(a_ClickedItem);
+			}
+
 			// Toss all dragged items:
-			a_Player.TossItem(true, a_Player.GetDraggingItem().m_ItemCount);
+			a_Player.TossHeldItem(a_Player.GetDraggingItem().m_ItemCount);
 			return;
 		}
 		case caLeftClickOutsideHoldNothing:
@@ -263,7 +286,7 @@ bool cWindow::ClosedByPlayer(cPlayer & a_Player, bool a_CanRefuse)
 	if (a_Player.IsDraggingItem())
 	{
 		LOGD("Player holds item! Dropping it...");
-		a_Player.TossItem(true, a_Player.GetDraggingItem().m_ItemCount);
+		a_Player.TossHeldItem(a_Player.GetDraggingItem().m_ItemCount);
 	}
 
 	cClientHandle * ClientHandle = a_Player.GetClientHandle();
@@ -614,7 +637,7 @@ int cWindow::DistributeItemToSlots(cPlayer & a_Player, const cItem & a_Item, int
 {
 	if ((size_t)(a_Item.m_ItemCount) < a_SlotNums.size())
 	{
-		LOGWARNING("%s: Distributing less items (%d) than slots (%u)", __FUNCTION__, (int)a_Item.m_ItemCount, a_SlotNums.size());
+		LOGWARNING("%s: Distributing less items (%d) than slots (" SIZE_T_FMT  ")", __FUNCTION__, (int)a_Item.m_ItemCount, a_SlotNums.size());
 		// This doesn't seem to happen with the 1.5.1 client, so we don't worry about it for now
 		return 0;
 	}
diff --git a/src/UI/WindowOwner.h b/src/UI/WindowOwner.h
index d41abf66d..e3c73edc4 100644
--- a/src/UI/WindowOwner.h
+++ b/src/UI/WindowOwner.h
@@ -33,6 +33,10 @@ public:
 	{
 	}
 	
+	virtual ~cWindowOwner()
+	{
+	}
+	
 	void CloseWindow(void)
 	{
 		m_Window = NULL;
diff --git a/src/Vector3.h b/src/Vector3.h
new file mode 100644
index 000000000..a00e14508
--- /dev/null
+++ b/src/Vector3.h
@@ -0,0 +1,293 @@
+
+#pragma once
+
+
+
+#define _USE_MATH_DEFINES // Enable non-standard math defines (MSVC)
+#include <math.h>
+
+
+
+
+
+template <typename T>
+// tolua_begin
+class Vector3
+{
+
+	TOLUA_TEMPLATE_BIND((T, int, float, double))
+
+public:
+
+	T x, y, z;
+
+
+	inline Vector3(void) : x(0), y(0), z(0) {}
+	inline Vector3(T a_x, T a_y, T a_z) : x(a_x), y(a_y), z(a_z) {}
+
+
+	// Hardcoded copy constructors (tolua++ does not support function templates .. yet)
+	Vector3(const Vector3<float>  & a_Rhs) : x((T) a_Rhs.x), y((T) a_Rhs.y), z((T) a_Rhs.z) {}
+	Vector3(const Vector3<double> & a_Rhs) : x((T) a_Rhs.x), y((T) a_Rhs.y), z((T) a_Rhs.z) {}
+	Vector3(const Vector3<int>    & a_Rhs) : x((T) a_Rhs.x), y((T) a_Rhs.y), z((T) a_Rhs.z) {}
+
+
+	// tolua_end
+	template <typename _T>
+	Vector3(const Vector3<_T> & a_Rhs) : x(a_Rhs.x), y(a_Rhs.y), z(a_Rhs.z) {}
+
+	template <typename _T>
+	Vector3(const Vector3<_T> * a_Rhs) : x(a_Rhs->x), y(a_Rhs->y), z(a_Rhs->z) {}
+	// tolua_begin
+
+
+	inline void Set(T a_x, T a_y, T a_z)
+	{
+		x = a_x;
+		y = a_y;
+		z = a_z;
+	}
+
+	inline void Normalize(void)
+	{
+		double Len = 1.0 / Length();
+
+		x = (T)(x * Len);
+		y = (T)(y * Len);
+		z = (T)(z * Len);
+	}
+
+	inline Vector3<T> NormalizeCopy(void) const
+	{
+		double Len = 1.0 / Length();
+
+		return Vector3<T>(
+			(T)(x * Len),
+			(T)(y * Len),
+			(T)(z * Len)
+		);
+	}
+
+	inline void NormalizeCopy(Vector3<T> & a_Rhs) const
+	{
+		double Len = 1.0 / Length();
+
+		a_Rhs.Set(
+			(T)(x * Len),
+			(T)(y * Len),
+			(T)(z * Len)
+		);
+	}
+
+	inline double Length(void) const
+	{
+		return sqrt((double)(x * x + y * y + z * z));
+	}
+
+	inline double SqrLength(void) const
+	{
+		return x * x + y * y + z * z;
+	}
+
+	inline T Dot(const Vector3<T> & a_Rhs) const
+	{
+		return x * a_Rhs.x + y * a_Rhs.y + z * a_Rhs.z;
+	}
+
+	inline Vector3<T> Cross(const Vector3<T> & a_Rhs) const
+	{
+		return Vector3<T>(
+			y * a_Rhs.z - z * a_Rhs.y,
+			z * a_Rhs.x - x * a_Rhs.z,
+			x * a_Rhs.y - y * a_Rhs.x
+		);
+	}
+
+	inline bool Equals(const Vector3<T> & a_Rhs) const
+	{
+		return x == a_Rhs.x && y == a_Rhs.y && z == a_Rhs.z;
+	}
+
+	inline bool operator < (const Vector3<T> & a_Rhs)
+	{
+		// return (x < a_Rhs.x) && (y < a_Rhs.y) && (z < a_Rhs.z); ?
+		return (x < a_Rhs.x) || (x == a_Rhs.x && y < a_Rhs.y) || (x == a_Rhs.x && y == a_Rhs.y && z < a_Rhs.z);
+	}
+
+	inline void Move(T a_X, T a_Y, T a_Z)
+	{
+		x += a_X;
+		y += a_Y;
+		z += a_Z;
+	}
+
+	inline void Move(const Vector3<T> & a_Diff)
+	{
+		x += a_Diff.x;
+		y += a_Diff.y;
+		z += a_Diff.z;
+	}
+
+	// tolua_end
+
+	inline void operator += (const Vector3<T> & a_Rhs)
+	{
+		x += a_Rhs.x;
+		y += a_Rhs.y;
+		z += a_Rhs.z;
+	}
+
+	inline void operator -= (const Vector3<T> & a_Rhs)
+	{
+		x -= a_Rhs.x;
+		y -= a_Rhs.y;
+		z -= a_Rhs.z;
+	}
+
+	inline void operator *= (const Vector3<T> & a_Rhs)
+	{
+		x *= a_Rhs.x;
+		y *= a_Rhs.y;
+		z *= a_Rhs.z;
+	}
+
+	inline void operator *= (T a_v)
+	{
+		x *= a_v;
+		y *= a_v;
+		z *= a_v;
+	}
+
+	// tolua_begin
+
+	inline Vector3<T> operator + (const Vector3<T>& a_Rhs) const
+	{
+		return Vector3<T>(
+			x + a_Rhs.x,
+			y + a_Rhs.y,
+			z + a_Rhs.z
+		);
+	}
+
+	inline Vector3<T> operator - (const Vector3<T>& a_Rhs) const
+	{
+		return Vector3<T>(
+			x - a_Rhs.x,
+			y - a_Rhs.y,
+			z - a_Rhs.z
+		);
+	}
+
+	inline Vector3<T> operator * (const Vector3<T>& a_Rhs) const
+	{
+		return Vector3<T>(
+			x * a_Rhs.x,
+			y * a_Rhs.y,
+			z * a_Rhs.z
+		);
+	}
+
+	inline Vector3<T> operator * (T a_v) const
+	{
+		return Vector3<T>(
+			x * a_v,
+			y * a_v,
+			z * a_v
+		);
+	}
+
+	inline Vector3<T> operator / (T a_v) const
+	{
+		return Vector3<T>(
+			x / a_v,
+			y / a_v,
+			z / a_v
+		);
+	}
+
+	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Z coord.
+	The result satisfies the following equation:
+	(*this + Result * (a_OtherEnd - *this)).z = a_Z
+	If the line is too close to being parallel, this function returns NO_INTERSECTION
+	*/
+	inline double LineCoeffToXYPlane(const Vector3<T> & a_OtherEnd, T a_Z) const
+	{
+		if (abs(z - a_OtherEnd.z) < EPS)
+		{
+			return NO_INTERSECTION;
+		}
+
+		return (a_Z - z) / (a_OtherEnd.z - z);
+	}
+
+	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Y coord.
+	The result satisfies the following equation:
+	(*this + Result * (a_OtherEnd - *this)).y = a_Y
+	If the line is too close to being parallel, this function returns NO_INTERSECTION
+	*/
+	inline double LineCoeffToXZPlane(const Vector3<T> & a_OtherEnd, T a_Y) const
+	{
+		if (abs(y - a_OtherEnd.y) < EPS)
+		{
+			return NO_INTERSECTION;
+		}
+
+		return (a_Y - y) / (a_OtherEnd.y - y);
+	}
+
+	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified X coord.
+	The result satisfies the following equation:
+	(*this + Result * (a_OtherEnd - *this)).x = a_X
+	If the line is too close to being parallel, this function returns NO_INTERSECTION
+	*/
+	inline double LineCoeffToYZPlane(const Vector3<T> & a_OtherEnd, T a_X) const
+	{
+		if (abs(x - a_OtherEnd.x) < EPS)
+		{
+			return NO_INTERSECTION;
+		}
+
+		return (a_X - x) / (a_OtherEnd.x - x);
+	}
+
+	/** The max difference between two coords for which the coords are assumed equal. */
+	static const double EPS;
+
+	/** Return value of LineCoeffToPlane() if the line is parallel to the plane. */
+	static const double NO_INTERSECTION;
+
+};
+// tolua_end
+
+
+
+
+
+template <typename T>
+const double Vector3<T>::EPS = 0.000001;
+
+template <typename T>
+const double Vector3<T>::NO_INTERSECTION = 1e70;
+
+
+
+
+
+// tolua_begin
+typedef Vector3<double> Vector3d;
+typedef Vector3<float>  Vector3f;
+typedef Vector3<int>    Vector3i;
+// tolua_end
+
+
+
+
+
+typedef std::list<Vector3i>   cVector3iList;
+typedef std::vector<Vector3i> cVector3iArray;
+
+
+
+
+
+
diff --git a/src/Vector3d.cpp b/src/Vector3d.cpp
deleted file mode 100644
index 96ebebab5..000000000
--- a/src/Vector3d.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Vector3d.h"
-#include "Vector3f.h"
-
-
-
-
-
-const double Vector3d::EPS = 0.000001;          ///< The max difference between two coords for which the coords are assumed equal
-const double Vector3d::NO_INTERSECTION = 1e70;  ///< Return value of LineCoeffToPlane() if the line is parallel to the plane
-
-
-
-
-
-Vector3d::Vector3d(const Vector3f & v) :
-	x(v.x),
-	y(v.y),
-	z(v.z)
-{
-}
-
-
-
-
-
-Vector3d::Vector3d(const Vector3f * v) :
-	x(v->x),
-	y(v->y),
-	z(v->z)
-{
-}
-
-
-
-
-
-double Vector3d::LineCoeffToXYPlane(const Vector3d & a_OtherEnd, double a_Z) const
-{
-	if (abs(z - a_OtherEnd.z) < EPS)
-	{
-		return NO_INTERSECTION;
-	}
-	return (a_Z - z) / (a_OtherEnd.z - z);
-}
-
-
-
-
-
-double Vector3d::LineCoeffToXZPlane(const Vector3d & a_OtherEnd, double a_Y) const
-{
-	if (abs(y - a_OtherEnd.y) < EPS)
-	{
-		return NO_INTERSECTION;
-	}
-	return (a_Y - y) / (a_OtherEnd.y - y);
-}
-
-
-
-
-
-double Vector3d::LineCoeffToYZPlane(const Vector3d & a_OtherEnd, double a_X) const
-{
-	if (abs(x - a_OtherEnd.x) < EPS)
-	{
-		return NO_INTERSECTION;
-	}
-	return (a_X - x) / (a_OtherEnd.x - x);
-}
-
-
-
-
diff --git a/src/Vector3d.h b/src/Vector3d.h
deleted file mode 100644
index a06a17c09..000000000
--- a/src/Vector3d.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-class Vector3f;
-
-
-
-// tolua_begin
-
-class Vector3d
-{
-public:
-	// convert from float
-	Vector3d(const Vector3f & v);
-	Vector3d(const Vector3f * v);
-
-	Vector3d() : x(0), y(0), z(0) {}
-	Vector3d(double a_x, double a_y, double a_z) : x(a_x), y(a_y), z(a_z) {}
-
-	inline void Set(double a_x, double a_y, double a_z) { x = a_x, y = a_y, z = a_z; }
-	inline void Normalize() { double l = 1.0f / Length(); x *= l; y *= l; z *= l; }
-	inline Vector3d NormalizeCopy() { double l = 1.0f / Length(); return Vector3d( x * l, y * l, z * l ); }
-	inline void NormalizeCopy(Vector3d & a_V) { double l = 1.0f / Length(); a_V.Set(x*l, y*l, z*l ); }
-	inline double Length() const { return (double)sqrt( x * x + y * y + z * z ); }
-	inline double SqrLength() const { return x * x + y * y + z * z; }
-	inline double Dot( const Vector3d & a_V ) const { return x * a_V.x + y * a_V.y + z * a_V.z; }
-	inline Vector3d Cross( const Vector3d & v ) const { return Vector3d( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
-	
-	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Z coord
-	The result satisfies the following equation:
-	(*this + Result * (a_OtherEnd - *this)).z = a_Z
-	If the line is too close to being parallel, this function returns NO_INTERSECTION
-	*/
-	double LineCoeffToXYPlane(const Vector3d & a_OtherEnd, double a_Z) const;
-
-	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Y coord
-	The result satisfies the following equation:
-	(*this + Result * (a_OtherEnd - *this)).y = a_Y
-	If the line is too close to being parallel, this function returns NO_INTERSECTION
-	*/
-	double LineCoeffToXZPlane(const Vector3d & a_OtherEnd, double a_Y) const;
-
-	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified X coord
-	The result satisfies the following equation:
-	(*this + Result * (a_OtherEnd - *this)).x = a_X
-	If the line is too close to being parallel, this function returns NO_INTERSECTION
-	*/
-	double LineCoeffToYZPlane(const Vector3d & a_OtherEnd, double a_X) const;
-
-	inline bool Equals(const Vector3d & v) const { return ((x == v.x) && (y == v.y) && (z == v.z)); }
-	
-	// tolua_end
-
-	void operator += ( const Vector3d& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
-	void operator += ( Vector3d* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
-	void operator -= ( const Vector3d& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
-	void operator -= ( Vector3d* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
-	void operator *= ( double a_f ) { x *= a_f; y *= a_f; z *= a_f; }
-
-	// tolua_begin
-	
-	Vector3d operator + (const Vector3d & v2) const { return Vector3d(x + v2.x, y + v2.y, z + v2.z ); }
-	Vector3d operator + (const Vector3d * v2) const { return Vector3d(x + v2->x, y + v2->y, z + v2->z ); }
-	Vector3d operator - (const Vector3d & v2) const { return Vector3d(x - v2.x, y - v2.y, z - v2.z ); }
-	Vector3d operator - (const Vector3d * v2) const { return Vector3d(x - v2->x, y - v2->y, z - v2->z ); }
-	Vector3d operator * (const double f)      const { return Vector3d(x * f, y * f, z * f ); }
-	Vector3d operator * (const Vector3d & v2) const { return Vector3d(x * v2.x, y * v2.y, z * v2.z ); }
-	Vector3d operator / (const double f)      const { return Vector3d(x / f, y / f, z / f ); }
-
-	double x, y, z;
-
-	static const double EPS;              ///< The max difference between two coords for which the coords are assumed equal
-	static const double NO_INTERSECTION;  ///< Return value of LineCoeffToPlane() if the line is parallel to the plane
-} ;
-
-// tolua_end
-
-
-
-
diff --git a/src/Vector3f.cpp b/src/Vector3f.cpp
deleted file mode 100644
index 59d71d371..000000000
--- a/src/Vector3f.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Vector3f.h"
-#include "Vector3d.h"
-#include "Vector3i.h"
-
-Vector3f::Vector3f( const Vector3d & v )
-	: x( (float)v.x )
-	, y( (float)v.y )
-	, z( (float)v.z )
-{
-}
-
-Vector3f::Vector3f( const Vector3d * v )
-	: x( (float)v->x )
-	, y( (float)v->y )
-	, z( (float)v->z )
-{
-}
-
-Vector3f::Vector3f( const Vector3i & v )
-	: x( (float)v.x )
-	, y( (float)v.y )
-	, z( (float)v.z )
-{
-}
-
-Vector3f::Vector3f( const Vector3i * v )
-	: x( (float)v->x )
-	, y( (float)v->y )
-	, z( (float)v->z )
-{
-}
\ No newline at end of file
diff --git a/src/Vector3f.h b/src/Vector3f.h
deleted file mode 100644
index adb154ad7..000000000
--- a/src/Vector3f.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-class Vector3i;
-class Vector3d;
-class Vector3f	// tolua_export
-{				// tolua_export
-public:			// tolua_export
-	Vector3f( const Vector3d & v );	// tolua_export
-	Vector3f( const Vector3d * v );	// tolua_export
-	Vector3f( const Vector3i & v );	// tolua_export
-	Vector3f( const Vector3i * v );	// tolua_export
-
-
-	Vector3f() : x(0), y(0), z(0) {}																			// tolua_export
-	Vector3f(float a_x, float a_y, float a_z) : x(a_x), y(a_y), z(a_z) {}										// tolua_export
-
-	inline void Set(float a_x, float a_y, float a_z) { x = a_x, y = a_y, z = a_z; }								// tolua_export
-	inline void Normalize() { float l = 1.0f / Length(); x *= l; y *= l; z *= l; }								// tolua_export
-	inline Vector3f NormalizeCopy() const { float l = 1.0f / Length(); return Vector3f( x * l, y * l, z * l ); }// tolua_export
-	inline void NormalizeCopy(Vector3f & a_V) const { float l = 1.0f / Length(); a_V.Set(x*l, y*l, z*l ); }		// tolua_export
-	inline float Length() const { return (float)sqrtf( x * x + y * y + z * z ); }								// tolua_export
-	inline float SqrLength() const { return x * x + y * y + z * z; }											// tolua_export
-	inline float Dot( const Vector3f & a_V ) const { return x * a_V.x + y * a_V.y + z * a_V.z; }				// tolua_export
-	inline Vector3f Cross( const Vector3f & v ) const { return Vector3f( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }	// tolua_export
-
-	inline bool Equals( const Vector3f & v ) const { return (x == v.x && y == v.y && z == v.z ); }										// tolua_export
-
-	void operator += ( const Vector3f& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
-	void operator += ( Vector3f* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
-	void operator -= ( const Vector3f& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
-	void operator -= ( Vector3f* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
-	void operator *= ( float a_f ) { x *= a_f; y *= a_f; z *= a_f; }
-	void operator *= ( Vector3f* a_V ) { x *= a_V->x; y *= a_V->y; z *= a_V->z; }
-	void operator *= ( const Vector3f& a_V ) { x *= a_V.x; y *= a_V.y; z *= a_V.z; }
-
-	Vector3f operator + ( const Vector3f& v2 ) const { return Vector3f( x + v2.x, y + v2.y, z + v2.z ); }									// tolua_export
-	Vector3f operator + ( const Vector3f* v2 ) const { return Vector3f( x + v2->x, y + v2->y, z + v2->z ); }								// tolua_export
-	Vector3f operator - ( const Vector3f& v2 ) const { return Vector3f( x - v2.x, y - v2.y, z - v2.z ); }									// tolua_export
-	Vector3f operator - ( const Vector3f* v2 ) const { return Vector3f( x - v2->x, y - v2->y, z - v2->z ); }								// tolua_export
-	Vector3f operator * ( const float f ) const { return Vector3f( x * f, y * f, z * f ); }												// tolua_export
-	Vector3f operator * ( const Vector3f& v2 ) const { return Vector3f( x * v2.x, y * v2.y, z * v2.z ); }									// tolua_export
-
-	float x, y, z;	// tolua_export
-
-};// tolua_export
diff --git a/src/Vector3i.cpp b/src/Vector3i.cpp
deleted file mode 100644
index 4ce1e2cf3..000000000
--- a/src/Vector3i.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Vector3i.h"
-#include "Vector3d.h"
-
-
-
-
-
-Vector3i::Vector3i( const Vector3d & v )
-	: x( (int)v.x )
-	, y( (int)v.y )
-	, z( (int)v.z )
-{
-}
\ No newline at end of file
diff --git a/src/Vector3i.h b/src/Vector3i.h
deleted file mode 100644
index 7d726a7b3..000000000
--- a/src/Vector3i.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-class Vector3d;
-class Vector3i	// tolua_export
-{				// tolua_export
-public:			// tolua_export
-	Vector3i( const Vector3d & v );														// tolua_export
-
-	Vector3i() : x(0), y(0), z(0) {}													// tolua_export
-	Vector3i(int a_x, int a_y, int a_z) : x(a_x), y(a_y), z(a_z) {}						// tolua_export
-
-	inline void Set(int a_x, int a_y, int a_z) { x = a_x, y = a_y, z = a_z; }			// tolua_export
-	inline float Length() const { return sqrtf( (float)( x * x + y * y + z * z) ); }	// tolua_export
-	inline int SqrLength() const { return x * x + y * y + z * z; }						// tolua_export
-
-	inline bool Equals( const Vector3i & v ) const { return (x == v.x && y == v.y && z == v.z ); }		// tolua_export
-	inline bool Equals( const Vector3i * v ) const { return (x == v->x && y == v->y && z == v->z ); }	// tolua_export
-
-	void operator += ( const Vector3i& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
-	void operator += ( Vector3i* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
-	void operator -= ( const Vector3i& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
-	void operator -= ( Vector3i* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
-	void operator *= ( int a_f ) { x *= a_f; y *= a_f; z *= a_f; }
-
-	friend Vector3i operator + ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z ); }
-	friend Vector3i operator + ( const Vector3i& v1, Vector3i* v2 ) { return Vector3i( v1.x + v2->x, v1.y + v2->y, v1.z + v2->z ); }
-	friend Vector3i operator - ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z ); }
-	friend Vector3i operator - ( const Vector3i& v1, Vector3i* v2 ) { return Vector3i( v1.x - v2->x, v1.y - v2->y, v1.z - v2->z ); }
-	friend Vector3i operator - ( const Vector3i* v1, Vector3i& v2 ) { return Vector3i( v1->x - v2.x, v1->y - v2.y, v1->z - v2.z ); }
-	friend Vector3i operator * ( const Vector3i& v, const int f ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }
-	friend Vector3i operator * ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x * v2.x, v1.y * v2.y, v1.z * v2.z ); }
-	friend Vector3i operator * ( const int f, const Vector3i& v ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }
-	friend bool operator < ( const Vector3i& v1, const Vector3i& v2 ) { return (v1.x<v2.x)||(v1.x==v2.x && v1.y<v2.y)||(v1.x==v2.x && v1.y == v2.y && v1.z<v2.z); }
-
-	int x, y, z;	// tolua_export
-};	// tolua_export
-
-typedef std::list<Vector3i>   cVector3iList;
-typedef std::vector<Vector3i> cVector3iArray;
-
-
-
-
diff --git a/src/WebAdmin.cpp b/src/WebAdmin.cpp
index e6a5a01b3..cd141f7eb 100644
--- a/src/WebAdmin.cpp
+++ b/src/WebAdmin.cpp
@@ -42,6 +42,7 @@ public:
 
 cWebAdmin::cWebAdmin(void) :
 	m_IsInitialized(false),
+	m_IsRunning(false),
 	m_TemplateScript("<webadmin_template>")
 {
 }
@@ -52,29 +53,26 @@ cWebAdmin::cWebAdmin(void) :
 
 cWebAdmin::~cWebAdmin()
 {
-	if (m_IsInitialized)
-	{
-		LOGD("Stopping WebAdmin...");
-	}
+	ASSERT(!m_IsRunning);  // Was the HTTP server stopped properly?
 }
 
 
 
 
 
-void cWebAdmin::AddPlugin( cWebPlugin * a_Plugin )
+void cWebAdmin::AddPlugin(cWebPlugin * a_Plugin)
 {
-	m_Plugins.remove( a_Plugin );
-	m_Plugins.push_back( a_Plugin );
+	m_Plugins.remove(a_Plugin);
+	m_Plugins.push_back(a_Plugin);
 }
 
 
 
 
 
-void cWebAdmin::RemovePlugin( cWebPlugin * a_Plugin )
+void cWebAdmin::RemovePlugin(cWebPlugin * a_Plugin)
 {
-	m_Plugins.remove( a_Plugin );
+	m_Plugins.remove(a_Plugin);
 }
 
 
@@ -87,7 +85,8 @@ bool cWebAdmin::Init(void)
 	{
 		LOGWARN("Regenerating webadmin.ini, all settings will be reset");
 		m_IniFile.AddHeaderComment(" This file controls the webadmin feature of MCServer");
-		m_IniFile.AddHeaderComment(" Username format: [User:*username*] | Password format: Password=*password*; for example:");
+		m_IniFile.AddHeaderComment(" Username format: [User:*username*]");
+		m_IniFile.AddHeaderComment(" Password format: Password=*password*; for example:");
 		m_IniFile.AddHeaderComment(" [User:admin]");
 		m_IniFile.AddHeaderComment(" Password=admin");
 	}
@@ -128,13 +127,31 @@ bool cWebAdmin::Start(void)
 
 	// Initialize the WebAdmin template script and load the file
 	m_TemplateScript.Create();
+	m_TemplateScript.RegisterAPILibs();
 	if (!m_TemplateScript.LoadFile(FILE_IO_PREFIX "webadmin/template.lua"))
 	{
 		LOGWARN("Could not load WebAdmin template \"%s\", using default template.", FILE_IO_PREFIX "webadmin/template.lua");
 		m_TemplateScript.Close();
 	}
 
-	return m_HTTPServer.Start(*this);
+	m_IsRunning = m_HTTPServer.Start(*this);
+	return m_IsRunning;
+}
+
+
+
+
+
+void cWebAdmin::Stop(void)
+{
+	if (!m_IsRunning)
+	{
+		return;
+	}
+	
+	LOGD("Stopping WebAdmin...");
+	m_HTTPServer.Stop();
+	m_IsRunning = false;
 }
 
 
@@ -473,7 +490,7 @@ void cWebAdmin::OnRequestBegun(cHTTPConnection & a_Connection, cHTTPRequest & a_
 
 
 
-void cWebAdmin::OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size)
+void cWebAdmin::OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, size_t a_Size)
 {
 	UNUSED(a_Connection);
 	cRequestData * Data = (cRequestData *)(a_Request.GetUserData());
@@ -520,7 +537,7 @@ void cWebAdmin::OnRequestFinished(cHTTPConnection & a_Connection, cHTTPRequest &
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cWebAdmin::cWebadminRequestData
 
-void cWebAdmin::cWebadminRequestData::OnBody(const char * a_Data, int a_Size)
+void cWebAdmin::cWebadminRequestData::OnBody(const char * a_Data, size_t a_Size)
 {
 	m_Form.Parse(a_Data, a_Size);
 }
diff --git a/src/WebAdmin.h b/src/WebAdmin.h
index 3eb807640..d5e45828f 100644
--- a/src/WebAdmin.h
+++ b/src/WebAdmin.h
@@ -56,13 +56,13 @@ struct HTTPRequest
 	AString Username;
 	// tolua_end
 
-	/// Parameters given in the URL, after the questionmark
+	/** Parameters given in the URL, after the questionmark */
 	StringStringMap Params;     // >> EXPORTED IN MANUALBINDINGS <<
 
-	/// Parameters posted as a part of a form - either in the URL (GET method) or in the body (POST method)
+	/** Parameters posted as a part of a form - either in the URL (GET method) or in the body (POST method) */
 	StringStringMap PostParams; // >> EXPORTED IN MANUALBINDINGS <<
 
-	/// Same as PostParams
+	/** Same as PostParams */
 	FormDataMap FormData;       // >> EXPORTED IN MANUALBINDINGS <<
 } ; // tolua_export
 
@@ -107,14 +107,17 @@ public:
 	cWebAdmin(void);
 	virtual ~cWebAdmin();
 
-	/// Initializes the object. Returns true if successfully initialized and ready to start
+	/** Initializes the object. Returns true if successfully initialized and ready to start */
 	bool Init(void);
 
-	/// Starts the HTTP server taking care of the admin. Returns true if successful
+	/** Starts the HTTP server taking care of the admin. Returns true if successful */
 	bool Start(void);
+	
+	/** Stops the HTTP server, if it was started. */
+	void Stop(void);
 
-	void AddPlugin( cWebPlugin* a_Plugin );
-	void RemovePlugin( cWebPlugin* a_Plugin );
+	void AddPlugin(cWebPlugin * a_Plugin);
+	void RemovePlugin(cWebPlugin * a_Plugin);
 
 	// TODO: Convert this to the auto-locking callback mechanism used for looping players in worlds and such
 	PluginList GetPlugins() const { return m_Plugins; } // >> EXPORTED IN MANUALBINDINGS <<
@@ -123,13 +126,13 @@ public:
 
 	sWebAdminPage GetPage(const HTTPRequest & a_Request);
 
-	/// Returns the contents of the default page - the list of plugins and players
+	/** Returns the contents of the default page - the list of plugins and players */
 	AString GetDefaultPage(void);
 
-	/// Returns the prefix needed for making a link point to the webadmin root from the given URL ("../../../webadmin"-style)
+	/** Returns the prefix needed for making a link point to the webadmin root from the given URL ("../../../webadmin"-style) */
 	AString GetBaseURL(const AString & a_URL);
 
-	/// Escapes text passed into it, so it can be embedded into html.
+	/** Escapes text passed into it, so it can be embedded into html. */
 	static AString GetHTMLEscapedString(const AString & a_Input);
 
 	AString GetIPv4Ports(void) const { return m_PortsIPv4; }
@@ -137,21 +140,21 @@ public:
 
 	// tolua_end
 
-	/// Returns the prefix needed for making a link point to the webadmin root from the given URL ("../../../webadmin"-style)
+	/** Returns the prefix needed for making a link point to the webadmin root from the given URL ("../../../webadmin"-style) */
 	AString GetBaseURL(const AStringVector& a_URLSplit);
 
 protected:
-	/// Common base class for request body data handlers
+	/** Common base class for request body data handlers */
 	class cRequestData
 	{
 	public:
 		virtual ~cRequestData() {}  // Force a virtual destructor in all descendants
 
-		/// Called when a new chunk of body data is received
-		virtual void OnBody(const char * a_Data, int a_Size) = 0;
+		/** Called when a new chunk of body data is received */
+		virtual void OnBody(const char * a_Data, size_t a_Size) = 0;
 	} ;
 
-	/// The body handler for requests in the "/webadmin" and "/~webadmin" paths
+	/** The body handler for requests in the "/webadmin" and "/~webadmin" paths */
 	class cWebadminRequestData :
 		public cRequestData,
 		public cHTTPFormParser::cCallbacks
@@ -166,14 +169,14 @@ protected:
 		}
 
 		// cRequestData overrides:
-		virtual void OnBody(const char * a_Data, int a_Size) override;
+		virtual void OnBody(const char * a_Data, size_t a_Size) override;
 
 		// cHTTPFormParser::cCallbacks overrides. Files are ignored:
-		virtual void OnFileStart(cHTTPFormParser &, const AString & a_FileName) override 
+		virtual void OnFileStart(cHTTPFormParser &, const AString & a_FileName) override
 		{
 			UNUSED(a_FileName);
 		}
-		virtual void OnFileData(cHTTPFormParser &, const char * a_Data, int a_Size) override 
+		virtual void OnFileData(cHTTPFormParser &, const char * a_Data, size_t a_Size) override
 		{
 			UNUSED(a_Data);
 			UNUSED(a_Size);
@@ -182,10 +185,13 @@ protected:
 	} ;
 
 
-	/// Set to true if Init() succeeds and the webadmin isn't to be disabled
+	/** Set to true if Init() succeeds and the webadmin isn't to be disabled */
 	bool m_IsInitialized;
+	
+	/** Set to true if Start() succeeds in starting the server, reset back to false in Stop(). */
+	bool m_IsRunning;
 
-	/// The webadmin.ini file, used for the settings and allowed logins
+	/** The webadmin.ini file, used for the settings and allowed logins */
 	cIniFile   m_IniFile;
 
 	PluginList m_Plugins;
@@ -193,24 +199,24 @@ protected:
 	AString m_PortsIPv4;
 	AString m_PortsIPv6;
 
-	/// The Lua template script to provide templates:
+	/** The Lua template script to provide templates: */
 	cLuaState m_TemplateScript;
 
-	/// The HTTP server which provides the underlying HTTP parsing, serialization and events
+	/** The HTTP server which provides the underlying HTTP parsing, serialization and events */
 	cHTTPServer m_HTTPServer;
 
 
 	AString GetTemplate(void);
 
-	/// Handles requests coming to the "/webadmin" or "/~webadmin" URLs
+	/** Handles requests coming to the "/webadmin" or "/~webadmin" URLs */
 	void HandleWebadminRequest(cHTTPConnection & a_Connection, cHTTPRequest & a_Request);
 
-	/// Handles requests for the root page
+	/** Handles requests for the root page */
 	void HandleRootRequest(cHTTPConnection & a_Connection, cHTTPRequest & a_Request);
 
 	// cHTTPServer::cCallbacks overrides:
 	virtual void OnRequestBegun   (cHTTPConnection & a_Connection, cHTTPRequest & a_Request) override;
-	virtual void OnRequestBody    (cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size) override;
+	virtual void OnRequestBody    (cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, size_t a_Size) override;
 	virtual void OnRequestFinished(cHTTPConnection & a_Connection, cHTTPRequest & a_Request) override;
 } ; // tolua_export
 
diff --git a/src/World.cpp b/src/World.cpp
index 5e9f4a38a..c188fd522 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -1,4 +1,3 @@
-
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "BlockID.h"
@@ -13,6 +12,9 @@
 #include "Generating/ChunkDesc.h"
 #include "OSSupport/Timer.h"
 
+// Serializers
+#include "WorldStorage/ScoreboardSerializer.h"
+
 // Entities (except mobs):
 #include "Entities/ExpOrb.h"
 #include "Entities/FallingBlock.h"
@@ -21,14 +23,18 @@
 #include "Entities/Player.h"
 #include "Entities/TNTEntity.h"
 
+#include "BlockEntities/CommandBlockEntity.h"
+
 // Simulators:
 #include "Simulator/SimulatorManager.h"
 #include "Simulator/FloodyFluidSimulator.h"
 #include "Simulator/FluidSimulator.h"
 #include "Simulator/FireSimulator.h"
 #include "Simulator/NoopFluidSimulator.h"
+#include "Simulator/NoopRedstoneSimulator.h"
 #include "Simulator/SandSimulator.h"
-#include "Simulator/RedstoneSimulator.h"
+#include "Simulator/IncrementalRedstoneSimulator.h"
+#include "Simulator/VanillaFluidSimulator.h"
 #include "Simulator/VaporizeFluidSimulator.h"
 
 // Mobs:
@@ -40,7 +46,6 @@
 #include "Generating/Trees.h"
 #include "Bindings/PluginManager.h"
 #include "Blocks/BlockHandler.h"
-#include "Vector3d.h"
 
 #include "Tracer.h"
 
@@ -55,9 +60,6 @@
 
 
 
-/// Up to this many m_SpreadQueue elements are handled each world tick
-const int MAX_LIGHTING_SPREAD_PER_TICK = 10;
-
 const int TIME_SUNSET        = 12000;
 const int TIME_NIGHT_START   = 13187;
 const int TIME_NIGHT_END     = 22812;
@@ -97,7 +99,7 @@ protected:
 	{
 		for (;;)
 		{
-			LOG("%d chunks to load, %d chunks to generate", 
+			LOG("" SIZE_T_FMT  " chunks to load, %d chunks to generate", 
 				m_World->GetStorage().GetLoadQueueLength(),
 				m_World->GetGenerator().GetQueueLength()
 			);
@@ -149,7 +151,7 @@ protected:
 	{
 		for (;;)
 		{
-			LOG("%d chunks remaining to light", m_Lighting->GetQueueLength()
+			LOG("" SIZE_T_FMT  " chunks remaining to light", m_Lighting->GetQueueLength()
 			);
 			
 			// Wait for 2 sec, but be "reasonably wakeable" when the thread is to finish
@@ -231,7 +233,11 @@ cWorld::cWorld(const AString & a_WorldName) :
 	m_WorldName(a_WorldName),
 	m_IniFileName(m_WorldName + "/world.ini"),
 	m_StorageSchema("Default"),
+#ifdef __arm__
+	m_StorageCompressionFactor(0),
+#else
 	m_StorageCompressionFactor(6),
+#endif
 	m_IsSpawnExplicitlySet(false),
 	m_WorldAgeSecs(0),
 	m_TimeOfDaySecs(0),
@@ -241,12 +247,18 @@ cWorld::cWorld(const AString & a_WorldName) :
 	m_SkyDarkness(0),
 	m_Weather(eWeather_Sunny),
 	m_WeatherInterval(24000),  // Guaranteed 1 day of sunshine at server start :)
+	m_Scoreboard(this),
+	m_MapManager(this),
 	m_GeneratorCallbacks(*this),
 	m_TickThread(*this)
 {
 	LOGD("cWorld::cWorld(\"%s\")", a_WorldName.c_str());
 
 	cFile::CreateFolder(FILE_IO_PREFIX + m_WorldName);
+
+	// Load the scoreboard
+	cScoreboardSerializer Serializer(m_WorldName, &m_Scoreboard);
+	Serializer.Load();
 }
 
 
@@ -266,6 +278,12 @@ cWorld::~cWorld()
 	
 	m_Storage.WaitForFinish();
 
+	// Unload the scoreboard
+	cScoreboardSerializer Serializer(m_WorldName, &m_Scoreboard);
+	Serializer.Save();
+
+	m_MapManager.SaveMapData();
+
 	delete m_ChunkMap;
 }
 
@@ -282,25 +300,52 @@ void cWorld::CastThunderbolt (int a_BlockX, int a_BlockY, int a_BlockZ)
 
 
 
+int cWorld::GetDefaultWeatherInterval(eWeather a_Weather)
+{
+	switch (a_Weather)
+	{
+		case eWeather_Sunny:
+		{
+			return 14400 + (m_TickRand.randInt() % 4800);  // 12 - 16 minutes
+		}
+		case eWeather_Rain:
+		{
+			return 9600 + (m_TickRand.randInt() % 7200);   // 8 - 14 minutes
+		}
+		case eWeather_ThunderStorm:
+		{
+			return 2400 + (m_TickRand.randInt() % 4800);   // 2 - 6 minutes
+		}
+		default:
+		{
+			LOGWARNING("%s: Missing default weather interval for weather %d.", __FUNCTION__, a_Weather);
+			return -1;
+		}
+	}  // switch (Weather)
+}
+
+
+
+
+
 void cWorld::SetWeather(eWeather a_NewWeather)
 {
 	// Do the plugins agree? Do they want a different weather?
-	cRoot::Get()->GetPluginManager()->CallHookWeatherChanging(*this, a_NewWeather);
+	if (cRoot::Get()->GetPluginManager()->CallHookWeatherChanging(*this, a_NewWeather))
+	{
+		m_WeatherInterval = GetDefaultWeatherInterval(m_Weather);
+		return;
+	}
 	
 	// Set new period for the selected weather:
-	switch (a_NewWeather)
+	m_WeatherInterval = GetDefaultWeatherInterval(a_NewWeather);
+	
+	// The weather can't be found:
+	if (m_WeatherInterval < 0)
 	{
-		case eWeather_Sunny:        m_WeatherInterval = 14400 + (m_TickRand.randInt() % 4800); break;  // 12 - 16 minutes
-		case eWeather_Rain:         m_WeatherInterval =  9600 + (m_TickRand.randInt() % 7200); break;  //  8 - 14 minutes
-		case eWeather_ThunderStorm: m_WeatherInterval =  2400 + (m_TickRand.randInt() % 4800); break;  //  2 - 6 minutes
-		default:
-		{
-			LOGWARNING("Requested unknown weather %d, setting sunny for a minute instead.", a_NewWeather);
-			a_NewWeather = eWeather_Sunny;
-			m_WeatherInterval = 1200;
-			break;
-		}
-	}  // switch (NewWeather)
+		return;
+	}
+	
 	m_Weather = a_NewWeather;
 	BroadcastWeather(m_Weather);
 	
@@ -512,26 +557,33 @@ void cWorld::Start(void)
 		m_SpawnZ = IniFile.GetValueF("SpawnPosition", "Z", m_SpawnZ);
 	}
 
-	m_StorageSchema             = IniFile.GetValueSet ("Storage",       "Schema",                    m_StorageSchema);
-	m_StorageCompressionFactor 	= IniFile.GetValueSetI ("Storage",       "CompressionFactor",                    m_StorageCompressionFactor);
-	m_MaxCactusHeight           = IniFile.GetValueSetI("Plants",        "MaxCactusHeight",           3);
-	m_MaxSugarcaneHeight        = IniFile.GetValueSetI("Plants",        "MaxSugarcaneHeight",        3);
-	m_IsCactusBonemealable      = IniFile.GetValueSetB("Plants",        "IsCactusBonemealable",      false);
-	m_IsCarrotsBonemealable     = IniFile.GetValueSetB("Plants",        "IsCarrotsBonemealable",     true);
-	m_IsCropsBonemealable       = IniFile.GetValueSetB("Plants",        "IsCropsBonemealable",       true);
-	m_IsGrassBonemealable       = IniFile.GetValueSetB("Plants",        "IsGrassBonemealable",       true);
-	m_IsMelonStemBonemealable   = IniFile.GetValueSetB("Plants",        "IsMelonStemBonemealable",   true);
-	m_IsMelonBonemealable       = IniFile.GetValueSetB("Plants",        "IsMelonBonemealable",       false);
-	m_IsPotatoesBonemealable    = IniFile.GetValueSetB("Plants",        "IsPotatoesBonemealable",    true);
-	m_IsPumpkinStemBonemealable = IniFile.GetValueSetB("Plants",        "IsPumpkinStemBonemealable", true);
-	m_IsPumpkinBonemealable     = IniFile.GetValueSetB("Plants",        "IsPumpkinBonemealable",     false);
-	m_IsSaplingBonemealable     = IniFile.GetValueSetB("Plants",        "IsSaplingBonemealable",     true);
-	m_IsSugarcaneBonemealable   = IniFile.GetValueSetB("Plants",        "IsSugarcaneBonemealable",   false);
-	m_bEnabledPVP               = IniFile.GetValueSetB("PVP",           "Enabled",                   true);
-	m_IsDeepSnowEnabled         = IniFile.GetValueSetB("Physics",       "DeepSnow",                  false);
-	m_ShouldLavaSpawnFire       = IniFile.GetValueSetB("Physics",       "ShouldLavaSpawnFire",       true);
-
-	m_GameMode = (eGameMode)IniFile.GetValueSetI("GameMode", "GameMode", m_GameMode);
+	m_StorageSchema               = IniFile.GetValueSet ("Storage",       "Schema",                      m_StorageSchema);
+	m_StorageCompressionFactor    = IniFile.GetValueSetI("Storage",       "CompressionFactor",           m_StorageCompressionFactor);
+	m_MaxCactusHeight             = IniFile.GetValueSetI("Plants",        "MaxCactusHeight",             3);
+	m_MaxSugarcaneHeight          = IniFile.GetValueSetI("Plants",        "MaxSugarcaneHeight",          3);
+	m_IsCactusBonemealable        = IniFile.GetValueSetB("Plants",        "IsCactusBonemealable",        false);
+	m_IsCarrotsBonemealable       = IniFile.GetValueSetB("Plants",        "IsCarrotsBonemealable",       true);
+	m_IsCropsBonemealable         = IniFile.GetValueSetB("Plants",        "IsCropsBonemealable",         true);
+	m_IsGrassBonemealable         = IniFile.GetValueSetB("Plants",        "IsGrassBonemealable",         true);
+	m_IsMelonStemBonemealable     = IniFile.GetValueSetB("Plants",        "IsMelonStemBonemealable",     true);
+	m_IsMelonBonemealable         = IniFile.GetValueSetB("Plants",        "IsMelonBonemealable",         false);
+	m_IsPotatoesBonemealable      = IniFile.GetValueSetB("Plants",        "IsPotatoesBonemealable",      true);
+	m_IsPumpkinStemBonemealable   = IniFile.GetValueSetB("Plants",        "IsPumpkinStemBonemealable",   true);
+	m_IsPumpkinBonemealable       = IniFile.GetValueSetB("Plants",        "IsPumpkinBonemealable",       false);
+	m_IsSaplingBonemealable       = IniFile.GetValueSetB("Plants",        "IsSaplingBonemealable",       true);
+	m_IsSugarcaneBonemealable     = IniFile.GetValueSetB("Plants",        "IsSugarcaneBonemealable",     false);
+	m_IsDeepSnowEnabled           = IniFile.GetValueSetB("Physics",       "DeepSnow",                    true);
+	m_ShouldLavaSpawnFire         = IniFile.GetValueSetB("Physics",       "ShouldLavaSpawnFire",         true);
+	int TNTShrapnelLevel          = IniFile.GetValueSetI("Physics",       "TNTShrapnelLevel",            (int)slNone);
+	m_bCommandBlocksEnabled       = IniFile.GetValueSetB("Mechanics",     "CommandBlocksEnabled",        false);
+	m_bEnabledPVP                 = IniFile.GetValueSetB("Mechanics",     "PVPEnabled",                  true);
+	m_bUseChatPrefixes            = IniFile.GetValueSetB("Mechanics",     "UseChatPrefixes",             true);
+	m_VillagersShouldHarvestCrops = IniFile.GetValueSetB("Monsters",      "VillagersShouldHarvestCrops", true);
+	int GameMode                  = IniFile.GetValueSetI("General",       "Gamemode",                    (int)m_GameMode);
+	
+	// Adjust the enum-backed variables into their respective bounds:
+	m_GameMode         = (eGameMode)     Clamp(GameMode,         (int)gmSurvival, (int)gmAdventure);
+	m_TNTShrapnelLevel = (eShrapnelLevel)Clamp(TNTShrapnelLevel, (int)slNone,     (int)slAll);
 
 	// Load allowed mobs:
 	const char * DefaultMonsters = "";
@@ -579,12 +631,11 @@ void cWorld::Start(void)
 	m_LavaSimulator     = InitializeFluidSimulator(IniFile, "Lava",  E_BLOCK_LAVA,  E_BLOCK_STATIONARY_LAVA);
 	m_SandSimulator     = new cSandSimulator(*this, IniFile);
 	m_FireSimulator     = new cFireSimulator(*this, IniFile);
-	m_RedstoneSimulator = new cRedstoneSimulator(*this);
+	m_RedstoneSimulator = InitializeRedstoneSimulator(IniFile);
 
-	// Water and Lava simulators get registered in InitializeFluidSimulator()
+	// Water, Lava and Redstone simulators get registered in their initialize function.
 	m_SimulatorManager->RegisterSimulator(m_SandSimulator, 1);
 	m_SimulatorManager->RegisterSimulator(m_FireSimulator, 1);
-	m_SimulatorManager->RegisterSimulator(m_RedstoneSimulator, 1);
 
 	m_Lighting.Start(this);
 	m_Storage.Start(this, m_StorageSchema, m_StorageCompressionFactor );
@@ -598,13 +649,13 @@ void cWorld::Start(void)
 	m_LastSpawnMonster.insert(std::map<cMonster::eFamily, Int64>::value_type(cMonster::mfAmbient, 0));
 	m_LastSpawnMonster.insert(std::map<cMonster::eFamily, Int64>::value_type(cMonster::mfWater, 0));
 
+	m_MapManager.LoadMapData();
 
 	// Save any changes that the defaults may have done to the ini file:
 	if (!IniFile.WriteFile(m_IniFileName))
 	{
 		LOGWARNING("Could not write world config to %s", m_IniFileName.c_str());
 	}
-
 }
 
 
@@ -615,7 +666,7 @@ void cWorld::GenerateRandomSpawn(void)
 {
 	LOGD("Generating random spawnpoint...");
 
-	while (IsBlockWater(GetBlock((int)m_SpawnX, GetHeight((int)m_SpawnX, (int)m_SpawnZ), (int)m_SpawnZ)))
+	while (IsBlockWaterOrIce(GetBlock((int)m_SpawnX, GetHeight((int)m_SpawnX, (int)m_SpawnZ), (int)m_SpawnZ)))
 	{
 		if ((GetTickRandomNumber(4) % 2) == 0) // Randomise whether to increment X or Z coords
 		{
@@ -699,19 +750,7 @@ void cWorld::Tick(float a_Dt, int a_LastTickDurationMSec)
 
 	TickWeather(a_Dt);
 
-	// Asynchronously set blocks:
-	sSetBlockList FastSetBlockQueueCopy;
-	{
-		cCSLock Lock(m_CSFastSetBlock);
-		std::swap(FastSetBlockQueueCopy, m_FastSetBlockQueue);
-	}
-	m_ChunkMap->FastSetBlocks(FastSetBlockQueueCopy);
-	if (!FastSetBlockQueueCopy.empty())
-	{
-		// Some blocks failed, store them for next tick:
-		cCSLock Lock(m_CSFastSetBlock);
-		m_FastSetBlockQueue.splice(m_FastSetBlockQueue.end(), FastSetBlockQueueCopy);
-	}
+	m_ChunkMap->FastSetQueuedBlocks();
 
 	if (m_WorldAge - m_LastSave > 60 * 5 * 20) // Save each 5 minutes
 	{
@@ -1157,6 +1196,24 @@ bool cWorld::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCom
 
 
 
+bool cWorld::DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback & a_Callback)
+{
+	return m_ChunkMap->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+}
+
+
+
+
+
+bool cWorld::DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback & a_Callback)
+{
+	return m_ChunkMap->DoWithFlowerPotAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+}
+
+
+
+
+
 bool cWorld::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4)
 {
 	return m_ChunkMap->GetSignLines(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4);
@@ -1199,10 +1256,12 @@ void cWorld::GrowTreeFromSapling(int a_X, int a_Y, int a_Z, NIBBLETYPE a_Sapling
 	sSetBlockVector Logs, Other;
 	switch (a_SaplingMeta & 0x07)
 	{
-		case E_META_SAPLING_APPLE:   GetAppleTreeImage  (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
-		case E_META_SAPLING_BIRCH:   GetBirchTreeImage  (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
-		case E_META_SAPLING_CONIFER: GetConiferTreeImage(a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
-		case E_META_SAPLING_JUNGLE:  GetJungleTreeImage (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
+		case E_META_SAPLING_APPLE:    GetAppleTreeImage  (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
+		case E_META_SAPLING_BIRCH:    GetBirchTreeImage  (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
+		case E_META_SAPLING_CONIFER:  GetConiferTreeImage(a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
+		case E_META_SAPLING_JUNGLE:   GetJungleTreeImage (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
+		case E_META_SAPLING_ACACIA:   GetAcaciaTreeImage (a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
+		case E_META_SAPLING_DARK_OAK: GetDarkoakTreeImage(a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), Logs, Other); break;
 	}
 	Other.insert(Other.begin(), Logs.begin(), Logs.end());
 	Logs.clear();
@@ -1217,7 +1276,7 @@ void cWorld::GrowTreeByBiome(int a_X, int a_Y, int a_Z)
 {
 	cNoise Noise(m_Generator.GetSeed());
 	sSetBlockVector Logs, Other;
-	GetTreeImageByBiome(a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), (EMCSBiome)GetBiomeAt(a_X, a_Z), Logs, Other);
+	GetTreeImageByBiome(a_X, a_Y, a_Z, Noise, (int)(m_WorldAge & 0xffffffff), GetBiomeAt(a_X, a_Z), Logs, Other);
 	Other.insert(Other.begin(), Logs.begin(), Logs.end());
 	Logs.clear();
 	GrowTreeImage(Other);
@@ -1470,7 +1529,7 @@ void cWorld::GrowSugarcane(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBl
 
 
 
-int cWorld::GetBiomeAt (int a_BlockX, int a_BlockZ)
+EMCSBiome cWorld::GetBiomeAt (int a_BlockX, int a_BlockZ)
 {
 	return m_ChunkMap->GetBiomeAt(a_BlockX, a_BlockZ);
 }
@@ -1479,86 +1538,44 @@ int cWorld::GetBiomeAt (int a_BlockX, int a_BlockZ)
 
 
 
-void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-{
-	if (a_BlockType == E_BLOCK_AIR)
-	{
-		BlockHandler(GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnDestroyed(this, a_BlockX, a_BlockY, a_BlockZ);
-	}
-	m_ChunkMap->SetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-
-	BlockHandler(a_BlockType)->OnPlaced(this, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-}
-
-
-
-
-
-void cWorld::FastSetBlock(int a_X, int a_Y, int a_Z, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+bool cWorld::SetBiomeAt(int a_BlockX, int a_BlockZ, EMCSBiome a_Biome)
 {
-	cCSLock Lock(m_CSFastSetBlock);
-	m_FastSetBlockQueue.push_back(sSetBlock(a_X, a_Y, a_Z, a_BlockType, a_BlockMeta)); 
+	return m_ChunkMap->SetBiomeAt(a_BlockX, a_BlockZ, a_Biome);
 }
 
 
 
 
 
-void cWorld::QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType)
+bool cWorld::SetAreaBiome(int a_MinX, int a_MaxX, int a_MinZ, int a_MaxZ, EMCSBiome a_Biome)
 {
-	m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, GetWorldAge() + a_TickDelay, a_PreviousBlockType);
+	return m_ChunkMap->SetAreaBiome(a_MinX, a_MaxX, a_MinZ, a_MaxZ, a_Biome);
 }
 
 
 
 
 
-BLOCKTYPE cWorld::GetBlock(int a_X, int a_Y, int a_Z)
+bool cWorld::SetAreaBiome(const cCuboid & a_Area, EMCSBiome a_Biome)
 {
-	// First check if it isn't queued in the m_FastSetBlockQueue:
-	{
-		int X = a_X, Y = a_Y, Z = a_Z;
-		int ChunkX, ChunkY, ChunkZ;
-		AbsoluteToRelative(X, Y, Z, ChunkX, ChunkY, ChunkZ);
-		
-		cCSLock Lock(m_CSFastSetBlock);
-		for (sSetBlockList::iterator itr = m_FastSetBlockQueue.begin(); itr != m_FastSetBlockQueue.end(); ++itr)
-		{
-			if ((itr->x == X) && (itr->y == Y) && (itr->z == Z) && (itr->ChunkX == ChunkX) && (itr->ChunkZ == ChunkZ))
-			{
-				return itr->BlockType;
-			}
-		}  // for itr - m_FastSetBlockQueue[]
-	}
-	
-	return m_ChunkMap->GetBlock(a_X, a_Y, a_Z);
+	return SetAreaBiome(
+		std::min(a_Area.p1.x, a_Area.p2.x), std::max(a_Area.p1.x, a_Area.p2.x),
+		std::min(a_Area.p1.z, a_Area.p2.z), std::max(a_Area.p1.z, a_Area.p2.z),
+		a_Biome
+	);
 }
 
 
 
 
 
-NIBBLETYPE cWorld::GetBlockMeta(int a_X, int a_Y, int a_Z)
+void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
-	// First check if it isn't queued in the m_FastSetBlockQueue:
-	{
-		cCSLock Lock(m_CSFastSetBlock);
-		for (sSetBlockList::iterator itr = m_FastSetBlockQueue.begin(); itr != m_FastSetBlockQueue.end(); ++itr)
-		{
-			if ((itr->x == a_X) && (itr->y == a_Y) && (itr->y == a_Y))
-			{
-				return itr->BlockMeta;
-			}
-		}  // for itr - m_FastSetBlockQueue[]
-	}
-	
-	return m_ChunkMap->GetBlockMeta(a_X, a_Y, a_Z);
+	m_ChunkMap->SetBlock(*this, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 }
 
 
 
-
-
 void cWorld::SetBlockMeta(int a_X, int a_Y, int a_Z, NIBBLETYPE a_MetaData)
 {
 	m_ChunkMap->SetBlockMeta(a_X, a_Y, a_Z, a_MetaData);
@@ -1619,7 +1636,7 @@ void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double
 	a_FlyAwaySpeed /= 100;  // Pre-divide, so that we don't have to divide each time inside the loop
 	for (cItems::const_iterator itr = a_Pickups.begin(); itr != a_Pickups.end(); ++itr)
 	{
-		if (!IsValidItem(itr->m_ItemType))
+		if (!IsValidItem(itr->m_ItemType) || itr->m_ItemType == E_BLOCK_AIR)
 		{
 			// Don't spawn pickup if item isn't even valid; should prevent client crashing too
 			continue;
@@ -1645,7 +1662,7 @@ void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double
 {
 	for (cItems::const_iterator itr = a_Pickups.begin(); itr != a_Pickups.end(); ++itr)
 	{
-		if (!IsValidItem(itr->m_ItemType))
+		if (!IsValidItem(itr->m_ItemType) || itr->m_ItemType == E_BLOCK_AIR)
 		{
 			continue;
 		}
@@ -1707,12 +1724,15 @@ int cWorld::SpawnMinecart(double a_X, double a_Y, double a_Z, int a_MinecartType
 
 
 
-void cWorld::SpawnPrimedTNT(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec, double a_InitialVelocityCoeff)
+void cWorld::SpawnPrimedTNT(double a_X, double a_Y, double a_Z, int a_FuseTicks, double a_InitialVelocityCoeff)
 {
-	UNUSED(a_InitialVelocityCoeff);
-	cTNTEntity * TNT = new cTNTEntity(a_X, a_Y, a_Z, a_FuseTimeInSec);
+	cTNTEntity * TNT = new cTNTEntity(a_X, a_Y, a_Z, a_FuseTicks);
 	TNT->Initialize(this);
-	// TODO: Add a bit of speed in horiz and vert axes, based on the a_InitialVelocityCoeff
+	TNT->SetSpeed(
+		a_InitialVelocityCoeff * (GetTickRandomNumber(2) - 1), /** -1, 0, 1 */
+		a_InitialVelocityCoeff * 2,
+		a_InitialVelocityCoeff * (GetTickRandomNumber(2) - 1)
+	);
 }
 
 
@@ -1739,8 +1759,9 @@ bool cWorld::GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure)
 
 bool cWorld::DigBlock(int a_X, int a_Y, int a_Z)
 {
-	cBlockHandler *Handler = cBlockHandler::GetBlockHandler(GetBlock(a_X, a_Y, a_Z));
-	Handler->OnDestroyed(this, a_X, a_Y, a_Z);
+	cBlockHandler * Handler = cBlockInfo::GetHandler(GetBlock(a_X, a_Y, a_Z));
+	cChunkInterface ChunkInterface(GetChunkMap());
+	Handler->OnDestroyed(ChunkInterface, *this, a_X, a_Y, a_Z);
 	return m_ChunkMap->DigBlock(a_X, a_Y, a_Z);
 }
 
@@ -1811,7 +1832,25 @@ void cWorld::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cons
 
 
 
-void cWorld::BroadcastChat(const AString & a_Message, const cClientHandle * a_Exclude)
+void cWorld::BroadcastChat(const AString & a_Message, const cClientHandle * a_Exclude, eMessageType a_ChatPrefix)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendChat(a_Message, a_ChatPrefix);
+	}
+}
+
+
+
+
+
+void cWorld::BroadcastChat(const cCompositeChat & a_Message, const cClientHandle * a_Exclude)
 {
 	cCSLock Lock(m_CSPlayers);
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
@@ -1981,6 +2020,60 @@ void cWorld::BroadcastRemoveEntityEffect(const cEntity & a_Entity, int a_EffectI
 
 
 
+void cWorld::BroadcastScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendScoreboardObjective(a_Name, a_DisplayName, a_Mode);
+	}
+}
+
+
+
+
+
+void cWorld::BroadcastScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendScoreUpdate(a_Objective, a_Player, a_Score, a_Mode);
+	}
+}
+
+
+
+
+
+void cWorld::BroadcastDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendDisplayObjective(a_Objective, a_Display);
+	}
+}
+
+
+
+
+
 void cWorld::BroadcastSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude)
 {
 	m_ChunkMap->BroadcastSoundEffect(a_SoundName, a_SrcX, a_SrcY, a_SrcZ, a_Volume, a_Pitch, a_Exclude);
@@ -2158,9 +2251,6 @@ void cWorld::SetChunkData(
 	{
 		m_ChunkSender.ChunkReady(a_ChunkX, a_ChunkZ);
 	}
-	
-	// Notify the lighting thread that the chunk has become valid (in case it is a neighbor of a postponed chunk):
-	m_Lighting.ChunkReady(a_ChunkX, a_ChunkZ);
 }
 
 
@@ -2226,6 +2316,15 @@ void cWorld::UnloadUnusedChunks(void)
 
 
 
+void cWorld::QueueUnloadUnusedChunks(void)
+{
+	QueueTask(new cWorld::cTaskUnloadUnusedChunks);
+}
+
+
+
+
+
 void cWorld::CollectPickupsByPlayer(cPlayer * a_Player)
 {
 	m_ChunkMap->CollectPickupsByPlayer(a_Player);
@@ -2352,22 +2451,27 @@ bool cWorld::FindAndDoWithPlayer(const AString & a_PlayerNameHint, cPlayerListCa
 
 
 // TODO: This interface is dangerous!
-cPlayer * cWorld::FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit)
+cPlayer * cWorld::FindClosestPlayer(const Vector3d & a_Pos, float a_SightLimit, bool a_CheckLineOfSight)
 {
 	cTracer LineOfSight(this);
 
-	float ClosestDistance = a_SightLimit;
-	cPlayer* ClosestPlayer = NULL;
+	double ClosestDistance = a_SightLimit;
+	cPlayer * ClosestPlayer = NULL;
 
 	cCSLock Lock(m_CSPlayers);
 	for (cPlayerList::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		Vector3f Pos = (*itr)->GetPosition();
-		float Distance = (Pos - a_Pos).Length();
+		double Distance = (Pos - a_Pos).Length();
 
 		if (Distance < ClosestDistance)
 		{
-			if (!LineOfSight.Trace(a_Pos,(Pos - a_Pos),(int)(Pos - a_Pos).Length()))
+			if (a_CheckLineOfSight && !LineOfSight.Trace(a_Pos,(Pos - a_Pos),(int)(Pos - a_Pos).Length()))
+			{
+				ClosestDistance = Distance;
+				ClosestPlayer = *itr;
+			}
+			else
 			{
 				ClosestDistance = Distance;
 				ClosestPlayer = *itr;
@@ -2471,6 +2575,16 @@ void cWorld::SendChunkTo(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client)
 
 
 
+void cWorld::ForceSendChunkTo(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client)
+{
+	a_Client->AddWantedChunk(a_ChunkX, a_ChunkZ);
+	m_ChunkSender.QueueSendChunkTo(a_ChunkX, a_ChunkZ, a_Client);
+}
+
+
+
+
+
 void cWorld::RemoveClientFromChunkSender(cClientHandle * a_Client)
 {
 	m_ChunkSender.RemoveClient(a_Client);
@@ -2547,9 +2661,63 @@ bool cWorld::UpdateSign(int a_BlockX, int a_BlockY, int a_BlockZ, const AString
 
 
 
-void cWorld::ChunksStay(const cChunkCoordsList & a_Chunks, bool a_Stay)
+bool cWorld::SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Command)
 {
-	m_ChunkMap->ChunksStay(a_Chunks, a_Stay);
+	class cUpdateCommandBlock : public cCommandBlockCallback
+	{
+		AString m_Command;
+	public:
+		cUpdateCommandBlock(const AString & a_Command) : m_Command(a_Command) {}
+			
+		virtual bool Item(cCommandBlockEntity * a_CommandBlock) override
+		{
+			a_CommandBlock->SetCommand(m_Command);
+			return false;
+		}
+	} CmdBlockCB (a_Command);
+
+	return DoWithCommandBlockAt(a_BlockX, a_BlockY, a_BlockZ, CmdBlockCB);
+}
+
+
+
+
+
+bool cWorld::IsTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	BLOCKTYPE Block;
+	NIBBLETYPE Meta;
+	GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, Block, Meta);
+	if (Block != E_BLOCK_TRAPDOOR)
+	{
+		return false;
+	}
+	
+	return (Meta & 0x4) > 0;
+}
+
+
+
+
+
+bool cWorld::SetTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ, bool a_Open)
+{
+	BLOCKTYPE Block;
+	NIBBLETYPE Meta;
+	GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, Block, Meta);
+	if (Block != E_BLOCK_TRAPDOOR)
+	{
+		return false;
+	}
+	
+	bool IsOpen = (Meta & 0x4) > 0;
+	if (a_Open != IsOpen)
+	{
+		SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta ^ 0x4);
+		BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+		return true;
+	}
+	return false;
 }
 
 
@@ -2813,9 +2981,9 @@ int cWorld::SpawnMobFinalize(cMonster * a_Monster)
 
 
 
-int cWorld::CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const Vector3d * a_Speed)
+int cWorld::CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem a_Item, const Vector3d * a_Speed)
 {
-	cProjectileEntity * Projectile = cProjectileEntity::Create(a_Kind, a_Creator, a_PosX, a_PosY, a_PosZ, a_Speed);
+	cProjectileEntity * Projectile = cProjectileEntity::Create(a_Kind, a_Creator, a_PosX, a_PosY, a_PosZ, a_Item, a_Speed);
 	if (Projectile == NULL)
 	{
 		return -1;
@@ -2825,7 +2993,6 @@ int cWorld::CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProje
 		delete Projectile;
 		return -1;
 	}
-	BroadcastSpawnEntity(*Projectile);
 	return Projectile->GetUniqueID();
 }
 
@@ -2838,19 +3005,49 @@ void cWorld::TabCompleteUserName(const AString & a_Text, AStringVector & a_Resul
 	cCSLock Lock(m_CSPlayers);
 	for (cPlayerList::iterator itr = m_Players.begin(), end = m_Players.end(); itr != end; ++itr)
 	{
-		size_t LastSpace = a_Text.find_last_of(" "); //Find the position of the last space
+		size_t LastSpace = a_Text.find_last_of(" "); // Find the position of the last space
 		
-		std::string LastWord = a_Text.substr(LastSpace + 1, a_Text.length()); //Find the last word
-		std::string PlayerName ((*itr)->GetName());
-		std::size_t Found = PlayerName.find(LastWord); //Try to find last word in playername
+		AString LastWord = a_Text.substr(LastSpace + 1, a_Text.length()); // Find the last word
+		AString PlayerName ((*itr)->GetName());
+		size_t Found = PlayerName.find(LastWord); // Try to find last word in playername
 		
-		if (Found!=0)
+		if (Found == AString::npos)
 		{
-			continue; //No match
+			continue; // No match
 		}
 		
-		a_Results.push_back((*itr)->GetName()); //Match!
+		a_Results.push_back(PlayerName); // Match!
+	}
+}
+
+
+
+
+
+cRedstoneSimulator * cWorld::InitializeRedstoneSimulator(cIniFile & a_IniFile)
+{
+	AString SimulatorName = a_IniFile.GetValueSet("Physics", "RedstoneSimulator", "");
+
+	if (SimulatorName.empty())
+	{
+		LOGWARNING("[Physics] RedstoneSimulator not present or empty in %s, using the default of \"incremental\".", GetIniFileName().c_str());
+		SimulatorName = "incremental";
+	}
+	
+	cRedstoneSimulator * res = NULL;
+
+	if (NoCaseCompare(SimulatorName, "incremental") == 0)
+	{
+		res = new cIncrementalRedstoneSimulator(*this);
+	}
+	else if (NoCaseCompare(SimulatorName, "noop") == 0)
+	{
+		res = new cRedstoneNoopSimulator(*this);
 	}
+	
+	m_SimulatorManager->RegisterSimulator(res, 1);
+	
+	return res;
 }
 
 
@@ -2866,8 +3063,8 @@ cFluidSimulator * cWorld::InitializeFluidSimulator(cIniFile & a_IniFile, const c
 	AString SimulatorName = a_IniFile.GetValueSet("Physics", SimulatorNameKey, "");
 	if (SimulatorName.empty())
 	{
-		LOGWARNING("[Physics] %s not present or empty in %s, using the default of \"Floody\".", SimulatorNameKey.c_str(), GetIniFileName().c_str());
-		SimulatorName = "Floody";
+		LOGWARNING("[Physics] %s not present or empty in %s, using the default of \"Vanilla\".", SimulatorNameKey.c_str(), GetIniFileName().c_str());
+		SimulatorName = "Vanilla";
 	}
 	
 	cFluidSimulator * res = NULL;
@@ -2891,15 +3088,24 @@ cFluidSimulator * cWorld::InitializeFluidSimulator(cIniFile & a_IniFile, const c
 	}
 	else
 	{
-		if (NoCaseCompare(SimulatorName, "floody") != 0)
-		{
-			// The simulator name doesn't match anything we have, issue a warning:
-			LOGWARNING("%s [Physics]:%s specifies an unknown simulator, using the default \"Floody\".", GetIniFileName().c_str(), SimulatorNameKey.c_str());
-		}
 		int Falloff               = a_IniFile.GetValueSetI(SimulatorSectionName, "Falloff",               IsWater ? 1 : 2);
 		int TickDelay             = a_IniFile.GetValueSetI(SimulatorSectionName, "TickDelay",             IsWater ? 5 : 30);
 		int NumNeighborsForSource = a_IniFile.GetValueSetI(SimulatorSectionName, "NumNeighborsForSource", IsWater ? 2 : -1);
-		res = new cFloodyFluidSimulator(*this, a_SimulateBlock, a_StationaryBlock, Falloff, TickDelay, NumNeighborsForSource);
+
+		if (NoCaseCompare(SimulatorName, "floody") == 0)
+		{
+			res = new cFloodyFluidSimulator(*this, a_SimulateBlock, a_StationaryBlock, Falloff, TickDelay, NumNeighborsForSource);
+		}
+		else if (NoCaseCompare(SimulatorName, "vanilla") == 0)
+		{
+			res = new cVanillaFluidSimulator(*this, a_SimulateBlock, a_StationaryBlock, Falloff, TickDelay, NumNeighborsForSource);
+		}
+		else
+		{
+			// The simulator name doesn't match anything we have, issue a warning:
+			LOGWARNING("%s [Physics]:%s specifies an unknown simulator, using the default \"Vanilla\".", GetIniFileName().c_str(), SimulatorNameKey.c_str());
+			res = new cVanillaFluidSimulator(*this, a_SimulateBlock, a_StationaryBlock, Falloff, TickDelay, NumNeighborsForSource);
+		}
 	}
 	
 	m_SimulatorManager->RegisterSimulator(res, Rate);
@@ -2910,6 +3116,8 @@ cFluidSimulator * cWorld::InitializeFluidSimulator(cIniFile & a_IniFile, const c
 
 
 
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cWorld::cTaskSaveAllChunks:
 
@@ -2923,6 +3131,18 @@ void cWorld::cTaskSaveAllChunks::Run(cWorld & a_World)
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cWorld::cTaskUnloadUnusedChunks
+
+void cWorld::cTaskUnloadUnusedChunks::Run(cWorld & a_World)
+{
+	a_World.UnloadUnusedChunks();
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cWorld::cChunkGeneratorCallbacks:
 
 cWorld::cChunkGeneratorCallbacks::cChunkGeneratorCallbacks(cWorld & a_World) :
diff --git a/src/World.h b/src/World.h
index 930d9d421..e08ef7f53 100644
--- a/src/World.h
+++ b/src/World.h
@@ -14,15 +14,18 @@
 #include "ChunkMap.h"
 #include "WorldStorage/WorldStorage.h"
 #include "Generating/ChunkGenerator.h"
-#include "Vector3i.h"
-#include "Vector3f.h"
+#include "Vector3.h"
 #include "ChunkSender.h"
 #include "Defines.h"
 #include "LightingThread.h"
 #include "Item.h"
 #include "Mobs/Monster.h"
 #include "Entities/ProjectileEntity.h"
-
+#include "ForEachChunkProvider.h"
+#include "Scoreboard.h"
+#include "MapManager.h"
+#include "Blocks/WorldInterface.h"
+#include "Blocks/BroadcastInterface.h"
 
 
 
@@ -40,9 +43,13 @@ class cWorldGenerator;  // The generator that actually generates the chunks for
 class cChunkGenerator;  // The thread responsible for generating chunks
 class cChestEntity;
 class cDispenserEntity;
+class cFlowerPotEntity;
 class cFurnaceEntity;
 class cNoteEntity;
+class cMobHeadEntity;
 class cMobCensus;
+class cCompositeChat;
+class cCuboid;
 
 typedef std::list< cPlayer * > cPlayerList;
 
@@ -53,6 +60,8 @@ typedef cItemCallback<cDispenserEntity>    cDispenserCallback;
 typedef cItemCallback<cFurnaceEntity>      cFurnaceCallback;
 typedef cItemCallback<cNoteEntity>         cNoteBlockCallback;
 typedef cItemCallback<cCommandBlockEntity> cCommandBlockCallback;
+typedef cItemCallback<cMobHeadEntity>      cMobHeadCallback;
+typedef cItemCallback<cFlowerPotEntity>    cFlowerPotCallback;
 
 
 
@@ -60,7 +69,10 @@ typedef cItemCallback<cCommandBlockEntity> cCommandBlockCallback;
 
 
 // tolua_begin
-class cWorld
+class cWorld :
+	public cForEachChunkProvider,
+	public cWorldInterface,
+	public cBroadcastInterface
 {
 public:
 
@@ -96,6 +108,15 @@ public:
 	} ;
 	
 
+	class cTaskUnloadUnusedChunks :
+		public cTask
+	{
+	protected:
+		// cTask overrides:
+		virtual void Run(cWorld & a_World) override;
+	};
+
+
 	static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
 	{
 		return "cWorld";
@@ -104,21 +125,26 @@ public:
 	// tolua_begin
 
 	int GetTicksUntilWeatherChange(void) const { return m_WeatherInterval; }
-	Int64 GetWorldAge(void)  const { return m_WorldAge; }
-	Int64 GetTimeOfDay(void) const { return m_TimeOfDay; }
+	
+	virtual Int64 GetWorldAge (void) const override { return m_WorldAge; }
+	virtual Int64 GetTimeOfDay(void) const override { return m_TimeOfDay; } 
 	
 	void SetTicksUntilWeatherChange(int a_WeatherInterval)
 	{
 		m_WeatherInterval = a_WeatherInterval;
 	}
 
-	void SetTimeOfDay(Int64 a_TimeOfDay)
+	virtual void SetTimeOfDay(Int64 a_TimeOfDay) override
 	{
 		m_TimeOfDay = a_TimeOfDay;
 		m_TimeOfDaySecs = (double)a_TimeOfDay / 20.0;
 		BroadcastTimeUpdate();
 	}
 	
+	/** Returns the default weather interval for the specific weather type.
+	Returns -1 for any unknown weather. */
+	int GetDefaultWeatherInterval(eWeather a_Weather);
+	
 	/** Returns the current game mode. Partly OBSOLETE, you should use IsGameModeXXX() functions wherever applicable */
 	eGameMode GetGameMode(void) const { return m_GameMode; }
 
@@ -136,7 +162,9 @@ public:
 	
 	bool ShouldLavaSpawnFire(void) const { return m_ShouldLavaSpawnFire; }
 	
-	eDimension GetDimension(void) const { return m_Dimension; }
+	bool VillagersShouldHarvestCrops(void) const { return m_VillagersShouldHarvestCrops; }
+
+	virtual eDimension GetDimension(void) const { return m_Dimension; }
 
 	/** Returns the world height at the specified coords; waits for the chunk to get loaded / generated */
 	int GetHeight(int a_BlockX, int a_BlockZ);
@@ -152,31 +180,50 @@ public:
 	void BroadcastBlockAction        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = NULL);  // tolua_export
 	void BroadcastBlockBreakAnimation(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = NULL);
 	void BroadcastBlockEntity        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);  ///< If there is a block entity at the specified coods, sends it to all clients except a_Exclude
-	void BroadcastChat               (const AString & a_Message, const cClientHandle * a_Exclude = NULL);  // tolua_export
-	void BroadcastChunkData          (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectPickup      (const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastDestroyEntity      (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEffect       (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEquipment    (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityHeadLook     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityMetadata     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMove      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMoveLook  (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityStatus       (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityVelocity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL);
-	void BroadcastParticleEffect     (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL);
-	void BroadcastPlayerListItem     (const cPlayer & a_Player, bool a_IsOnline, const cClientHandle * a_Exclude = NULL);
-	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
-	void BroadcastSoundEffect        (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export a_Src coords are Block * 8
-	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL); // tolua_export
-	void BroadcastSpawnEntity        (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTeleportEntity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastThunderbolt        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTimeUpdate         (const cClientHandle * a_Exclude = NULL);
-	void BroadcastUseBed             (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ );
-	void BroadcastWeather            (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
+
+	// tolua_begin
+	void BroadcastChat       (const AString & a_Message, const cClientHandle * a_Exclude = NULL, eMessageType a_ChatPrefix = mtCustom);
+	void BroadcastChatInfo   (const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtInformation); }
+	void BroadcastChatFailure(const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtFailure); }
+	void BroadcastChatSuccess(const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtSuccess); }
+	void BroadcastChatWarning(const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtWarning); }
+	void BroadcastChatFatal  (const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtFailure); }
+	void BroadcastChatDeath  (const AString & a_Message, const cClientHandle * a_Exclude = NULL) { BroadcastChat(a_Message, a_Exclude, mtDeath); }
+	void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = NULL);
+	// tolua_end
+
+	void BroadcastChunkData              (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
+	void BroadcastCollectPickup          (const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastDestroyEntity          (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityEffect           (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityEquipment        (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityHeadLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityMetadata         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityRelMove          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityRelMoveLook      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityStatus           (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityVelocity         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) override;
+	void BroadcastParticleEffect         (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL); // tolua_export
+	void BroadcastPlayerListItem         (const cPlayer & a_Player, bool a_IsOnline, const cClientHandle * a_Exclude = NULL);
+	void BroadcastRemoveEntityEffect     (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
+	void BroadcastScoreboardObjective    (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
+	void BroadcastScoreUpdate            (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
+	void BroadcastDisplayObjective       (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
+	void BroadcastSoundEffect            (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export a_Src coords are Block * 8
+	void BroadcastSoundParticleEffect    (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL); // tolua_export
+	void BroadcastSpawnEntity            (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastTeleportEntity         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastThunderbolt            (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastTimeUpdate             (const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastUseBed         (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	void BroadcastWeather                (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
+	
+	virtual cBroadcastInterface & GetBroadcastManager(void) override
+	{
+		return *this;
+	}
 	
 	/** If there is a block entity at the specified coords, sends it to the client specified */
 	void SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client);
@@ -218,7 +265,8 @@ public:
 	bool IsChunkValid      (int a_ChunkX, int a_ChunkZ) const;
 	bool HasChunkAnyClients(int a_ChunkX, int a_ChunkZ) const;
 	
-	void UnloadUnusedChunks(void);    // tolua_export
+	/** Queues a task to unload unused chunks onto the tick thread. The prefferred way of unloading*/
+	void QueueUnloadUnusedChunks(void);  // tolua_export
 	
 	void CollectPickupsByPlayer(cPlayer * a_Player);
 
@@ -226,7 +274,7 @@ public:
 	void RemovePlayer( cPlayer* a_Player );
 
 	/** Calls the callback for each player in the list; returns true if all players processed, false if the callback aborted by returning true */
-	bool ForEachPlayer(cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
+	virtual bool ForEachPlayer(cPlayerListCallback & a_Callback) override;  // >> EXPORTED IN MANUALBINDINGS <<
 
 	/** Calls the callback for the player of the given name; returns true if the player was found and the callback called, false if player not found. Callback return ignored */
 	bool DoWithPlayer(const AString & a_PlayerName, cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
@@ -235,7 +283,7 @@ public:
 	bool FindAndDoWithPlayer(const AString & a_PlayerNameHint, cPlayerListCallback & a_Callback);	// >> EXPORTED IN MANUALBINDINGS <<
 	
 	// TODO: This interface is dangerous - rewrite to DoWithClosestPlayer(pos, sight, action)
-	cPlayer * FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit);
+	cPlayer * FindClosestPlayer(const Vector3d & a_Pos, float a_SightLimit, bool a_CheckLineOfSight = true); 
 	
 	void SendPlayerList(cPlayer * a_DestPlayer);  // Sends playerlist to the player
 
@@ -268,9 +316,14 @@ public:
 	/** Removes the client from all chunks it is present in */
 	void RemoveClientFromChunks(cClientHandle * a_Client);
 	
-	/** Sends the chunk to the client specified, if the chunk is valid. If not valid, the request is postponed (ChunkSender will send that chunk when it becomes valid+lighted) */
+	/** Sends the chunk to the client specified, if the client doesn't have the chunk yet.
+	If chunk not valid, the request is postponed (ChunkSender will send that chunk when it becomes valid + lighted). */
 	void SendChunkTo(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
 	
+	/** Sends the chunk to the client specified, even if the client already has the chunk.
+	If the chunk's not valid, the request is postponed (ChunkSender will send that chunk when it becomes valid + lighted). */
+	void ForceSendChunkTo(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
+	
 	/** Removes client from ChunkSender's queue of chunks to be sent */
 	void RemoveClientFromChunkSender(cClientHandle * a_Client);
 	
@@ -292,9 +345,15 @@ public:
 	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be NULL. Returns true if sign text changed. Same as SetSignLines() */
 	bool UpdateSign(int a_X, int a_Y, int a_Z, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = NULL);	// Exported in ManualBindings.cpp
 
-	/** Marks (a_Stay == true) or unmarks (a_Stay == false) chunks as non-unloadable. To be used only by cChunkStay! */
-	void ChunksStay(const cChunkCoordsList & a_Chunks, bool a_Stay = true);
-	
+	/** Sets the command block command. Returns true if command changed. */
+	bool SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Command);	// tolua_export
+
+	/** Is the trapdoor open? Returns false if there is no trapdoor at the specified coords. */
+	bool IsTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ);                                      // tolua_export
+
+	/** Set the state of a trapdoor. Returns true if the trapdoor was update, false if there was no trapdoor at those coords. */
+	bool SetTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ, bool a_Open);                        // tolua_export
+
 	/** Regenerate the given chunk: */
 	void RegenerateChunk(int a_ChunkX, int a_ChunkZ);													// tolua_export
 	
@@ -307,7 +366,7 @@ public:
 	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 	
 	/** Calls the callback for each chunk in the coords specified (all cords are inclusive). Returns true if all chunks have been processed successfully */
-	bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback);
+	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override;
 
 	// tolua_begin
 	
@@ -320,15 +379,28 @@ public:
 	The replacement doesn't trigger block updates.
 	The replaced blocks aren't checked for block entities (block entity is leaked if it exists at this block)
 	*/
-	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+	{
+		m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+	}
 	
 	/** Queues a SetBlock() with the specified parameters after the specified number of ticks.
 	Calls SetBlock(), so performs full processing of the replaced block.
 	*/
-	void QueueSetBlock(int a_BlockX, int a_BLockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR);
+	void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR)
+	{
+		m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, GetWorldAge() + a_TickDelay, a_PreviousBlockType);
+	}
 	
-	BLOCKTYPE  GetBlock          (int a_BlockX, int a_BlockY, int a_BlockZ);
-	NIBBLETYPE GetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ);
+	BLOCKTYPE  GetBlock          (int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		return m_ChunkMap->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+	}
+	
+	NIBBLETYPE GetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	}
 	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData);
 	NIBBLETYPE GetBlockSkyLight  (int a_BlockX, int a_BlockY, int a_BlockZ);
 	NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ);
@@ -353,15 +425,15 @@ public:
 	Prefer cBlockArea::Write() instead, this is the internal implementation; cBlockArea does error checking, too.
 	a_DataTypes is a bitmask of cBlockArea::baXXX constants ORed together.
 	*/
-	bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);
+	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override;
 	
 	// tolua_begin
 
 	/** Spawns item pickups for each item in the list. May compress pickups if too many entities: */
-	void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0, bool IsPlayerCreated = false);
+	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0, bool IsPlayerCreated = false) override;
 	
 	/** Spawns item pickups for each item in the list. May compress pickups if too many entities. All pickups get the speed specified: */
-	void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated = false);
+	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated = false) override;
 	
 	/** Spawns an falling block entity at the given position. It returns the UniqueID of the spawned falling block. */
 	int SpawnFallingBlock(int a_X, int a_Y, int a_Z, BLOCKTYPE BlockType, NIBBLETYPE BlockMeta);
@@ -373,7 +445,7 @@ public:
 	int SpawnExperienceOrb(double a_X, double a_Y, double a_Z, int a_Reward);
 
 	/** Spawns a new primed TNT entity at the specified block coords and specified fuse duration. Initial velocity is given based on the relative coefficient provided */
-	void SpawnPrimedTNT(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec, double a_InitialVelocityCoeff = 1);
+	void SpawnPrimedTNT(double a_X, double a_Y, double a_Z, int a_FuseTimeInSec = 80, double a_InitialVelocityCoeff = 1);
 
 	// tolua_end
 
@@ -385,7 +457,7 @@ public:
 	
 	// tolua_begin
 	bool DigBlock   (int a_X, int a_Y, int a_Z);
-	void SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer * a_Player );
+	virtual void SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer * a_Player) override;
 
 	double GetSpawnX(void) const { return m_SpawnX; }
 	double GetSpawnY(void) const { return m_SpawnY; }
@@ -425,18 +497,18 @@ public:
 	
 	/** Does an explosion with the specified strength at the specified coordinate
 	a_SourceData exact type depends on the a_Source:
-	| esOther | void * |
-	| esPrimedTNT | cTNTEntity * |
-	| esMonster | cMonster * |
-	| esBed | cVector3i * |
-	| esEnderCrystal | Vector3i * |
-	| esGhastFireball | cGhastFireball * |
-	| esWitherSkullBlack | TBD |
-	| esWitherSkullBlue | TBD |
-	| esWitherBirth | TBD |
-	| esPlugin | void * |
+	| esOther            | void *           |
+	| esPrimedTNT        | cTNTEntity *     |
+	| esMonster          | cMonster *       |
+	| esBed              | cVector3i *      |
+	| esEnderCrystal     | Vector3i *       |
+	| esGhastFireball    | cGhastFireball * |
+	| esWitherSkullBlack | TBD              |
+	| esWitherSkullBlue  | TBD              |
+	| esWitherBirth      | cMonster *       |
+	| esPlugin           | void *           |
 	*/
-	void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData);  // tolua_export
+	virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData) override;  // tolua_export
 
 	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
 	bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback & a_Callback);  // Exported in ManualBindings.cpp
@@ -461,7 +533,13 @@ public:
 
 	/** Calls the callback for the command block at the specified coords; returns false if there's no command block at those coords or callback returns true, returns true if found */
 	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback & a_Callback);  // Exported in ManualBindings.cpp
-	
+
+	/** Calls the callback for the mob head block at the specified coords; returns false if there's no mob head block at those coords or callback returns true, returns true if found */
+	bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback & a_Callback);  // Exported in ManualBindings.cpp
+
+	/** Calls the callback for the flower pot at the specified coords; returns false if there's no flower pot at those coords or callback returns true, returns true if found */
+	bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback & a_Callback);  // Exported in ManualBindings.cpp
+
 	/** Retrieves the test on the sign at the specified coords; returns false if there's no sign at those coords, true if found */
 	bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Exported in ManualBindings.cpp
 	
@@ -497,30 +575,43 @@ public:
 	void GrowSugarcane(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBlocksToGrow);
 	
 	/** Returns the biome at the specified coords. Reads the biome from the chunk, if loaded, otherwise uses the world generator to provide the biome value */
-	int GetBiomeAt(int a_BlockX, int a_BlockZ);
+	EMCSBiome GetBiomeAt(int a_BlockX, int a_BlockZ);
+	
+	/** Sets the biome at the specified coords. Returns true if successful, false if not (chunk not loaded).
+	Doesn't resend the chunk to clients, use ForceSendChunkTo() for that. */
+	bool SetBiomeAt(int a_BlockX, int a_BlockZ, EMCSBiome a_Biome);
+	
+	/** Sets the biome at the area. Returns true if successful, false if any subarea failed (chunk not loaded).
+	(Re)sends the chunks to their relevant clients if successful. */
+	bool SetAreaBiome(int a_MinX, int a_MaxX, int a_MinZ, int a_MaxZ, EMCSBiome a_Biome);
+	
+	/** Sets the biome at the area. Returns true if successful, false if any subarea failed (chunk not loaded).
+	(Re)sends the chunks to their relevant clients if successful.
+	The cuboid needn't be sorted. */
+	bool SetAreaBiome(const cCuboid & a_Area, EMCSBiome a_Biome);
 
 	/** Returns the name of the world */
 	const AString & GetName(void) const { return m_WorldName; }
 	
 	/** Returns the name of the world.ini file used by this world */
 	const AString & GetIniFileName(void) const {return m_IniFileName; }
-	
-	// tolua_end
 
-	inline static void AbsoluteToRelative( int & a_X, int & a_Y, int & a_Z, int & a_ChunkX, int & a_ChunkY, int & a_ChunkZ )
-	{
-		// TODO: Use floor() instead of weird if statements
-		// Also fix Y
-		a_ChunkX = a_X/cChunkDef::Width;
-		if(a_X < 0 && a_X % cChunkDef::Width != 0) a_ChunkX--;
-		a_ChunkY = 0;
-		a_ChunkZ = a_Z/cChunkDef::Width;
-		if(a_Z < 0 && a_Z % cChunkDef::Width != 0) a_ChunkZ--;
+	/** Returns the associated scoreboard instance. */
+	cScoreboard & GetScoreBoard(void) { return m_Scoreboard; }
 
-		a_X = a_X - a_ChunkX*cChunkDef::Width;
-		a_Y = a_Y - a_ChunkY*cChunkDef::Height;
-		a_Z = a_Z - a_ChunkZ*cChunkDef::Width;
-	}
+	/** Returns the associated map manager instance. */
+	cMapManager & GetMapManager(void) { return m_MapManager; }
+
+	bool AreCommandBlocksEnabled(void) const { return m_bCommandBlocksEnabled; }
+	void SetCommandBlocksEnabled(bool a_Flag) { m_bCommandBlocksEnabled = a_Flag; }
+
+	eShrapnelLevel GetTNTShrapnelLevel(void) const { return m_TNTShrapnelLevel; }
+	void SetTNTShrapnelLevel(eShrapnelLevel a_Flag) { m_TNTShrapnelLevel = a_Flag; }
+
+	bool ShouldUseChatPrefixes(void) const { return m_bUseChatPrefixes; }
+	void SetShouldUseChatPrefixes(bool a_Flag) { m_bUseChatPrefixes = a_Flag; }
+	
+	// tolua_end
 	
 	inline static void BlockToChunk( int a_X, int a_Y, int a_Z, int & a_ChunkX, int & a_ChunkY, int & a_ChunkZ )
 	{
@@ -555,9 +646,9 @@ public:
 
 	// Various queues length queries (cannot be const, they lock their CS):
 	inline int GetGeneratorQueueLength  (void) { return m_Generator.GetQueueLength();   }    // tolua_export
-	inline int GetLightingQueueLength   (void) { return m_Lighting.GetQueueLength();    }    // tolua_export
-	inline int GetStorageLoadQueueLength(void) { return m_Storage.GetLoadQueueLength(); }    // tolua_export
-	inline int GetStorageSaveQueueLength(void) { return m_Storage.GetSaveQueueLength(); }    // tolua_export
+	inline size_t GetLightingQueueLength   (void) { return m_Lighting.GetQueueLength();    }    // tolua_export
+	inline size_t GetStorageLoadQueueLength(void) { return m_Storage.GetLoadQueueLength(); }    // tolua_export
+	inline size_t GetStorageSaveQueueLength(void) { return m_Storage.GetSaveQueueLength(); }    // tolua_export
 
 	void InitializeSpawn(void);
 	
@@ -616,11 +707,11 @@ public:
 	bool IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ);  // tolua_export
 	
 	/** Spawns a mob of the specified type. Returns the mob's EntityID if recognized and spawned, <0 otherwise */
-	int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType);  // tolua_export
+	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType) override;  // tolua_export
 	int SpawnMobFinalize(cMonster* a_Monster);
 	
 	/** Creates a projectile of the specified type. Returns the projectile's EntityID if successful, <0 otherwise */
-	int CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const Vector3d * a_Speed = NULL);  // tolua_export
+	int CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem a_Item, const Vector3d * a_Speed = NULL);  // tolua_export
 	
 	/** Returns a random number from the m_TickRand in range [0 .. a_Range]. To be used only in the tick thread! */
 	int GetTickRandomNumber(unsigned a_Range) { return (int)(m_TickRand.randInt(a_Range)); }
@@ -728,6 +819,7 @@ private:
 	bool m_bEnabledPVP;
 	bool m_IsDeepSnowEnabled;
 	bool m_ShouldLavaSpawnFire;
+	bool m_VillagersShouldHarvestCrops;
 	
 	std::vector<BlockTickQueueItem *> m_BlockTickQueue;
 	std::vector<BlockTickQueueItem *> m_BlockTickQueueCopy;	 // Second is for safely removing the objects from the queue
@@ -767,11 +859,23 @@ private:
 	bool m_IsPumpkinBonemealable;
 	bool m_IsSaplingBonemealable;
 	bool m_IsSugarcaneBonemealable;
+
+	/** Whether command blocks are enabled or not */
+	bool m_bCommandBlocksEnabled;
+	
+	/** Whether prefixes such as [INFO] are prepended to SendMessageXXX() / BroadcastChatXXX() functions */
+	bool m_bUseChatPrefixes;
+
+	/** The level of DoExplosionAt() projecting random affected blocks as FallingBlock entities
+	See the eShrapnelLevel enumeration for details
+	*/
+	eShrapnelLevel m_TNTShrapnelLevel;
 	
-	cCriticalSection m_CSFastSetBlock;
-	sSetBlockList    m_FastSetBlockQueue;
 
 	cChunkGenerator  m_Generator;
+
+	cScoreboard      m_Scoreboard;
+	cMapManager      m_MapManager;
 	
 	/** The callbacks that the ChunkGenerator uses to store new chunks and interface to plugins */
 	cChunkGeneratorCallbacks m_GeneratorCallbacks;
@@ -808,7 +912,7 @@ private:
 
 
 	cWorld(const AString & a_WorldName);
-	~cWorld();
+	virtual ~cWorld();
 
 	void Tick(float a_Dt, int a_LastTickDurationMSec);
 
@@ -827,6 +931,9 @@ private:
 	/** Ticks all clients that are in this world */
 	void TickClients(float a_Dt);
 
+	/** Unloads all chunks immediately.*/
+	void UnloadUnusedChunks(void);
+
 	void UpdateSkyDarkness(void);
 
 	/** <summary>Generates a random spawnpoint on solid land by walking chunks and finding their biomes</summary> */
@@ -834,6 +941,9 @@ private:
 	
 	/** Creates a new fluid simulator, loads its settings from the inifile (a_FluidName section) */
 	cFluidSimulator * InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock);
+
+	/** Creates a new redstone simulator.*/
+	cRedstoneSimulator * InitializeRedstoneSimulator(cIniFile & a_IniFile);
 }; // tolua_export
 
 
diff --git a/src/WorldStorage/FastNBT.cpp b/src/WorldStorage/FastNBT.cpp
index 8f80c3f75..be25fd1a4 100644
--- a/src/WorldStorage/FastNBT.cpp
+++ b/src/WorldStorage/FastNBT.cpp
@@ -506,22 +506,18 @@ void cFastNBTWriter::AddIntArray(const AString & a_Name, const int * a_Value, si
 {
 	TagCommon(a_Name, TAG_IntArray);
 	Int32 len = htonl(a_NumElements);
+	size_t cap = m_Result.capacity();
+	size_t size = m_Result.length();
+	if ((cap - size) < (4 + a_NumElements * 4))
+	{
+		m_Result.reserve(size + 4 + (a_NumElements * 4));
+	}
 	m_Result.append((const char *)&len, 4);
-#if defined(ANDROID_NDK)
-	// Android has alignment issues - cannot byteswap (htonl) an int that is not 32-bit-aligned, which happens in the regular version
 	for (size_t i = 0; i < a_NumElements; i++)
 	{
 		int Element = htonl(a_Value[i]);
 		m_Result.append((const char *)&Element, 4);
 	}
-#else
-	int * Elements = (int *)(m_Result.data() + m_Result.size());
-	m_Result.append(a_NumElements * 4, (char)0);
-	for (size_t i = 0; i < a_NumElements; i++)
-	{
-		Elements[i] = htonl(a_Value[i]);
-	}
-#endif
 }
 
 
diff --git a/src/WorldStorage/FastNBT.h b/src/WorldStorage/FastNBT.h
index b84eda1a1..5e5af3ca3 100644
--- a/src/WorldStorage/FastNBT.h
+++ b/src/WorldStorage/FastNBT.h
@@ -106,6 +106,10 @@ public:
 /** Parses and contains the parsed data
 Also implements data accessor functions for tree traversal and value getters
 The data pointer passed in the constructor is assumed to be valid throughout the object's life. Care must be taken not to initialize from a temporary.
+The parser decomposes the input data into a tree of tags that is stored as an array of cFastNBTTag items,
+and accessing the tree is done by using the array indices for tags. Each tag stores the indices for its parent,
+first child, last child, prev sibling and next sibling, a value of -1 indicates that the indice is not valid.
+Each primitive tag also stores the length of the contained data, in bytes.
 */
 class cParsedNBT
 {
@@ -114,86 +118,134 @@ public:
 	
 	bool IsValid(void) const {return m_IsValid; }
 	
+	/** Returns the root tag of the hierarchy. */
 	int GetRoot(void) const {return 0; }
-	int GetFirstChild (int a_Tag) const { return m_Tags[a_Tag].m_FirstChild; }
-	int GetLastChild  (int a_Tag) const { return m_Tags[a_Tag].m_LastChild; }
-	int GetNextSibling(int a_Tag) const { return m_Tags[a_Tag].m_NextSibling; }
-	int GetPrevSibling(int a_Tag) const { return m_Tags[a_Tag].m_PrevSibling; }
-	int GetDataLength (int a_Tag) const { return m_Tags[a_Tag].m_DataLength; }
 
+	/** Returns the first child of the specified tag, or -1 if none / not applicable. */
+	int GetFirstChild (int a_Tag) const { return m_Tags[(size_t)a_Tag].m_FirstChild; }
+	
+	/** Returns the last child of the specified tag, or -1 if none / not applicable. */
+	int GetLastChild  (int a_Tag) const { return m_Tags[(size_t)a_Tag].m_LastChild; }
+	
+	/** Returns the next sibling of the specified tag, or -1 if none. */
+	int GetNextSibling(int a_Tag) const { return m_Tags[(size_t)a_Tag].m_NextSibling; }
+	
+	/** Returns the previous sibling of the specified tag, or -1 if none. */
+	int GetPrevSibling(int a_Tag) const { return m_Tags[(size_t)a_Tag].m_PrevSibling; }
+	
+	/** Returns the length of the tag's data, in bytes.
+	Not valid for Compound or List tags! */
+	int GetDataLength (int a_Tag) const
+	{
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type != TAG_List);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type != TAG_Compound);
+		return m_Tags[(size_t)a_Tag].m_DataLength;
+	}
+
+	/** Returns the data stored in this tag.
+	Not valid for Compound or List tags! */
 	const char * GetData(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type != TAG_List);
-		ASSERT(m_Tags[a_Tag].m_Type != TAG_Compound);
-		return m_Data + m_Tags[a_Tag].m_DataStart;
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type != TAG_List);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type != TAG_Compound);
+		return m_Data + m_Tags[(size_t)a_Tag].m_DataStart;
 	}
 	
+	/** Returns the direct child tag of the specified name, or -1 if no such tag. */
 	int FindChildByName(int a_Tag, const AString & a_Name) const
 	{
 		return FindChildByName(a_Tag, a_Name.c_str(), a_Name.length());
 	}
 	
+	/** Returns the direct child tag of the specified name, or -1 if no such tag. */
 	int FindChildByName(int a_Tag, const char * a_Name, size_t a_NameLength = 0) const;
-	int FindTagByPath  (int a_Tag, const AString & a_Path) const;
+
+	/** Returns the child tag of the specified path (Name1\Name2\Name3...), or -1 if no such tag. */
+	int FindTagByPath(int a_Tag, const AString & a_Path) const;
 	
-	eTagType GetType(int a_Tag) const { return m_Tags[a_Tag].m_Type; }
+	eTagType GetType(int a_Tag) const { return m_Tags[(size_t)a_Tag].m_Type; }
 	
-	/// Returns the children type for a list tag; undefined on other tags. If list empty, returns TAG_End
+	/** Returns the children type for a List tag; undefined on other tags. If list empty, returns TAG_End. */
 	eTagType GetChildrenType(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_List);
-		return (m_Tags[a_Tag].m_FirstChild < 0) ? TAG_End : m_Tags[m_Tags[a_Tag].m_FirstChild].m_Type;
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_List);
+		return (m_Tags[(size_t)a_Tag].m_FirstChild < 0) ? TAG_End : m_Tags[(size_t)m_Tags[(size_t)a_Tag].m_FirstChild].m_Type;
 	}
 	
+	/** Returns the value stored in a Byte tag. Not valid for any other tag type. */
 	inline unsigned char GetByte(int a_Tag) const 
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_Byte);
-		return (unsigned char)(m_Data[m_Tags[a_Tag].m_DataStart]);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Byte);
+		return (unsigned char)(m_Data[(size_t)m_Tags[(size_t)a_Tag].m_DataStart]);
 	}
 	
+	/** Returns the value stored in a Short tag. Not valid for any other tag type. */
 	inline Int16 GetShort(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_Short);
-		return GetBEShort(m_Data + m_Tags[a_Tag].m_DataStart);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Short);
+		return GetBEShort(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
 	}
 
+	/** Returns the value stored in an Int tag. Not valid for any other tag type. */
 	inline Int32 GetInt(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_Int);
-		return GetBEInt(m_Data + m_Tags[a_Tag].m_DataStart);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Int);
+		return GetBEInt(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
 	}
 
+	/** Returns the value stored in a Long tag. Not valid for any other tag type. */
 	inline Int64 GetLong(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_Long);
-		return NetworkToHostLong8(m_Data + m_Tags[a_Tag].m_DataStart);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Long);
+		return NetworkToHostLong8(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
 	}
 
+	/** Returns the value stored in a Float tag. Not valid for any other tag type. */
 	inline float GetFloat(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_Float);
-		Int32 tmp = GetBEInt(m_Data + m_Tags[a_Tag].m_DataStart);
-		return *((float *)&tmp);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Float);
+		
+		// Cause a compile-time error if sizeof(float) != 4
+		// If your platform produces a compiler error here, you'll need to add code that manually decodes 32-bit floats
+		char Check1[5 - sizeof(float)];  // Fails if sizeof(float) > 4
+		char Check2[sizeof(float) - 3];  // Fails if sizeof(float) < 4
+		UNUSED(Check1);
+		UNUSED(Check2);
+		
+		Int32 i = GetBEInt(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
+		float f;
+		memcpy(&f, &i, sizeof(f));
+		return f;
 	}
 	
+	/** Returns the value stored in a Double tag. Not valid for any other tag type. */
 	inline double GetDouble(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_Double);
-		return NetworkToHostDouble8(m_Data + m_Tags[a_Tag].m_DataStart);
+		// Cause a compile-time error if sizeof(double) != 8
+		// If your platform produces a compiler error here, you'll need to add code that manually decodes 64-bit doubles
+		char Check1[9 - sizeof(double)];  // Fails if sizeof(double) > 8
+		char Check2[sizeof(double) - 7];  // Fails if sizeof(double) < 8
+		UNUSED(Check1);
+		UNUSED(Check2);
+
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Double);
+		return NetworkToHostDouble8(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
 	}
 	
+	/** Returns the value stored in a String tag. Not valid for any other tag type. */
 	inline AString GetString(int a_Tag) const
 	{
-		ASSERT(m_Tags[a_Tag].m_Type == TAG_String);
+		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_String);
 		AString res;
-		res.assign(m_Data + m_Tags[a_Tag].m_DataStart, m_Tags[a_Tag].m_DataLength);
+		res.assign(m_Data + m_Tags[(size_t)a_Tag].m_DataStart, m_Tags[(size_t)a_Tag].m_DataLength);
 		return res;
 	}
 	
+	/** Returns the tag's name. For tags that are not named, returns an empty string. */
 	inline AString GetName(int a_Tag) const
 	{
 		AString res;
-		res.assign(m_Data + m_Tags[a_Tag].m_NameStart, m_Tags[a_Tag].m_NameLength);
+		res.assign(m_Data + m_Tags[(size_t)a_Tag].m_NameStart, m_Tags[(size_t)a_Tag].m_NameLength);
 		return res;
 	}
 	
@@ -257,7 +309,7 @@ protected:
 		eTagType m_ItemType;  // for TAG_List, the element type
 	} ;
 	
-	static const int MAX_STACK = 50;  // Highliy doubtful that an NBT would be constructed this many levels deep
+	static const int MAX_STACK = 50;  // Highly doubtful that an NBT would be constructed this many levels deep
 	
 	// These two fields emulate a stack. A raw array is used due to speed issues - no reallocations are allowed.
 	sParent m_Stack[MAX_STACK];
diff --git a/src/WorldStorage/FireworksSerializer.cpp b/src/WorldStorage/FireworksSerializer.cpp
new file mode 100644
index 000000000..744fc731f
--- /dev/null
+++ b/src/WorldStorage/FireworksSerializer.cpp
@@ -0,0 +1,262 @@
+
+#include "Globals.h"
+#include "FireworksSerializer.h"
+#include "WorldStorage/FastNBT.h"
+
+
+
+
+
+void cFireworkItem::WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFastNBTWriter & a_Writer, const ENUM_ITEM_ID a_Type)
+{
+	switch (a_Type)
+	{
+		case E_ITEM_FIREWORK_ROCKET:
+		{
+			a_Writer.BeginCompound("Fireworks");
+			a_Writer.AddByte("Flight", a_FireworkItem.m_FlightTimeInTicks / 20);
+			a_Writer.BeginList("Explosions", TAG_Compound);
+			a_Writer.BeginCompound("");
+			a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
+			a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
+			a_Writer.AddByte("Type", a_FireworkItem.m_Type);
+			if (!a_FireworkItem.m_Colours.empty())
+			{
+				a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
+			}
+			if (!a_FireworkItem.m_FadeColours.empty())
+			{
+				a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
+			}
+			a_Writer.EndCompound();
+			a_Writer.EndList();
+			a_Writer.EndCompound();
+			break;
+		}
+		case E_ITEM_FIREWORK_STAR:
+		{
+			a_Writer.BeginCompound("Explosion");
+			a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
+			a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
+			a_Writer.AddByte("Type", a_FireworkItem.m_Type);
+			if (!a_FireworkItem.m_Colours.empty())
+			{
+				a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
+			}
+			if (!a_FireworkItem.m_FadeColours.empty())
+			{
+				a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
+			}
+			a_Writer.EndCompound();
+			break;
+		}
+		default: ASSERT(!"Unhandled firework item!"); break;
+	}
+}
+
+
+
+
+
+void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNBT & a_NBT, int a_TagIdx, const ENUM_ITEM_ID a_Type)
+{
+	if (a_TagIdx < 0)
+	{
+		return;
+	}
+
+	switch (a_Type)
+	{
+		case E_ITEM_FIREWORK_STAR:
+		{
+			for (int explosiontag = a_NBT.GetFirstChild(a_TagIdx); explosiontag >= 0; explosiontag = a_NBT.GetNextSibling(explosiontag))
+			{
+				eTagType TagType = a_NBT.GetType(explosiontag);
+				if (TagType == TAG_Byte) // Custon name tag
+				{
+					AString ExplosionName = a_NBT.GetName(explosiontag);
+
+					if (ExplosionName == "Flicker")
+					{
+						a_FireworkItem.m_HasFlicker = (a_NBT.GetByte(explosiontag) == 1);
+					}
+					else if (ExplosionName == "Trail")
+					{
+						a_FireworkItem.m_HasTrail = (a_NBT.GetByte(explosiontag) == 1);
+					}
+					else if (ExplosionName == "Type")
+					{
+						a_FireworkItem.m_Type = a_NBT.GetByte(explosiontag);
+					}
+				}
+				else if (TagType == TAG_IntArray)
+				{
+					AString ExplosionName = a_NBT.GetName(explosiontag);
+
+					if (ExplosionName == "Colors")
+					{
+						// Divide by four as data length returned in bytes
+						int DataLength = a_NBT.GetDataLength(explosiontag);
+						// round to the next highest multiple of four
+						DataLength -= DataLength % 4; 
+						if (DataLength == 0)
+						{
+							continue;
+						}
+
+						const char * ColourData = (a_NBT.GetData(explosiontag));
+						for (int i = 0; i < DataLength; i += 4 /* Size of network int*/)
+						{
+							a_FireworkItem.m_Colours.push_back(GetBEInt(ColourData + i));
+						}
+					}
+					else if (ExplosionName == "FadeColors")
+					{
+						int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
+						// round to the next highest multiple of four
+						DataLength -= DataLength % 4; 
+						if (DataLength == 0)
+						{
+							continue;
+						}
+
+						const char * FadeColourData = (a_NBT.GetData(explosiontag));
+						for (int i = 0; i < DataLength; i += 4 /* Size of network int*/)
+						{
+							a_FireworkItem.m_FadeColours.push_back(GetBEInt(FadeColourData + i));
+						}
+					}
+				}
+			}
+			break;
+		}
+		case E_ITEM_FIREWORK_ROCKET:
+		{
+			for (int fireworkstag = a_NBT.GetFirstChild(a_TagIdx); fireworkstag >= 0; fireworkstag = a_NBT.GetNextSibling(fireworkstag))
+			{
+				eTagType TagType = a_NBT.GetType(fireworkstag);
+				if (TagType == TAG_Byte) // Custon name tag
+				{
+					if (a_NBT.GetName(fireworkstag) == "Flight")
+					{
+						a_FireworkItem.m_FlightTimeInTicks = a_NBT.GetByte(fireworkstag) * 20;
+					}
+				}
+				else if ((TagType == TAG_List) && (a_NBT.GetName(fireworkstag) == "Explosions"))
+				{
+					int ExplosionsChild = a_NBT.GetFirstChild(fireworkstag);
+					if ((a_NBT.GetType(ExplosionsChild) == TAG_Compound) && (a_NBT.GetName(ExplosionsChild).empty()))
+					{
+						ParseFromNBT(a_FireworkItem, a_NBT, ExplosionsChild, E_ITEM_FIREWORK_STAR);
+					}
+				}
+			}
+			break;
+		}
+		default: ASSERT(!"Unhandled firework item!"); break;
+	}
+}
+
+
+
+
+
+AString cFireworkItem::ColoursToString(const cFireworkItem & a_FireworkItem)
+{
+	AString Result;
+
+	for (std::vector<int>::const_iterator itr = a_FireworkItem.m_Colours.begin(); itr != a_FireworkItem.m_Colours.end(); ++itr)
+	{
+		AppendPrintf(Result, "%i;", *itr);
+	}
+
+	return Result;
+}
+
+
+
+
+
+void cFireworkItem::ColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem)
+{
+	AStringVector Split = StringSplit(a_String, ";");
+
+	for (size_t itr = 0; itr < Split.size(); ++itr)
+	{
+		if (Split[itr].empty())
+		{
+			continue;
+		}
+
+		a_FireworkItem.m_Colours.push_back(atoi(Split[itr].c_str()));
+	}
+}
+
+
+
+
+
+AString cFireworkItem::FadeColoursToString(const cFireworkItem & a_FireworkItem)
+{
+	AString Result;
+
+	for (std::vector<int>::const_iterator itr = a_FireworkItem.m_FadeColours.begin(); itr != a_FireworkItem.m_FadeColours.end(); ++itr)
+	{
+		AppendPrintf(Result, "%i;", *itr);
+	}
+
+	return Result;
+}
+
+
+
+
+
+void cFireworkItem::FadeColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem)
+{
+	AStringVector Split = StringSplit(a_String, ";");
+
+	for (size_t itr = 0; itr < Split.size(); ++itr)
+	{
+		if (Split[itr].empty())
+		{
+			continue;
+		}
+
+		a_FireworkItem.m_FadeColours.push_back(atoi(Split[itr].c_str()));
+	}
+}
+
+
+
+
+
+int cFireworkItem::GetVanillaColourCodeFromDye(short a_DyeMeta)
+{
+	/*
+	Colours are supposed to be calculated via: R << 16 + G << 8 + B
+	However, the RGB values fireworks use aren't the same as the ones for dyes (the ones listed in the MC Wiki)
+	Therefore, here is a list of numbers gotten via the Protocol Proxy
+	*/
+
+	switch (a_DyeMeta)
+	{
+		case E_META_DYE_BLACK: return 0x1E1B1B;
+		case E_META_DYE_RED: return 0xB3312C;
+		case E_META_DYE_GREEN: return 0x3B511A;
+		case E_META_DYE_BROWN:  return 0x51301A;
+		case E_META_DYE_BLUE: return 0x253192;
+		case E_META_DYE_PURPLE: return 0x7B2FBE;
+		case E_META_DYE_CYAN: return 0x287697;
+		case E_META_DYE_LIGHTGRAY: return 0xABABAB;
+		case E_META_DYE_GRAY: return 0x434343;
+		case E_META_DYE_PINK: return 0xD88198;
+		case E_META_DYE_LIGHTGREEN: return 0x41CD34;
+		case E_META_DYE_YELLOW: return 0xDECF2A;
+		case E_META_DYE_LIGHTBLUE: return 0x6689D3;
+		case E_META_DYE_MAGENTA: return 0xC354CD;
+		case E_META_DYE_ORANGE: return 0xEB8844;
+		case E_META_DYE_WHITE: return 0xF0F0F0;
+		default: ASSERT(!"Unhandled dye meta whilst trying to get colour code for fireworks!"); return 0;
+	}
+}
diff --git a/src/WorldStorage/FireworksSerializer.h b/src/WorldStorage/FireworksSerializer.h
new file mode 100644
index 000000000..cbc544a14
--- /dev/null
+++ b/src/WorldStorage/FireworksSerializer.h
@@ -0,0 +1,92 @@
+
+// FireworksSerializer.h
+
+// Declares the cFireworkItem class representing a firework or firework star
+
+
+
+
+
+#pragma once
+
+#include "Defines.h"
+
+class cFastNBTWriter;
+class cParsedNBT;
+
+
+
+
+
+class cFireworkItem
+{
+public:
+	cFireworkItem(void) :
+		m_HasFlicker(false),
+		m_HasTrail(false),
+		m_Type(0),
+		m_FlightTimeInTicks(0)
+	{
+	}
+
+	inline void CopyFrom(const cFireworkItem & a_Item)
+	{
+		m_FlightTimeInTicks = a_Item.m_FlightTimeInTicks;
+		m_HasFlicker = a_Item.m_HasFlicker;
+		m_HasTrail = a_Item.m_HasTrail;
+		m_Type = a_Item.m_Type;
+		m_Colours = a_Item.m_Colours;
+		m_FadeColours = a_Item.m_FadeColours;
+	}
+
+	inline void EmptyData(void)
+	{
+		m_FlightTimeInTicks = 0;
+		m_HasFlicker = false;
+		m_Type = 0;
+		m_HasTrail = false;
+		m_Colours.clear();
+		m_FadeColours.clear();
+	}
+
+	inline bool IsEqualTo(const cFireworkItem & a_Item) const
+	{
+		return
+			(
+			(m_FlightTimeInTicks == a_Item.m_FlightTimeInTicks) &&
+			(m_HasFlicker == a_Item.m_HasFlicker) &&
+			(m_HasTrail == a_Item.m_HasTrail) &&
+			(m_Type == a_Item.m_Type) &&
+			(m_Colours == a_Item.m_Colours) &&
+			(m_FadeColours == a_Item.m_FadeColours)
+			);
+	}
+
+	/** Writes firework NBT data to a Writer object */
+	static void WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFastNBTWriter & a_Writer, const ENUM_ITEM_ID a_Type);
+
+	/** Reads NBT data from a NBT object and populates a FireworkItem with it */
+	static void ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNBT & a_NBT, int a_TagIdx, const ENUM_ITEM_ID a_Type);
+
+	/** Converts the firework's vector of colours into a string of values separated by a semicolon */
+	static AString ColoursToString(const cFireworkItem & a_FireworkItem);
+
+	/** Parses a string containing encoded firework colours and populates a FireworkItem with it */
+	static void ColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem);
+
+	/** Converts the firework's vector of fade colours into a string of values separated by a semicolon */
+	static AString FadeColoursToString(const cFireworkItem & a_FireworkItem);
+
+	/** Parses a string containing encoded firework fade colours and populates a FireworkItem with it */
+	static void FadeColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem);
+
+	/** Returns a colour code for fireworks used by the network code */
+	static int GetVanillaColourCodeFromDye(short a_DyeMeta);
+
+	bool m_HasFlicker;
+	bool m_HasTrail;
+	NIBBLETYPE m_Type;
+	short m_FlightTimeInTicks;
+	std::vector<int> m_Colours;
+	std::vector<int> m_FadeColours;
+};
diff --git a/src/WorldStorage/MapSerializer.cpp b/src/WorldStorage/MapSerializer.cpp
new file mode 100644
index 000000000..df72d1cc9
--- /dev/null
+++ b/src/WorldStorage/MapSerializer.cpp
@@ -0,0 +1,280 @@
+
+// MapSerializer.cpp
+
+
+#include "Globals.h"
+#include "MapSerializer.h"
+#include "../StringCompression.h"
+#include "zlib/zlib.h"
+#include "FastNBT.h"
+
+#include "../Map.h"
+#include "../World.h"
+
+
+
+
+
+cMapSerializer::cMapSerializer(const AString& a_WorldName, cMap * a_Map)
+	: m_Map(a_Map)
+{
+	AString DataPath;
+	Printf(DataPath, "%s/data", a_WorldName.c_str());
+
+	Printf(m_Path, "%s/map_%i.dat", DataPath.c_str(), a_Map->GetID());
+
+	cFile::CreateFolder(FILE_IO_PREFIX + DataPath);
+}
+
+
+
+
+
+bool cMapSerializer::Load(void)
+{
+	AString Data = cFile::ReadWholeFile(FILE_IO_PREFIX + m_Path);
+	if (Data.empty())
+	{
+		return false;
+	}
+
+	AString Uncompressed;
+	int res = UncompressStringGZIP(Data.data(), Data.size(), Uncompressed);
+
+	if (res != Z_OK)
+	{
+		return false;
+	}
+
+	// Parse the NBT data:
+	cParsedNBT NBT(Uncompressed.data(), Uncompressed.size());
+	if (!NBT.IsValid())
+	{
+		// NBT Parsing failed
+		return false;
+	}
+
+	return LoadMapFromNBT(NBT);
+}
+
+
+
+
+
+bool cMapSerializer::Save(void)
+{
+	cFastNBTWriter Writer;
+
+	SaveMapToNBT(Writer);
+
+	Writer.Finish();
+	
+	#ifdef _DEBUG
+	cParsedNBT TestParse(Writer.GetResult().data(), Writer.GetResult().size());
+	ASSERT(TestParse.IsValid());
+	#endif  // _DEBUG
+
+	cFile File;
+	if (!File.Open(FILE_IO_PREFIX + m_Path, cFile::fmWrite))
+	{
+		return false;
+	}
+
+	AString Compressed;
+	int res = CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
+
+	if (res != Z_OK)
+	{
+		return false;
+	}
+
+	File.Write(Compressed.data(), Compressed.size());
+	File.Close();
+
+	return true;
+}
+
+
+
+
+
+void cMapSerializer::SaveMapToNBT(cFastNBTWriter & a_Writer)
+{
+	a_Writer.BeginCompound("data");
+
+	a_Writer.AddByte("scale", m_Map->GetScale());
+	a_Writer.AddByte("dimension", (int) m_Map->GetDimension());
+
+	a_Writer.AddShort("width",  m_Map->GetWidth());
+	a_Writer.AddShort("height", m_Map->GetHeight());
+
+	a_Writer.AddInt("xCenter", m_Map->GetCenterX());
+	a_Writer.AddInt("zCenter", m_Map->GetCenterZ());
+
+	const cMap::cColorList & Data = m_Map->GetData();
+	a_Writer.AddByteArray("colors", (char *) &Data[0], Data.size());
+
+	a_Writer.EndCompound();
+}
+
+
+
+
+
+bool cMapSerializer::LoadMapFromNBT(const cParsedNBT & a_NBT)
+{
+	int Data = a_NBT.FindChildByName(0, "data");
+	if (Data < 0)
+	{
+		return false;
+	}
+
+	int CurrLine = a_NBT.FindChildByName(Data, "scale");
+	if (CurrLine >= 0)
+	{
+		unsigned int Scale = a_NBT.GetByte(CurrLine);
+		m_Map->SetScale(Scale);
+	}
+
+	CurrLine = a_NBT.FindChildByName(Data, "dimension");
+	if (CurrLine >= 0)
+	{
+		eDimension Dimension = (eDimension) a_NBT.GetByte(CurrLine);
+		
+		if (Dimension != m_Map->m_World->GetDimension())
+		{
+			// TODO 2014-03-20 xdot: We should store nether maps in nether worlds, e.t.c.
+			return false;
+		}
+	}
+
+	CurrLine = a_NBT.FindChildByName(Data, "width");
+	if (CurrLine >= 0)
+	{
+		unsigned int Width = a_NBT.GetShort(CurrLine);
+		m_Map->m_Width = Width;
+	}
+
+	CurrLine = a_NBT.FindChildByName(Data, "height");
+	if (CurrLine >= 0)
+	{
+		unsigned int Height = a_NBT.GetShort(CurrLine);
+		m_Map->m_Height = Height;
+	}
+
+	CurrLine = a_NBT.FindChildByName(Data, "xCenter");
+	if (CurrLine >= 0)
+	{
+		int CenterX = a_NBT.GetInt(CurrLine);
+		m_Map->m_CenterX = CenterX;
+	}
+
+	CurrLine = a_NBT.FindChildByName(Data, "zCenter");
+	if (CurrLine >= 0)
+	{
+		int CenterZ = a_NBT.GetInt(CurrLine);
+		m_Map->m_CenterZ = CenterZ;
+	}
+
+	unsigned int NumPixels = m_Map->GetNumPixels();
+	m_Map->m_Data.resize(NumPixels);
+
+	CurrLine = a_NBT.FindChildByName(Data, "colors");
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_ByteArray))
+	{
+		memcpy(&m_Map->m_Data[0], a_NBT.GetData(CurrLine), NumPixels);
+	}
+
+	return true;
+}
+
+
+
+
+
+cIDCountSerializer::cIDCountSerializer(const AString & a_WorldName) : m_MapCount(0)
+{
+	AString DataPath;
+	Printf(DataPath, "%s/data", a_WorldName.c_str());
+
+	Printf(m_Path, "%s/idcounts.dat", DataPath.c_str());
+
+	cFile::CreateFolder(FILE_IO_PREFIX + DataPath);
+}
+
+
+
+
+
+bool cIDCountSerializer::Load(void)
+{
+	AString Data = cFile::ReadWholeFile(FILE_IO_PREFIX + m_Path);
+	if (Data.empty())
+	{
+		return false;
+	}
+
+	// NOTE: idcounts.dat is not compressed (raw format)
+
+	// Parse the NBT data:
+	cParsedNBT NBT(Data.data(), Data.size());
+	if (!NBT.IsValid())
+	{
+		// NBT Parsing failed
+		return false;
+	}
+
+	int CurrLine = NBT.FindChildByName(0, "map");
+	if (CurrLine >= 0)
+	{
+		m_MapCount = (int)NBT.GetShort(CurrLine) + 1;
+	}
+	else
+	{
+		m_MapCount = 0;
+	}
+
+	return true;
+}
+
+
+
+
+
+bool cIDCountSerializer::Save(void)
+{
+	cFastNBTWriter Writer;
+
+	if (m_MapCount > 0)
+	{
+		Writer.AddShort("map", m_MapCount - 1);
+	}
+
+	Writer.Finish();
+	
+	#ifdef _DEBUG
+	cParsedNBT TestParse(Writer.GetResult().data(), Writer.GetResult().size());
+	ASSERT(TestParse.IsValid());
+	#endif  // _DEBUG
+
+	cFile File;
+	if (!File.Open(FILE_IO_PREFIX + m_Path, cFile::fmWrite))
+	{
+		return false;
+	}
+
+	// NOTE: idcounts.dat is not compressed (raw format)
+
+	File.Write(Writer.GetResult().data(), Writer.GetResult().size());
+	File.Close();
+
+	return true;
+}
+
+
+
+
+
+
+
+
diff --git a/src/WorldStorage/MapSerializer.h b/src/WorldStorage/MapSerializer.h
new file mode 100644
index 000000000..eb7678a08
--- /dev/null
+++ b/src/WorldStorage/MapSerializer.h
@@ -0,0 +1,86 @@
+
+// MapSerializer.h
+
+// Declares the cMapSerializer class that is used for saving maps into NBT format used by Anvil
+
+
+
+
+
+#pragma once
+
+
+
+
+
+// fwd:
+class cFastNBTWriter;
+class cParsedNBT;
+class cMap;
+
+
+
+
+/** Utility class used to serialize maps. */
+class cMapSerializer
+{
+public:
+
+	cMapSerializer(const AString& a_WorldName, cMap * a_Map);
+
+	/** Try to load the scoreboard */
+	bool Load(void);
+
+	/** Try to save the scoreboard */
+	bool Save(void);
+
+
+private:
+
+	void SaveMapToNBT(cFastNBTWriter & a_Writer);
+
+	bool LoadMapFromNBT(const cParsedNBT & a_NBT);
+
+	cMap * m_Map;
+
+	AString m_Path;
+
+
+} ;
+
+
+
+
+/** Utility class used to serialize item ID counts.
+ *
+ * In order to perform bounds checking (while loading),
+ * the last registered ID of each item is serialized to an NBT file.
+ */
+class cIDCountSerializer
+{
+public:
+
+	cIDCountSerializer(const AString & a_WorldName);
+
+	/** Try to load the ID counts */
+	bool Load(void);
+
+	/** Try to save the ID counts */
+	bool Save(void);
+
+	inline unsigned int GetMapCount(void) const { return m_MapCount; }
+
+	inline void SetMapCount(unsigned int a_MapCount) { m_MapCount = a_MapCount; }
+
+
+private:
+
+	AString m_Path;
+
+	unsigned int m_MapCount;
+
+};
+
+
+
+
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index c84128022..415693ae2 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -19,13 +19,20 @@
 #include "../BlockEntities/JukeboxEntity.h"
 #include "../BlockEntities/NoteEntity.h"
 #include "../BlockEntities/SignEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 
 #include "../Entities/Entity.h"
+#include "../Entities/EnderCrystal.h"
 #include "../Entities/FallingBlock.h"
 #include "../Entities/Boat.h"
 #include "../Entities/Minecart.h"
 #include "../Entities/Pickup.h"
 #include "../Entities/ProjectileEntity.h"
+#include "../Entities/TNTEntity.h"
+#include "../Entities/ExpOrb.h"
+#include "../Entities/HangingEntity.h"
+#include "../Entities/ItemFrame.h"
 
 #include "../Mobs/Monster.h"
 #include "../Mobs/Bat.h"
@@ -37,6 +44,7 @@
 #include "../Mobs/Slime.h"
 #include "../Mobs/Skeleton.h"
 #include "../Mobs/Villager.h"
+#include "../Mobs/Wither.h"
 #include "../Mobs/Wolf.h"
 #include "../Mobs/Zombie.h"
 
@@ -89,11 +97,19 @@ void cNBTChunkSerializer::AddItem(const cItem & a_Item, int a_Slot, const AStrin
 	}
 	
 	// Write the enchantments:
-	if (!a_Item.m_Enchantments.IsEmpty())
+	if (!a_Item.m_Enchantments.IsEmpty() || ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR)))
 	{
-		const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
 		m_Writer.BeginCompound("tag");
-			EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, m_Writer, TagName);
+			if ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR))
+			{
+				cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, m_Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
+			}
+			
+			if (!a_Item.m_Enchantments.IsEmpty())
+			{
+				const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
+				EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, m_Writer, TagName);
+			}
 		m_Writer.EndCompound();
 	}
 	
@@ -248,11 +264,38 @@ void cNBTChunkSerializer::AddCommandBlockEntity(cCommandBlockEntity * a_CmdBlock
 void cNBTChunkSerializer::AddSignEntity(cSignEntity * a_Sign)
 {
 	m_Writer.BeginCompound("");
-	AddBasicTileEntity(a_Sign, "Sign");
-	m_Writer.AddString("Text1",   a_Sign->GetLine(0));
-	m_Writer.AddString("Text2",   a_Sign->GetLine(1));
-	m_Writer.AddString("Text3",   a_Sign->GetLine(2));
-	m_Writer.AddString("Text4",   a_Sign->GetLine(3));
+		AddBasicTileEntity(a_Sign, "Sign");
+		m_Writer.AddString("Text1",   a_Sign->GetLine(0));
+		m_Writer.AddString("Text2",   a_Sign->GetLine(1));
+		m_Writer.AddString("Text3",   a_Sign->GetLine(2));
+		m_Writer.AddString("Text4",   a_Sign->GetLine(3));
+	m_Writer.EndCompound();
+}
+
+
+
+
+
+void cNBTChunkSerializer::AddMobHeadEntity(cMobHeadEntity * a_MobHead)
+{
+	m_Writer.BeginCompound("");
+		AddBasicTileEntity(a_MobHead, "Skull");
+		m_Writer.AddByte  ("SkullType", a_MobHead->GetType() & 0xFF);
+		m_Writer.AddByte  ("Rot",       a_MobHead->GetRotation() & 0xFF);
+		m_Writer.AddString("ExtraType", a_MobHead->GetOwner());
+	m_Writer.EndCompound();
+}
+
+
+
+
+
+void cNBTChunkSerializer::AddFlowerPotEntity(cFlowerPotEntity * a_FlowerPot)
+{
+	m_Writer.BeginCompound("");
+		AddBasicTileEntity(a_FlowerPot, "FlowerPot");
+		m_Writer.AddInt   ("Item", (Int32) a_FlowerPot->GetItem().m_ItemType);
+		m_Writer.AddInt   ("Data", (Int32) a_FlowerPot->GetItem().m_ItemDamage);
 	m_Writer.EndCompound();
 }
 
@@ -294,6 +337,17 @@ void cNBTChunkSerializer::AddBoatEntity(cBoat * a_Boat)
 
 
 
+void cNBTChunkSerializer::AddEnderCrystalEntity(cEnderCrystal * a_EnderCrystal)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_EnderCrystal, "EnderCrystal");
+	m_Writer.EndCompound();
+}
+
+
+
+
+
 void cNBTChunkSerializer::AddFallingBlockEntity(cFallingBlock * a_FallingBlock)
 {
 	m_Writer.BeginCompound("");
@@ -381,7 +435,7 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 		case cMonster::mtSquid:         EntityClass = "Squid";          break;
 		case cMonster::mtVillager:      EntityClass = "Villager";       break;
 		case cMonster::mtWitch:         EntityClass = "Witch";          break;
-		case cMonster::mtWither:        EntityClass = "Wither";         break;
+		case cMonster::mtWither:        EntityClass = "WitherBoss";     break;
 		case cMonster::mtWolf:          EntityClass = "Wolf";           break;
 		case cMonster::mtZombie:        EntityClass = "Zombie";         break;
 		case cMonster::mtZombiePigman:  EntityClass = "PigZombie";      break;
@@ -394,6 +448,14 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 
 	m_Writer.BeginCompound("");
 		AddBasicEntity(a_Monster, EntityClass);
+		m_Writer.BeginList("DropChances", TAG_Float);
+			m_Writer.AddFloat("", a_Monster->GetDropChanceWeapon());
+			m_Writer.AddFloat("", a_Monster->GetDropChanceHelmet());
+			m_Writer.AddFloat("", a_Monster->GetDropChanceChestplate());
+			m_Writer.AddFloat("", a_Monster->GetDropChanceLeggings());
+			m_Writer.AddFloat("", a_Monster->GetDropChanceBoots());
+		m_Writer.EndList();
+		m_Writer.AddByte("CanPickUpLoot", (char)a_Monster->CanPickUpLoot());
 		switch (a_Monster->GetMobType())
 		{
 			case cMonster::mtBat:
@@ -452,10 +514,17 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 				m_Writer.AddInt("Profession", ((const cVillager *)a_Monster)->GetVilType());
 				break;
 			}
+			case cMonster::mtWither:
+			{
+				m_Writer.AddInt("Invul", ((const cWither *)a_Monster)->GetNumInvulnerableTicks());
+				break;
+			}
 			case cMonster::mtWolf:
 			{
-				// TODO:
-				// _X: CopyPasta error: m_Writer.AddInt("Profession", ((const cVillager *)a_Monster)->GetVilType());
+				m_Writer.AddString("Owner", ((const cWolf *)a_Monster)->GetOwner());
+				m_Writer.AddByte("Sitting", (((const cWolf *)a_Monster)->IsSitting() ? 1 : 0));
+				m_Writer.AddByte("Angry", (((const cWolf *)a_Monster)->IsAngry() ? 1 : 0));
+				m_Writer.AddInt("CollarColor", ((const cWolf *)a_Monster)->GetCollarColor());
 				break;
 			}
 			case cMonster::mtZombie:
@@ -478,8 +547,8 @@ void cNBTChunkSerializer::AddPickupEntity(cPickup * a_Pickup)
 	m_Writer.BeginCompound("");
 		AddBasicEntity(a_Pickup, "Item");
 		AddItem(a_Pickup->GetItem(), -1, "Item");
-		m_Writer.AddShort("Health", a_Pickup->GetHealth());
-		m_Writer.AddShort("Age",    a_Pickup->GetAge());
+		m_Writer.AddShort("Health", (Int16)(unsigned char)a_Pickup->GetHealth());
+		m_Writer.AddShort("Age",    (Int16)a_Pickup->GetAge());
 	m_Writer.EndCompound();
 }
 
@@ -544,6 +613,66 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
 
 
 
+void cNBTChunkSerializer::AddHangingEntity(cHangingEntity * a_Hanging)
+{
+	m_Writer.AddByte("Direction", (unsigned char)a_Hanging->GetDirection());
+	m_Writer.AddInt("TileX", a_Hanging->GetTileX());
+	m_Writer.AddInt("TileY", a_Hanging->GetTileY());
+	m_Writer.AddInt("TileZ", a_Hanging->GetTileZ());
+	switch (a_Hanging->GetDirection())
+	{
+		case 0:    m_Writer.AddByte("Dir", (unsigned char)2); break;
+		case 1:    m_Writer.AddByte("Dir", (unsigned char)1); break;
+		case 2:    m_Writer.AddByte("Dir", (unsigned char)0); break;
+		case 3:    m_Writer.AddByte("Dir", (unsigned char)3); break;
+	}
+}
+
+
+
+
+
+void cNBTChunkSerializer::AddTNTEntity(cTNTEntity * a_TNT)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_TNT, "PrimedTnt");
+		m_Writer.AddByte("Fuse", (unsigned char)a_TNT->GetFuseTicks());
+	m_Writer.EndCompound();
+}
+
+
+
+
+
+void cNBTChunkSerializer::AddExpOrbEntity(cExpOrb * a_ExpOrb)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_ExpOrb, "XPOrb");
+		m_Writer.AddShort("Health", (Int16)(unsigned char)a_ExpOrb->GetHealth());
+		m_Writer.AddShort("Age", (Int16)a_ExpOrb->GetAge());
+		m_Writer.AddShort("Value", (Int16)a_ExpOrb->GetReward());
+	m_Writer.EndCompound();
+}
+
+
+
+
+
+void cNBTChunkSerializer::AddItemFrameEntity(cItemFrame * a_ItemFrame)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_ItemFrame, "ItemFrame");
+		AddHangingEntity(a_ItemFrame);
+		AddItem(a_ItemFrame->GetItem(), -1, "Item");
+		m_Writer.AddByte("ItemRotation", (unsigned char)a_ItemFrame->GetRotation());
+		m_Writer.AddFloat("ItemDropChance", 1.0F);
+	m_Writer.EndCompound();
+}
+
+
+
+
+
 void cNBTChunkSerializer::AddMinecartChestContents(cMinecartWithChest * a_Minecart)
 {
 	m_Writer.BeginList("Items", TAG_Compound);
@@ -618,12 +747,16 @@ void cNBTChunkSerializer::Entity(cEntity * a_Entity)
 	switch (a_Entity->GetEntityType())
 	{
 		case cEntity::etBoat:         AddBoatEntity        ((cBoat *)            a_Entity); break;
+		case cEntity::etEnderCrystal: AddEnderCrystalEntity((cEnderCrystal *)    a_Entity); break;
 		case cEntity::etFallingBlock: AddFallingBlockEntity((cFallingBlock *)    a_Entity); break;
 		case cEntity::etMinecart:     AddMinecartEntity    ((cMinecart *)        a_Entity); break;
 		case cEntity::etMonster:      AddMonsterEntity     ((cMonster *)         a_Entity); break;
 		case cEntity::etPickup:       AddPickupEntity      ((cPickup *)          a_Entity); break;
 		case cEntity::etProjectile:   AddProjectileEntity  ((cProjectileEntity *)a_Entity); break;
-		case cEntity::etExpOrb: /* TODO */ break;
+		case cEntity::etTNT:          AddTNTEntity         ((cTNTEntity *)       a_Entity); break;
+		case cEntity::etExpOrb:       AddExpOrbEntity      ((cExpOrb *)          a_Entity); break;
+		case cEntity::etItemFrame:    AddItemFrameEntity   ((cItemFrame *)       a_Entity); break;
+		case cEntity::etPainting: /* TODO */ break;
 		case cEntity::etPlayer: return;  // Players aren't saved into the world
 		default:
 		{
@@ -652,20 +785,23 @@ void cNBTChunkSerializer::BlockEntity(cBlockEntity * a_Entity)
 		m_Writer.BeginList("TileEntities", TAG_Compound);
 	}
 	m_IsTagOpen = true;
-	
+
 	// Add tile-entity into NBT:
 	switch (a_Entity->GetBlockType())
 	{
-		case E_BLOCK_CHEST:         AddChestEntity     ((cChestEntity *)     a_Entity); break;
-		case E_BLOCK_DISPENSER:     AddDispenserEntity ((cDispenserEntity *) a_Entity); break;
-		case E_BLOCK_DROPPER:       AddDropperEntity   ((cDropperEntity *)   a_Entity); break;
-		case E_BLOCK_FURNACE:       AddFurnaceEntity   ((cFurnaceEntity *)   a_Entity); break;
-		case E_BLOCK_HOPPER:        AddHopperEntity    ((cHopperEntity *)    a_Entity); break;
+		case E_BLOCK_CHEST:         AddChestEntity       ((cChestEntity *)        a_Entity); break;
+		case E_BLOCK_DISPENSER:     AddDispenserEntity   ((cDispenserEntity *)    a_Entity); break;
+		case E_BLOCK_DROPPER:       AddDropperEntity     ((cDropperEntity *)      a_Entity); break;
+		case E_BLOCK_FLOWER_POT:    AddFlowerPotEntity   ((cFlowerPotEntity *)    a_Entity); break;
+		case E_BLOCK_FURNACE:       AddFurnaceEntity     ((cFurnaceEntity *)      a_Entity); break;
+		case E_BLOCK_HOPPER:        AddHopperEntity      ((cHopperEntity *)       a_Entity); break;
 		case E_BLOCK_SIGN_POST:
-		case E_BLOCK_WALLSIGN:      AddSignEntity      ((cSignEntity *)      a_Entity); break;
-		case E_BLOCK_NOTE_BLOCK:    AddNoteEntity      ((cNoteEntity *)      a_Entity); break;
-		case E_BLOCK_JUKEBOX:       AddJukeboxEntity   ((cJukeboxEntity *)   a_Entity); break;
+		case E_BLOCK_WALLSIGN:      AddSignEntity        ((cSignEntity *)         a_Entity); break;
+		case E_BLOCK_HEAD:          AddMobHeadEntity     ((cMobHeadEntity *)      a_Entity); break;
+		case E_BLOCK_NOTE_BLOCK:    AddNoteEntity        ((cNoteEntity *)         a_Entity); break;
+		case E_BLOCK_JUKEBOX:       AddJukeboxEntity     ((cJukeboxEntity *)      a_Entity); break;
 		case E_BLOCK_COMMAND_BLOCK: AddCommandBlockEntity((cCommandBlockEntity *) a_Entity); break;
+
 		default:
 		{
 			ASSERT(!"Unhandled block entity saved into Anvil");
diff --git a/src/WorldStorage/NBTChunkSerializer.h b/src/WorldStorage/NBTChunkSerializer.h
index 245b68063..51d104970 100644
--- a/src/WorldStorage/NBTChunkSerializer.h
+++ b/src/WorldStorage/NBTChunkSerializer.h
@@ -24,11 +24,14 @@ class cChestEntity;
 class cCommandBlockEntity;
 class cDispenserEntity;
 class cDropperEntity;
+class cEnderCrystal;
 class cFurnaceEntity;
 class cHopperEntity;
 class cJukeboxEntity;
 class cNoteEntity;
 class cSignEntity;
+class cMobHeadEntity;
+class cFlowerPotEntity;
 class cFallingBlock;
 class cMinecart;
 class cMinecartWithChest;
@@ -39,6 +42,10 @@ class cMonster;
 class cPickup;
 class cItemGrid;
 class cProjectileEntity;
+class cTNTEntity;
+class cExpOrb;
+class cHangingEntity;
+class cItemFrame;
 
 
 
@@ -93,16 +100,23 @@ protected:
 	void AddJukeboxEntity  (cJukeboxEntity *   a_Jukebox);
 	void AddNoteEntity     (cNoteEntity *      a_Note);
 	void AddSignEntity     (cSignEntity *      a_Sign);
+	void AddMobHeadEntity  (cMobHeadEntity *     a_MobHead);
 	void AddCommandBlockEntity(cCommandBlockEntity * a_CmdBlock);
+	void AddFlowerPotEntity(cFlowerPotEntity * a_FlowerPot);
 	
 	// Entities:
 	void AddBasicEntity       (cEntity * a_Entity, const AString & a_ClassName);
 	void AddBoatEntity        (cBoat * a_Boat);
+	void AddEnderCrystalEntity(cEnderCrystal * a_EnderCrystal);
 	void AddFallingBlockEntity(cFallingBlock * a_FallingBlock);
 	void AddMinecartEntity    (cMinecart * a_Minecart);
 	void AddMonsterEntity     (cMonster * a_Monster);
 	void AddPickupEntity      (cPickup * a_Pickup);
 	void AddProjectileEntity  (cProjectileEntity * a_Projectile);
+	void AddHangingEntity     (cHangingEntity * a_Hanging);
+	void AddTNTEntity         (cTNTEntity * a_TNT);
+	void AddExpOrbEntity      (cExpOrb * a_ExpOrb);
+	void AddItemFrameEntity   (cItemFrame * a_ItemFrame);
 	
 	void AddMinecartChestContents(cMinecartWithChest * a_Minecart);
 	
diff --git a/src/WorldStorage/SchematicFileSerializer.cpp b/src/WorldStorage/SchematicFileSerializer.cpp
new file mode 100644
index 000000000..9d594a084
--- /dev/null
+++ b/src/WorldStorage/SchematicFileSerializer.cpp
@@ -0,0 +1,305 @@
+
+// SchematicFileSerializer.cpp
+
+// Implements the cSchematicFileSerializer class representing the interface to load and save cBlockArea to a .schematic file
+
+#include "Globals.h"
+
+#include "OSSupport/GZipFile.h"
+#include "FastNBT.h"
+#include "SchematicFileSerializer.h"
+#include "../StringCompression.h"
+
+
+
+
+
+#ifdef SELF_TEST
+
+static class cSchematicStringSelfTest
+{
+public:
+	cSchematicStringSelfTest(void)
+	{
+		cBlockArea ba;
+		ba.Create(21, 256, 21);
+		ba.RelLine(0, 0, 0, 9, 8, 7, cBlockArea::baTypes | cBlockArea::baMetas, E_BLOCK_WOODEN_STAIRS, 1);
+		AString Schematic;
+		if (!cSchematicFileSerializer::SaveToSchematicString(ba, Schematic))
+		{
+			assert_test(!"Schematic failed to save!");
+		}
+		cBlockArea ba2;
+		if (!cSchematicFileSerializer::LoadFromSchematicString(ba2, Schematic))
+		{
+			assert_test(!"Schematic failed to load!");
+		}
+	}
+} g_SelfTest;
+
+#endif
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cSchematicFileSerializer:
+
+bool cSchematicFileSerializer::LoadFromSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName)
+{
+	// Un-GZip the contents:
+	AString Contents;
+	cGZipFile File;
+	if (!File.Open(a_FileName, cGZipFile::fmRead))
+	{
+		LOG("Cannot open the schematic file \"%s\".", a_FileName.c_str());
+		return false;
+	}
+	int NumBytesRead = File.ReadRestOfFile(Contents);
+	if (NumBytesRead < 0)
+	{
+		LOG("Cannot read GZipped data in the schematic file \"%s\", error %d", a_FileName.c_str(), NumBytesRead);
+		return false;
+	}
+	File.Close();
+	
+	// Parse the NBT:
+	cParsedNBT NBT(Contents.data(), Contents.size());
+	if (!NBT.IsValid())
+	{
+		LOG("Cannot parse the NBT in the schematic file \"%s\".", a_FileName.c_str());
+		return false;
+	}
+	
+	return LoadFromSchematicNBT(a_BlockArea, NBT);
+}
+
+
+
+
+
+
+bool cSchematicFileSerializer::LoadFromSchematicString(cBlockArea & a_BlockArea, const AString & a_SchematicData)
+{
+	// Uncompress the data:
+	AString UngzippedData;
+	if (UncompressStringGZIP(a_SchematicData.data(), a_SchematicData.size(), UngzippedData) != Z_OK)
+	{
+		LOG("%s: Cannot unGZip the schematic data.", __FUNCTION__);
+		return false;
+	}
+
+	// Parse the NBT:
+	cParsedNBT NBT(UngzippedData.data(), UngzippedData.size());
+	if (!NBT.IsValid())
+	{
+		LOG("%s: Cannot parse the NBT in the schematic data.", __FUNCTION__);
+		return false;
+	}
+	
+	return LoadFromSchematicNBT(a_BlockArea, NBT);
+}
+
+
+
+
+
+bool cSchematicFileSerializer::SaveToSchematicFile(const cBlockArea & a_BlockArea, const AString & a_FileName)
+{
+	// Serialize into NBT data:
+	AString NBT = SaveToSchematicNBT(a_BlockArea);
+	if (NBT.empty())
+	{
+		LOG("%s: Cannot serialize the area into an NBT representation for file \"%s\".", __FUNCTION__, a_FileName.c_str());
+		return false;
+	}
+	
+	// Save to file
+	cGZipFile File;
+	if (!File.Open(a_FileName, cGZipFile::fmWrite))
+	{
+		LOG("%s: Cannot open file \"%s\" for writing.", __FUNCTION__, a_FileName.c_str());
+		return false;
+	}
+	if (!File.Write(NBT))
+	{
+		LOG("%s: Cannot write data to file \"%s\".", __FUNCTION__, a_FileName.c_str());
+		return false;
+	}
+	return true;
+}
+
+
+
+
+
+
+bool cSchematicFileSerializer::SaveToSchematicString(const cBlockArea & a_BlockArea, AString & a_Out)
+{
+	// Serialize into NBT data:
+	AString NBT = SaveToSchematicNBT(a_BlockArea);
+	if (NBT.empty())
+	{
+		LOG("%s: Cannot serialize the area into an NBT representation.", __FUNCTION__);
+		return false;
+	}
+	
+	// Gzip the data:
+	int res = CompressStringGZIP(NBT.data(), NBT.size(), a_Out);
+	if (res != Z_OK)
+	{
+		LOG("%s: Cannot Gzip the area data NBT representation: %d", __FUNCTION__, res);
+		return false;
+	}
+	return true;
+}
+
+
+
+
+
+bool cSchematicFileSerializer::LoadFromSchematicNBT(cBlockArea & a_BlockArea, cParsedNBT & a_NBT)
+{
+	int TMaterials = a_NBT.FindChildByName(a_NBT.GetRoot(), "Materials");
+	if ((TMaterials > 0) && (a_NBT.GetType(TMaterials) == TAG_String))
+	{
+		AString Materials = a_NBT.GetString(TMaterials);
+		if (Materials.compare("Alpha") != 0)
+		{
+			LOG("Materials tag is present and \"%s\" instead of \"Alpha\". Possibly a wrong-format schematic file.", Materials.c_str());
+			return false;
+		}
+	}
+	int TSizeX = a_NBT.FindChildByName(a_NBT.GetRoot(), "Width");
+	int TSizeY = a_NBT.FindChildByName(a_NBT.GetRoot(), "Height");
+	int TSizeZ = a_NBT.FindChildByName(a_NBT.GetRoot(), "Length");
+	if (
+		(TSizeX < 0) || (TSizeY < 0) || (TSizeZ < 0) ||
+		(a_NBT.GetType(TSizeX) != TAG_Short) ||
+		(a_NBT.GetType(TSizeY) != TAG_Short) ||
+		(a_NBT.GetType(TSizeZ) != TAG_Short)
+	)
+	{
+		LOG("Dimensions are missing from the schematic file (%d, %d, %d), (%d, %d, %d)",
+			TSizeX, TSizeY, TSizeZ,
+			a_NBT.GetType(TSizeX), a_NBT.GetType(TSizeY), a_NBT.GetType(TSizeZ)
+		);
+		return false;
+	}
+	
+	int SizeX = a_NBT.GetShort(TSizeX);
+	int SizeY = a_NBT.GetShort(TSizeY);
+	int SizeZ = a_NBT.GetShort(TSizeZ);
+	if ((SizeX < 1) || (SizeY < 1) || (SizeZ < 1))
+	{
+		LOG("Dimensions are invalid in the schematic file: %d, %d, %d", SizeX, SizeY, SizeZ);
+		return false;
+	}
+	
+	int TBlockTypes = a_NBT.FindChildByName(a_NBT.GetRoot(), "Blocks");
+	int TBlockMetas = a_NBT.FindChildByName(a_NBT.GetRoot(), "Data");
+	if ((TBlockTypes < 0) || (a_NBT.GetType(TBlockTypes) != TAG_ByteArray))
+	{
+		LOG("BlockTypes are invalid in the schematic file: %d", TBlockTypes);
+		return false;
+	}
+	bool AreMetasPresent = (TBlockMetas > 0) && (a_NBT.GetType(TBlockMetas) == TAG_ByteArray);
+	
+	a_BlockArea.Clear();
+	a_BlockArea.SetSize(SizeX, SizeY, SizeZ, AreMetasPresent ? (cBlockArea::baTypes | cBlockArea::baMetas) : cBlockArea::baTypes);
+	
+	int TOffsetX = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetX");
+	int TOffsetY = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetY");
+	int TOffsetZ = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetZ");
+	
+	if (
+		(TOffsetX < 0) || (TOffsetY < 0) || (TOffsetZ < 0) ||
+		(a_NBT.GetType(TOffsetX) != TAG_Int) ||
+		(a_NBT.GetType(TOffsetY) != TAG_Int) ||
+		(a_NBT.GetType(TOffsetZ) != TAG_Int)
+	)
+	{
+		// Not every schematic file has an offset, so we shoudn't give a warn message.
+		a_BlockArea.SetWEOffset(0, 0, 0);
+	}
+	else
+	{
+		a_BlockArea.SetWEOffset(a_NBT.GetInt(TOffsetX), a_NBT.GetInt(TOffsetY), a_NBT.GetInt(TOffsetZ));
+	}
+
+	// Copy the block types and metas:
+	int NumBytes = a_BlockArea.GetBlockCount();
+	if (a_NBT.GetDataLength(TBlockTypes) < NumBytes)
+	{
+		LOG("BlockTypes truncated in the schematic file (exp %d, got %d bytes). Loading partial.",
+			NumBytes, a_NBT.GetDataLength(TBlockTypes)
+		);
+		NumBytes = a_NBT.GetDataLength(TBlockTypes);
+	}
+	memcpy(a_BlockArea.m_BlockTypes, a_NBT.GetData(TBlockTypes), NumBytes);
+	
+	if (AreMetasPresent)
+	{
+		int NumBytes = a_BlockArea.GetBlockCount();
+		if (a_NBT.GetDataLength(TBlockMetas) < NumBytes)
+		{
+			LOG("BlockMetas truncated in the schematic file (exp %d, got %d bytes). Loading partial.",
+				NumBytes, a_NBT.GetDataLength(TBlockMetas)
+			);
+			NumBytes = a_NBT.GetDataLength(TBlockMetas);
+		}
+		memcpy(a_BlockArea.m_BlockMetas, a_NBT.GetData(TBlockMetas), NumBytes);
+	}
+	
+	return true;
+}
+
+
+
+
+
+AString cSchematicFileSerializer::SaveToSchematicNBT(const cBlockArea & a_BlockArea)
+{
+	cFastNBTWriter Writer("Schematic");
+	Writer.AddShort("Width",  a_BlockArea.m_Size.x);
+	Writer.AddShort("Height", a_BlockArea.m_Size.y);
+	Writer.AddShort("Length", a_BlockArea.m_Size.z);
+	Writer.AddString("Materials", "Alpha");
+	if (a_BlockArea.HasBlockTypes())
+	{
+		Writer.AddByteArray("Blocks", (const char *)a_BlockArea.m_BlockTypes, a_BlockArea.GetBlockCount());
+	}
+	else
+	{
+		AString Dummy(a_BlockArea.GetBlockCount(), 0);
+		Writer.AddByteArray("Blocks", Dummy.data(), Dummy.size());
+	}
+	if (a_BlockArea.HasBlockMetas())
+	{
+		Writer.AddByteArray("Data", (const char *)a_BlockArea.m_BlockMetas, a_BlockArea.GetBlockCount());
+	}
+	else
+	{
+		AString Dummy(a_BlockArea.GetBlockCount(), 0);
+		Writer.AddByteArray("Data", Dummy.data(), Dummy.size());
+	}
+	
+	Writer.AddInt("WEOffsetX", a_BlockArea.m_WEOffset.x);
+	Writer.AddInt("WEOffsetY", a_BlockArea.m_WEOffset.y);
+	Writer.AddInt("WEOffsetZ", a_BlockArea.m_WEOffset.z);
+
+	// TODO: Save entities and block entities
+	Writer.BeginList("Entities", TAG_Compound);
+	Writer.EndList();
+	Writer.BeginList("TileEntities", TAG_Compound);
+	Writer.EndList();
+	Writer.Finish();
+	
+	return Writer.GetResult();
+}
+
+
+
+
diff --git a/src/WorldStorage/SchematicFileSerializer.h b/src/WorldStorage/SchematicFileSerializer.h
new file mode 100644
index 000000000..05b6c74f4
--- /dev/null
+++ b/src/WorldStorage/SchematicFileSerializer.h
@@ -0,0 +1,54 @@
+
+// SchematicFileSerializer.h
+
+// Declares the cSchematicFileSerializer class representing the interface to load and save cBlockArea to a .schematic file
+
+
+
+
+
+#pragma once
+
+#include "../BlockArea.h"
+
+
+
+
+
+// fwd: FastNBT.h
+class cParsedNBT;
+
+
+
+
+
+class cSchematicFileSerializer
+{
+public:
+		
+	/** Loads an area from a .schematic file. Returns true if successful. */
+	static bool LoadFromSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName);
+	
+	/** Loads an area from a string containing the .schematic file data. Returns true if successful. */
+	static bool LoadFromSchematicString(cBlockArea & a_BlockArea, const AString & a_SchematicData);
+	
+	/** Saves the area into a .schematic file. Returns true if successful. */
+	static bool SaveToSchematicFile(const cBlockArea & a_BlockArea, const AString & a_FileName);
+	
+	/** Saves the area into a string containing the .schematic file data.
+	Returns true if successful, false on failure. The data is stored into a_Out. */
+	static bool SaveToSchematicString(const cBlockArea & a_BlockArea, AString & a_Out);
+	
+private:
+	/** Loads the area from a schematic file uncompressed and parsed into a NBT tree.
+	Returns true if successful. */
+	static bool LoadFromSchematicNBT(cBlockArea & a_BlockArea, cParsedNBT & a_NBT);
+
+	/** Saves the area into a NBT representation and returns the NBT data as a string.
+	Returns an empty string if failed. */
+	static AString SaveToSchematicNBT(const cBlockArea & a_BlockArea);
+};
+
+
+
+
diff --git a/src/WorldStorage/ScoreboardSerializer.cpp b/src/WorldStorage/ScoreboardSerializer.cpp
new file mode 100644
index 000000000..6c885bb45
--- /dev/null
+++ b/src/WorldStorage/ScoreboardSerializer.cpp
@@ -0,0 +1,377 @@
+
+// ScoreboardSerializer.cpp
+
+
+#include "Globals.h"
+#include "ScoreboardSerializer.h"
+#include "../StringCompression.h"
+#include "zlib/zlib.h"
+#include "FastNBT.h"
+
+#include "../Scoreboard.h"
+
+
+
+
+
+cScoreboardSerializer::cScoreboardSerializer(const AString & a_WorldName, cScoreboard* a_ScoreBoard)
+	: m_ScoreBoard(a_ScoreBoard)
+{
+	AString DataPath;
+	Printf(DataPath, "%s/data", a_WorldName.c_str());
+
+	m_Path = DataPath + "/scoreboard.dat";
+
+	cFile::CreateFolder(FILE_IO_PREFIX + DataPath);
+}
+
+
+
+
+
+bool cScoreboardSerializer::Load(void)
+{
+	AString Data = cFile::ReadWholeFile(FILE_IO_PREFIX + m_Path);
+	if (Data.empty())
+	{
+		return false;
+	}
+
+	AString Uncompressed;
+	int res = UncompressStringGZIP(Data.data(), Data.size(), Uncompressed);
+
+	if (res != Z_OK)
+	{
+		return false;
+	}
+
+	// Parse the NBT data:
+	cParsedNBT NBT(Uncompressed.data(), Uncompressed.size());
+	if (!NBT.IsValid())
+	{
+		// NBT Parsing failed
+		return false;
+	}
+
+	return LoadScoreboardFromNBT(NBT);
+}
+
+
+
+
+
+bool cScoreboardSerializer::Save(void)
+{
+	cFastNBTWriter Writer;
+
+	SaveScoreboardToNBT(Writer);
+
+	Writer.Finish();
+	
+	#ifdef _DEBUG
+	cParsedNBT TestParse(Writer.GetResult().data(), Writer.GetResult().size());
+	ASSERT(TestParse.IsValid());
+	#endif  // _DEBUG
+
+	cFile File;
+	if (!File.Open(FILE_IO_PREFIX + m_Path, cFile::fmWrite))
+	{
+		return false;
+	}
+
+	AString Compressed;
+	int res = CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
+
+	if (res != Z_OK)
+	{
+		return false;
+	}
+
+	File.Write(Compressed.data(), Compressed.size());
+	File.Close();
+
+	return true;
+}
+
+
+
+
+
+void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
+{
+	a_Writer.BeginCompound("data");
+
+	a_Writer.BeginList("Objectives", TAG_Compound);
+	
+	for (cScoreboard::cObjectiveMap::const_iterator it = m_ScoreBoard->m_Objectives.begin(); it != m_ScoreBoard->m_Objectives.end(); ++it)
+	{
+		const cObjective & Objective = it->second;
+
+		a_Writer.BeginCompound("");
+
+		a_Writer.AddString("CriteriaName", cObjective::TypeToString(Objective.GetType()));
+
+		a_Writer.AddString("DisplayName", Objective.GetDisplayName());
+		a_Writer.AddString("Name", it->first);
+
+		a_Writer.EndCompound();
+	}
+
+	a_Writer.EndList(); // Objectives
+
+	a_Writer.BeginList("PlayerScores", TAG_Compound);
+
+	for (cScoreboard::cObjectiveMap::const_iterator it = m_ScoreBoard->m_Objectives.begin(); it != m_ScoreBoard->m_Objectives.end(); ++it)
+	{
+		const cObjective & Objective = it->second;
+
+		for (cObjective::cScoreMap::const_iterator it2 = Objective.m_Scores.begin(); it2 != Objective.m_Scores.end(); ++it2)
+		{
+			a_Writer.BeginCompound("");
+
+			a_Writer.AddInt("Score", it2->second);
+
+			a_Writer.AddString("Name", it2->first);
+			a_Writer.AddString("Objective", it->first);
+			
+			a_Writer.EndCompound();
+		}
+	}
+
+	a_Writer.EndList(); // PlayerScores
+
+	a_Writer.BeginList("Teams", TAG_Compound);
+	
+	for (cScoreboard::cTeamMap::const_iterator it = m_ScoreBoard->m_Teams.begin(); it != m_ScoreBoard->m_Teams.end(); ++it)
+	{
+		const cTeam & Team = it->second;
+
+		a_Writer.BeginCompound("");
+
+		a_Writer.AddByte("AllowFriendlyFire",     Team.AllowsFriendlyFire()      ? 1 : 0);
+		a_Writer.AddByte("SeeFriendlyInvisibles", Team.CanSeeFriendlyInvisible() ? 1 : 0);
+
+		a_Writer.AddString("DisplayName", Team.GetDisplayName());
+		a_Writer.AddString("Name", it->first);
+
+		a_Writer.AddString("Prefix", Team.GetPrefix());
+		a_Writer.AddString("Suffix", Team.GetSuffix());
+
+		a_Writer.BeginList("Players", TAG_String);
+
+		for (cTeam::cPlayerNameSet::const_iterator it2 = Team.m_Players.begin(); it2 != Team.m_Players.end(); ++it2)
+		{
+			a_Writer.AddString("", *it2);
+		}
+
+		a_Writer.EndList();
+
+		a_Writer.EndCompound();
+	}
+
+	a_Writer.EndList(); // Teams
+
+	a_Writer.BeginCompound("DisplaySlots");
+
+	cObjective * Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsList);
+	a_Writer.AddString("slot_0", (Objective == NULL) ? "" : Objective->GetName());
+
+	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsSidebar);
+	a_Writer.AddString("slot_1", (Objective == NULL) ? "" : Objective->GetName());
+
+	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsName);
+	a_Writer.AddString("slot_2", (Objective == NULL) ? "" : Objective->GetName());
+
+	a_Writer.EndCompound(); // DisplaySlots
+
+	a_Writer.EndCompound(); // Data
+}
+
+
+
+
+
+bool cScoreboardSerializer::LoadScoreboardFromNBT(const cParsedNBT & a_NBT)
+{
+	int Data = a_NBT.FindChildByName(0, "data");
+	if (Data < 0)
+	{
+		return false;
+	}
+
+	int Objectives = a_NBT.FindChildByName(Data, "Objectives");
+	if (Objectives < 0)
+	{
+		return false;
+	}
+
+	for (int Child = a_NBT.GetFirstChild(Objectives); Child >= 0; Child = a_NBT.GetNextSibling(Child))
+	{
+		AString CriteriaName, DisplayName, Name;
+
+		int CurrLine = a_NBT.FindChildByName(Child, "CriteriaName");
+		if (CurrLine >= 0)
+		{
+			CriteriaName = a_NBT.GetString(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "DisplayName");
+		if (CurrLine >= 0)
+		{
+			DisplayName = a_NBT.GetString(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "Name");
+		if (CurrLine >= 0)
+		{
+			Name = a_NBT.GetString(CurrLine);
+		}
+
+		cObjective::eType Type = cObjective::StringToType(CriteriaName);
+
+		m_ScoreBoard->RegisterObjective(Name, DisplayName, Type);
+	}
+
+	int PlayerScores = a_NBT.FindChildByName(Data, "PlayerScores");
+	if (PlayerScores < 0)
+	{
+		return false;
+	}
+
+	for (int Child = a_NBT.GetFirstChild(PlayerScores); Child >= 0; Child = a_NBT.GetNextSibling(Child))
+	{
+		AString Name, ObjectiveName;
+
+		cObjective::Score Score = 0;
+
+		int CurrLine = a_NBT.FindChildByName(Child, "Score");
+		if (CurrLine >= 0)
+		{
+			Score = a_NBT.GetInt(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "Name");
+		if (CurrLine >= 0)
+		{
+			Name = a_NBT.GetString(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "Objective");
+		if (CurrLine >= 0)
+		{
+			ObjectiveName = a_NBT.GetString(CurrLine);
+		}
+
+		cObjective * Objective = m_ScoreBoard->GetObjective(ObjectiveName);
+
+		if (Objective)
+		{
+			Objective->SetScore(Name, Score);
+		}
+	}
+
+	int Teams = a_NBT.FindChildByName(Data, "Teams");
+	if (Teams < 0)
+	{
+		return false;
+	}
+
+	for (int Child = a_NBT.GetFirstChild(Teams); Child >= 0; Child = a_NBT.GetNextSibling(Child))
+	{
+		AString Name, DisplayName, Prefix, Suffix;
+
+		bool AllowsFriendlyFire = true, CanSeeFriendlyInvisible = false;
+
+		int CurrLine = a_NBT.FindChildByName(Child, "Name");
+		if (CurrLine >= 0)
+		{
+			Name = a_NBT.GetInt(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "DisplayName");
+		if (CurrLine >= 0)
+		{
+			DisplayName = a_NBT.GetInt(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "Prefix");
+		if (CurrLine >= 0)
+		{
+			Prefix = a_NBT.GetInt(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "Suffix");
+		if (CurrLine >= 0)
+		{
+			Suffix = a_NBT.GetInt(CurrLine);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "AllowFriendlyFire");
+		if (CurrLine >= 0)
+		{
+			AllowsFriendlyFire = (a_NBT.GetInt(CurrLine) != 0);
+		}
+
+		CurrLine = a_NBT.FindChildByName(Child, "SeeFriendlyInvisibles");
+		if (CurrLine >= 0)
+		{
+			CanSeeFriendlyInvisible = (a_NBT.GetInt(CurrLine) != 0);
+		}
+
+		cTeam * Team = m_ScoreBoard->RegisterTeam(Name, DisplayName, Prefix, Suffix);
+
+		Team->SetFriendlyFire(AllowsFriendlyFire);
+		Team->SetCanSeeFriendlyInvisible(CanSeeFriendlyInvisible);
+
+		int Players = a_NBT.FindChildByName(Child, "Players");
+		if (Players < 0)
+		{
+			continue;
+		}
+
+		for (int ChildB = a_NBT.GetFirstChild(Players); ChildB >= 0; ChildB = a_NBT.GetNextSibling(ChildB))
+		{
+			Team->AddPlayer(a_NBT.GetString(ChildB));
+		}
+	}
+
+	int DisplaySlots = a_NBT.FindChildByName(Data, "DisplaySlots");
+	if (DisplaySlots < 0)
+	{
+		return false;
+	}
+
+	int CurrLine = a_NBT.FindChildByName(DisplaySlots, "slot_0");
+	if (CurrLine >= 0)
+	{
+		AString Name = a_NBT.GetString(CurrLine);
+
+		m_ScoreBoard->SetDisplay(Name, cScoreboard::dsList);
+	}
+
+	CurrLine = a_NBT.FindChildByName(DisplaySlots, "slot_1");
+	if (CurrLine >= 0)
+	{
+		AString Name = a_NBT.GetString(CurrLine);
+
+		m_ScoreBoard->SetDisplay(Name, cScoreboard::dsSidebar);
+	}
+
+	CurrLine = a_NBT.FindChildByName(DisplaySlots, "slot_2");
+	if (CurrLine >= 0)
+	{
+		AString Name = a_NBT.GetString(CurrLine);
+
+		m_ScoreBoard->SetDisplay(Name, cScoreboard::dsName);
+	}
+
+	return true;
+}
+
+
+
+
+
+
+
+
diff --git a/src/WorldStorage/ScoreboardSerializer.h b/src/WorldStorage/ScoreboardSerializer.h
new file mode 100644
index 000000000..048fa3ab4
--- /dev/null
+++ b/src/WorldStorage/ScoreboardSerializer.h
@@ -0,0 +1,52 @@
+
+// ScoreboardSerializer.h
+
+// Declares the cScoreboardSerializer class that is used for saving scoreboards into NBT format used by Anvil
+
+
+
+
+
+#pragma once
+
+
+
+
+
+// fwd:
+class cFastNBTWriter;
+class cParsedNBT;
+class cScoreboard;
+
+
+
+
+class cScoreboardSerializer
+{
+public:
+
+	cScoreboardSerializer(const AString & a_WorldName, cScoreboard* a_ScoreBoard);
+
+	/// Try to load the scoreboard
+	bool Load(void);
+
+	/// Try to save the scoreboard
+	bool Save(void);
+
+
+private:
+
+	void SaveScoreboardToNBT(cFastNBTWriter & a_Writer);
+
+	bool LoadScoreboardFromNBT(const cParsedNBT & a_NBT);
+
+	cScoreboard* m_ScoreBoard;
+
+	AString m_Path;
+
+
+} ;
+
+
+
+
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index 8983f25ba..48934d074 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -24,16 +24,23 @@
 #include "../BlockEntities/JukeboxEntity.h"
 #include "../BlockEntities/NoteEntity.h"
 #include "../BlockEntities/SignEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 
 
 #include "../Mobs/Monster.h"
 #include "../Mobs/IncludeAllMonsters.h"
 
 #include "../Entities/Boat.h"
+#include "../Entities/EnderCrystal.h"
 #include "../Entities/FallingBlock.h"
 #include "../Entities/Minecart.h"
 #include "../Entities/Pickup.h"
 #include "../Entities/ProjectileEntity.h"
+#include "../Entities/TNTEntity.h"
+#include "../Entities/ExpOrb.h"
+#include "../Entities/HangingEntity.h"
+#include "../Entities/ItemFrame.h"
 
 
 
@@ -363,6 +370,7 @@ bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, const cParsedNBT
 				{
 					case E_BLOCK_AIR:
 					case E_BLOCK_LEAVES:
+					case E_BLOCK_NEW_LEAVES:
 					{
 						// nothing needed
 						break;
@@ -504,10 +512,10 @@ cChunkDef::BiomeMap * cWSSAnvil::LoadBiomeMapFromNBT(cChunkDef::BiomeMap * a_Bio
 		// The biomes stored don't match in size
 		return NULL;
 	}
-	const int * BiomeData = (const int *)(a_NBT.GetData(a_TagIdx));
+	const char * BiomeData = (a_NBT.GetData(a_TagIdx));
 	for (size_t i = 0; i < ARRAYCOUNT(*a_BiomeMap); i++)
 	{
-		(*a_BiomeMap)[i] = (EMCSBiome)(ntohl(BiomeData[i]));
+		(*a_BiomeMap)[i] = (EMCSBiome)(GetBEInt(&BiomeData[i * 4]));
 		if ((*a_BiomeMap)[i] == 0xff)
 		{
 			// Unassigned biomes
@@ -577,6 +585,10 @@ void cWSSAnvil::LoadBlockEntitiesFromNBT(cBlockEntityList & a_BlockEntities, con
 		{
 			LoadDropperFromNBT(a_BlockEntities, a_NBT, Child);
 		}
+		else if (strncmp(a_NBT.GetData(sID), "FlowerPot", a_NBT.GetDataLength(sID)) == 0)
+		{
+			LoadFlowerPotFromNBT(a_BlockEntities, a_NBT, Child);
+		}
 		else if (strncmp(a_NBT.GetData(sID), "Furnace", a_NBT.GetDataLength(sID)) == 0)
 		{
 			LoadFurnaceFromNBT(a_BlockEntities, a_NBT, Child, a_BlockTypes, a_BlockMetas);
@@ -597,6 +609,10 @@ void cWSSAnvil::LoadBlockEntitiesFromNBT(cBlockEntityList & a_BlockEntities, con
 		{
 			LoadSignFromNBT(a_BlockEntities, a_NBT, Child);
 		}
+		else if (strncmp(a_NBT.GetData(sID), "Skull", a_NBT.GetDataLength(sID)) == 0)
+		{
+			LoadMobHeadFromNBT(a_BlockEntities, a_NBT, Child);
+		}
 		else if (strncmp(a_NBT.GetData(sID), "Trap", a_NBT.GetDataLength(sID)) == 0)
 		{
 			LoadDispenserFromNBT(a_BlockEntities, a_NBT, Child);
@@ -611,12 +627,18 @@ void cWSSAnvil::LoadBlockEntitiesFromNBT(cBlockEntityList & a_BlockEntities, con
 
 bool cWSSAnvil::LoadItemFromNBT(cItem & a_Item, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	int ID = a_NBT.FindChildByName(a_TagIdx, "id");
-	if ((ID < 0) || (a_NBT.GetType(ID) != TAG_Short))
+	int Type = a_NBT.FindChildByName(a_TagIdx, "id");
+	if ((Type < 0) || (a_NBT.GetType(Type) != TAG_Short))
 	{
 		return false;
 	}
-	a_Item.m_ItemType = (ENUM_ITEM_ID)(a_NBT.GetShort(ID));
+	a_Item.m_ItemType = a_NBT.GetShort(Type);
+	if (a_Item.m_ItemType < 0)
+	{
+		LOGD("Encountered an item with negative type (%d). Replacing with an empty item.", a_NBT.GetShort(Type));
+		a_Item.Empty();
+		return true;
+	}
 	
 	int Damage = a_NBT.FindChildByName(a_TagIdx, "Damage");
 	if ((Damage < 0) || (a_NBT.GetType(Damage) != TAG_Short))
@@ -647,6 +669,12 @@ bool cWSSAnvil::LoadItemFromNBT(cItem & a_Item, const cParsedNBT & a_NBT, int a_
 	{
 		EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, a_NBT, EnchTag);
 	}
+
+	int FireworksTag = a_NBT.FindChildByName(TagTag, ((a_Item.m_ItemType == E_ITEM_FIREWORK_STAR) ? "Fireworks" : "Explosion"));
+	if (EnchTag > 0)
+	{
+		cFireworkItem::ParseFromNBT(a_Item.m_FireworkItem, a_NBT, FireworksTag, (ENUM_ITEM_ID)a_Item.m_ItemType);
+	}
 	
 	return true;
 }
@@ -749,6 +777,37 @@ void cWSSAnvil::LoadDropperFromNBT(cBlockEntityList & a_BlockEntities, const cPa
 
 
 
+void cWSSAnvil::LoadFlowerPotFromNBT(cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	ASSERT(a_NBT.GetType(a_TagIdx) == TAG_Compound);
+	int x, y, z;
+	if (!GetBlockEntityNBTPos(a_NBT, a_TagIdx, x, y, z))
+	{
+		return;
+	}
+	std::auto_ptr<cFlowerPotEntity> FlowerPot(new cFlowerPotEntity(x, y, z, m_World));
+	short ItemType = 0, ItemData = 0;
+
+	int currentLine = a_NBT.FindChildByName(a_TagIdx, "Item");
+	if (currentLine >= 0)
+	{
+		ItemType = (short) a_NBT.GetInt(currentLine);
+	}
+
+	currentLine = a_NBT.FindChildByName(a_TagIdx, "Data");
+	if (currentLine >= 0)
+	{
+		ItemData = (short) a_NBT.GetInt(currentLine);
+	}
+
+	FlowerPot->SetItem(cItem(ItemType, 1, ItemData));
+	a_BlockEntities.push_back(FlowerPot.release());
+}
+
+
+
+
+
 void cWSSAnvil::LoadFurnaceFromNBT(cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx, BLOCKTYPE * a_BlockTypes, NIBBLETYPE * a_BlockMetas)
 {
 	ASSERT(a_NBT.GetType(a_TagIdx) == TAG_Compound);
@@ -921,6 +980,41 @@ void cWSSAnvil::LoadSignFromNBT(cBlockEntityList & a_BlockEntities, const cParse
 
 
 
+void cWSSAnvil::LoadMobHeadFromNBT(cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	ASSERT(a_NBT.GetType(a_TagIdx) == TAG_Compound);
+	int x, y, z;
+	if (!GetBlockEntityNBTPos(a_NBT, a_TagIdx, x, y, z))
+	{
+		return;
+	}
+	std::auto_ptr<cMobHeadEntity> MobHead(new cMobHeadEntity(x, y, z, m_World));
+
+	int currentLine = a_NBT.FindChildByName(a_TagIdx, "SkullType");
+	if (currentLine >= 0)
+	{
+		MobHead->SetType(static_cast<eMobHeadType>(a_NBT.GetByte(currentLine)));
+	}
+
+	currentLine = a_NBT.FindChildByName(a_TagIdx, "Rot");
+	if (currentLine >= 0)
+	{
+		MobHead->SetRotation(static_cast<eMobHeadRotation>(a_NBT.GetByte(currentLine)));
+	}
+
+	currentLine = a_NBT.FindChildByName(a_TagIdx, "ExtraType");
+	if (currentLine >= 0)
+	{
+		MobHead->SetOwner(a_NBT.GetString(currentLine));
+	}
+
+	a_BlockEntities.push_back(MobHead.release());
+}
+
+
+
+
+
 void cWSSAnvil::LoadCommandBlockFromNBT(cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	ASSERT(a_NBT.GetType(a_TagIdx) == TAG_Compound);
@@ -964,6 +1058,10 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadBoatFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
+	else if (strncmp(a_IDTag, "EnderCrystal", a_IDTagLength) == 0)
+	{
+		LoadEnderCrystalFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
 	else if (strncmp(a_IDTag, "FallingBlock", a_IDTagLength) == 0)
 	{
 		LoadFallingBlockFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
@@ -1009,6 +1107,18 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadPickupFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
+	else if (strncmp(a_IDTag, "PrimedTnt", a_IDTagLength) == 0)
+	{
+		LoadTNTFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
+	else if (strncmp(a_IDTag, "XPOrb", a_IDTagLength) == 0)
+	{
+		LoadExpOrbFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
+	else if (strncmp(a_IDTag, "ItemFrame", a_IDTagLength) == 0)
+	{
+		LoadItemFrameFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
 	else if (strncmp(a_IDTag, "Arrow", a_IDTagLength) == 0)
 	{
 		LoadArrowFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
@@ -1077,6 +1187,10 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadHorseFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
+	else if (strncmp(a_IDTag, "Villager", a_IDTagLength) == 0)
+	{
+		LoadVillagerFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
 	else if (strncmp(a_IDTag, "VillagerGolem", a_IDTagLength) == 0)
 	{
 		LoadIronGolemFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
@@ -1125,15 +1239,11 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadSquidFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
-	else if (strncmp(a_IDTag, "Villager", a_IDTagLength) == 0)
-	{
-		LoadVillagerFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
-	}
 	else if (strncmp(a_IDTag, "Witch", a_IDTagLength) == 0)
 	{
 		LoadWitchFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
-	else if (strncmp(a_IDTag, "Wither", a_IDTagLength) == 0)
+	else if (strncmp(a_IDTag, "WitherBoss", a_IDTagLength) == 0)
 	{
 		LoadWitherFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
@@ -1170,6 +1280,20 @@ void cWSSAnvil::LoadBoatFromNBT(cEntityList & a_Entities, const cParsedNBT & a_N
 
 
 
+void cWSSAnvil::LoadEnderCrystalFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	std::auto_ptr<cEnderCrystal> EnderCrystal(new cEnderCrystal(0, 0, 0));
+	if (!LoadEntityBaseFromNBT(*EnderCrystal.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	a_Entities.push_back(EnderCrystal.release());
+}
+
+
+
+
+
 void cWSSAnvil::LoadFallingBlockFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	int TypeIdx = a_NBT.FindChildByName(a_TagIdx, "TileID");
@@ -1291,6 +1415,7 @@ void cWSSAnvil::LoadMinecartHFromNBT(cEntityList & a_Entities, const cParsedNBT
 
 void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
+	// Load item:
 	int ItemTag = a_NBT.FindChildByName(a_TagIdx, "Item");
 	if ((ItemTag < 0) || (a_NBT.GetType(ItemTag) != TAG_Compound))
 	{
@@ -1301,11 +1426,27 @@ void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
+	
 	std::auto_ptr<cPickup> Pickup(new cPickup(0, 0, 0, Item, false)); // Pickup delay doesn't matter, just say false
 	if (!LoadEntityBaseFromNBT(*Pickup.get(), a_NBT, a_TagIdx))
 	{
 		return;
 	}
+
+	// Load health:
+	int Health = a_NBT.FindChildByName(a_TagIdx, "Health");
+	if (Health > 0)
+	{
+		Pickup->SetHealth((int) (a_NBT.GetShort(Health) & 0xFF));
+	}
+	
+	// Load age:
+	int Age = a_NBT.FindChildByName(a_TagIdx, "Age");
+	if (Age > 0)
+	{
+		Pickup->SetAge(a_NBT.GetShort(Age));
+	}
+
 	a_Entities.push_back(Pickup.release());
 }
 
@@ -1313,6 +1454,148 @@ void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 
 
 
+void cWSSAnvil::LoadTNTFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	std::auto_ptr<cTNTEntity> TNT(new cTNTEntity(0.0, 0.0, 0.0, 0));
+	if (!LoadEntityBaseFromNBT(*TNT.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	
+	// Load Fuse Ticks:
+	int FuseTicks = a_NBT.FindChildByName(a_TagIdx, "Fuse");
+	if (FuseTicks > 0)
+	{
+		TNT->SetFuseTicks((int) a_NBT.GetByte(FuseTicks));
+	}
+	
+	a_Entities.push_back(TNT.release());
+}
+
+
+
+
+
+void cWSSAnvil::LoadExpOrbFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	std::auto_ptr<cExpOrb> ExpOrb(new cExpOrb(0.0, 0.0, 0.0, 0));
+	if (!LoadEntityBaseFromNBT(*ExpOrb.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+
+	// Load Health:
+	int Health = a_NBT.FindChildByName(a_TagIdx, "Health");
+	if (Health > 0)
+	{
+		ExpOrb->SetHealth((int) (a_NBT.GetShort(Health) & 0xFF));
+	}
+
+	// Load Age:
+	int Age = a_NBT.FindChildByName(a_TagIdx, "Age");
+	if (Age > 0)
+	{
+		ExpOrb->SetAge(a_NBT.GetShort(Age));
+	}
+
+	// Load Reward (Value):
+	int Reward = a_NBT.FindChildByName(a_TagIdx, "Value");
+	if (Reward > 0)
+	{
+		ExpOrb->SetReward(a_NBT.GetShort(Reward));
+	}
+
+	a_Entities.push_back(ExpOrb.release());
+}
+
+
+
+
+
+void cWSSAnvil::LoadHangingFromNBT(cHangingEntity & a_Hanging, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	int Direction = a_NBT.FindChildByName(a_TagIdx, "Direction");
+	if (Direction > 0)
+	{
+		Direction = (int)a_NBT.GetByte(Direction);
+		if ((Direction < 0) || (Direction > 5))
+		{
+			a_Hanging.SetDirection(BLOCK_FACE_NORTH);
+		}
+		else
+		{
+			a_Hanging.SetDirection(static_cast<eBlockFace>(Direction));
+		}
+	}
+	else
+	{
+		Direction = a_NBT.FindChildByName(a_TagIdx, "Dir");
+		if (Direction > 0)
+		{
+			switch ((int)a_NBT.GetByte(Direction))
+			{
+				case 0:   a_Hanging.SetDirection(BLOCK_FACE_NORTH);  break;
+				case 1:   a_Hanging.SetDirection(BLOCK_FACE_TOP);    break;
+				case 2:   a_Hanging.SetDirection(BLOCK_FACE_BOTTOM); break;
+				case 3:   a_Hanging.SetDirection(BLOCK_FACE_SOUTH);  break;
+			}
+		}
+	}
+
+	int TileX = a_NBT.FindChildByName(a_TagIdx, "TileX");
+	int TileY = a_NBT.FindChildByName(a_TagIdx, "TileY");
+	int TileZ = a_NBT.FindChildByName(a_TagIdx, "TileZ");
+	if ((TileX > 0) && (TileY > 0) && (TileZ > 0))
+	{
+		a_Hanging.SetPosition(
+			(double)a_NBT.GetInt(TileX),
+			(double)a_NBT.GetInt(TileY),
+			(double)a_NBT.GetInt(TileZ)
+		);
+	}
+}
+
+
+
+
+
+void cWSSAnvil::LoadItemFrameFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	// Load item:
+	int ItemTag = a_NBT.FindChildByName(a_TagIdx, "Item");
+	if ((ItemTag < 0) || (a_NBT.GetType(ItemTag) != TAG_Compound))
+	{
+		return;
+	}
+	cItem Item;
+	if (!LoadItemFromNBT(Item, a_NBT, ItemTag))
+	{
+		return;
+	}
+	
+	std::auto_ptr<cItemFrame> ItemFrame(new cItemFrame(BLOCK_FACE_NONE, 0.0, 0.0, 0.0));
+	if (!LoadEntityBaseFromNBT(*ItemFrame.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	ItemFrame->SetItem(Item);
+
+	LoadHangingFromNBT(*ItemFrame.get(), a_NBT, a_TagIdx);
+	
+	// Load Rotation:
+	int Rotation = a_NBT.FindChildByName(a_TagIdx, "ItemRotation");
+	if (Rotation > 0)
+	{
+		ItemFrame->SetRotation((Byte)a_NBT.GetByte(Rotation));
+	}
+	
+	a_Entities.push_back(ItemFrame.release());
+}
+
+
+
+
+
 void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	std::auto_ptr<cArrowEntity> Arrow(new cArrowEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
@@ -1439,6 +1722,11 @@ void cWSSAnvil::LoadBatFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NB
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1454,6 +1742,11 @@ void cWSSAnvil::LoadBlazeFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1469,6 +1762,11 @@ void cWSSAnvil::LoadCaveSpiderFromNBT(cEntityList & a_Entities, const cParsedNBT
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1484,6 +1782,11 @@ void cWSSAnvil::LoadChickenFromNBT(cEntityList & a_Entities, const cParsedNBT &
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1499,6 +1802,11 @@ void cWSSAnvil::LoadCowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NB
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1514,6 +1822,11 @@ void cWSSAnvil::LoadCreeperFromNBT(cEntityList & a_Entities, const cParsedNBT &
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1529,6 +1842,11 @@ void cWSSAnvil::LoadEnderDragonFromNBT(cEntityList & a_Entities, const cParsedNB
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1545,6 +1863,11 @@ void cWSSAnvil::LoadEndermanFromNBT(cEntityList & a_Entities, const cParsedNBT &
 		return;
 	}
 
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+
 	a_Entities.push_back(Monster.release());
 }
 
@@ -1560,6 +1883,11 @@ void cWSSAnvil::LoadGhastFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 		return;
 	}
 
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+
 	a_Entities.push_back(Monster.release());
 }
 
@@ -1574,6 +1902,11 @@ void cWSSAnvil::LoadGiantFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1600,6 +1933,11 @@ void cWSSAnvil::LoadHorseFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1615,6 +1953,11 @@ void cWSSAnvil::LoadIronGolemFromNBT(cEntityList & a_Entities, const cParsedNBT
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1636,6 +1979,11 @@ void cWSSAnvil::LoadMagmaCubeFromNBT(cEntityList & a_Entities, const cParsedNBT
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1651,6 +1999,11 @@ void cWSSAnvil::LoadMooshroomFromNBT(cEntityList & a_Entities, const cParsedNBT
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1666,6 +2019,11 @@ void cWSSAnvil::LoadOcelotFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1681,6 +2039,11 @@ void cWSSAnvil::LoadPigFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NB
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1702,6 +2065,11 @@ void cWSSAnvil::LoadSheepFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1717,6 +2085,11 @@ void cWSSAnvil::LoadSilverfishFromNBT(cEntityList & a_Entities, const cParsedNBT
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1738,6 +2111,11 @@ void cWSSAnvil::LoadSkeletonFromNBT(cEntityList & a_Entities, const cParsedNBT &
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1759,6 +2137,11 @@ void cWSSAnvil::LoadSlimeFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1774,6 +2157,11 @@ void cWSSAnvil::LoadSnowGolemFromNBT(cEntityList & a_Entities, const cParsedNBT
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1789,6 +2177,11 @@ void cWSSAnvil::LoadSpiderFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1804,6 +2197,11 @@ void cWSSAnvil::LoadSquidFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1825,6 +2223,11 @@ void cWSSAnvil::LoadVillagerFromNBT(cEntityList & a_Entities, const cParsedNBT &
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1840,6 +2243,11 @@ void cWSSAnvil::LoadWitchFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1855,6 +2263,17 @@ void cWSSAnvil::LoadWitherFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+
+	int CurrLine = a_NBT.FindChildByName(a_TagIdx, "Invul");
+	if (CurrLine > 0)
+	{
+		Monster->SetNumInvulnerableTicks(a_NBT.GetInt(CurrLine));
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1870,7 +2289,38 @@ void cWSSAnvil::LoadWolfFromNBT(cEntityList & a_Entities, const cParsedNBT & a_N
 	{
 		return;
 	}
-
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	int OwnerIdx = a_NBT.FindChildByName(a_TagIdx, "Owner");
+	if (OwnerIdx > 0) 
+	{ 
+		AString OwnerName = a_NBT.GetString(OwnerIdx);
+		if (OwnerName != "")
+		{
+			Monster->SetOwner(OwnerName);
+			Monster->SetIsTame(true);
+		}
+	}
+	int SittingIdx = a_NBT.FindChildByName(a_TagIdx, "Sitting");
+	if (SittingIdx > 0)
+	{
+		bool Sitting = ((a_NBT.GetByte(SittingIdx) == 1) ? true : false);
+		Monster->SetIsSitting(Sitting);
+	}
+	int AngryIdx = a_NBT.FindChildByName(a_TagIdx, "Angry");
+	if (AngryIdx > 0)
+	{
+		bool Angry = ((a_NBT.GetByte(AngryIdx) == 1) ? true : false);
+		Monster->SetIsAngry(Angry);
+	}
+	int CollarColorIdx = a_NBT.FindChildByName(a_TagIdx, "CollarColor");
+	if (CollarColorIdx > 0)
+	{
+		int CollarColor = a_NBT.GetInt(CollarColorIdx);
+		Monster->SetCollarColor(CollarColor);
+	}
 	a_Entities.push_back(Monster.release());
 }
 
@@ -1891,6 +2341,11 @@ void cWSSAnvil::LoadZombieFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
+	
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
 
 	a_Entities.push_back(Monster.release());
 }
@@ -1907,6 +2362,11 @@ void cWSSAnvil::LoadPigZombieFromNBT(cEntityList & a_Entities, const cParsedNBT
 		return;
 	}
 
+	if (!LoadMonsterBaseFromNBT(*Monster.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+
 	a_Entities.push_back(Monster.release());
 }
 
@@ -1926,17 +2386,22 @@ bool cWSSAnvil::LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_N
 	double Speed[3];
 	if (!LoadDoublesListFromNBT(Speed, 3, a_NBT, a_NBT.FindChildByName(a_TagIdx, "Motion")))
 	{
-		return false;
+		// Provide default speed:
+		Speed[0] = 0;
+		Speed[1] = 0;
+		Speed[2] = 0;
 	}
 	a_Entity.SetSpeed(Speed[0], Speed[1], Speed[2]);
 	
 	double Rotation[3];
 	if (!LoadDoublesListFromNBT(Rotation, 2, a_NBT, a_NBT.FindChildByName(a_TagIdx, "Rotation")))
 	{
-		return false;
+		// Provide default rotation:
+		Rotation[0] = 0;
+		Rotation[1] = 0;
 	}
 	a_Entity.SetYaw(Rotation[0]);
-	a_Entity.SetRoll    (Rotation[1]);
+	a_Entity.SetRoll(Rotation[1]);
 	
 	return true;
 }
@@ -1945,6 +2410,27 @@ bool cWSSAnvil::LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_N
 
 
 
+bool cWSSAnvil::LoadMonsterBaseFromNBT(cMonster & a_Monster, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	float DropChance[5];
+	if (!LoadFloatsListFromNBT(DropChance, 5, a_NBT, a_NBT.FindChildByName(a_TagIdx, "DropChance")))
+	{
+		return false;
+	}
+	a_Monster.SetDropChanceWeapon(DropChance[0]);
+	a_Monster.SetDropChanceHelmet(DropChance[1]);
+	a_Monster.SetDropChanceChestplate(DropChance[2]);
+	a_Monster.SetDropChanceLeggings(DropChance[3]);
+	a_Monster.SetDropChanceBoots(DropChance[4]);
+	bool CanPickUpLoot = (a_NBT.GetByte(a_NBT.FindChildByName(a_TagIdx, "CanPickUpLoot")) == 1);
+	a_Monster.SetCanPickUpLoot(CanPickUpLoot);
+	return true;
+}
+
+
+
+
+
 bool cWSSAnvil::LoadProjectileBaseFromNBT(cProjectileEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	if (!LoadEntityBaseFromNBT(a_Entity, a_NBT, a_TagIdx))
@@ -1987,6 +2473,24 @@ bool cWSSAnvil::LoadDoublesListFromNBT(double * a_Doubles, int a_NumDoubles, con
 
 
 
+bool cWSSAnvil::LoadFloatsListFromNBT(float * a_Floats, int a_NumFloats, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	if ((a_TagIdx < 0) || (a_NBT.GetType(a_TagIdx) != TAG_List) || (a_NBT.GetChildrenType(a_TagIdx) != TAG_Float))
+	{
+		return false;
+	}
+	int idx = 0;
+	for (int Tag = a_NBT.GetFirstChild(a_TagIdx); (Tag > 0) && (idx < a_NumFloats); Tag = a_NBT.GetNextSibling(Tag), ++idx)
+	{
+		a_Floats[idx] = a_NBT.GetFloat(Tag);
+	}  // for Tag - PosTag[]
+	return (idx == a_NumFloats);  // Did we read enough doubles?
+}
+
+
+
+
+
 bool cWSSAnvil::GetBlockEntityNBTPos(const cParsedNBT & a_NBT, int a_TagIdx, int & a_X, int & a_Y, int & a_Z)
 {
 	int x = a_NBT.FindChildByName(a_TagIdx, "x");
diff --git a/src/WorldStorage/WSSAnvil.h b/src/WorldStorage/WSSAnvil.h
index 5093ad083..1773ee882 100644
--- a/src/WorldStorage/WSSAnvil.h
+++ b/src/WorldStorage/WSSAnvil.h
@@ -10,6 +10,7 @@
 
 #include "WorldStorage.h"
 #include "FastNBT.h"
+#include "../Mobs/Monster.h"
 
 
 
@@ -19,6 +20,7 @@
 class cItemGrid;
 
 class cProjectileEntity;
+class cHangingEntity;
 
 
 
@@ -134,18 +136,25 @@ protected:
 	void LoadChestFromNBT       (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadDispenserFromNBT   (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadDropperFromNBT     (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadFlowerPotFromNBT   (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadFurnaceFromNBT     (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx, BLOCKTYPE * a_BlockTypes, NIBBLETYPE * a_BlockMetas);
 	void LoadHopperFromNBT      (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadJukeboxFromNBT     (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadNoteFromNBT        (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadSignFromNBT        (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadMobHeadFromNBT     (cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadCommandBlockFromNBT(cBlockEntityList & a_BlockEntities, const cParsedNBT & a_NBT, int a_TagIdx);
 	
 	void LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_EntityTagIdx, const char * a_IDTag, int a_IDTagLength);
 	
 	void LoadBoatFromNBT            (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadEnderCrystalFromNBT    (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadFallingBlockFromNBT    (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadPickupFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadTNTFromNBT             (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadExpOrbFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadHangingFromNBT         (cHangingEntity & a_Hanging,const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadItemFrameFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 
 	void LoadMinecartRFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadMinecartCFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
@@ -193,12 +202,18 @@ protected:
 	/// Loads entity common data from the NBT compound; returns true if successful
 	bool LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx);
 	
+	/// Loads monster common data from the NBT compound; returns true if successful
+	bool LoadMonsterBaseFromNBT(cMonster & a_Monster, const cParsedNBT & a_NBT, int a_TagIdx);
+	
 	/// Loads projectile common data from the NBT compound; returns true if successful
 	bool LoadProjectileBaseFromNBT(cProjectileEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIx);
 	
 	/// Loads an array of doubles of the specified length from the specified NBT list tag a_TagIdx; returns true if successful
 	bool LoadDoublesListFromNBT(double * a_Doubles, int a_NumDoubles, const cParsedNBT & a_NBT, int a_TagIdx);
 
+	/// Loads an array of floats of the specified length from the specified NBT list tag a_TagIdx; returns true if successful
+	bool LoadFloatsListFromNBT(float * a_Floats, int a_NumFloats, const cParsedNBT & a_NBT, int a_TagIdx);
+
 	/// Helper function for extracting the X, Y, and Z int subtags of a NBT compound; returns true if successful
 	bool GetBlockEntityNBTPos(const cParsedNBT & a_NBT, int a_TagIdx, int & a_X, int & a_Y, int & a_Z);
 	
diff --git a/src/WorldStorage/WSSCompact.cpp b/src/WorldStorage/WSSCompact.cpp
index ea17a8ec1..bb9d4b9e6 100644
--- a/src/WorldStorage/WSSCompact.cpp
+++ b/src/WorldStorage/WSSCompact.cpp
@@ -10,9 +10,12 @@
 #include "json/json.h"
 #include "../StringCompression.h"
 #include "../BlockEntities/ChestEntity.h"
+#include "../BlockEntities/CommandBlockEntity.h"
 #include "../BlockEntities/DispenserEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 #include "../BlockEntities/FurnaceEntity.h"
 #include "../BlockEntities/JukeboxEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
 #include "../BlockEntities/NoteEntity.h"
 #include "../BlockEntities/SignEntity.h"
 
@@ -36,7 +39,7 @@ struct cWSSCompact::sChunkHeader
 
 
 /// The maximum number of PAK files that are cached
-const int MAX_PAK_FILES = 16;
+const size_t MAX_PAK_FILES = 16;
 
 /// The maximum number of unsaved chunks before the cPAKFile saves them to disk
 const int MAX_DIRTY_CHUNKS = 16;
@@ -71,14 +74,17 @@ void cJsonChunkSerializer::BlockEntity(cBlockEntity * a_BlockEntity)
 	const char * SaveInto = NULL;
 	switch (a_BlockEntity->GetBlockType())
 	{
-		case E_BLOCK_CHEST:      SaveInto = "Chests";      break;
-		case E_BLOCK_DISPENSER:  SaveInto = "Dispensers";  break;
-		case E_BLOCK_DROPPER:    SaveInto = "Droppers";    break;
-		case E_BLOCK_FURNACE:    SaveInto = "Furnaces";    break;
-		case E_BLOCK_SIGN_POST:  SaveInto = "Signs";       break;
-		case E_BLOCK_WALLSIGN:   SaveInto = "Signs";       break;
-		case E_BLOCK_NOTE_BLOCK: SaveInto = "Notes";       break;
-		case E_BLOCK_JUKEBOX:    SaveInto = "Jukeboxes";   break;
+		case E_BLOCK_CHEST:         SaveInto = "Chests";        break;
+		case E_BLOCK_DISPENSER:     SaveInto = "Dispensers";    break;
+		case E_BLOCK_DROPPER:       SaveInto = "Droppers";      break;
+		case E_BLOCK_FLOWER_POT:    SaveInto = "FlowerPots";    break;
+		case E_BLOCK_FURNACE:       SaveInto = "Furnaces";      break;
+		case E_BLOCK_SIGN_POST:     SaveInto = "Signs";         break;
+		case E_BLOCK_WALLSIGN:      SaveInto = "Signs";         break;
+		case E_BLOCK_NOTE_BLOCK:    SaveInto = "Notes";         break;
+		case E_BLOCK_JUKEBOX:       SaveInto = "Jukeboxes";     break;
+		case E_BLOCK_COMMAND_BLOCK: SaveInto = "CommandBlocks"; break;
+		case E_BLOCK_HEAD:          SaveInto = "MobHeads";      break;
 
 		default:
 		{
@@ -263,126 +269,144 @@ bool cWSSCompact::EraseChunkData(const cChunkCoords & a_Chunk)
 
 void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_Entities, cBlockEntityList & a_BlockEntities, cWorld * a_World)
 {
-	// Load chests
+	// Load chests:
 	Json::Value AllChests = a_Value.get("Chests", Json::nullValue);
 	if (!AllChests.empty())
 	{
 		for (Json::Value::iterator itr = AllChests.begin(); itr != AllChests.end(); ++itr )
 		{
-			Json::Value & Chest = *itr;
-			cChestEntity * ChestEntity = new cChestEntity(0,0,0, a_World);
-			if (!ChestEntity->LoadFromJson( Chest ) )
+			std::auto_ptr<cChestEntity> ChestEntity(new cChestEntity(0, 0, 0, a_World));
+			if (!ChestEntity->LoadFromJson(*itr))
 			{
-				LOGERROR("ERROR READING CHEST FROM JSON!" );
-				delete ChestEntity;
+				LOGWARNING("ERROR READING CHEST FROM JSON!" );
 			}
 			else
 			{
-				a_BlockEntities.push_back( ChestEntity );
+				a_BlockEntities.push_back(ChestEntity.release());
 			}
 		}  // for itr - AllChests[]
 	}
 
-	// Load dispensers
+	// Load dispensers:
 	Json::Value AllDispensers = a_Value.get("Dispensers", Json::nullValue);
-	if( !AllDispensers.empty() )
+	for (Json::Value::iterator itr = AllDispensers.begin(); itr != AllDispensers.end(); ++itr)
 	{
-		for( Json::Value::iterator itr = AllDispensers.begin(); itr != AllDispensers.end(); ++itr )
+		std::auto_ptr<cDispenserEntity> DispenserEntity(new cDispenserEntity(0, 0, 0, a_World));
+		if (!DispenserEntity->LoadFromJson(*itr))
 		{
-			Json::Value & Dispenser = *itr;
-			cDispenserEntity * DispenserEntity = new cDispenserEntity(0,0,0, a_World);
-			if( !DispenserEntity->LoadFromJson( Dispenser ) )
-			{
-				LOGERROR("ERROR READING DISPENSER FROM JSON!" );
-				delete DispenserEntity;
-			}
-			else
-			{
-				a_BlockEntities.push_back( DispenserEntity );
-			}
-		}  // for itr - AllDispensers[]
-	}
+			LOGWARNING("ERROR READING DISPENSER FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(DispenserEntity.release());
+		}
+	}  // for itr - AllDispensers[]
 
-	// Load furnaces
+	// Load Flowerpots:
+	Json::Value AllFlowerPots = a_Value.get("FlowerPots", Json::nullValue);
+	for (Json::Value::iterator itr = AllFlowerPots.begin(); itr != AllFlowerPots.end(); ++itr)
+	{
+		std::auto_ptr<cFlowerPotEntity> FlowerPotEntity(new cFlowerPotEntity(0, 0, 0, a_World));
+		if (!FlowerPotEntity->LoadFromJson(*itr))
+		{
+			LOGWARNING("ERROR READING FLOWERPOT FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(FlowerPotEntity.release());
+		}
+	}  // for itr - AllFlowerPots[]
+
+	// Load furnaces:
 	Json::Value AllFurnaces = a_Value.get("Furnaces", Json::nullValue);
-	if( !AllFurnaces.empty() )
+	for (Json::Value::iterator itr = AllFurnaces.begin(); itr != AllFurnaces.end(); ++itr)
 	{
-		for( Json::Value::iterator itr = AllFurnaces.begin(); itr != AllFurnaces.end(); ++itr )
+		// TODO: The block type and meta aren't correct, there's no way to get them here
+		std::auto_ptr<cFurnaceEntity> FurnaceEntity(new cFurnaceEntity(0, 0, 0, E_BLOCK_FURNACE, 0, a_World));
+		if (!FurnaceEntity->LoadFromJson(*itr))
 		{
-			Json::Value & Furnace = *itr;
-			// TODO: The block type and meta aren't correct, there's no way to get them here
-			cFurnaceEntity * FurnaceEntity = new cFurnaceEntity(0, 0, 0, E_BLOCK_FURNACE, 0, a_World);
-			if (!FurnaceEntity->LoadFromJson(Furnace))
-			{
-				LOGERROR("ERROR READING FURNACE FROM JSON!" );
-				delete FurnaceEntity;
-			}
-			else
-			{
-				a_BlockEntities.push_back(FurnaceEntity);
-			}
-		}  // for itr - AllFurnaces[]
-	}
+			LOGWARNING("ERROR READING FURNACE FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(FurnaceEntity.release());
+		}
+	}  // for itr - AllFurnaces[]
 
-	// Load signs
+	// Load signs:
 	Json::Value AllSigns = a_Value.get("Signs", Json::nullValue);
-	if( !AllSigns.empty() )
+	for (Json::Value::iterator itr = AllSigns.begin(); itr != AllSigns.end(); ++itr)
 	{
-		for( Json::Value::iterator itr = AllSigns.begin(); itr != AllSigns.end(); ++itr )
+		std::auto_ptr<cSignEntity> SignEntity(new cSignEntity(E_BLOCK_SIGN_POST, 0, 0, 0, a_World));
+		if (!SignEntity->LoadFromJson(*itr))
 		{
-			Json::Value & Sign = *itr;
-			cSignEntity * SignEntity = new cSignEntity( E_BLOCK_SIGN_POST, 0,0,0, a_World);
-			if ( !SignEntity->LoadFromJson( Sign ) )
-			{
-				LOGERROR("ERROR READING SIGN FROM JSON!" );
-				delete SignEntity;
-			}
-			else
-			{
-				a_BlockEntities.push_back( SignEntity );
-			}
-		}  // for itr - AllSigns[]
-	}
+			LOGWARNING("ERROR READING SIGN FROM JSON!");
+		}
+		else
+		{
+			a_BlockEntities.push_back(SignEntity.release());
+		}
+	}  // for itr - AllSigns[]
 
-	// Load note blocks
+	// Load note blocks:
 	Json::Value AllNotes = a_Value.get("Notes", Json::nullValue);
-	if( !AllNotes.empty() )
+	for (Json::Value::iterator itr = AllNotes.begin(); itr != AllNotes.end(); ++itr)
 	{
-		for( Json::Value::iterator itr = AllNotes.begin(); itr != AllNotes.end(); ++itr )
+		std::auto_ptr<cNoteEntity> NoteEntity(new cNoteEntity(0, 0, 0, a_World));
+		if (!NoteEntity->LoadFromJson(*itr))
 		{
-			Json::Value & Note = *itr;
-			cNoteEntity * NoteEntity = new cNoteEntity(0, 0, 0, a_World);
-			if ( !NoteEntity->LoadFromJson( Note ) )
-			{
-				LOGERROR("ERROR READING NOTE BLOCK FROM JSON!" );
-				delete NoteEntity;
-			}
-			else
-			{
-				a_BlockEntities.push_back( NoteEntity );
-			}
-		}  // for itr - AllNotes[]
-	}
+			LOGWARNING("ERROR READING NOTE BLOCK FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(NoteEntity.release());
+		}
+	}  // for itr - AllNotes[]
 
-	// Load jukeboxes
+	// Load jukeboxes:
 	Json::Value AllJukeboxes = a_Value.get("Jukeboxes", Json::nullValue);
-	if( !AllJukeboxes.empty() )
+	for (Json::Value::iterator itr = AllJukeboxes.begin(); itr != AllJukeboxes.end(); ++itr)
 	{
-		for( Json::Value::iterator itr = AllJukeboxes.begin(); itr != AllJukeboxes.end(); ++itr )
+		std::auto_ptr<cJukeboxEntity> JukeboxEntity(new cJukeboxEntity(0, 0, 0, a_World));
+		if (!JukeboxEntity->LoadFromJson(*itr))
 		{
-			Json::Value & Jukebox = *itr;
-			cJukeboxEntity * JukeboxEntity = new cJukeboxEntity(0, 0, 0, a_World);
-			if ( !JukeboxEntity->LoadFromJson( Jukebox ) )
-			{
-				LOGERROR("ERROR READING JUKEBOX FROM JSON!" );
-				delete JukeboxEntity;
-			}
-			else
-			{
-				a_BlockEntities.push_back( JukeboxEntity );
-			}
-		}  // for itr - AllJukeboxes[]
-	}
+			LOGWARNING("ERROR READING JUKEBOX FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(JukeboxEntity.release());
+		}
+	}  // for itr - AllJukeboxes[]
+
+	// Load command blocks:
+	Json::Value AllCommandBlocks = a_Value.get("CommandBlocks", Json::nullValue);
+	for (Json::Value::iterator itr = AllCommandBlocks.begin(); itr != AllCommandBlocks.end(); ++itr)
+	{
+		std::auto_ptr<cCommandBlockEntity> CommandBlockEntity(new cCommandBlockEntity(0, 0, 0, a_World));
+		if (!CommandBlockEntity->LoadFromJson(*itr))
+		{
+			LOGWARNING("ERROR READING COMMAND BLOCK FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(CommandBlockEntity.release());
+		}
+	}  // for itr - AllCommandBlocks[]
+
+	// Load mob heads:
+	Json::Value AllMobHeads = a_Value.get("MobHeads", Json::nullValue);
+	for (Json::Value::iterator itr = AllMobHeads.begin(); itr != AllMobHeads.end(); ++itr)
+	{
+		std::auto_ptr<cMobHeadEntity> MobHeadEntity(new cMobHeadEntity(0, 0, 0, a_World));
+		if (!MobHeadEntity->LoadFromJson(*itr))
+		{
+			LOGWARNING("ERROR READING MOB HEAD FROM JSON!" );
+		}
+		else
+		{
+			a_BlockEntities.push_back(MobHeadEntity.release());
+		}
+	}  // for itr - AllMobHeads[]
 }
 
 
@@ -545,7 +569,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 
 		if( ChunksConverted % 32 == 0 )
 		{
-			LOGINFO("Updating \"%s\" version 1 to version 2: %d %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
+			LOGINFO("Updating \"%s\" version 1 to version 2: " SIZE_T_FMT  " %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
 		}
 		ChunksConverted++;
 
@@ -583,7 +607,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 
 		if (UncompressedSize != (int)UncompressedData.size())
 		{
-			LOGWARNING("Uncompressed data size differs (exp %d bytes, got %d) for chunk [%d, %d]",
+			LOGWARNING("Uncompressed data size differs (exp %d bytes, got " SIZE_T_FMT  ") for chunk [%d, %d]",
 				UncompressedSize, UncompressedData.size(),
 				Header->m_ChunkX, Header->m_ChunkZ
 				);
@@ -689,7 +713,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 
 		if( ChunksConverted % 32 == 0 )
 		{
-			LOGINFO("Updating \"%s\" version 2 to version 3: %d %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
+			LOGINFO("Updating \"%s\" version 2 to version 3: " SIZE_T_FMT  " %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
 		}
 		ChunksConverted++;
 
@@ -727,7 +751,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 
 		if (UncompressedSize != (int)UncompressedData.size())
 		{
-			LOGWARNING("Uncompressed data size differs (exp %d bytes, got %d) for chunk [%d, %d]",
+			LOGWARNING("Uncompressed data size differs (exp %d bytes, got " SIZE_T_FMT  ") for chunk [%d, %d]",
 				UncompressedSize, UncompressedData.size(),
 				Header->m_ChunkX, Header->m_ChunkZ
 				);
@@ -740,7 +764,6 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 
 		// Cannot use cChunk::MakeIndex because it might change again?????????
 		// For compatibility, use what we know is current
-		#define MAKE_2_INDEX( x, y, z ) ( y + (z * 256) + (x * 256 * 16) )
 		#define MAKE_3_INDEX( x, y, z ) ( x + (z * 16) + (y * 16 * 16) )
 
 		unsigned int InChunkOffset = 0;
@@ -843,7 +866,7 @@ bool cWSSCompact::LoadChunkFromData(const cChunkCoords & a_Chunk, int & a_Uncomp
 	
 	if (a_UncompressedSize != (int)UncompressedData.size())
 	{
-		LOGWARNING("Uncompressed data size differs (exp %d bytes, got %d) for chunk [%d, %d]",
+		LOGWARNING("Uncompressed data size differs (exp %d bytes, got " SIZE_T_FMT  ") for chunk [%d, %d]",
 			a_UncompressedSize, UncompressedData.size(),
 			a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ
 		);
diff --git a/src/WorldStorage/WSSCompact.h b/src/WorldStorage/WSSCompact.h
index 64b8d7f31..4df146ec3 100644
--- a/src/WorldStorage/WSSCompact.h
+++ b/src/WorldStorage/WSSCompact.h
@@ -12,7 +12,7 @@
 #define WSSCOMPACT_H_INCLUDED
 
 #include "WorldStorage.h"
-#include "../Vector3i.h"
+#include "../Vector3.h"
 #include "json/json.h"
 
 
diff --git a/src/main.cpp b/src/main.cpp
index 340149e0b..68eea7f4d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -19,8 +19,20 @@ bool g_SERVER_TERMINATED = false; // Set to true when the server terminates, so
 
 
 
+/** If set to true, the protocols will log each player's incoming (C->S) communication to a per-connection logfile */
+bool g_ShouldLogCommIn;
+
+/** If set to true, the protocols will log each player's outgoing (S->C) communication to a per-connection logfile */
+bool g_ShouldLogCommOut;
+
+
+
+
+
 /// If defined, a thorough leak finder will be used (debug MSVC only); leaks will be output to the Output window
-#define ENABLE_LEAK_FINDER
+// _X 2014_02_20: Disabled for canon repo, it makes the debug version too slow in MSVC2013
+// and we haven't had a memory leak for over a year anyway.
+// #define ENABLE_LEAK_FINDER
 
 
 
@@ -59,11 +71,12 @@ void NonCtrlHandler(int a_Signal)
 			std::signal(a_Signal, SIG_DFL);
 			LOGERROR("  D:    | MCServer has encountered an error and needs to close");
 			LOGERROR("Details | SIGABRT: Server self-terminated due to an internal fault");
-			break;
+			exit(EXIT_FAILURE);
 		}
+		case SIGINT:
 		case SIGTERM:
 		{
-			std::signal(SIGTERM, SIG_IGN); // Server is shutting down, wait for it...
+			std::signal(a_Signal, SIG_IGN); // Server is shutting down, wait for it...
 			break;
 		}
 		default: break;
@@ -216,12 +229,50 @@ int main( int argc, char **argv )
 	#ifndef _DEBUG
 	std::signal(SIGSEGV, NonCtrlHandler);
 	std::signal(SIGTERM, NonCtrlHandler);
-	std::signal(SIGINT, NonCtrlHandler);
+	std::signal(SIGINT,  NonCtrlHandler);
+	std::signal(SIGABRT, NonCtrlHandler);
+	#ifdef SIGABRT_COMPAT
+	std::signal(SIGABRT_COMPAT, NonCtrlHandler);
+	#endif // SIGABRT_COMPAT
 	#endif
 
 	// DEBUG: test the dumpfile creation:
 	// *((int *)0) = 0;
 	
+	// Check if comm logging is to be enabled:
+	for (int i = 0; i < argc; i++)
+	{
+		AString Arg(argv[i]);
+		if (
+			(NoCaseCompare(Arg, "/commlog") == 0) ||
+			(NoCaseCompare(Arg, "/logcomm") == 0)
+		)
+		{
+			g_ShouldLogCommIn = true;
+			g_ShouldLogCommOut = true;
+		}
+		else if (
+			(NoCaseCompare(Arg, "/commlogin") == 0) ||
+			(NoCaseCompare(Arg, "/comminlog") == 0) ||
+			(NoCaseCompare(Arg, "/logcommin") == 0)
+		)
+		{
+			g_ShouldLogCommIn = true;
+		}
+		else if (
+			(NoCaseCompare(Arg, "/commlogout") == 0) ||
+			(NoCaseCompare(Arg, "/commoutlog") == 0) ||
+			(NoCaseCompare(Arg, "/logcommout") == 0)
+		)
+		{
+			g_ShouldLogCommOut = true;
+		}
+		else if (NoCaseCompare(Arg, "nooutbuf") == 0)
+		{
+			setvbuf(stdout, NULL, _IONBF, 0);
+		}
+	}  // for i - argv[]
+	
 	#if !defined(ANDROID_NDK)
 	try
 	#endif