121 files changed, 3619 insertions, 1342 deletions

diff --git a/src/Bindings/AllToLua.pkg b/src/Bindings/AllToLua.pkg
index 6537437cd..2676281f9 100644
--- a/src/Bindings/AllToLua.pkg
+++ b/src/Bindings/AllToLua.pkg
@@ -26,6 +26,7 @@ $cfile "WebPlugin.h"
 $cfile "LuaWindow.h"
 
 $cfile "../BlockID.h"
+$cfile "../BlockInfo.h"
 $cfile "../StringUtils.h"
 $cfile "../Defines.h"
 $cfile "../ChatColor.h"
@@ -57,6 +58,8 @@ $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"
@@ -75,6 +78,7 @@ $cfile "../Mobs/Monster.h"
 $cfile "../CompositeChat.h"
 $cfile "../Map.h"
 $cfile "../MapManager.h"
+$cfile "../Scoreboard.h"
 
 
 
diff --git a/src/Bindings/DeprecatedBindings.cpp b/src/Bindings/DeprecatedBindings.cpp
new file mode 100644
index 000000000..408b1b84a
--- /dev/null
+++ b/src/Bindings/DeprecatedBindings.cpp
@@ -0,0 +1,506 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "DeprecatedBindings.h"
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushnumber(tolua_S,(lua_Number)cBlockInfo::GetLightValue(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockLightValue */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockLightValue
+static int tolua_set_AllToLua_g_BlockLightValue(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_LightValue = ((unsigned char)  tolua_tonumber(tolua_S,3,0));
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushnumber(tolua_S,(lua_Number)cBlockInfo::GetSpreadLightFalloff(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockSpreadLightFalloff */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockSpreadLightFalloff
+static int tolua_set_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_SpreadLightFalloff = ((unsigned char)  tolua_tonumber(tolua_S,3,0));
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S, cBlockInfo::IsTransparent(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockTransparent */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockTransparent
+static int tolua_set_AllToLua_g_BlockTransparent(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_Transparent = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S,(bool)cBlockInfo::IsOneHitDig(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockOneHitDig */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockOneHitDig
+static int tolua_set_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_OneHitDig = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S,(bool)cBlockInfo::IsPistonBreakable(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockPistonBreakable */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockPistonBreakable
+static int tolua_set_AllToLua_g_BlockPistonBreakable(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_PistonBreakable = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S,(bool)cBlockInfo::IsSnowable(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockIsSnowable */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockIsSnowable
+static int tolua_set_AllToLua_g_BlockIsSnowable(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_IsSnowable = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S,(bool)cBlockInfo::RequiresSpecialTool(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockRequiresSpecialTool */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockRequiresSpecialTool
+static int tolua_set_AllToLua_g_BlockRequiresSpecialTool(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_RequiresSpecialTool = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S,(bool)cBlockInfo::IsSolid(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockIsSolid */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockIsSolid
+static int tolua_set_AllToLua_g_BlockIsSolid(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_IsSolid = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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 tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	tolua_pushboolean(tolua_S,(bool)cBlockInfo::FullyOccupiesVoxel(tolua_index));
+	return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+
+
+
+/* set function: g_BlockFullyOccupiesVoxel */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockFullyOccupiesVoxel
+static int tolua_set_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
+{
+	int tolua_index;
+	#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
+	tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+	#ifndef TOLUA_RELEASE
+	if (tolua_index<0 || tolua_index>=256)
+		tolua_error(tolua_S,"array indexing out of range.",NULL);
+	#endif
+	cBlockInfo::Get(tolua_index).m_FullyOccupiesVoxel = (tolua_toboolean(tolua_S,3,0) != 0);
+	return 0;
+}
+#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,          tolua_set_AllToLua_g_BlockLightValue);
+	tolua_array(tolua_S, "g_BlockSpreadLightFalloff",  tolua_get_AllToLua_g_BlockSpreadLightFalloff,  tolua_set_AllToLua_g_BlockSpreadLightFalloff);
+	tolua_array(tolua_S, "g_BlockTransparent",         tolua_get_AllToLua_g_BlockTransparent,         tolua_set_AllToLua_g_BlockTransparent);
+	tolua_array(tolua_S, "g_BlockOneHitDig",           tolua_get_AllToLua_g_BlockOneHitDig,           tolua_set_AllToLua_g_BlockOneHitDig);
+	tolua_array(tolua_S, "g_BlockPistonBreakable",     tolua_get_AllToLua_g_BlockPistonBreakable,     tolua_set_AllToLua_g_BlockPistonBreakable);
+	tolua_array(tolua_S, "g_BlockIsSnowable",          tolua_get_AllToLua_g_BlockIsSnowable,          tolua_set_AllToLua_g_BlockIsSnowable);
+	tolua_array(tolua_S, "g_BlockRequiresSpecialTool", tolua_get_AllToLua_g_BlockRequiresSpecialTool, tolua_set_AllToLua_g_BlockRequiresSpecialTool);
+	tolua_array(tolua_S, "g_BlockIsSolid",             tolua_get_AllToLua_g_BlockIsSolid,             tolua_set_AllToLua_g_BlockIsSolid);
+	tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel",  tolua_get_AllToLua_g_BlockFullyOccupiesVoxel,  tolua_set_AllToLua_g_BlockFullyOccupiesVoxel);
+
+	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/LuaState.cpp b/src/Bindings/LuaState.cpp
index 45a066efe..1890dcfe5 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -14,6 +14,7 @@ extern "C"
 #include "tolua++/include/tolua++.h"
 #include "Bindings.h"
 #include "ManualBindings.h"
+#include "DeprecatedBindings.h"
 
 // fwd: SQLite/lsqlite3.c
 extern "C"
@@ -95,6 +96,7 @@ void cLuaState::Create(void)
 	luaL_openlibs(m_LuaState);
 	tolua_AllToLua_open(m_LuaState);
 	ManualBindings::Bind(m_LuaState);
+	DeprecatedBindings::Bind(m_LuaState);
 	luaopen_lsqlite3(m_LuaState);
 	luaopen_lxp(m_LuaState);
 	m_IsOwned = true;
@@ -714,7 +716,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);
 }
@@ -723,11 +725,17 @@ 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_Value.assign(data, len);
+	}
+	else
 	{
-		a_ReturnedVal = tolua_tocppstring(m_LuaState, a_StackPos, a_ReturnedVal.c_str());
+		a_Value.clear();
 	}
 }
 
@@ -735,7 +743,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))
 	{
@@ -747,7 +755,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))
 	{
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index dcb660c3f..4a7a6fadb 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -197,6 +197,19 @@ 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: */
 	template <typename FnT>
@@ -270,7 +283,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -292,7 +305,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		ASSERT(InitialTop == lua_gettop(m_LuaState));
 		return true;
@@ -315,7 +328,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -338,7 +351,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -362,7 +375,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -387,7 +400,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -414,7 +427,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -442,7 +455,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -471,7 +484,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -501,7 +514,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -532,7 +545,7 @@ public:
 		{
 			return false;
 		}
-		GetReturn(-1, a_Ret1);
+		GetStackValue(-1, a_Ret1);
 		lua_pop(m_LuaState, 1);
 		return true;
 	}
@@ -553,8 +566,8 @@ 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;
 	}
@@ -576,8 +589,8 @@ 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;
 	}
@@ -601,8 +614,8 @@ 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;
 	}
@@ -627,8 +640,8 @@ 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;
 	}
@@ -654,8 +667,8 @@ 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;
 	}
@@ -683,8 +696,8 @@ 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;
 	}
@@ -713,8 +726,8 @@ 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;
 	}
@@ -743,9 +756,9 @@ 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;
 	}
@@ -775,9 +788,9 @@ 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;
 	}
@@ -808,11 +821,11 @@ 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;
 	}
@@ -918,18 +931,6 @@ protected:
 	/** 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 461186d3b..a5247bbe6 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -23,9 +23,11 @@
 #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"
 
 
 
@@ -2455,7 +2457,7 @@ static int tolua_cBlockArea_GetSize(lua_State * tolua_S)
 static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * tolua_S)
 {
 	// function cBlockArea::LoadFromSchematicFile
-	// Exported manually because function has been moved to SchematicFileSerilizer.cpp
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
 	cLuaState L(tolua_S);
 	if (
 		!L.CheckParamUserType(1, "cBlockArea") ||
@@ -2482,10 +2484,41 @@ static int tolua_cBlockArea_LoadFromSchematicFile(lua_State * tolua_S)
 
 
 
+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 SchematicFileSerilizer.cpp
+	// Exported manually because function has been moved to SchematicFileSerializer.cpp
 	cLuaState L(tolua_S);
 	if (
 		!L.CheckParamUserType(1, "cBlockArea") ||
@@ -2511,6 +2544,285 @@ static int tolua_cBlockArea_SaveToSchematicFile(lua_State * tolua_S)
 
 
 
+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);
@@ -2527,12 +2839,24 @@ void ManualBindings::Bind(lua_State * tolua_S)
 		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, "SaveToSchematicFile",   tolua_cBlockArea_SaveToSchematicFile);
+			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");
@@ -2561,7 +2885,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, "DoWithMobHeadBlockAt",      tolua_DoWithXYZ<cWorld, cMobHeadEntity,      &cWorld::DoWithMobHeadBlockAt>);
+			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>);
@@ -2583,6 +2908,11 @@ void ManualBindings::Bind(lua_State * 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);
diff --git a/src/BlockEntities/BlockEntity.cpp b/src/BlockEntities/BlockEntity.cpp
index 57ad83de9..b42318c2f 100644
--- a/src/BlockEntities/BlockEntity.cpp
+++ b/src/BlockEntities/BlockEntity.cpp
@@ -10,6 +10,7 @@
 #include "DispenserEntity.h"
 #include "DropperEntity.h"
 #include "EnderChestEntity.h"
+#include "FlowerPotEntity.h"
 #include "FurnaceEntity.h"
 #include "HopperEntity.h"
 #include "JukeboxEntity.h"
@@ -30,6 +31,7 @@ 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);
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/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 734d7bb66..3d1d604f7 100644
--- a/src/BlockEntities/JukeboxEntity.h
+++ b/src/BlockEntities/JukeboxEntity.h
@@ -37,10 +37,21 @@ 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
 
diff --git a/src/BlockID.cpp b/src/BlockID.cpp
index ff1c54e3f..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:
@@ -481,389 +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_HEAVY_WEIGHTED_PRESSURE_PLATE] = 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_LIGHT_WEIGHTED_PRESSURE_PLATE] = 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_HEAVY_WEIGHTED_PRESSURE_PLATE] = 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_LIGHT_WEIGHTED_PRESSURE_PLATE] = 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_POTATOES]              = 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_NEW_LOG]               = true;
-		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 3413555f4..1c454cd23 100644
--- a/src/BlockID.h
+++ b/src/BlockID.h
@@ -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
@@ -905,17 +909,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/BlockInfo.cpp b/src/BlockInfo.cpp
new file mode 100644
index 000000000..20336a07c
--- /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)
+{
+	ASSERT(a_Type < 256);
+
+	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_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;
+
+
+	// Torch placeable blocks:
+	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_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/Blocks/BlockBed.h b/src/Blocks/BlockBed.h
index caec2b56f..6daa94730 100644
--- a/src/Blocks/BlockBed.h
+++ b/src/Blocks/BlockBed.h
@@ -4,6 +4,7 @@
 #include "BlockHandler.h"
 #include "ChunkInterface.h"
 #include "WorldInterface.h"
+#include "MetaRotater.h"
 #include "../Entities/Player.h"
 
 
@@ -11,11 +12,11 @@
 
 
 class cBlockBedHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01, true>
 {
 public:
 	cBlockBedHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotater<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01,true>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockButton.h b/src/Blocks/BlockButton.h
index ca6850ced..740cbe3c4 100644
--- a/src/Blocks/BlockButton.h
+++ b/src/Blocks/BlockButton.h
@@ -2,16 +2,17 @@
 
 #include "BlockHandler.h"
 #include "Chunk.h"
+#include "MetaRotater.h"
 
 
 
 
 class cBlockButtonHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>
 {
 public:
 	cBlockButtonHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotater<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>(a_BlockType)
 	{
 	}
 
@@ -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 83595d2b9..ed441517d 100644
--- a/src/Blocks/BlockCactus.h
+++ b/src/Blocks/BlockCactus.h
@@ -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;
diff --git a/src/Blocks/BlockChest.h b/src/Blocks/BlockChest.h
index 02ecc4346..30588d8fc 100644
--- a/src/Blocks/BlockChest.h
+++ b/src/Blocks/BlockChest.h
@@ -4,17 +4,18 @@
 #include "BlockEntity.h"
 #include "../BlockArea.h"
 #include "../Entities/Player.h"
+#include "MetaRotater.h"
 
 
 
 
 
 class cBlockChestHandler :
-	public cBlockEntityHandler
+	public cMetaRotater<cBlockEntityHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>
 {
 public:
 	cBlockChestHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotater<cBlockEntityHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockComparator.h b/src/Blocks/BlockComparator.h
index aba390d9d..e570ff302 100644
--- a/src/Blocks/BlockComparator.h
+++ b/src/Blocks/BlockComparator.h
@@ -3,17 +3,18 @@
 
 #include "BlockHandler.h"
 #include "BlockRedstoneRepeater.h"
+#include "MetaRotater.h"
 
 
 
 
 
 class cBlockComparatorHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>
 {
 public:
 	cBlockComparatorHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotater<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>(a_BlockType)
 	{
 	}
 
@@ -26,6 +27,13 @@ public:
 	}
 
 
+	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 void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
diff --git a/src/Blocks/BlockDirt.h b/src/Blocks/BlockDirt.h
index 91534c5e5..544424a04 100644
--- a/src/Blocks/BlockDirt.h
+++ b/src/Blocks/BlockDirt.h
@@ -36,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;
@@ -77,7 +77,7 @@ 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);
 			}
diff --git a/src/Blocks/BlockDoor.cpp b/src/Blocks/BlockDoor.cpp
index 2ff5c1c37..4e38ef334 100644
--- a/src/Blocks/BlockDoor.cpp
+++ b/src/Blocks/BlockDoor.cpp
@@ -9,7 +9,7 @@
 
 
 cBlockDoorHandler::cBlockDoorHandler(BLOCKTYPE a_BlockType)
-	: cBlockHandler(a_BlockType)
+	: super(a_BlockType)
 {
 }
 
@@ -55,6 +55,29 @@ void cBlockDoorHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterfac
 
 
 
+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);
+	}
+}
+
+
+
+
+
 void cBlockDoorHandler::OnPlacedByPlayer(
 	cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
 	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
diff --git a/src/Blocks/BlockDoor.h b/src/Blocks/BlockDoor.h
index ef0dbb787..981774c17 100644
--- a/src/Blocks/BlockDoor.h
+++ b/src/Blocks/BlockDoor.h
@@ -4,18 +4,21 @@
 #include "BlockHandler.h"
 #include "../Entities/Player.h"
 #include "Chunk.h"
+#include "MetaRotater.h"
 
 
 
 
 class cBlockDoorHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true>
 {
+	typedef cMetaRotater<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true> super;
 public:
 	cBlockDoorHandler(BLOCKTYPE a_BlockType);
 
 	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;
 	
 	
@@ -167,6 +170,60 @@ public:
 	}
 	
 	
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		if (a_Meta & 0x08) 
+		{
+			return a_Meta;
+		}
+		else
+		{
+			return super::MetaRotateCCW(a_Meta);
+		}
+	}
+	
+	
+	
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		if (a_Meta & 0x08) 
+		{
+			return a_Meta;
+		}
+		else
+		{
+			return super::MetaRotateCW(a_Meta);
+		}
+	}
+	
+	
+	
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
+	{
+		if (a_Meta & 0x08) 
+		{
+			return a_Meta;
+		}
+		else
+		{
+			return super::MetaMirrorXY(a_Meta);
+		}
+	}
+	
+	
+	
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
+	{
+		if (a_Meta & 0x08) 
+		{
+			return a_Meta;
+		}
+		else
+		{
+			return super::MetaMirrorYZ(a_Meta);
+		}
+	}
+	
 } ;
 
 
diff --git a/src/Blocks/BlockDropSpenser.h b/src/Blocks/BlockDropSpenser.h
index 30d347ec9..7e0ad0e55 100644
--- a/src/Blocks/BlockDropSpenser.h
+++ b/src/Blocks/BlockDropSpenser.h
@@ -6,17 +6,18 @@
 #pragma once
 
 #include "../Piston.h"
+#include "MetaRotater.h"
 
 
 
 
 
 class cBlockDropSpenserHandler :
-	public cBlockEntityHandler
+	public cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockDropSpenserHandler(BLOCKTYPE a_BlockType) :
-		cBlockEntityHandler(a_BlockType)
+		cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 	
@@ -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 b4b0b995d..97cf484fb 100644
--- a/src/Blocks/BlockEnderchest.h
+++ b/src/Blocks/BlockEnderchest.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockEntity.h"
-
+#include "MetaRotater.h"
 
 
 
 
 class cBlockEnderchestHandler :
-	public cBlockEntityHandler
+	public cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockEnderchestHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockFenceGate.h b/src/Blocks/BlockFenceGate.h
index fb984f345..e3162bbd6 100644
--- a/src/Blocks/BlockFenceGate.h
+++ b/src/Blocks/BlockFenceGate.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotater.h"
 
 
 
 
 class cBlockFenceGateHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>
 {
 public:
 	cBlockFenceGateHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cMetaRotater<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>(a_BlockType)
 	{
 	}
 
@@ -48,6 +48,12 @@ public:
 	}
 
 
+	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/BlockFlowerPot.h b/src/Blocks/BlockFlowerPot.h
index 4de85f629..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, cWorldInterface * a_WorldInterface, 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/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index 834727c9a..aa97b2ca9 100644
--- a/src/Blocks/BlockHandler.cpp
+++ b/src/Blocks/BlockHandler.cpp
@@ -57,6 +57,7 @@
 #include "BlockRedstoneLamp.h"
 #include "BlockRedstoneRepeater.h"
 #include "BlockRedstoneTorch.h"
+#include "BlockTNT.h"
 #include "BlockSand.h"
 #include "BlockSapling.h"
 #include "BlockSideways.h"
@@ -77,33 +78,6 @@
 
 
 
-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)
@@ -172,6 +146,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE 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);
@@ -192,7 +167,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);
@@ -212,6 +187,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);
@@ -231,20 +207,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;
@@ -329,7 +291,7 @@ void cBlockHandler::NeighborChanged(cChunkInterface & a_ChunkInterface, int a_Bl
 {
 	if ((a_BlockY >= 0) && (a_BlockY < cChunkDef::Height))
 	{
-		GetBlockHandler(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnNeighborChanged(a_ChunkInterface, 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);
 	}
 }
 
@@ -361,6 +323,14 @@ void cBlockHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface &
 
 
 
+void cBlockHandler::OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace)
+{
+}
+
+
+
+
+
 void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
 {
 	// Setting the meta to a_BlockMeta keeps most textures. The few other blocks have to override this.
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
index a2913d7f8..50c2e2ad5 100644
--- a/src/Blocks/BlockHandler.h
+++ b/src/Blocks/BlockHandler.h
@@ -69,6 +69,9 @@ public:
 	/// Called if the user right clicks the block and the block is useable
 	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);
 	
@@ -136,30 +139,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/BlockLadder.h b/src/Blocks/BlockLadder.h
index 6a105d5c9..a3e9edc6b 100644
--- a/src/Blocks/BlockLadder.h
+++ b/src/Blocks/BlockLadder.h
@@ -91,7 +91,7 @@ public:
 
 		AddFaceDirection( a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true);
 
-		return g_BlockIsSolid[a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)];
+		return cBlockInfo::IsSolid(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ));
 	}
 
 
diff --git a/src/Blocks/BlockLever.h b/src/Blocks/BlockLever.h
index 48c7e774b..ef6e102cd 100644
--- a/src/Blocks/BlockLever.h
+++ b/src/Blocks/BlockLever.h
@@ -102,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/BlockMobHead.h b/src/Blocks/BlockMobHead.h
index 6a00c3acd..2b128f13b 100644
--- a/src/Blocks/BlockMobHead.h
+++ b/src/Blocks/BlockMobHead.h
@@ -29,7 +29,7 @@ public:
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	) override
 	{
-		class cCallback : public cMobHeadBlockCallback
+		class cCallback : public cMobHeadCallback
 		{
 			cPlayer * m_Player;
 			NIBBLETYPE m_OldBlockMeta;
@@ -45,6 +45,7 @@ public:
 				
 				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;
 			}
 		
@@ -59,7 +60,7 @@ public:
 		
 		a_BlockMeta = a_BlockFace;
 		cWorld * World = (cWorld *) &a_WorldInterface;
-		World->DoWithMobHeadBlockAt(a_BlockX, a_BlockY, a_BlockZ, Callback);
+		World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, Callback);
 		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta);
 	}
 } ;
diff --git a/src/Blocks/BlockRail.h b/src/Blocks/BlockRail.h
index 52d6f60b3..07e9814cd 100644
--- a/src/Blocks/BlockRail.h
+++ b/src/Blocks/BlockRail.h
@@ -98,7 +98,7 @@ public:
 		{
 			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;
 		}
@@ -130,7 +130,7 @@ public:
 					// Too close to the edge, cannot simulate
 					return true;
 				}
-				return g_BlockIsSolid[BlockType];
+				return cBlockInfo::IsSolid(BlockType);
 			}
 		}
 		return true;
diff --git a/src/Blocks/BlockRedstone.h b/src/Blocks/BlockRedstone.h
index 10de96197..a898c9acb 100644
--- a/src/Blocks/BlockRedstone.h
+++ b/src/Blocks/BlockRedstone.h
@@ -20,7 +20,7 @@ public:
 
 	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 eb0918acf..1e2a86949 100644
--- a/src/Blocks/BlockRedstoneRepeater.h
+++ b/src/Blocks/BlockRedstoneRepeater.h
@@ -29,7 +29,7 @@ public:
 		a_BlockMeta = RepeaterRotationToMetaData(a_Player->GetYaw());
 		return true;
 	}
-	
+
 
 	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
 	{
@@ -37,6 +37,13 @@ public:
 	}
 
 
+	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 void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
diff --git a/src/Blocks/BlockSlab.h b/src/Blocks/BlockSlab.h
index 3628303ce..7cd2c97b2 100644
--- a/src/Blocks/BlockSlab.h
+++ b/src/Blocks/BlockSlab.h
@@ -28,7 +28,7 @@ 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));
 	}
 
 
@@ -41,7 +41,7 @@ public:
 	{
 		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));
@@ -159,21 +159,30 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		if (m_BlockType ==  E_BLOCK_DOUBLE_STONE_SLAB)
-		{
-			m_BlockType = E_BLOCK_STONE_SLAB;
-		}
-		else
+		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_WOODEN_SLAB;
+			case E_BLOCK_DOUBLE_STONE_SLAB:  return E_BLOCK_STONE_SLAB;
+			case E_BLOCK_DOUBLE_WOODEN_SLAB: return E_BLOCK_WOODEN_SLAB;
 		}
-		a_Pickups.push_back(cItem(m_BlockType, 2, a_BlockMeta));
+		ASSERT(!"Unhandled double slab type!");
+		return a_BlockType;
 	}
-
 	
 	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";
+	{
+		switch (m_BlockType)
+		{
+			case E_BLOCK_DOUBLE_STONE_SLAB:  return "step.stone";
+			case E_BLOCK_DOUBLE_WOODEN_SLAB: return "step.wood";
+		}
+		ASSERT(!"Unhandled double slab type!");
+		return "";
 	}
 } ;
 
diff --git a/src/Blocks/BlockSnow.h b/src/Blocks/BlockSnow.h
index a3daf0393..b21995d3c 100644
--- a/src/Blocks/BlockSnow.h
+++ b/src/Blocks/BlockSnow.h
@@ -72,7 +72,7 @@ public:
 			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 c1887bc46..bbbe0ee84 100644
--- a/src/Blocks/BlockStairs.h
+++ b/src/Blocks/BlockStairs.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotater.h"
 
 
 
 
 class cBlockStairsHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>
 {
 public:
 	cBlockStairsHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cMetaRotater<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>(a_BlockType)
 	{
 
 	}
@@ -96,54 +96,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 +103,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/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/BlockTorch.h b/src/Blocks/BlockTorch.h
index f2a4c8665..d32c77629 100644
--- a/src/Blocks/BlockTorch.h
+++ b/src/Blocks/BlockTorch.h
@@ -2,17 +2,17 @@
 
 #include "BlockHandler.h"
 #include "../Chunk.h"
-
+#include "MetaRotater.h"
 
 
 
 
 class cBlockTorchHandler :
-	public cBlockHandler
+	public cMetaRotater<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>
 {
 public:
 	cBlockTorchHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotater<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>(a_BlockType)
 	{
 	}
 	
@@ -99,7 +99,7 @@ public:
 
 	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
 		}
@@ -129,7 +129,7 @@ public:
 			{
 				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 Face;
@@ -163,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;
 		}
@@ -185,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 08fc28327..9bae92c4d 100644
--- a/src/Blocks/BlockTrapdoor.h
+++ b/src/Blocks/BlockTrapdoor.h
@@ -36,8 +36,16 @@ public:
 	{
 		// Flip the ON bit on/off using the XOR bitwise operation
 		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());
+	}
+
+	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(
@@ -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 ee7dcee8a..e28645142 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -1,8 +1,7 @@
-
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotater.h"
 
 
 
@@ -70,7 +69,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) || cBlockInfo::IsSolid(a_BlockType);
 	}
 
 
@@ -180,8 +179,8 @@ 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
@@ -194,6 +193,7 @@ public:
 		// Bits 1 and 3 stay, bits 2 and 4 swap
 		return ((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2));
 	}
+
 } ;
 
 
diff --git a/src/Blocks/ChunkInterface.cpp b/src/Blocks/ChunkInterface.cpp
index b2dda19f4..540581ae7 100644
--- a/src/Blocks/ChunkInterface.cpp
+++ b/src/Blocks/ChunkInterface.cpp
@@ -6,7 +6,7 @@
 
 bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z)
 {
-	cBlockHandler *Handler = cBlockHandler::GetBlockHandler(GetBlock(a_X, a_Y, 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
index b30eff1e4..be7c2e0e5 100644
--- a/src/Blocks/ChunkInterface.h
+++ b/src/Blocks/ChunkInterface.h
@@ -5,31 +5,35 @@
 #include "../ForEachChunkProvider.h"
 #include "WorldInterface.h"
 
-class cBlockHandler;
 
-class cChunkInterface : public cForEachChunkProvider
+
+
+
+class cChunkInterface:
+	public cForEachChunkProvider
 {
 public:
 
 	cChunkInterface(cChunkMap * a_ChunkMap) : m_ChunkMap(a_ChunkMap) {}
 
-	BLOCKTYPE  GetBlock          (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);
 	}
-	BLOCKTYPE  GetBlock    (const Vector3i & a_Pos ) 
+	BLOCKTYPE GetBlock(const Vector3i & a_Pos)
 	{ 
-		return GetBlock( a_Pos.x, a_Pos.y, a_Pos.z ); 
+		return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
 	}
-	NIBBLETYPE GetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ)
+	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)
+	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.
 	*/
@@ -37,7 +41,8 @@ public:
 	{
 		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)
+	
+	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);
 	}
@@ -55,7 +60,11 @@ public:
 	{
 		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 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)
 	{
@@ -77,3 +86,7 @@ public:
 private:
 	cChunkMap * m_ChunkMap;
 };
+
+
+
+
diff --git a/src/Blocks/MetaRotater.h b/src/Blocks/MetaRotater.h
new file mode 100644
index 000000000..d3664b6f1
--- /dev/null
+++ b/src/Blocks/MetaRotater.h
@@ -0,0 +1,99 @@
+// MetaRotater.h
+
+// Provides a mixin for rotations and reflections
+
+#pragma once
+
+/*
+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 cMetaRotater : public Base
+{
+public:
+
+	cMetaRotater(BLOCKTYPE a_BlockType) :
+		Base(a_BlockType)
+	{}
+	
+	virtual ~cMetaRotater() {}
+
+	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 cMetaRotater<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 cMetaRotater<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 cMetaRotater<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 cMetaRotater<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
index b6f2f55a7..e59b00eff 100644
--- a/src/Blocks/WorldInterface.h
+++ b/src/Blocks/WorldInterface.h
@@ -27,4 +27,7 @@ public:
 	
 	/** 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;
 };
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 387556775..5029906aa 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -40,6 +40,7 @@ if (NOT MSVC)
 		BlockEntities/NoteEntity.h
 		BlockEntities/SignEntity.h
 		BlockEntities/MobHeadEntity.h
+		BlockEntities/FlowerPotEntity.h
 		BlockID.h
 		BoundingBox.h
 		ChatColor.h
@@ -95,6 +96,7 @@ if (NOT MSVC)
 	#add cpp files here
 	add_library(Bindings
 		Bindings/Bindings
+		Bindings/DeprecatedBindings
 		Bindings/LuaChunkStay
 		Bindings/LuaState
 		Bindings/LuaWindow
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 8dfbbeef5..957d7d575 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -20,6 +20,7 @@
 #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"
@@ -883,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))
 			{
 				SetBlock(X, Height + 1, Z, E_BLOCK_SNOW, 0);
 			}
@@ -1311,6 +1312,7 @@ void cChunk::CreateBlockEntities(void)
 					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))
 						{
@@ -1440,6 +1442,7 @@ void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType,
 		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;
@@ -1540,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;
@@ -2337,7 +2340,7 @@ bool cChunk::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCom
 
 
 
-bool cChunk::DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadBlockCallback & a_Callback)
+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)
@@ -2369,6 +2372,38 @@ bool cChunk::DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMob
 
 
 
+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
diff --git a/src/Chunk.h b/src/Chunk.h
index c9e9697ca..b3fa563cc 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -32,6 +32,7 @@ class cDispenserEntity;
 class cFurnaceEntity;
 class cNoteEntity;
 class cMobHeadEntity;
+class cFlowerPotEntity;
 class cBlockArea;
 class cPawn;
 class cPickup;
@@ -48,7 +49,8 @@ typedef cItemCallback<cDispenserEntity>    cDispenserCallback;
 typedef cItemCallback<cFurnaceEntity>      cFurnaceCallback;
 typedef cItemCallback<cNoteEntity>         cNoteBlockCallback;
 typedef cItemCallback<cCommandBlockEntity> cCommandBlockCallback;
-typedef cItemCallback<cMobHeadEntity>      cMobHeadBlockCallback;
+typedef cItemCallback<cMobHeadEntity>      cMobHeadCallback;
+typedef cItemCallback<cFlowerPotEntity>    cFlowerPotCallback;
 
 
 
@@ -253,8 +255,11 @@ 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);
 	
-	/** Calls the callback for the mob head block at the specified coords; returns false if there's no mob header block at those coords or callback returns true, returns true if found */
-	bool DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadBlockCallback & 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 */
 	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
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index b5795fbaf..40964c654 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -2182,7 +2182,7 @@ bool cChunkMap::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, c
 
 
 
-bool cChunkMap::DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadBlockCallback & a_Callback)
+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;
@@ -2193,7 +2193,25 @@ bool cChunkMap::DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, c
 	{
 		return false;
 	}
-	return Chunk->DoWithMobHeadBlockAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+	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);
 }
 
 
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 9df68c403..9d973f2a9 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -26,6 +26,7 @@ class cFurnaceEntity;
 class cNoteEntity;
 class cCommandBlockEntity;
 class cMobHeadEntity;
+class cFlowerPotEntity;
 class cPawn;
 class cPickup;
 class cChunkDataSerializer;
@@ -41,10 +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>      cMobHeadBlockCallback;
+typedef cItemCallback<cMobHeadEntity>      cMobHeadCallback;
 typedef cItemCallback<cChunk>              cChunkCallback;
 
 
@@ -257,7 +259,10 @@ public:
 	bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback & a_Callback);  // Lua-accessible
 
 	/** 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 DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadBlockCallback & a_Callback);  // Lua-accessible
+	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
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 9f08b43a5..d268a4122 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -558,12 +558,25 @@ void cClientHandle::HandlePluginMessage(const AString & a_Channel, const AString
 	}
 	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;
+	}
 
 	cPluginManager::Get()->CallHookPluginMessage(*this, a_Channel, a_Message);
 }
@@ -824,7 +837,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);
@@ -843,7 +856,7 @@ void cClientHandle::HandleBlockDigStarted(int a_BlockX, int a_BlockY, int a_Bloc
 
 	cWorld * World = m_Player->GetWorld();
 	cChunkInterface ChunkInterface(World->GetChunkMap());
-	cBlockHandler * Handler = cBlockHandler::GetBlockHandler(a_OldBlock);
+	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());
@@ -857,7 +870,7 @@ 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())
 		{
@@ -925,14 +938,22 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, e
 		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:
+		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;
 	}
@@ -958,17 +979,15 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, e
 		if (a_BlockFace > -1)
 		{
 			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())
 	{
@@ -1048,7 +1067,7 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, e
 	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
diff --git a/src/CompositeChat.h b/src/CompositeChat.h
index 51600da4f..27319490d 100644
--- a/src/CompositeChat.h
+++ b/src/CompositeChat.h
@@ -124,14 +124,15 @@ public:
 	/** 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 = "");
 	
-	// tolua_end
-	
-	/** Adds a part that is translated client-side, with the formatting parameters and optional style.
-	Exported in ManualBindings due to AStringVector usage - Lua uses an array-table of strings. */
+	/** 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
@@ -155,12 +156,14 @@ public:
 	/** Sets the message type, which is indicated by prefixes added to the message when serializing. */
 	void SetMessageType(eMessageType a_MessageType);
 	
-	/** Returns the message type set previously by SetMessageType(). */
-	eMessageType GetMessageType(void) const { return m_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; }
+	
 	// tolua_end
 	
 	const cParts & GetParts(void) const { return m_Parts; }
diff --git a/src/Defines.h b/src/Defines.h
index ba2866f83..6ab2274a4 100644
--- a/src/Defines.h
+++ b/src/Defines.h
@@ -17,33 +17,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
 {
@@ -253,6 +226,56 @@ 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;
+	}
+}
+
+
+
+
+
 inline bool IsValidBlock(int a_BlockType)
 {
 	if (
@@ -654,7 +677,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/Entities/Entity.cpp b/src/Entities/Entity.cpp
index 8554ab2a5..96e8c15a5 100644
--- a/src/Entities/Entity.cpp
+++ b/src/Entities/Entity.cpp
@@ -582,11 +582,11 @@ void cEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 		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 (!cBlockInfo::IsSolid(BlockIn))  // Making sure we are not inside a solid block
 		{
 			if (m_bOnGround)  // check if it's still on the ground
 			{
-				if (!g_BlockIsSolid[BlockBelow])  // Check if block below is air or water.
+				if (!cBlockInfo::IsSolid(BlockBelow))  // Check if block below is air or water.
 				{
 					m_bOnGround = false;
 				}
@@ -616,7 +616,7 @@ void cEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 					// The pickup is too close to an unloaded chunk, bail out of any physics handling
 					return;
 				}
-				if (!g_BlockIsSolid[GotBlock])
+				if (!cBlockInfo::IsSolid(GotBlock))
 				{
 					NextPos.x += gCrossCoords[i].x;
 					NextPos.z += gCrossCoords[i].z;
diff --git a/src/Entities/Minecart.cpp b/src/Entities/Minecart.cpp
index d854906b7..f52a7b6d9 100644
--- a/src/Entities/Minecart.cpp
+++ b/src/Entities/Minecart.cpp
@@ -720,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);
@@ -737,7 +737,7 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 			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());
@@ -757,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());
@@ -773,7 +773,7 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
 			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());
@@ -798,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);
diff --git a/src/Entities/Painting.cpp b/src/Entities/Painting.cpp
index b98c1e67a..e217556c7 100644
--- a/src/Entities/Painting.cpp
+++ b/src/Entities/Painting.cpp
@@ -4,6 +4,7 @@
 #include "Painting.h"
 #include "ClientHandle.h"
 #include "Player.h"
+#include "../Chunk.h"
 
 
 
@@ -30,6 +31,16 @@ void cPainting::SpawnOn(cClientHandle & a_Client)
 
 
 
+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())
diff --git a/src/Entities/Painting.h b/src/Entities/Painting.h
index 95afbed1e..c1024bd1b 100644
--- a/src/Entities/Painting.h
+++ b/src/Entities/Painting.h
@@ -24,7 +24,7 @@ public:
 private:
 
 	virtual void SpawnOn(cClientHandle & a_Client) override;
-	virtual void Tick(float a_Dt, cChunk & a_Chunk) 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
 	{
diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp
index 2a62931ab..ccdd151f3 100644
--- a/src/Entities/Player.cpp
+++ b/src/Entities/Player.cpp
@@ -847,6 +847,8 @@ void cPlayer::KilledBy(cEntity * a_Killer)
 	else if (a_Killer->IsPlayer())
 	{
 		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
 	{
@@ -856,24 +858,7 @@ void cPlayer::KilledBy(cEntity * a_Killer)
 		GetWorld()->BroadcastChatDeath(Printf("%s was killed by a %s", GetName().c_str(), KillerClass.c_str()));
 	}
 
-	class cIncrementCounterCB
-		: public cObjectiveCallback
-	{
-		AString m_Name;
-	public:
-		cIncrementCounterCB(const AString & a_Name) : m_Name(a_Name) {}
-
-		virtual bool Item(cObjective * a_Objective) override
-		{
-			a_Objective->AddScore(m_Name, 1);
-			return true;
-		}
-	} IncrementCounter (GetName());
-
-	cScoreboard & Scoreboard = m_World->GetScoreBoard();
-
-	// Update scoreboard objectives
-	Scoreboard.ForEachObjectiveWith(cObjective::E_TYPE_DEATH_COUNT, IncrementCounter);
+	m_World->GetScoreBoard().AddPlayerScore(GetName(), cObjective::otDeathCount, 1);
 }
 
 
@@ -1497,10 +1482,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
@@ -1508,16 +1497,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();
@@ -1884,7 +1872,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/ProjectileEntity.cpp b/src/Entities/ProjectileEntity.cpp
index be8e24540..12d2025ec 100644
--- a/src/Entities/ProjectileEntity.cpp
+++ b/src/Entities/ProjectileEntity.cpp
@@ -50,12 +50,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:
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 d9529b4b0..308fbe423 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -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;
 }
 
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index cfa7e9c6f..e96e9a645 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/src/Generating/ComposableGenerator.cpp
@@ -133,11 +133,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 +159,6 @@ void cComposableGenerator::Initialize(cIniFile & a_IniFile)
 	InitBiomeGen(a_IniFile);
 	InitHeightGen(a_IniFile);
 	InitCompositionGen(a_IniFile);
-	InitStructureGens(a_IniFile);
 	InitFinishGens(a_IniFile);
 }
 
@@ -201,14 +195,6 @@ void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a
 		m_CompositionGen->ComposeTerrain(a_ChunkDesc);
 	}
 
-	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)
@@ -290,35 +276,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,71 +347,11 @@ 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(
+			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)
-		{
-			m_StructureGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));
-		}
-		else if (NoCaseCompare(*itr, "WaterLakes") == 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));
-		}
-		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)
-		{
-			m_StructureGens.push_back(new cStructGenWormNestCaves(Seed));
-		}
-		else
-		{
-			LOGWARNING("Unknown structure generator: \"%s\". Ignoring.", itr->c_str());
-		}
-	}  // 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)
-		{
-			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, "Ice") == 0)
-		{
-			m_FinishGens.push_back(new cFinishGenIce);
-		}
-		else if (NoCaseCompare(*itr, "LavaSprings") == 0)
-		{
-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, Dimension));
-		}
 		else if (NoCaseCompare(*itr, "Lilypads") == 0)
 		{
 			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_LILY_PAD, biSwampland, 4, E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER));
@@ -400,10 +360,18 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		{
 			m_FinishGens.push_back(new cFinishGenNetherClumpFoliage(Seed));
 		}
+		else if (NoCaseCompare(*itr, "OreNests") == 0)
+		{
+			m_FinishGens.push_back(new cStructGenOreNests(Seed));
+		}
 		else if (NoCaseCompare(*itr, "PreSimulator") == 0)
 		{
 			m_FinishGens.push_back(new cFinishGenPreSimulator);
 		}
+		else if (NoCaseCompare(*itr, "Ravines") == 0)
+		{
+			m_FinishGens.push_back(new cStructGenRavines(Seed, 128));
+		}
 		else if (NoCaseCompare(*itr, "Snow") == 0)
 		{
 			m_FinishGens.push_back(new cFinishGenSnow);
@@ -412,10 +380,27 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		{
 			m_FinishGens.push_back(new cFinishGenSprinkleFoliage(Seed));
 		}
+		else if (NoCaseCompare(*itr, "Trees") == 0)
+		{
+			m_FinishGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));
+		}
+		else if (NoCaseCompare(*itr, "WaterLakes") == 0)
+		{
+			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, "WaterSprings") == 0)
 		{
 			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, Dimension));
 		}
+		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)
+		{
+			m_FinishGens.push_back(new cStructGenWormNestCaves(Seed));
+		}
+		else
+		{
+			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/MineShafts.cpp b/src/Generating/MineShafts.cpp
index cc39cef7b..d9acc57bb 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -1407,7 +1407,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/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 47945cc2b..3cc8a09c3 100644
--- a/src/Generating/StructGen.cpp
+++ b/src/Generating/StructGen.cpp
@@ -54,7 +54,7 @@ const int NEST_SIZE_GRAVEL = 32;
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenTrees:
 
-void cStructGenTrees::GenStructures(cChunkDesc & a_ChunkDesc)
+void cStructGenTrees::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	int ChunkX = a_ChunkDesc.GetChunkX();
 	int ChunkZ = a_ChunkDesc.GetChunkZ();
@@ -306,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();
@@ -413,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();
@@ -545,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))
@@ -665,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/Globals.h b/src/Globals.h
index e4737a98a..28805a83f 100644
--- a/src/Globals.h
+++ b/src/Globals.h
@@ -250,6 +250,7 @@ T Clamp(T a_Value, T a_Min, T a_Max)
 #include "ChunkDef.h"
 #include "BiomeDef.h"
 #include "BlockID.h"
+#include "BlockInfo.h"
 #include "Entities/Effects.h"
 
 
diff --git a/src/GroupManager.cpp b/src/GroupManager.cpp
index 723b86f94..33b601e82 100644
--- a/src/GroupManager.cpp
+++ b/src/GroupManager.cpp
@@ -46,6 +46,7 @@ cGroupManager::cGroupManager()
 	LOGD("-- Loading Groups --");
 	
 	LoadGroups();
+	CheckUsers();
 	
 	LOGD("-- Groups Successfully Loaded --");
 }
@@ -54,6 +55,53 @@ cGroupManager::cGroupManager()
 
 
 
+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;
@@ -137,6 +185,16 @@ void cGroupManager::LoadGroups()
 
 
 
+bool cGroupManager::ExistsGroup( const AString & a_Name )
+{
+	GroupMap::iterator itr = m_pState->Groups.find( a_Name );
+	return ( itr != m_pState->Groups.end() );
+}
+
+
+
+
+
 cGroup* cGroupManager::GetGroup( const AString & a_Name )
 {
 	GroupMap::iterator itr = m_pState->Groups.find( a_Name );
diff --git a/src/GroupManager.h b/src/GroupManager.h
index 02a58fe4e..9e1689a76 100644
--- a/src/GroupManager.h
+++ b/src/GroupManager.h
@@ -14,8 +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/HTTPServer.cpp b/src/HTTPServer/HTTPServer.cpp
index f6f5b0f8b..4e9195a00 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));
@@ -38,6 +40,8 @@ class cDebugCallbacks :
 		
 		virtual void OnRequestBody(cHTTPConnection & a_Connection, cHTTPRequest & a_Request, const char * a_Data, int a_Size) override
 		{
+			UNUSED(a_Connection);
+			
 			cHTTPFormParser * FormParser = (cHTTPFormParser *)(a_Request.GetUserData());
 			if (FormParser != NULL)
 			{
diff --git a/src/Inventory.cpp b/src/Inventory.cpp
index 7f434adfd..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());
+	}
 }
 
 
diff --git a/src/Items/ItemEmptyMap.h b/src/Items/ItemEmptyMap.h
index 6618bfce2..f0b1e1424 100644
--- a/src/Items/ItemEmptyMap.h
+++ b/src/Items/ItemEmptyMap.h
@@ -36,10 +36,10 @@ public:
 
 		// 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 * pow(2.0, (double) DEFAULT_SCALE);
+		const int RegionWidth = cChunkDef::Width * 8;
 
-		int CenterX = floor(a_Player->GetPosX() / (float) RegionWidth) * RegionWidth;
-		int CenterZ = floor(a_Player->GetPosZ() / (float) RegionWidth) * RegionWidth;
+		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);
 
diff --git a/src/Items/ItemHandler.cpp b/src/Items/ItemHandler.cpp
index c10d13edc..1d357fcf1 100644
--- a/src/Items/ItemHandler.cpp
+++ b/src/Items/ItemHandler.cpp
@@ -248,6 +248,14 @@ 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, 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;
 }
 
@@ -257,6 +265,14 @@ 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, 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;
 }
 
@@ -266,8 +282,10 @@ 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())
 	{
@@ -288,7 +306,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);
 }
 
 
@@ -461,6 +481,8 @@ bool cItemHandler::IsPlaceable(void)
 
 bool cItemHandler::CanHarvestBlock(BLOCKTYPE a_BlockType)
 {
+	UNUSED(a_BlockType);
+	
 	return false;
 }
 
@@ -499,6 +521,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))
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 18c6b8615..274d905a5 100644
--- a/src/Items/ItemRedstoneDust.h
+++ b/src/Items/ItemRedstoneDust.h
@@ -27,7 +27,7 @@ public:
 		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/LightingThread.cpp b/src/LightingThread.cpp
index 9c81d004d..44dadb8a9 100644
--- a/src/LightingThread.cpp
+++ b/src/LightingThread.cpp
@@ -391,7 +391,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;
 				}
@@ -401,7 +401,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]);
 			}
 		}
 	}
diff --git a/src/LightingThread.h b/src/LightingThread.h
index 72d561348..198f27248 100644
--- a/src/LightingThread.h
+++ b/src/LightingThread.h
@@ -169,13 +169,13 @@ protected:
 		ASSERT(a_DstIdx >= 0);
 		ASSERT(a_DstIdx < (int)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;
diff --git a/src/Log.cpp b/src/Log.cpp
index 2d6be0f59..1ea327d5d 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;
 }
 
 
diff --git a/src/Map.cpp b/src/Map.cpp
index 337c9cd31..2d8f57168 100644
--- a/src/Map.cpp
+++ b/src/Map.cpp
@@ -357,6 +357,8 @@ void cMap::AddPlayer(cPlayer * a_Player, Int64 a_WorldAge)
 	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);
 
diff --git a/src/MobSpawner.cpp b/src/MobSpawner.cpp
index c86268e63..7704f6cf3 100644
--- a/src/MobSpawner.cpp
+++ b/src/MobSpawner.cpp
@@ -145,7 +145,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 +157,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)
 				);
@@ -188,7 +188,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)
 						);
@@ -215,7 +215,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 							HaveFloor ||
 							(
 								a_Chunk->UnboundedRelGetBlockType(a_RelX + x, a_RelY - 1, a_RelZ + z, TargetBlock) &&
-								!g_BlockTransparent[TargetBlock]
+								!cBlockInfo::IsTransparent(TargetBlock)
 							)
 						);
 					}
@@ -230,7 +230,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 +242,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 +255,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/Creeper.cpp b/src/Mobs/Creeper.cpp
index 40ee20e44..3471b4cf1 100644
--- a/src/Mobs/Creeper.cpp
+++ b/src/Mobs/Creeper.cpp
@@ -4,6 +4,7 @@
 #include "Creeper.h"
 #include "../World.h"
 #include "../Entities/ProjectileEntity.h"
+#include "../Entities/Player.h"
 
 
 
@@ -13,6 +14,7 @@ cCreeper::cCreeper(void) :
 	super("Creeper", mtCreeper, "mob.creeper.say", "mob.creeper.say", 0.6, 1.8),
 	m_bIsBlowing(false),
 	m_bIsCharged(false),
+	m_BurnedWithFlintAndSteel(false),
 	m_ExplodingTimer(0)
 {
 }
@@ -25,12 +27,25 @@ void cCreeper::Tick(float a_Dt, cChunk & a_Chunk)
 {
 	super::Tick(a_Dt, a_Chunk);
 
-	if (!ReachedFinalDestination())
+	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();
+		}
+	}
 }
 
 
@@ -80,22 +95,30 @@ void cCreeper::Attack(float a_Dt)
 {
 	UNUSED(a_Dt);
 
-	m_ExplodingTimer += 1;
-
 	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);
 	}
-
-	if (m_ExplodingTimer == 20)
-	{
-		m_World->DoExplosionAt((m_bIsCharged ? 5 : 3), GetPosX(), GetPosY(), GetPosZ(), false, esMonster, this);
-		Destroy();
-	}
 }
 
 
 
 
+
+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 0f71e5ad2..9abca369b 100644
--- a/src/Mobs/Creeper.h
+++ b/src/Mobs/Creeper.h
@@ -21,13 +21,14 @@ public:
 	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/Monster.cpp b/src/Mobs/Monster.cpp
index ac9137ccd..6e3c91d58 100644
--- a/src/Mobs/Monster.cpp
+++ b/src/Mobs/Monster.cpp
@@ -148,11 +148,11 @@ void cMonster::TickPathFinding()
 		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 ((!g_BlockIsSolid[BlockAtY]) && (!g_BlockIsSolid[BlockAtYP]) && (!IsBlockLava(BlockAtYM)) && (BlockAtY != E_BLOCK_FENCE) && (BlockAtY != E_BLOCK_FENCE_GATE))
+		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 ((g_BlockIsSolid[BlockAtY]) && (!g_BlockIsSolid[BlockAtYP]) && (!g_BlockIsSolid[BlockAtYPP]) && (!IsBlockLava(BlockAtYM)) && (BlockAtY != E_BLOCK_FENCE) && (BlockAtY != E_BLOCK_FENCE_GATE))
+		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));
 		}
@@ -416,9 +416,9 @@ int cMonster::FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ)
 	else if (PosY > cChunkDef::Height)
 		PosY = cChunkDef::Height;
 
-	if (!g_BlockIsSolid[m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))])
+	if (!cBlockInfo::IsSolid(m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))))
 	{
-		while (!g_BlockIsSolid[m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))] && (PosY > 0))
+		while (!cBlockInfo::IsSolid(m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))) && (PosY > 0))
 		{
 			PosY--;
 		}
@@ -427,7 +427,7 @@ int cMonster::FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ)
 	}
 	else
 	{
-		while (g_BlockIsSolid[m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))] && (PosY < cChunkDef::Height))
+		while (cBlockInfo::IsSolid(m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))) && (PosY < cChunkDef::Height))
 		{
 			PosY++;
 		}
diff --git a/src/Mobs/Mooshroom.cpp b/src/Mobs/Mooshroom.cpp
index 8e4c52ae6..81bd3e3b4 100644
--- a/src/Mobs/Mooshroom.cpp
+++ b/src/Mobs/Mooshroom.cpp
@@ -67,6 +67,8 @@ void cMooshroom::OnRightClicked(cPlayer & a_Player)
 			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/SnowGolem.cpp b/src/Mobs/SnowGolem.cpp
index 67e3a3bb8..c1979a495 100644
--- a/src/Mobs/SnowGolem.cpp
+++ b/src/Mobs/SnowGolem.cpp
@@ -38,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/Villager.cpp b/src/Mobs/Villager.cpp
index 09a6e2d09..bbd8d6aaa 100644
--- a/src/Mobs/Villager.cpp
+++ b/src/Mobs/Villager.cpp
@@ -150,7 +150,7 @@ void cVillager::HandleFarmerTryHarvestCrops()
 		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 = cBlockHandler::GetBlockHandler(CropBlock);
+			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);
diff --git a/src/OSSupport/BlockingTCPLink.cpp b/src/OSSupport/BlockingTCPLink.cpp
index af50eda5d..e9c00d6d4 100644
--- a/src/OSSupport/BlockingTCPLink.cpp
+++ b/src/OSSupport/BlockingTCPLink.cpp
@@ -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/Piston.cpp b/src/Piston.cpp
index 5eb14451d..b21d576f3 100644
--- a/src/Piston.cpp
+++ b/src/Piston.cpp
@@ -242,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/Protocol/Protocol17x.cpp b/src/Protocol/Protocol17x.cpp
index e0f02930c..74759aeb9 100644
--- a/src/Protocol/Protocol17x.cpp
+++ b/src/Protocol/Protocol17x.cpp
@@ -29,6 +29,7 @@ Implements the 1.7.x protocol classes:
 #include "../UI/Window.h"
 #include "../BlockEntities/CommandBlockEntity.h"
 #include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 #include "../CompositeChat.h"
 
 
@@ -1115,6 +1116,7 @@ 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);
@@ -2360,7 +2362,7 @@ void cProtocol172::cPacketizer::WriteBlockEntity(const cBlockEntity & a_BlockEnt
 		case E_BLOCK_HEAD:
 		{
 			cMobHeadEntity & MobHeadEntity = (cMobHeadEntity &)a_BlockEntity;
-			
+
 			Writer.AddInt("x", MobHeadEntity.GetPosX());
 			Writer.AddInt("y", MobHeadEntity.GetPosY());
 			Writer.AddInt("z", MobHeadEntity.GetPosZ());
@@ -2370,6 +2372,18 @@ void cProtocol172::cPacketizer::WriteBlockEntity(const cBlockEntity & a_BlockEnt
 			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;
 	}
 
diff --git a/src/Root.cpp b/src/Root.cpp
index 206255916..78c94888d 100644
--- a/src/Root.cpp
+++ b/src/Root.cpp
@@ -194,7 +194,7 @@ 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();
@@ -245,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;
@@ -536,7 +535,9 @@ void cRoot::SaveAllChunks(void)
 
 void cRoot::ReloadGroups(void)
 {
+	LOG("Reload groups ...");
 	m_GroupManager->LoadGroups();
+	m_GroupManager->CheckUsers();
 }
 
 
diff --git a/src/Scoreboard.cpp b/src/Scoreboard.cpp
index 61ecac5b7..8088e624b 100644
--- a/src/Scoreboard.cpp
+++ b/src/Scoreboard.cpp
@@ -17,19 +17,19 @@ AString cObjective::TypeToString(eType a_Type)
 {
 	switch (a_Type)
 	{
-		case E_TYPE_DUMMY:                 return "dummy";
-		case E_TYPE_DEATH_COUNT:           return "deathCount";
-		case E_TYPE_PLAYER_KILL_COUNT:     return "playerKillCount";
-		case E_TYPE_TOTAL_KILL_COUNT:      return "totalKillCount";
-		case E_TYPE_HEALTH:                return "health";
-		case E_TYPE_ACHIEVEMENT:           return "achievement";
-		case E_TYPE_STAT:                  return "stat";
-		case E_TYPE_STAT_ITEM_CRAFT:       return "stat.craftItem";
-		case E_TYPE_STAT_ITEM_USE:         return "stat.useItem";
-		case E_TYPE_STAT_ITEM_BREAK:       return "stat.breakItem";
-		case E_TYPE_STAT_BLOCK_MINE:       return "stat.mineBlock";
-		case E_TYPE_STAT_ENTITY_KILL:      return "stat.killEntity";
-		case E_TYPE_STAT_ENTITY_KILLED_BY: return "stat.entityKilledBy";
+		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";
 
 		default: return "";
 	}
@@ -46,19 +46,19 @@ cObjective::eType cObjective::StringToType(const AString & a_Name)
 		const char * m_String;
 	} TypeMap [] =
 	{
-		{E_TYPE_DUMMY,                 "dummy"},
-		{E_TYPE_DEATH_COUNT,           "deathCount"},
-		{E_TYPE_PLAYER_KILL_COUNT,     "playerKillCount"},
-		{E_TYPE_TOTAL_KILL_COUNT,      "totalKillCount"},
-		{E_TYPE_HEALTH,                "health"},
-		{E_TYPE_ACHIEVEMENT,           "achievement"},
-		{E_TYPE_STAT,                  "stat"},
-		{E_TYPE_STAT_ITEM_CRAFT,       "stat.craftItem"},
-		{E_TYPE_STAT_ITEM_USE,         "stat.useItem"},
-		{E_TYPE_STAT_ITEM_BREAK,       "stat.breakItem"},
-		{E_TYPE_STAT_BLOCK_MINE,       "stat.mineBlock"},
-		{E_TYPE_STAT_ENTITY_KILL,      "stat.killEntity"},
-		{E_TYPE_STAT_ENTITY_KILLED_BY, "stat.entityKilledBy"}
+		{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++)
 	{
@@ -67,7 +67,7 @@ cObjective::eType cObjective::StringToType(const AString & a_Name)
 			return TypeMap[i].m_Type;
 		}
 	}  // for i - TypeMap[]
-	return E_TYPE_DUMMY;
+	return otDummy;
 }
 
 
@@ -246,6 +246,17 @@ void cTeam::Reset(void)
 
 
 
+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();
@@ -257,7 +268,7 @@ unsigned int cTeam::GetNumPlayers(void) const
 
 cScoreboard::cScoreboard(cWorld * a_World) : m_World(a_World)
 {
-	for (int i = 0; i < (int) E_DISPLAY_SLOT_COUNT; ++i)
+	for (int i = 0; i < (int) dsCount; ++i)
 	{
 		m_Display[i] = NULL;
 	}
@@ -301,11 +312,19 @@ bool cScoreboard::RemoveObjective(const AString & a_Name)
 		return false;
 	}
 
-	m_Objectives.erase(it);
-
 	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;
 }
 
@@ -410,7 +429,7 @@ cTeam * cScoreboard::QueryPlayerTeam(const AString & a_Name)
 
 void cScoreboard::SetDisplay(const AString & a_Objective, eDisplaySlot a_Slot)
 {
-	ASSERT(a_Slot < E_DISPLAY_SLOT_COUNT);
+	ASSERT(a_Slot < dsCount);
 
 	cObjective * Objective = GetObjective(a_Objective);
 
@@ -435,7 +454,7 @@ void cScoreboard::SetDisplay(cObjective * a_Objective, eDisplaySlot a_Slot)
 
 cObjective * cScoreboard::GetObjectiveIn(eDisplaySlot a_Slot)
 {
-	ASSERT(a_Slot < E_DISPLAY_SLOT_COUNT);
+	ASSERT(a_Slot < dsCount);
 
 	return m_Display[a_Slot];
 }
@@ -444,7 +463,7 @@ cObjective * cScoreboard::GetObjectiveIn(eDisplaySlot a_Slot)
 
 
 
-void cScoreboard::ForEachObjectiveWith(cObjective::eType a_Type, cObjectiveCallback& a_Callback)
+bool cScoreboard::ForEachObjectiveWith(cObjective::eType a_Type, cObjectiveCallback& a_Callback)
 {
 	cCSLock Lock(m_CSObjectives);
 
@@ -455,10 +474,66 @@ void cScoreboard::ForEachObjectiveWith(cObjective::eType a_Type, cObjectiveCallb
 			// Call callback
 			if (a_Callback.Item(&it->second))
 			{
-				return;
+				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);
+		}
+	}
 }
 
 
@@ -474,7 +549,7 @@ void cScoreboard::SendTo(cClientHandle & a_Client)
 		it->second.SendTo(a_Client);
 	}
 
-	for (int i = 0; i < (int) E_DISPLAY_SLOT_COUNT; ++i)
+	for (int i = 0; i < (int) dsCount; ++i)
 	{
 		// Avoid race conditions
 		cObjective * Objective = m_Display[i];
diff --git a/src/Scoreboard.h b/src/Scoreboard.h
index f64ba2bce..e22ecaeb1 100644
--- a/src/Scoreboard.h
+++ b/src/Scoreboard.h
@@ -14,9 +14,11 @@
 
 
 class cObjective;
+class cTeam;
 class cWorld;
 
 typedef cItemCallback<cObjective> cObjectiveCallback;
+typedef cItemCallback<cTeam>      cTeamCallback;
 
 
 
@@ -31,23 +33,23 @@ public:
 
 	enum eType
 	{
-		E_TYPE_DUMMY,
+		otDummy,
 
-		E_TYPE_DEATH_COUNT,
-		E_TYPE_PLAYER_KILL_COUNT,
-		E_TYPE_TOTAL_KILL_COUNT,
-		E_TYPE_HEALTH,
+		otDeathCount,
+		otPlayerKillCount,
+		otTotalKillCount,
+		otHealth,
 
-		E_TYPE_ACHIEVEMENT,
+		otAchievement,
 
-		E_TYPE_STAT,
-		E_TYPE_STAT_ITEM_CRAFT,
-		E_TYPE_STAT_ITEM_USE,
-		E_TYPE_STAT_ITEM_BREAK,
+		otStat,
+		otStatItemCraft,
+		otStatItemUse,
+		otStatItemBreak,
 
-		E_TYPE_STAT_BLOCK_MINE,
-		E_TYPE_STAT_ENTITY_KILL,
-		E_TYPE_STAT_ENTITY_KILLED_BY
+		otStatBlockMine,
+		otStatEntityKill,
+		otStatEntityKilledBy
 	};
 
 	// tolua_end
@@ -67,31 +69,37 @@ public:
 	const AString & GetName(void)        const { return m_Name; }
 	const AString & GetDisplayName(void) const { return m_DisplayName; }
 
-	/// Resets the objective
+	/** Resets the objective */
 	void Reset(void);
 
-	/// Returns the score of the specified player
+	/** Returns the score of the specified player */
 	Score GetScore(const AString & a_Name) const;
 
-	/// Sets the score of the specified player
+	/** Sets the score of the specified player */
 	void SetScore(const AString & a_Name, Score a_Score);
 
-	/// Resets the score of the specified player
+	/** Resets the score of the specified player */
 	void ResetScore(const AString & a_Name);
 
-	/// Adds a_Delta and returns the new score
+	/** 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
+	/** 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
+	/** 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;
@@ -109,7 +117,8 @@ private:
 
 	friend class cScoreboardSerializer;
 
-};
+
+}; // tolua_export
 
 
 
@@ -127,21 +136,21 @@ public:
 		const AString & a_Prefix, const AString & a_Suffix
 	);
 
-	/// Adds a new player to the team
+	// tolua_begin
+
+	/** Adds a new player to the team */
 	bool AddPlayer(const AString & a_Name);
 
-	/// Removes a player from the team
+	/** Removes a player from the team */
 	bool RemovePlayer(const AString & a_Name);
 
-	/// Returns whether the specified player is in this team
+	/** Returns whether the specified player is in this team */
 	bool HasPlayer(const AString & a_Name) const;
 
-	/// Removes all registered players
+	/** Removes all registered players */
 	void Reset(void);
 
-	// tolua_begin
-
-	/// Returns the number of registered players
+	/** Returns the number of registered players */
 	unsigned int GetNumPlayers(void) const;
 
 	bool AllowsFriendlyFire(void)      const { return m_AllowsFriendlyFire; }
@@ -163,6 +172,11 @@ public:
 
 	// tolua_end
 
+	static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
+	{
+		return "cTeam";
+	}
+
 private:
 
 	typedef std::set<AString> cPlayerNameSet;
@@ -180,7 +194,8 @@ private:
 
 	friend class cScoreboardSerializer;
 
-};
+
+}; // tolua_export
 
 
 
@@ -193,11 +208,11 @@ public:
 
 	enum eDisplaySlot
 	{
-		E_DISPLAY_SLOT_LIST = 0,
-		E_DISPLAY_SLOT_SIDEBAR,
-		E_DISPLAY_SLOT_NAME,
+		dsList = 0,
+		dsSidebar,
+		dsName,
 
-		E_DISPLAY_SLOT_COUNT
+		dsCount
 	};
 
 	// tolua_end
@@ -209,44 +224,61 @@ public:
 
 	// tolua_begin
 
-	/// Registers a new scoreboard objective, returns the cObjective instance, NULL on name collision
+	/** 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
+	/** 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
+	/** 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
+	/** 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
+	/** 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
+	/** Retrieves the team with the specified name, NULL if not found */
 	cTeam * GetTeam(const AString & a_Name);
 
-	cTeam * QueryPlayerTeam(const AString & a_Name); // WARNING: O(n logn)
-
 	void SetDisplay(const AString & a_Objective, eDisplaySlot a_Slot);
 
-	void SetDisplay(cObjective * a_Objective, eDisplaySlot a_Slot);
-
 	cObjective * GetObjectiveIn(eDisplaySlot a_Slot);
 
-	/// Execute callback for each objective with the specified type
-	void ForEachObjectiveWith(cObjective::eType a_Type, cObjectiveCallback& a_Callback);
-
 	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
+	/** 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:
 
@@ -265,11 +297,12 @@ private:
 
 	cWorld * m_World;
 
-	cObjective* m_Display[E_DISPLAY_SLOT_COUNT];
+	cObjective * m_Display[dsCount];
 
 	friend class cScoreboardSerializer;
 
-} ;
+
+}; // tolua_export
 
 
 
diff --git a/src/Server.cpp b/src/Server.cpp
index c60418b41..fcbcaa919 100644
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -472,6 +472,8 @@ void cServer::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallbac
 	if (split[0] == "reloadgroups")
 	{
 		cRoot::Get()->ReloadGroups();
+		a_Output.Out("Groups reloaded!");
+		a_Output.Finished();
 		return;
 	}
 	
diff --git a/src/Simulator/FireSimulator.cpp b/src/Simulator/FireSimulator.cpp
index b77fa1658..4967c83f9 100644
--- a/src/Simulator/FireSimulator.cpp
+++ b/src/Simulator/FireSimulator.cpp
@@ -162,14 +162,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;
 		}
@@ -239,7 +252,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++)
diff --git a/src/Simulator/FloodyFluidSimulator.cpp b/src/Simulator/FloodyFluidSimulator.cpp
index 95182345c..03e94e791 100644
--- a/src/Simulator/FloodyFluidSimulator.cpp
+++ b/src/Simulator/FloodyFluidSimulator.cpp
@@ -54,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.
@@ -86,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 (
@@ -105,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:
@@ -119,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:
@@ -296,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);
 }
 
 
@@ -348,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/IncrementalRedstoneSimulator.cpp b/src/Simulator/IncrementalRedstoneSimulator.cpp
index 91de9e0cc..f377b0aa7 100644
--- a/src/Simulator/IncrementalRedstoneSimulator.cpp
+++ b/src/Simulator/IncrementalRedstoneSimulator.cpp
@@ -566,14 +566,14 @@ void cIncrementalRedstoneSimulator::HandleRedstoneWire(int a_BlockX, int a_Block
 		{
 			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)...
+				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 (g_BlockIsSolid[m_World.GetBlock(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y + 1, a_BlockZ + gCrossCoords[i].z)])
+				if (cBlockInfo::IsSolid(m_World.GetBlock(a_BlockX + gCrossCoords[i].x, a_BlockY + gCrossCoords[i].y + 1, a_BlockZ + gCrossCoords[i].z)))
 				{
 					continue;
 				}
@@ -937,17 +937,15 @@ void cIncrementalRedstoneSimulator::HandleTrapdoor(int a_BlockX, int a_BlockY, i
 	{
 		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);
-			m_World.BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+			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.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
-			m_World.BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0);
+			m_World.SetTrapdoorOpen(a_BlockX, a_BlockY, a_BlockZ, false);
 			SetPlayerToggleableBlockAsSimulated(a_BlockX, a_BlockY, a_BlockZ, false);
 		}
 	}
diff --git a/src/Simulator/IncrementalRedstoneSimulator.h b/src/Simulator/IncrementalRedstoneSimulator.h
index e6bc28621..8b7363366 100644
--- a/src/Simulator/IncrementalRedstoneSimulator.h
+++ b/src/Simulator/IncrementalRedstoneSimulator.h
@@ -170,7 +170,7 @@ private:
 
 	/* ====== 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]; }
+	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)
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/Tracer.cpp b/src/Tracer.cpp
index ef136302f..968a64439 100644
--- a/src/Tracer.cpp
+++ b/src/Tracer.cpp
@@ -226,7 +226,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/UI/SlotArea.cpp b/src/UI/SlotArea.cpp
index bfcad3d92..88977e005 100644
--- a/src/UI/SlotArea.cpp
+++ b/src/UI/SlotArea.cpp
@@ -224,6 +224,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++)
@@ -447,6 +465,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 d31c87e0c..25b367cff 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/World.cpp b/src/World.cpp
index 8b791fa48..2627da0ba 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -34,6 +34,7 @@
 #include "Simulator/NoopRedstoneSimulator.h"
 #include "Simulator/SandSimulator.h"
 #include "Simulator/IncrementalRedstoneSimulator.h"
+#include "Simulator/VanillaFluidSimulator.h"
 #include "Simulator/VaporizeFluidSimulator.h"
 
 // Mobs:
@@ -264,8 +265,6 @@ cWorld::cWorld(const AString & a_WorldName) :
 	// Load the scoreboard
 	cScoreboardSerializer Serializer(m_WorldName, &m_Scoreboard);
 	Serializer.Load();
-
-	m_MapManager.LoadMapData();
 }
 
 
@@ -307,25 +306,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);
 	
@@ -625,13 +651,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());
 	}
-
 }
 
 
@@ -1172,9 +1198,18 @@ bool cWorld::DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCom
 
 
 
-bool cWorld::DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadBlockCallback & a_Callback)
+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->DoWithMobHeadBlockAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
+	return m_ChunkMap->DoWithFlowerPotAt(a_BlockX, a_BlockY, a_BlockZ, a_Callback);
 }
 
 
@@ -1723,7 +1758,7 @@ 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));
+	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);
@@ -2647,6 +2682,47 @@ bool cWorld::SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, co
 
 
 
+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;
+}
+
+
+
+
+
 void cWorld::RegenerateChunk(int a_ChunkX, int a_ChunkZ)
 {
 	m_ChunkMap->MarkChunkRegenerating(a_ChunkX, a_ChunkZ);
@@ -2987,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;
@@ -3012,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);
diff --git a/src/World.h b/src/World.h
index 4fdbd8c0d..1b74eccc3 100644
--- a/src/World.h
+++ b/src/World.h
@@ -44,6 +44,7 @@ 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;
@@ -60,7 +61,8 @@ typedef cItemCallback<cDispenserEntity>    cDispenserCallback;
 typedef cItemCallback<cFurnaceEntity>      cFurnaceCallback;
 typedef cItemCallback<cNoteEntity>         cNoteBlockCallback;
 typedef cItemCallback<cCommandBlockEntity> cCommandBlockCallback;
-typedef cItemCallback<cMobHeadEntity>      cMobHeadBlockCallback;
+typedef cItemCallback<cMobHeadEntity>      cMobHeadCallback;
+typedef cItemCallback<cFlowerPotEntity>    cFlowerPotCallback;
 
 
 
@@ -139,6 +141,10 @@ public:
 		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; }
 
@@ -342,6 +348,12 @@ public:
 	/** 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
 	
@@ -445,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);
 
 	double GetSpawnX(void) const { return m_SpawnX; }
 	double GetSpawnY(void) const { return m_SpawnY; }
@@ -521,10 +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 DoWithMobHeadBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadBlockCallback & a_Callback);  // Exported in ManualBindings.cpp
-	
+	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
 	
diff --git a/src/WorldStorage/FastNBT.h b/src/WorldStorage/FastNBT.h
index e7e56282f..1b8b09c21 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,13 +118,32 @@ public:
 	
 	bool IsValid(void) const {return m_IsValid; }
 	
+	/** Returns the root tag of the hierarchy. */
 	int GetRoot(void) const {return 0; }
+
+	/** Returns the first child of the specified tag, or -1 if none / not applicable. */
 	int GetFirstChild (int a_Tag) const { return m_Tags[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[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[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[a_Tag].m_PrevSibling; }
-	int GetDataLength (int a_Tag) const { return m_Tags[a_Tag].m_DataLength; }
+	
+	/** 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[a_Tag].m_Type != TAG_List);
+		ASSERT(m_Tags[a_Tag].m_Type != TAG_Compound);
+		return m_Tags[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);
@@ -128,69 +151,88 @@ public:
 		return m_Data + m_Tags[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; }
 	
-	/// 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;
 	}
 	
+	/** 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]);
 	}
 	
+	/** 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);
 	}
 
+	/** 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);
 	}
 
+	/** 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);
 	}
 
+	/** 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);
 		
-		// Cause a compile-time error if sizeof(int) != sizeof(float)
-		char Check1[sizeof(int) - sizeof(float) + 1];  // sizeof(int) >= sizeof(float)
-		char Check2[sizeof(float) - sizeof(int) + 1];  // sizeof(float) >= sizeof(int)
+		// 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);
 		
-		int i = GetBEInt(m_Data + m_Tags[a_Tag].m_DataStart);
+		Int32 i = GetBEInt(m_Data + m_Tags[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
 	{
+		// 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[a_Tag].m_Type == TAG_Double);
 		return NetworkToHostDouble8(m_Data + m_Tags[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);
@@ -199,6 +241,7 @@ public:
 		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;
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index 6d82cba86..e9fa11fe6 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -20,6 +20,7 @@
 #include "../BlockEntities/NoteEntity.h"
 #include "../BlockEntities/SignEntity.h"
 #include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 
 #include "../Entities/Entity.h"
 #include "../Entities/FallingBlock.h"
@@ -283,6 +284,19 @@ void cNBTChunkSerializer::AddMobHeadEntity(cMobHeadEntity * a_MobHead)
 
 
 
+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();
+}
+
+
+
+
+
 void cNBTChunkSerializer::AddBasicEntity(cEntity * a_Entity, const AString & a_ClassName)
 {
 	m_Writer.AddString("id", a_ClassName);
@@ -695,6 +709,7 @@ void cNBTChunkSerializer::BlockEntity(cBlockEntity * a_Entity)
 		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:
diff --git a/src/WorldStorage/NBTChunkSerializer.h b/src/WorldStorage/NBTChunkSerializer.h
index 5f9e16ed1..8a9e18413 100644
--- a/src/WorldStorage/NBTChunkSerializer.h
+++ b/src/WorldStorage/NBTChunkSerializer.h
@@ -30,6 +30,7 @@ class cJukeboxEntity;
 class cNoteEntity;
 class cSignEntity;
 class cMobHeadEntity;
+class cFlowerPotEntity;
 class cFallingBlock;
 class cMinecart;
 class cMinecartWithChest;
@@ -96,6 +97,7 @@ protected:
 	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);
diff --git a/src/WorldStorage/SchematicFileSerializer.cpp b/src/WorldStorage/SchematicFileSerializer.cpp
index 45fd967bd..b021aeb0c 100644
--- a/src/WorldStorage/SchematicFileSerializer.cpp
+++ b/src/WorldStorage/SchematicFileSerializer.cpp
@@ -1,10 +1,18 @@
 
+// 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"
+
+
+
+
 
 bool cSchematicFileSerializer::LoadFromSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName)
 {
@@ -40,48 +48,51 @@ bool cSchematicFileSerializer::LoadFromSchematicFile(cBlockArea & a_BlockArea, c
 
 
 
-bool cSchematicFileSerializer::SaveToSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName)
+bool cSchematicFileSerializer::LoadFromSchematicString(cBlockArea & a_BlockArea, const AString & a_SchematicData)
 {
-	cFastNBTWriter Writer("Schematic");
-	Writer.AddShort("Width",  a_BlockArea.m_SizeX);
-	Writer.AddShort("Height", a_BlockArea.m_SizeY);
-	Writer.AddShort("Length", a_BlockArea.m_SizeZ);
-	Writer.AddString("Materials", "Alpha");
-	if (a_BlockArea.HasBlockTypes())
+	// Uncompress the data:
+	AString UngzippedData;
+	if (UncompressStringGZIP(a_SchematicData.data(), a_SchematicData.size(), UngzippedData) != Z_OK)
 	{
-		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());
+		LOG("%s: Cannot unGZip the schematic data.", __FUNCTION__);
+		return false;
 	}
-	if (a_BlockArea.HasBlockMetas())
+
+	// Parse the NBT:
+	cParsedNBT NBT(UngzippedData.data(), UngzippedData.size());
+	if (!NBT.IsValid())
 	{
-		Writer.AddByteArray("Data", (const char *)a_BlockArea.m_BlockMetas, a_BlockArea.GetBlockCount());
+		LOG("%s: Cannot parse the NBT in the schematic data.", __FUNCTION__);
+		return false;
 	}
-	else
+	
+	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())
 	{
-		AString Dummy(a_BlockArea.GetBlockCount(), 0);
-		Writer.AddByteArray("Data", Dummy.data(), Dummy.size());
+		LOG("%s: Cannot serialize the area into an NBT representation for file \"%s\".", __FUNCTION__, a_FileName.c_str());
+		return false;
 	}
-	// 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());
+		LOG("%s: Cannot open file \"%s\" for writing.", __FUNCTION__, a_FileName.c_str());
 		return false;
 	}
-	if (!File.Write(Writer.GetResult()))
+	if (!File.Write(NBT))
 	{
-		LOG("Cannot write data to file \"%s\".", a_FileName.c_str());
+		LOG("%s: Cannot write data to file \"%s\".", __FUNCTION__, a_FileName.c_str());
 		return false;
 	}
 	return true;
@@ -92,6 +103,30 @@ bool cSchematicFileSerializer::SaveToSchematicFile(cBlockArea & a_BlockArea, con
 
 
 
+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");
@@ -170,3 +205,45 @@ bool cSchematicFileSerializer::LoadFromSchematicNBT(cBlockArea & a_BlockArea, cP
 }
 
 
+
+
+
+AString cSchematicFileSerializer::SaveToSchematicNBT(const cBlockArea & a_BlockArea)
+{
+	cFastNBTWriter Writer("Schematic");
+	Writer.AddShort("Width",  a_BlockArea.m_SizeX);
+	Writer.AddShort("Height", a_BlockArea.m_SizeY);
+	Writer.AddShort("Length", a_BlockArea.m_SizeZ);
+	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());
+	}
+	
+	// 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
index 9be2e5b57..05b6c74f4 100644
--- a/src/WorldStorage/SchematicFileSerializer.h
+++ b/src/WorldStorage/SchematicFileSerializer.h
@@ -1,4 +1,12 @@
 
+// SchematicFileSerializer.h
+
+// Declares the cSchematicFileSerializer class representing the interface to load and save cBlockArea to a .schematic file
+
+
+
+
+
 #pragma once
 
 #include "../BlockArea.h"
@@ -13,17 +21,34 @@ class cParsedNBT;
 
 
 
+
 class cSchematicFileSerializer
 {
 public:
 		
-	/// Loads an area from a .schematic file. Returns true if successful
+	/** Loads an area from a .schematic file. Returns true if successful. */
 	static bool LoadFromSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName);
 	
-	/// Saves the area into a .schematic file. Returns true if successful
-	static bool SaveToSchematicFile(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.
+	/** 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
index 9b8b661c4..6c885bb45 100644
--- a/src/WorldStorage/ScoreboardSerializer.cpp
+++ b/src/WorldStorage/ScoreboardSerializer.cpp
@@ -173,13 +173,13 @@ void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
 
 	a_Writer.BeginCompound("DisplaySlots");
 
-	cObjective * Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::E_DISPLAY_SLOT_LIST);
+	cObjective * Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsList);
 	a_Writer.AddString("slot_0", (Objective == NULL) ? "" : Objective->GetName());
 
-	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::E_DISPLAY_SLOT_SIDEBAR);
+	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsSidebar);
 	a_Writer.AddString("slot_1", (Objective == NULL) ? "" : Objective->GetName());
 
-	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::E_DISPLAY_SLOT_NAME);
+	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsName);
 	a_Writer.AddString("slot_2", (Objective == NULL) ? "" : Objective->GetName());
 
 	a_Writer.EndCompound(); // DisplaySlots
@@ -280,7 +280,7 @@ bool cScoreboardSerializer::LoadScoreboardFromNBT(const cParsedNBT & a_NBT)
 	{
 		AString Name, DisplayName, Prefix, Suffix;
 
-		bool AllowsFriendlyFire = false, CanSeeFriendlyInvisible = false;
+		bool AllowsFriendlyFire = true, CanSeeFriendlyInvisible = false;
 
 		int CurrLine = a_NBT.FindChildByName(Child, "Name");
 		if (CurrLine >= 0)
@@ -346,7 +346,7 @@ bool cScoreboardSerializer::LoadScoreboardFromNBT(const cParsedNBT & a_NBT)
 	{
 		AString Name = a_NBT.GetString(CurrLine);
 
-		m_ScoreBoard->SetDisplay(Name, cScoreboard::E_DISPLAY_SLOT_LIST);
+		m_ScoreBoard->SetDisplay(Name, cScoreboard::dsList);
 	}
 
 	CurrLine = a_NBT.FindChildByName(DisplaySlots, "slot_1");
@@ -354,7 +354,7 @@ bool cScoreboardSerializer::LoadScoreboardFromNBT(const cParsedNBT & a_NBT)
 	{
 		AString Name = a_NBT.GetString(CurrLine);
 
-		m_ScoreBoard->SetDisplay(Name, cScoreboard::E_DISPLAY_SLOT_SIDEBAR);
+		m_ScoreBoard->SetDisplay(Name, cScoreboard::dsSidebar);
 	}
 
 	CurrLine = a_NBT.FindChildByName(DisplaySlots, "slot_2");
@@ -362,7 +362,7 @@ bool cScoreboardSerializer::LoadScoreboardFromNBT(const cParsedNBT & a_NBT)
 	{
 		AString Name = a_NBT.GetString(CurrLine);
 
-		m_ScoreBoard->SetDisplay(Name, cScoreboard::E_DISPLAY_SLOT_NAME);
+		m_ScoreBoard->SetDisplay(Name, cScoreboard::dsName);
 	}
 
 	return true;
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index 0658d5029..07cf87ab3 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -25,6 +25,7 @@
 #include "../BlockEntities/NoteEntity.h"
 #include "../BlockEntities/SignEntity.h"
 #include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
 
 
 #include "../Mobs/Monster.h"
@@ -578,6 +579,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);
@@ -766,6 +771,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);
diff --git a/src/WorldStorage/WSSAnvil.h b/src/WorldStorage/WSSAnvil.h
index 4acf3f2a1..b26345b13 100644
--- a/src/WorldStorage/WSSAnvil.h
+++ b/src/WorldStorage/WSSAnvil.h
@@ -135,6 +135,7 @@ 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);
diff --git a/src/WorldStorage/WSSCompact.cpp b/src/WorldStorage/WSSCompact.cpp
index 4c0684dd8..5e49e4909 100644
--- a/src/WorldStorage/WSSCompact.cpp
+++ b/src/WorldStorage/WSSCompact.cpp
@@ -12,8 +12,10 @@
 #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"
 
@@ -75,12 +77,14 @@ void cJsonChunkSerializer::BlockEntity(cBlockEntity * a_BlockEntity)
 		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:
 		{
@@ -298,6 +302,21 @@ void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_En
 		}
 	}  // for itr - AllDispensers[]
 
+	// 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);
 	for (Json::Value::iterator itr = AllFurnaces.begin(); itr != AllFurnaces.end(); ++itr)
@@ -331,7 +350,7 @@ void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_En
 
 	// Load note blocks:
 	Json::Value AllNotes = a_Value.get("Notes", Json::nullValue);
-	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))
@@ -346,7 +365,7 @@ void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_En
 
 	// Load jukeboxes:
 	Json::Value AllJukeboxes = a_Value.get("Jukeboxes", Json::nullValue);
-	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))
@@ -361,7 +380,7 @@ void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_En
 
 	// Load command blocks:
 	Json::Value AllCommandBlocks = a_Value.get("CommandBlocks", Json::nullValue);
-	for( Json::Value::iterator itr = AllCommandBlocks.begin(); itr != AllCommandBlocks.end(); ++itr )
+	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))
@@ -373,6 +392,21 @@ void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_En
 			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[]
 }
 
 
diff --git a/src/main.cpp b/src/main.cpp
index 4d2801926..2ae8a413b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -243,31 +243,36 @@ int main( int argc, char **argv )
 	// Check if comm logging is to be enabled:
 	for (int i = 0; i < argc; i++)
 	{
+		AString Arg(argv[i]);
 		if (
-			(NoCaseCompare(argv[i], "/commlog") == 0) ||
-			(NoCaseCompare(argv[i], "/logcomm") == 0)
+			(NoCaseCompare(Arg, "/commlog") == 0) ||
+			(NoCaseCompare(Arg, "/logcomm") == 0)
 		)
 		{
 			g_ShouldLogCommIn = true;
 			g_ShouldLogCommOut = true;
 		}
-		if (
-			(NoCaseCompare(argv[i], "/commlogin") == 0) ||
-			(NoCaseCompare(argv[i], "/comminlog") == 0) ||
-			(NoCaseCompare(argv[i], "/logcommin") == 0)
+		else if (
+			(NoCaseCompare(Arg, "/commlogin") == 0) ||
+			(NoCaseCompare(Arg, "/comminlog") == 0) ||
+			(NoCaseCompare(Arg, "/logcommin") == 0)
 		)
 		{
 			g_ShouldLogCommIn = true;
 		}
-		if (
-			(NoCaseCompare(argv[i], "/commlogout") == 0) ||
-			(NoCaseCompare(argv[i], "/commoutlog") == 0) ||
-			(NoCaseCompare(argv[i], "/logcommout") == 0)
+		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