120 files changed, 3001 insertions, 1024 deletions

diff --git a/src/Bindings/AllToLua.pkg b/src/Bindings/AllToLua.pkg
index 2676281f9..1cd7c74f8 100644
--- a/src/Bindings/AllToLua.pkg
+++ b/src/Bindings/AllToLua.pkg
@@ -11,6 +11,7 @@ typedef unsigned int       UInt32;
 typedef unsigned short     UInt16;
 
 
+$cfile "../Vector3.h"
 $cfile "../ChunkDef.h"
 $cfile "../BiomeDef.h"
 
@@ -62,10 +63,6 @@ $cfile "../BlockEntities/MobHeadEntity.h"
 $cfile "../BlockEntities/FlowerPotEntity.h"
 $cfile "../WebAdmin.h"
 $cfile "../Root.h"
-$cfile "../Vector3f.h"
-$cfile "../Vector3d.h"
-$cfile "../Vector3i.h"
-$cfile "../Matrix4f.h"
 $cfile "../Cuboid.h"
 $cfile "../BoundingBox.h"
 $cfile "../Tracer.h"
@@ -97,4 +94,10 @@ typedef unsigned char Byte;
 
 
 
+// Aliases
+$renaming Vector3<double> @ Vector3d
+$renaming Vector3<float>  @ Vector3f
+$renaming Vector3<int>    @ Vector3i
+
+
 
diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index aa6ee05b3..f24e15c3b 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -94,12 +94,20 @@ void cLuaState::Create(void)
 	}
 	m_LuaState = lua_open();
 	luaL_openlibs(m_LuaState);
+	m_IsOwned = true;
+}
+
+
+
+
+
+void cLuaState::RegisterAPILibs(void)
+{
 	tolua_AllToLua_open(m_LuaState);
 	ManualBindings::Bind(m_LuaState);
 	DeprecatedBindings::Bind(m_LuaState);
 	luaopen_lsqlite3(m_LuaState);
 	luaopen_lxp(m_LuaState);
-	m_IsOwned = true;
 }
 
 
@@ -734,10 +742,6 @@ void cLuaState::GetStackValue(int a_StackPos, AString & a_Value)
 	{
 		a_Value.assign(data, len);
 	}
-	else
-	{
-		a_Value.clear();
-	}
 }
 
 
@@ -1281,7 +1285,9 @@ void cLuaState::LogStack(lua_State * a_LuaState, const char * a_Header)
 {
 	UNUSED(a_Header);  // The param seems unused when compiling for release, so the compiler warns
 	
-	LOGD((a_Header != NULL) ? a_Header : "Lua C API Stack contents:");
+	
+	// Format string consisting only of %s is used to appease the compiler
+	LOGD("%s",(a_Header != NULL) ? a_Header : "Lua C API Stack contents:");
 	for (int i = lua_gettop(a_LuaState); i > 0; i--)
 	{
 		AString Value;
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index 4a7a6fadb..f5cb8379d 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -29,6 +29,8 @@ extern "C"
 	#include "lua/src/lauxlib.h"
 }
 
+#include "../Vector3.h"
+
 
 
 
@@ -52,7 +54,6 @@ class cWebAdmin;
 struct HTTPTemplateRequest;
 class cTNTEntity;
 class cCreeper;
-class Vector3i;
 class cHopperEntity;
 class cBlockEntity;
 
@@ -139,9 +140,14 @@ public:
 	/** Allows this object to be used in the same way as a lua_State *, for example in the LuaLib functions */
 	operator lua_State * (void) { return m_LuaState; }
 	
-	/** Creates the m_LuaState, if not closed already. This state will be automatically closed in the destructor */
+	/** Creates the m_LuaState, if not closed already. This state will be automatically closed in the destructor.
+	The regular Lua libs are registered, but the MCS API is not registered (so that Lua can be used as
+	lite-config as well), use RegisterAPILibs() to do that. */
 	void Create(void);
 	
+	/** Registers all the API libraries that MCS provides into m_LuaState. */
+	void RegisterAPILibs(void);
+	
 	/** Closes the m_LuaState, if not closed already */
 	void Close(void);
 	
@@ -194,7 +200,7 @@ public:
 	void Push(const HTTPTemplateRequest * a_Request);
 	void Push(cTNTEntity * a_TNTEntity);
 	void Push(Vector3i * a_Vector);
-	void Push(void * a_Ptr);
+	NORETURNDEBUG void Push(void * a_Ptr);
 	void Push(cHopperEntity * a_Hopper);
 	void Push(cBlockEntity * a_BlockEntity);
 	
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index a5247bbe6..20bbc48f2 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -1497,7 +1497,8 @@ static int tolua_cPluginManager_BindCommand(lua_State * L)
 	}
 	
 	Plugin->BindCommand(Command, FnRef);
-	return 0;
+	lua_pushboolean(L, true);
+	return 1;
 }
 
 
@@ -1521,7 +1522,10 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	// Read the arguments to this API call:
 	tolua_Error tolua_err;
 	int idx = 1;
-	if (tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err))
+	if (
+		tolua_isusertype(L, 1, "cPluginManager", 0, &tolua_err) ||
+		tolua_isusertable(L, 1, "cPluginManager", 0, &tolua_err)
+	)
 	{
 		idx++;
 	}
@@ -1561,7 +1565,8 @@ static int tolua_cPluginManager_BindConsoleCommand(lua_State * L)
 	}
 	
 	Plugin->BindConsoleCommand(Command, FnRef);
-	return 0;
+	lua_pushboolean(L, true);
+	return 1;
 }
 
 
diff --git a/src/Bindings/PluginLua.cpp b/src/Bindings/PluginLua.cpp
index 45c8216be..cccbc3c93 100644
--- a/src/Bindings/PluginLua.cpp
+++ b/src/Bindings/PluginLua.cpp
@@ -75,6 +75,7 @@ bool cPluginLua::Initialize(void)
 	if (!m_LuaState.IsValid())
 	{	
 		m_LuaState.Create();
+		m_LuaState.RegisterAPILibs();
 		
 		// Inject the identification global variables into the state:
 		lua_pushlightuserdata(m_LuaState, this);
diff --git a/src/Bindings/PluginManager.cpp b/src/Bindings/PluginManager.cpp
index c7df6357e..b9cf160c4 100644
--- a/src/Bindings/PluginManager.cpp
+++ b/src/Bindings/PluginManager.cpp
@@ -248,7 +248,7 @@ bool cPluginManager::CallHookChat(cPlayer * a_Player, AString & a_Message)
 	{
 		AStringVector Split(StringSplit(a_Message, " "));
 		ASSERT(!Split.empty());  // This should not happen - we know there's at least one char in the message so the split needs to be at least one item long
-		a_Player->SendMessageInfo(Printf("Unknown command: \"%s\"", Split[0].c_str()));
+		a_Player->SendMessageInfo(Printf("Unknown command: \"%s\"", a_Message.c_str()));
 		LOGINFO("Player %s issued an unknown command: \"%s\"", a_Player->GetName().c_str(), a_Message.c_str());
 		return true;  // Cancel sending
 	}
diff --git a/src/BlockArea.cpp b/src/BlockArea.cpp
index d07ef747a..406e18a3b 100644
--- a/src/BlockArea.cpp
+++ b/src/BlockArea.cpp
@@ -168,6 +168,7 @@ cBlockArea::cBlockArea(void) :
 	m_SizeX(0),
 	m_SizeY(0),
 	m_SizeZ(0),
+	m_WEOffset(0, 0, 0),
 	m_BlockTypes(NULL),
 	m_BlockMetas(NULL),
 	m_BlockLight(NULL),
@@ -254,6 +255,24 @@ void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes)
 
 
 
+void cBlockArea::SetWEOffset(int a_OffsetX, int a_OffsetY, int a_OffsetZ)
+{
+	m_WEOffset.Set(a_OffsetX, a_OffsetY, a_OffsetZ);
+}
+
+
+
+
+
+void cBlockArea::SetWEOffset(const Vector3i & a_Offset)
+{
+	m_WEOffset.Set(a_Offset.x, a_Offset.y, a_Offset.z);
+}
+
+
+
+
+
 void cBlockArea::SetOrigin(int a_OriginX, int a_OriginY, int a_OriginZ)
 {
 	m_OriginX = a_OriginX;
diff --git a/src/BlockArea.h b/src/BlockArea.h
index 0703f195e..e0e8fe972 100644
--- a/src/BlockArea.h
+++ b/src/BlockArea.h
@@ -13,13 +13,13 @@
 #pragma once
 
 #include "ForEachChunkProvider.h"
+#include "Vector3.h"
 
 
 
 
 // fwd:
 class cCuboid;
-class Vector3i;
 
 
 
@@ -209,6 +209,8 @@ public:
 	void SetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockLight);
 	void SetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockSkyLight);
 	void SetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockSkyLight);
+	void SetWEOffset        (int a_OffsetX, int a_OffsetY, int a_OffsetZ);
+	void SetWEOffset        (const Vector3i & a_Offset);
 
 	// Getters:
 	BLOCKTYPE  GetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ)   const;
@@ -219,6 +221,7 @@ public:
 	NIBBLETYPE GetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ) const;
 	NIBBLETYPE GetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ)   const;
 	NIBBLETYPE GetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ) const;
+	const Vector3i & GetWEOffset  (void)                                     const {return m_WEOffset;}
 
 	void SetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
 	void SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
@@ -299,6 +302,10 @@ protected:
 	int m_SizeY;
 	int m_SizeZ;
 	
+	/** An extra data value sometimes stored in the .schematic file. Used mainly by the WorldEdit plugin.
+	cBlockArea doesn't use this value in any way. */
+	Vector3i m_WEOffset;
+
 	BLOCKTYPE *  m_BlockTypes;
 	NIBBLETYPE * m_BlockMetas;     // Each meta is stored as a separate byte for faster access
 	NIBBLETYPE * m_BlockLight;     // Each light value is stored as a separate byte for faster access
diff --git a/src/BlockEntities/DispenserEntity.cpp b/src/BlockEntities/DispenserEntity.cpp
index cbfbb1b6a..e03bf776d 100644
--- a/src/BlockEntities/DispenserEntity.cpp
+++ b/src/BlockEntities/DispenserEntity.cpp
@@ -138,6 +138,12 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
 			break;
 		}
 		
+		case E_ITEM_FIRE_CHARGE:
+		{
+			// TODO: Spawn fireball entity
+			break;
+		}
+		
 		default:
 		{
 			DropFromSlot(a_Chunk, a_SlotNum);
diff --git a/src/BlockEntities/HopperEntity.cpp b/src/BlockEntities/HopperEntity.cpp
index af7043767..41fb9f811 100644
--- a/src/BlockEntities/HopperEntity.cpp
+++ b/src/BlockEntities/HopperEntity.cpp
@@ -219,7 +219,7 @@ bool cHopperEntity::MovePickupsIn(cChunk & a_Chunk, Int64 a_CurrentTick)
 
 			Vector3f EntityPos = a_Entity->GetPosition();
 			Vector3f BlockPos(m_Pos.x + 0.5f, (float)m_Pos.y + 1, m_Pos.z + 0.5f); // One block above hopper, and search from center outwards
-			float Distance = (EntityPos - BlockPos).Length();
+			double Distance = (EntityPos - BlockPos).Length();
 
 			if (Distance < 0.5)
 			{
diff --git a/src/BlockInfo.cpp b/src/BlockInfo.cpp
index d1ecfdf7e..7d438ba3e 100644
--- a/src/BlockInfo.cpp
+++ b/src/BlockInfo.cpp
@@ -93,6 +93,7 @@ void cBlockInfo::Initialize(void)
 	ms_Info[E_BLOCK_IRON_BARS           ].m_SpreadLightFalloff = 1;
 	ms_Info[E_BLOCK_IRON_DOOR           ].m_SpreadLightFalloff = 1;
 	ms_Info[E_BLOCK_LEAVES              ].m_SpreadLightFalloff = 1;
+	ms_Info[E_BLOCK_NEW_LEAVES          ].m_SpreadLightFalloff = 1;
 	ms_Info[E_BLOCK_SIGN_POST           ].m_SpreadLightFalloff = 1;
 	ms_Info[E_BLOCK_TORCH               ].m_SpreadLightFalloff = 1;
 	ms_Info[E_BLOCK_VINES               ].m_SpreadLightFalloff = 1;
diff --git a/src/Blocks/BlockAnvil.h b/src/Blocks/BlockAnvil.h
new file mode 100644
index 000000000..9f5f84be0
--- /dev/null
+++ b/src/Blocks/BlockAnvil.h
@@ -0,0 +1,63 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cBlockAnvilHandler :
+	public cBlockHandler
+{
+public:
+	cBlockAnvilHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_ANVIL, 1, a_BlockMeta >> 2));
+	}
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		
+		int Direction = (int)floor(a_Player->GetYaw() * 4.0 / 360.0 + 0.5) & 0x3;
+		int RawMeta = a_BlockMeta >> 2;
+		
+		Direction++;
+		Direction %= 4;
+		switch (Direction)
+		{
+			case 0:      a_BlockMeta = 0x2 | RawMeta << 2; break;
+			case 1:      a_BlockMeta = 0x3 | RawMeta << 2; break;
+			case 2:      a_BlockMeta = 0x0 | RawMeta << 2; break;
+			case 3:      a_BlockMeta = 0x1 | RawMeta << 2; break;
+			default:
+			{
+				return false;
+			}
+		}
+		
+		return true;
+	}
+
+	virtual bool IsUseable() override
+	{
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index 3dad4feba..6a3c6a55b 100644
--- a/src/Blocks/BlockBed.cpp
+++ b/src/Blocks/BlockBed.cpp
@@ -51,6 +51,49 @@ void cBlockBedHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInt
 
 
 
+class cTimeFastForwardTester :
+	public cPlayerListCallback
+{
+	virtual bool Item(cPlayer * a_Player) override
+	{
+		if (!a_Player->IsInBed())
+		{
+			return true;
+		}
+
+		return false;
+	}
+};
+
+
+
+
+
+class cPlayerBedStateUnsetter :
+	public cPlayerListCallback
+{
+public:
+	cPlayerBedStateUnsetter(Vector3i a_Position, cWorldInterface & a_WorldInterface) :
+		m_Position(a_Position), m_WorldInterface(a_WorldInterface)
+	{
+	}
+
+	virtual bool Item(cPlayer * a_Player) override
+	{
+		a_Player->SetIsInBed(false);
+		m_WorldInterface.GetBroadcastManager().BroadcastEntityAnimation(*a_Player, 2);
+		return false;
+	}
+
+private:
+	Vector3i m_Position;
+	cWorldInterface & m_WorldInterface;
+};
+
+
+
+
+
 void cBlockBedHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
 {
 	if (a_WorldInterface.GetDimension() != dimOverworld)
@@ -69,6 +112,8 @@ void cBlockBedHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface
 			}
 			else
 			{
+				Vector3i PillowDirection(0, 0, 0);
+
 				if (Meta & 0x8)
 				{
 					// Is pillow	
@@ -77,16 +122,30 @@ void cBlockBedHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface
 				else
 				{
 					// Is foot end
-					Vector3i Direction = MetaDataToDirection( Meta & 0x7 );
-					if (a_ChunkInterface.GetBlock(a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z) == E_BLOCK_BED) // Must always use pillow location for sleeping
+					VERIFY((Meta & 0x4) != 0x4); // Occupied flag should never be set, else our compilator (intended) is broken
+
+					PillowDirection = MetaDataToDirection(Meta & 0x7);
+					if (a_ChunkInterface.GetBlock(a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z) == E_BLOCK_BED) // Must always use pillow location for sleeping
 					{
-						a_WorldInterface.GetBroadcastManager().BroadcastUseBed(*a_Player, a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z);
+						a_WorldInterface.GetBroadcastManager().BroadcastUseBed(*a_Player, a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z);
 					}
 				}
-				a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, (Meta | (1 << 2)));
-			}
-			
-		} else {
+
+				a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta | 0x4); // Where 0x4 = occupied bit
+				a_Player->SetIsInBed(true);
+
+				cTimeFastForwardTester Tester;
+				if (a_WorldInterface.ForEachPlayer(Tester))
+				{
+					cPlayerBedStateUnsetter Unsetter(Vector3i(a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z), a_WorldInterface);
+					a_WorldInterface.ForEachPlayer(Unsetter);
+					a_WorldInterface.SetTimeOfDay(0);
+					a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta & 0xB); // Where 0xB = 1011, and zero is to make sure 'occupied' bit is always unset
+				}
+			}			
+		}
+		else
+		{
 			a_Player->SendMessageFailure("You can only sleep at night");
 		}
 	}
diff --git a/src/Blocks/BlockCake.h b/src/Blocks/BlockCake.h
new file mode 100644
index 000000000..36e133388
--- /dev/null
+++ b/src/Blocks/BlockCake.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockCakeHandler :
+	public cBlockHandler
+{
+public:
+	cBlockCakeHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+		if (!a_Player->Feed(2, 0.1))
+		{
+			return;
+		}
+		
+		if (Meta >= 5)
+		{
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+		}
+		else
+		{
+			a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta + 1);
+		}
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Give nothing
+	}
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.cloth";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index aa97b2ca9..4f74e2f45 100644
--- a/src/Blocks/BlockHandler.cpp
+++ b/src/Blocks/BlockHandler.cpp
@@ -6,10 +6,12 @@
 #include "../Root.h"
 #include "../Bindings/PluginManager.h"
 #include "../Chunk.h"
+#include "BlockAnvil.h"
 #include "BlockBed.h"
 #include "BlockBrewingStand.h"
 #include "BlockButton.h"
 #include "BlockCactus.h"
+#include "BlockCake.h"
 #include "BlockCarpet.h"
 #include "BlockCauldron.h"
 #include "BlockChest.h"
@@ -85,12 +87,14 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		// Block handlers, alphabetically sorted:
 		case E_BLOCK_ACACIA_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_ACTIVATOR_RAIL:        return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_ANVIL:                 return new cBlockAnvilHandler           (a_BlockType);
 		case E_BLOCK_BED:                   return new cBlockBedHandler             (a_BlockType);
 		case E_BLOCK_BIRCH_WOOD_STAIRS:     return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_BREWING_STAND:         return new cBlockBrewingStandHandler    (a_BlockType);
 		case E_BLOCK_BRICK_STAIRS:          return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_BROWN_MUSHROOM:        return new cBlockMushroomHandler        (a_BlockType);
 		case E_BLOCK_CACTUS:                return new cBlockCactusHandler          (a_BlockType);
+		case E_BLOCK_CAKE:                  return new cBlockCakeHandler            (a_BlockType);
 		case E_BLOCK_CARROTS:               return new cBlockCropsHandler           (a_BlockType);
 		case E_BLOCK_CARPET:                return new cBlockCarpetHandler          (a_BlockType);
 		case E_BLOCK_CAULDRON:              return new cBlockCauldronHandler        (a_BlockType);
diff --git a/src/Blocks/BlockLeaves.h b/src/Blocks/BlockLeaves.h
index 7b8f0b378..a6d3373c1 100644
--- a/src/Blocks/BlockLeaves.h
+++ b/src/Blocks/BlockLeaves.h
@@ -16,6 +16,7 @@
 	{ \
 		case E_BLOCK_LEAVES: a_Area.SetBlockType(x, y, z, (BLOCKTYPE)(E_BLOCK_SPONGE + i + 1)); break; \
 		case E_BLOCK_LOG: return true; \
+		case E_BLOCK_NEW_LOG: return true; \
 	}
 
 bool HasNearLog(cBlockArea &a_Area, int a_BlockX, int a_BlockY, int a_BlockZ);
diff --git a/src/Blocks/BlockMushroom.h b/src/Blocks/BlockMushroom.h
index 623cfda64..c30c1a401 100644
--- a/src/Blocks/BlockMushroom.h
+++ b/src/Blocks/BlockMushroom.h
@@ -39,6 +39,7 @@ public:
 			case E_BLOCK_CACTUS:
 			case E_BLOCK_ICE:
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			case E_BLOCK_AIR:
 			{
 				return false;
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
index 708583e70..8041d9359 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -73,7 +73,7 @@ public:
 	/// Returns true if the specified block type is good for vines to attach to
 	static bool IsBlockAttachable(BLOCKTYPE a_BlockType)
 	{
-		return (a_BlockType == E_BLOCK_LEAVES) || cBlockInfo::IsSolid(a_BlockType);
+		return (a_BlockType == E_BLOCK_LEAVES) || (a_BlockType == E_BLOCK_NEW_LEAVES) || cBlockInfo::IsSolid(a_BlockType);
 	}
 
 
diff --git a/src/Blocks/BroadcastInterface.h b/src/Blocks/BroadcastInterface.h
index f6ccd580b..01966ffbd 100644
--- a/src/Blocks/BroadcastInterface.h
+++ b/src/Blocks/BroadcastInterface.h
@@ -5,6 +5,7 @@ class cBroadcastInterface
 {
 public:
 
-	virtual void BroadcastUseBed(const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ ) = 0;
-	virtual void BroadcastSoundEffect        (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL) = 0; 
+	virtual void BroadcastUseBed     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ ) = 0;
+	virtual void BroadcastSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL) = 0;
+	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) = 0;
 };
diff --git a/src/Blocks/WorldInterface.h b/src/Blocks/WorldInterface.h
index e59b00eff..580339d32 100644
--- a/src/Blocks/WorldInterface.h
+++ b/src/Blocks/WorldInterface.h
@@ -27,7 +27,13 @@ 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;
+
+	/** Calls the callback for each player in the list; returns true if all players processed, false if the callback aborted by returning true */
+	virtual bool ForEachPlayer(cItemCallback<cPlayer> & a_Callback) = 0;
+
+	virtual void SetTimeOfDay(Int64 a_TimeOfDay) = 0;
+
 };
diff --git a/src/BoundingBox.cpp b/src/BoundingBox.cpp
index aab51c539..482f9923f 100644
--- a/src/BoundingBox.cpp
+++ b/src/BoundingBox.cpp
@@ -10,7 +10,7 @@
 
 
 
-#if SELF_TEST
+#ifdef SELF_TEST
 
 /** A simple self-test that is executed on program start, used to verify bbox functionality */
 static class SelfTest_BoundingBox
diff --git a/src/BoundingBox.h b/src/BoundingBox.h
index 9ac5f11b8..a7c6c3eea 100644
--- a/src/BoundingBox.h
+++ b/src/BoundingBox.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "Vector3d.h"
+#include "Vector3.h"
 #include "Defines.h"
 
 
diff --git a/src/ByteBuffer.cpp b/src/ByteBuffer.cpp
index 96a135562..1893d89a8 100644
--- a/src/ByteBuffer.cpp
+++ b/src/ByteBuffer.cpp
@@ -62,11 +62,11 @@ public:
 		cByteBuffer buf(50);
 		buf.Write("\x05\xac\x02\x00", 4);
 		UInt32 v1;
-		assert(buf.ReadVarInt(v1) && (v1 == 5));
+		assert_test(buf.ReadVarInt(v1) && (v1 == 5));
 		UInt32 v2;
-		assert(buf.ReadVarInt(v2) && (v2 == 300));
+		assert_test(buf.ReadVarInt(v2) && (v2 == 300));
 		UInt32 v3;
-		assert(buf.ReadVarInt(v3) && (v3 == 0));
+		assert_test(buf.ReadVarInt(v3) && (v3 == 0));
 	}
 	
 	void TestWrite(void)
@@ -77,8 +77,8 @@ public:
 		buf.WriteVarInt(0);
 		AString All;
 		buf.ReadAll(All);
-		assert(All.size() == 4);
-		assert(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
+		assert_test(All.size() == 4);
+		assert_test(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
 	}
 	
 	void TestWrap(void)
@@ -87,17 +87,17 @@ public:
 		for (int i = 0; i < 1000; i++)
 		{
 			size_t FreeSpace = buf.GetFreeSpace();
-			assert(buf.GetReadableSpace() == 0);
-			assert(FreeSpace > 0);
-			assert(buf.Write("a", 1));
-			assert(buf.CanReadBytes(1));
-			assert(buf.GetReadableSpace() == 1);
+			assert_test(buf.GetReadableSpace() == 0);
+			assert_test(FreeSpace > 0);
+			assert_test(buf.Write("a", 1));
+			assert_test(buf.CanReadBytes(1));
+			assert_test(buf.GetReadableSpace() == 1);
 			unsigned char v = 0;
-			assert(buf.ReadByte(v));
-			assert(v == 'a');
-			assert(buf.GetReadableSpace() == 0);
+			assert_test(buf.ReadByte(v));
+			assert_test(v == 'a');
+			assert_test(buf.GetReadableSpace() == 0);
 			buf.CommitRead();
-			assert(buf.GetFreeSpace() == FreeSpace);  // We're back to normal
+			assert_test(buf.GetFreeSpace() == FreeSpace);  // We're back to normal
 		}
 	}
 	
@@ -459,7 +459,7 @@ bool cByteBuffer::ReadVarUTF8String(AString & a_Value)
 	}
 	if (Size > MAX_STRING_SIZE)
 	{
-		LOGWARNING("%s: String too large: %llu (%llu KiB)", __FUNCTION__, Size, Size / 1024);
+		LOGWARNING("%s: String too large: %u (%u KiB)", __FUNCTION__, Size, Size / 1024);
 	}
 	return ReadString(a_Value, (int)Size);
 }
@@ -767,7 +767,7 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
 	{
 		return false;
 	}
-	RawBEToUTF8((short *)(RawData.data()), a_NumChars, a_String);
+	RawBEToUTF8(RawData.data(), a_NumChars, a_String);
 	return true;
 }
 
diff --git a/src/ByteBuffer.h b/src/ByteBuffer.h
index ed2e10a55..1915467f3 100644
--- a/src/ByteBuffer.h
+++ b/src/ByteBuffer.h
@@ -43,7 +43,7 @@ public:
 	size_t GetReadableSpace(void) const;
 	
 	/// Returns the current data start index. For debugging purposes.
-	int  GetDataStart(void) const { return m_DataStart; }
+	size_t  GetDataStart(void) const { return m_DataStart; }
 	
 	/// Returns true if the specified amount of bytes are available for reading
 	bool CanReadBytes(size_t a_Count) const;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5029906aa..0f0db9c80 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,3 @@
-
 cmake_minimum_required (VERSION 2.8.2)
 project (MCServer)
 
@@ -10,7 +9,6 @@ set(FOLDERS OSSupport HTTPServer Items Blocks Protocol Generating)
 set(FOLDERS ${FOLDERS} WorldStorage Mobs Entities Simulator UI BlockEntities)
 
 
-
 if (NOT MSVC)
 
 	#Bindings needs to reference other folders so are done here
@@ -59,12 +57,14 @@ if (NOT MSVC)
 		Entities/Player.h
 		Entities/ProjectileEntity.h
 		Entities/TNTEntity.h
+		Entities/ExpOrb.h
+		Entities/HangingEntity.h
+		Entities/ItemFrame.h
 		Generating/ChunkDesc.h
 		Group.h
 		Inventory.h
 		Item.h
 		ItemGrid.h
-		Matrix4f.h
 		Mobs/Monster.h
 		OSSupport/File.h
 		Root.h
@@ -72,9 +72,7 @@ if (NOT MSVC)
 		StringUtils.h
 		Tracer.h
 		UI/Window.h
-		Vector3d.h
-		Vector3f.h
-		Vector3i.h
+		Vector3.h
 		WebAdmin.h
 		World.h
 	)
diff --git a/src/ChunkDef.h b/src/ChunkDef.h
index 63431f211..9c7753820 100644
--- a/src/ChunkDef.h
+++ b/src/ChunkDef.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "Vector3i.h"
+#include "Vector3.h"
 #include "BiomeDef.h"
 
 
@@ -62,16 +62,12 @@ typedef unsigned char HEIGHTTYPE;
 class cChunkDef
 {
 public:
-	enum
-	{
-		// Chunk dimensions:
-		Width = 16U,
-		Height = 256U,
-		NumBlocks = Width * Height * Width,
-		
-		/// If the data is collected into a single buffer, how large it needs to be:
-		BlockDataSize = cChunkDef::NumBlocks * 2 + (cChunkDef::NumBlocks / 2),  // 2.5 * numblocks
-	} ;
+	// Chunk dimensions:
+	static const int Width = 16;
+	static const int Height = 256;
+	static const int NumBlocks = Width * Height * Width;
+	/// If the data is collected into a single buffer, how large it needs to be:
+	static const int BlockDataSize = cChunkDef::NumBlocks * 2 + (cChunkDef::NumBlocks / 2);  // 2.5 * numblocks
 
 	/// The type used for any heightmap operations and storage; idx = x + Width * z; Height points to the highest non-air block in the column
 	typedef HEIGHTTYPE HeightMap[Width * Width];
@@ -116,7 +112,7 @@ public:
 	}
 
 
-	inline static unsigned int MakeIndex(int x, int y, int z )
+	inline static int MakeIndex(int x, int y, int z )
 	{
 		if (
 			(x < Width)  && (x > -1) &&
@@ -132,7 +128,7 @@ public:
 	}
 
 
-	inline static unsigned int MakeIndexNoCheck(unsigned int x, unsigned int y, unsigned int z)
+	inline static int MakeIndexNoCheck(int x, int y, int z)
 	{
 		#if AXIS_ORDER == AXIS_ORDER_XZY
 			// For some reason, NOT using the Horner schema is faster. Weird.
@@ -240,7 +236,7 @@ public:
 	{
 		if ((x < Width) && (x > -1) && (y < Height) && (y > -1) && (z < Width) && (z > -1))
 		{
-			unsigned int Index = MakeIndexNoCheck(x, y, z);
+			int Index = MakeIndexNoCheck(x, y, z);
 			return (a_Buffer[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
 		}
 		ASSERT(!"cChunkDef::GetNibble(): coords out of chunk range!");
@@ -255,8 +251,8 @@ public:
 			ASSERT(!"cChunkDef::SetNibble(): index out of range!");
 			return;
 		}
-		a_Buffer[a_BlockIdx / 2] = (
-			(a_Buffer[a_BlockIdx / 2] & (0xf0 >> (static_cast<NIBBLETYPE>(a_BlockIdx & 1) * 4))) |  // The untouched nibble
+		a_Buffer[a_BlockIdx / 2] = static_cast<NIBBLETYPE>(
+			(a_Buffer[a_BlockIdx / 2] & (0xf0 >> ((a_BlockIdx & 1) * 4))) |  // The untouched nibble
 			((a_Nibble & 0x0f) << ((a_BlockIdx & 1) * 4))  // The nibble being set
 		);
 	}
@@ -275,7 +271,7 @@ public:
 		}
 
 		int Index = MakeIndexNoCheck(x, y, z);
-		a_Buffer[Index / 2] = (
+		a_Buffer[Index / 2] = static_cast<NIBBLETYPE>(
 			(a_Buffer[Index / 2] & (0xf0 >> ((Index & 1) * 4))) |  // The untouched nibble
 			((a_Nibble & 0x0f) << ((Index & 1) * 4))  // The nibble being set
 		);
@@ -435,6 +431,9 @@ Used primarily for entity moving while both chunks are locked.
 class cClientDiffCallback
 {
 public:
+
+	virtual ~cClientDiffCallback() {}
+
 	/// Called for clients that are in Chunk1 and not in Chunk2,
 	virtual void Removed(cClientHandle * a_Client) = 0;
 	
@@ -495,6 +494,9 @@ typedef std::vector<cChunkCoords> cChunkCoordsVector;
 class cChunkCoordCallback
 {
 public:
+
+	virtual ~cChunkCoordCallback() {}
+
 	virtual void Call(int a_ChunkX, int a_ChunkZ) = 0;
 } ;
 
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index 6ce928252..867b37ed0 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -1376,8 +1376,9 @@ void cChunkMap::ReplaceTreeBlocks(const sSetBlockVector & a_Blocks)
 				break;
 			}
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			{
-				if (itr->BlockType == E_BLOCK_LOG)
+				if ((itr->BlockType == E_BLOCK_LOG) || (itr->BlockType == E_BLOCK_NEW_LOG))
 				{
 					Chunk->SetBlock(itr->x, itr->y, itr->z, itr->BlockType, itr->BlockMeta);
 				}
@@ -1784,70 +1785,73 @@ void cChunkMap::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_
 					BLOCKTYPE Block = area.GetBlockType(bx + x, by + y, bz + z);
 					switch (Block)
 					{
-					case E_BLOCK_TNT:
-					{
-						// Activate the TNT, with a random fuse between 10 to 30 game ticks
-						double FuseTime = (double)(10 + m_World->GetTickRandomNumber(20)) / 20;
-						m_World->SpawnPrimedTNT(a_BlockX + x + 0.5, a_BlockY + y + 0.5, a_BlockZ + z + 0.5, FuseTime);
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
-						a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
-						break;
-					}
-					case E_BLOCK_OBSIDIAN:
-					case E_BLOCK_BEDROCK:
-					case E_BLOCK_WATER:
-					case E_BLOCK_LAVA:
-					{
-						// These blocks are not affected by explosions
-						break;
-					}
-
-					case E_BLOCK_STATIONARY_WATER:
-					{
-						// Turn into simulated water:
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_WATER);
-						break;
-					}
-
-					case E_BLOCK_STATIONARY_LAVA:
-					{
-						// Turn into simulated lava:
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_LAVA);
-						break;
-					}
+						case E_BLOCK_TNT:
+						{
+							// Activate the TNT, with a random fuse between 10 to 30 game ticks
+							int FuseTime = 10 + m_World->GetTickRandomNumber(20);
+							m_World->SpawnPrimedTNT(a_BlockX + x + 0.5, a_BlockY + y + 0.5, a_BlockZ + z + 0.5, FuseTime);
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
+							a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
+							break;
+						}
+						
+						case E_BLOCK_OBSIDIAN:
+						case E_BLOCK_BEDROCK:
+						case E_BLOCK_WATER:
+						case E_BLOCK_LAVA:
+						{
+							// These blocks are not affected by explosions
+							break;
+						}
 
-					case E_BLOCK_AIR:
-					{
-						// No pickups for air
-						break;
-					}
+						case E_BLOCK_STATIONARY_WATER:
+						{
+							// Turn into simulated water:
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_WATER);
+							break;
+						}
 
-					default:
-					{
-						if (m_World->GetTickRandomNumber(100) <= 25) // 25% chance of pickups
+						case E_BLOCK_STATIONARY_LAVA:
 						{
-							cItems Drops;
-							cBlockHandler * Handler = BlockHandler(Block);
+							// Turn into simulated lava:
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_LAVA);
+							break;
+						}
 
-							Handler->ConvertToPickups(Drops, area.GetBlockMeta(bx + x, by + y, bz + z)); // Stone becomes cobblestone, coal ore becomes coal, etc.
-							m_World->SpawnItemPickups(Drops, bx + x, by + y, bz + z);
+						case E_BLOCK_AIR:
+						{
+							// No pickups for air
+							break;
 						}
-						else if ((m_World->GetTNTShrapnelLevel() > 0) && (m_World->GetTickRandomNumber(100) < 20)) // 20% chance of flinging stuff around
+
+						default:
 						{
-							if (!cBlockInfo::FullyOccupiesVoxel(Block))
+							if (m_World->GetTickRandomNumber(100) <= 25) // 25% chance of pickups
 							{
-								break;
+								cItems Drops;
+								cBlockHandler * Handler = BlockHandler(Block);
+
+								Handler->ConvertToPickups(Drops, area.GetBlockMeta(bx + x, by + y, bz + z)); // Stone becomes cobblestone, coal ore becomes coal, etc.
+								m_World->SpawnItemPickups(Drops, bx + x, by + y, bz + z);
 							}
-							else if ((m_World->GetTNTShrapnelLevel() == 1) && ((Block != E_BLOCK_SAND) && (Block != E_BLOCK_GRAVEL)))
+							else if ((m_World->GetTNTShrapnelLevel() > 0) && (m_World->GetTickRandomNumber(100) < 20)) // 20% chance of flinging stuff around
 							{
-								break;
+								if (!cBlockInfo::FullyOccupiesVoxel(Block))
+								{
+									break;
+								}
+								else if ((m_World->GetTNTShrapnelLevel() == 1) && ((Block != E_BLOCK_SAND) && (Block != E_BLOCK_GRAVEL)))
+								{
+									break;
+								}
+								m_World->SpawnFallingBlock(bx + x, by + y + 5, bz + z, Block, area.GetBlockMeta(bx + x, by + y, bz + z));
 							}
-							m_World->SpawnFallingBlock(bx + x, by + y + 5, bz + z, Block, area.GetBlockMeta(bx + x, by + y, bz + z));
+
+							area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
+							a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
+							break;
+							
 						}
-						area.SetBlockType(bx + x, by + y, bz + z, E_BLOCK_AIR);
-						a_BlocksAffected.push_back(Vector3i(bx + x, by + y, bz + z));
-						break;
-					}
 					}  // switch (BlockType)
 				}  // for z
 			}  // for y
@@ -1902,7 +1906,7 @@ void cChunkMap::DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_
 			else if (FinalDamage < 0)
 				FinalDamage = 0;
 
-			if (!a_Entity->IsTNT() && !a_Entity->IsFallingBlock()) // Don't apply damage to other TNT entities, they should be invincible
+			if (!a_Entity->IsTNT() && !a_Entity->IsFallingBlock()) // Don't apply damage to other TNT entities and falling blocks, they should be invincible
 			{
 				a_Entity->TakeDamage(dtExplosion, NULL, (int)FinalDamage, 0);
 			}
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 94c9f5f71..46c10ae82 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -22,9 +22,6 @@
 #include "Blocks/BlockSlab.h"
 #include "Blocks/ChunkInterface.h"
 
-#include "Vector3f.h"
-#include "Vector3d.h"
-
 #include "Root.h"
 
 #include "Authenticator.h"
@@ -36,19 +33,6 @@
 
 
 
-
-
-#define AddPistonDir(x, y, z, dir, amount) switch (dir) { case 0: (y)-=(amount); break; case 1: (y)+=(amount); break;\
-													 case 2: (z)-=(amount); break; case 3: (z)+=(amount); break;\
-													 case 4: (x)-=(amount); break; case 5: (x)+=(amount); break; }
-
-
-
-
-
-/** If the number of queued outgoing packets reaches this, the client will be kicked */
-#define MAX_OUTGOING_PACKETS 2000
-
 /** Maximum number of explosions to send this tick, server will start dropping if exceeded */
 #define MAX_EXPLOSIONS_PER_TICK 20
 
@@ -895,7 +879,7 @@ void cClientHandle::HandleBlockDigFinished(int a_BlockX, int a_BlockY, int a_Blo
 		LOGD("Prevented a dig/aim bug in the client (finish {%d, %d, %d} vs start {%d, %d, %d}, HSD: %s)",
 			a_BlockX, a_BlockY, a_BlockZ,
 			m_LastDigBlockX, m_LastDigBlockY, m_LastDigBlockZ,
-			m_HasStartedDigging
+			(m_HasStartedDigging ? "True" : "False")
 		);
 		return;
 	}
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index 72b1c7d09..8366caa16 100644
--- a/src/ClientHandle.h
+++ b/src/ClientHandle.h
@@ -12,7 +12,7 @@
 #define CCLIENTHANDLE_H_INCLUDED
 
 #include "Defines.h"
-#include "Vector3d.h"
+#include "Vector3.h"
 #include "OSSupport/SocketThreads.h"
 #include "ChunkDef.h"
 #include "ByteBuffer.h"
diff --git a/src/CommandOutput.cpp b/src/CommandOutput.cpp
index c221682a1..2c116b3d6 100644
--- a/src/CommandOutput.cpp
+++ b/src/CommandOutput.cpp
@@ -51,7 +51,7 @@ void cLogCommandOutputCallback::Finished(void)
 		{
 			case '\n':
 			{
-				LOG(m_Buffer.substr(last, i - last).c_str());
+				LOG("%s", m_Buffer.substr(last, i - last).c_str());
 				last = i + 1;
 				break;
 			}
@@ -59,7 +59,7 @@ void cLogCommandOutputCallback::Finished(void)
 	}  // for i - m_Buffer[]
 	if (last < len)
 	{
-		LOG(m_Buffer.substr(last).c_str());
+		LOG("%s", m_Buffer.substr(last).c_str());
 	}
 	
 	// Clear the buffer for the next command output:
diff --git a/src/CommandOutput.h b/src/CommandOutput.h
index 3763d625f..5682b4fd8 100644
--- a/src/CommandOutput.h
+++ b/src/CommandOutput.h
@@ -17,7 +17,7 @@ public:
 	virtual ~cCommandOutputCallback() {};  // Force a virtual destructor in subclasses
 	
 	/// Syntax sugar function, calls Out() with Printf()-ed parameters; appends a "\n"
-	void Out(const char * a_Fmt, ...);
+	void Out(const char * a_Fmt, ...) FORMATSTRING(2, 3);
 	
 	/// Called when the command wants to output anything; may be called multiple times
 	virtual void Out(const AString & a_Text) = 0;
diff --git a/src/CompositeChat.cpp b/src/CompositeChat.cpp
index 3eec35657..a917ee70f 100644
--- a/src/CompositeChat.cpp
+++ b/src/CompositeChat.cpp
@@ -10,7 +10,7 @@
 
 
 
-#if SELF_TEST
+#ifdef SELF_TEST
 
 /** A simple self-test that verifies that the composite chat parser is working properly. */
 class SelfTest_CompositeChat
@@ -32,15 +32,15 @@ public:
 		cCompositeChat Msg;
 		Msg.ParseText("Testing @2color codes and http://links parser");
 		const cCompositeChat::cParts & Parts = Msg.GetParts();
-		assert(Parts.size() == 4);
-		assert(Parts[0]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[1]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[2]->m_PartType == cCompositeChat::ptUrl);
-		assert(Parts[3]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[0]->m_Style == "");
-		assert(Parts[1]->m_Style == "@2");
-		assert(Parts[2]->m_Style == "@2");
-		assert(Parts[3]->m_Style == "@2");
+		assert_test(Parts.size() == 4);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[2]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[3]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[0]->m_Style == "");
+		assert_test(Parts[1]->m_Style == "@2");
+		assert_test(Parts[2]->m_Style == "@2");
+		assert_test(Parts[3]->m_Style == "@2");
 	}
 	
 	void TestParser2(void)
@@ -48,15 +48,15 @@ public:
 		cCompositeChat Msg;
 		Msg.ParseText("@3Advanced stuff: @5overriding color codes and http://links.with/@4color-in-them handling");
 		const cCompositeChat::cParts & Parts = Msg.GetParts();
-		assert(Parts.size() == 4);
-		assert(Parts[0]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[1]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[2]->m_PartType == cCompositeChat::ptUrl);
-		assert(Parts[3]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[0]->m_Style == "@3");
-		assert(Parts[1]->m_Style == "@5");
-		assert(Parts[2]->m_Style == "@5");
-		assert(Parts[3]->m_Style == "@5");
+		assert_test(Parts.size() == 4);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[2]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[3]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[0]->m_Style == "@3");
+		assert_test(Parts[1]->m_Style == "@5");
+		assert_test(Parts[2]->m_Style == "@5");
+		assert_test(Parts[3]->m_Style == "@5");
 	}
 	
 	void TestParser3(void)
@@ -64,11 +64,11 @@ public:
 		cCompositeChat Msg;
 		Msg.ParseText("http://links.starting the text");
 		const cCompositeChat::cParts & Parts = Msg.GetParts();
-		assert(Parts.size() == 2);
-		assert(Parts[0]->m_PartType == cCompositeChat::ptUrl);
-		assert(Parts[1]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[0]->m_Style == "");
-		assert(Parts[1]->m_Style == "");
+		assert_test(Parts.size() == 2);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[0]->m_Style == "");
+		assert_test(Parts[1]->m_Style == "");
 	}
 	
 	void TestParser4(void)
@@ -76,11 +76,11 @@ public:
 		cCompositeChat Msg;
 		Msg.ParseText("links finishing the text: http://some.server");
 		const cCompositeChat::cParts & Parts = Msg.GetParts();
-		assert(Parts.size() == 2);
-		assert(Parts[0]->m_PartType == cCompositeChat::ptText);
-		assert(Parts[1]->m_PartType == cCompositeChat::ptUrl);
-		assert(Parts[0]->m_Style == "");
-		assert(Parts[1]->m_Style == "");
+		assert_test(Parts.size() == 2);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptText);
+		assert_test(Parts[1]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[0]->m_Style == "");
+		assert_test(Parts[1]->m_Style == "");
 	}
 	
 	void TestParser5(void)
@@ -88,9 +88,9 @@ public:
 		cCompositeChat Msg;
 		Msg.ParseText("http://only.links");
 		const cCompositeChat::cParts & Parts = Msg.GetParts();
-		assert(Parts.size() == 1);
-		assert(Parts[0]->m_PartType == cCompositeChat::ptUrl);
-		assert(Parts[0]->m_Style == "");
+		assert_test(Parts.size() == 1);
+		assert_test(Parts[0]->m_PartType == cCompositeChat::ptUrl);
+		assert_test(Parts[0]->m_Style == "");
 	}
 	
 } gTest;
diff --git a/src/CraftingRecipes.cpp b/src/CraftingRecipes.cpp
index 868182394..30e7a8733 100644
--- a/src/CraftingRecipes.cpp
+++ b/src/CraftingRecipes.cpp
@@ -192,7 +192,9 @@ void cCraftingGrid::Dump(void)
 {
 	for (int y = 0; y < m_Height; y++) for (int x = 0; x < m_Width; x++)
 	{
+		#ifdef _DEBUG
 		int idx = x + m_Width * y;
+		#endif
 		LOGD("Slot (%d, %d): Type %d, health %d, count %d", 
 			x, y, m_Items[idx].m_ItemType, m_Items[idx].m_ItemDamage, m_Items[idx].m_ItemCount
 		);
@@ -338,7 +340,7 @@ void cCraftingRecipes::LoadRecipes(void)
 		}
 		AddRecipeLine(LineNum, Recipe);
 	}  // for itr - Split[]
-	LOG("Loaded %d crafting recipes", m_Recipes.size());
+	LOG("Loaded " SIZE_T_FMT " crafting recipes", m_Recipes.size());
 }
 
 
diff --git a/src/Cuboid.cpp b/src/Cuboid.cpp
index 782837b23..3e5240248 100644
--- a/src/Cuboid.cpp
+++ b/src/Cuboid.cpp
@@ -38,6 +38,20 @@ void cCuboid::Assign(int a_X1, int a_Y1, int a_Z1, int a_X2, int a_Y2, int a_Z2)
 
 
 
+void cCuboid::Assign(const cCuboid & a_SrcCuboid)
+{
+	p1.x = a_SrcCuboid.p1.x;
+	p1.y = a_SrcCuboid.p1.y;
+	p1.z = a_SrcCuboid.p1.z;
+	p2.x = a_SrcCuboid.p2.x;
+	p2.y = a_SrcCuboid.p2.y;
+	p2.z = a_SrcCuboid.p2.z;
+}
+
+
+
+
+
 void cCuboid::Sort(void)
 {
 	if (p1.x > p2.x)
@@ -72,6 +86,9 @@ int cCuboid::GetVolume(void) const
 
 bool cCuboid::DoesIntersect(const cCuboid & a_Other) const
 {
+	ASSERT(IsSorted());
+	ASSERT(a_Other.IsSorted());
+	
 	// In order for cuboids to intersect, each of their coord intervals need to intersect
 	return (
 		DoIntervalsIntersect(p1.x, p2.x, a_Other.p1.x, a_Other.p2.x) &&
@@ -86,6 +103,9 @@ bool cCuboid::DoesIntersect(const cCuboid & a_Other) const
 
 bool cCuboid::IsCompletelyInside(const cCuboid & a_Outer) const
 {
+	ASSERT(IsSorted());
+	ASSERT(a_Outer.IsSorted());
+	
 	return (
 		(p1.x >= a_Outer.p1.x) &&
 		(p2.x <= a_Outer.p2.x) &&
@@ -197,3 +217,37 @@ bool cCuboid::IsSorted(void) const
 
 
 
+
+void cCuboid::Engulf(const Vector3i & a_Point)
+{
+	if (a_Point.x < p1.x)
+	{
+		p1.x = a_Point.x;
+	}
+	else if (a_Point.x > p2.x)
+	{
+		p2.x = a_Point.x;
+	}
+
+	if (a_Point.y < p1.y)
+	{
+		p1.y = a_Point.y;
+	}
+	else if (a_Point.y > p2.y)
+	{
+		p2.y = a_Point.y;
+	}
+
+	if (a_Point.z < p1.z)
+	{
+		p1.z = a_Point.z;
+	}
+	else if (a_Point.z > p2.z)
+	{
+		p2.z = a_Point.z;
+	}
+}
+
+
+
+
diff --git a/src/Cuboid.h b/src/Cuboid.h
index 51ccf799b..3239c54fc 100644
--- a/src/Cuboid.h
+++ b/src/Cuboid.h
@@ -1,8 +1,7 @@
 
 #pragma once
 
-#include "Vector3i.h"
-#include "Vector3d.h"
+#include "Vector3.h"
 
 
 
@@ -22,6 +21,7 @@ public:
 	cCuboid(int a_X1, int a_Y1, int a_Z1, int a_X2, int a_Y2, int a_Z2) : p1(a_X1, a_Y1, a_Z1), p2(a_X2, a_Y2, a_Z2) {}
 
 	void Assign(int a_X1, int a_Y1, int a_Z1, int a_X2, int a_Y2, int a_Z2);
+	void Assign(const cCuboid & a_SrcCuboid);
 
 	void Sort(void);
 	
@@ -34,7 +34,8 @@ public:
 	Works on unsorted cuboids, too. */
 	int GetVolume(void) const;
 	
-	/** Returns true if the cuboids have at least one voxel in common. Both coords are considered inclusive. */
+	/** Returns true if the cuboids have at least one voxel in common. Both coords are considered inclusive.
+	Assumes both cuboids are sorted. */
 	bool DoesIntersect(const cCuboid & a_Other) const;
 
 	bool IsInside(const Vector3i & v)	const
@@ -64,7 +65,8 @@ public:
 		);
 	}
 	
-	/** Returns true if this cuboid is completely inside the specifie cuboid (in all 6 coords) */
+	/** Returns true if this cuboid is completely inside the specifie cuboid (in all 6 coords).
+	Assumes both cuboids are sorted. */
 	bool IsCompletelyInside(const cCuboid & a_Outer) const;
 	
 	/** Moves the cuboid by the specified offsets in each direction */
@@ -72,7 +74,7 @@ public:
 	
 	/** Expands the cuboid by the specified amount in each direction.
 	Works on unsorted cuboids as well.
-	Note that this function doesn't check for underflows. */
+	Note that this function doesn't check for underflows when using negative amounts. */
 	void Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 	
 	/** Clamps both X coords to the specified range. Works on unsorted cuboids, too. */
@@ -86,6 +88,9 @@ public:
 
 	/** Returns true if the coords are properly sorted (lesser in p1, greater in p2) */
 	bool IsSorted(void) const;
+	
+	/** If needed, expands the cuboid so that it contains the specified point. Assumes sorted. Doesn't contract. */
+	void Engulf(const Vector3i & a_Point);
 } ;
 // tolua_end
 
diff --git a/src/DeadlockDetect.h b/src/DeadlockDetect.h
index cb2309169..6aa98acbb 100644
--- a/src/DeadlockDetect.h
+++ b/src/DeadlockDetect.h
@@ -60,7 +60,7 @@ protected:
 	void CheckWorldAge(const AString & a_WorldName, Int64 a_Age);
 	
 	/// Called when a deadlock is detected. Aborts the server.
-	void DeadlockDetected(void);
+	NORETURN void DeadlockDetected(void);
 } ;
 
 
diff --git a/src/Defines.h b/src/Defines.h
index 6ab2274a4..38411c69d 100644
--- a/src/Defines.h
+++ b/src/Defines.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include "ChatColor.h"
+#include <limits>
 
 
 
@@ -276,6 +277,26 @@ inline eBlockFace RotateBlockFaceCW(eBlockFace a_BlockFace)
 
 
 
+/** Returns the textual representation of the BlockFace constant. */
+inline AString BlockFaceToString(eBlockFace a_BlockFace)
+{
+	switch (a_BlockFace)
+	{
+		case BLOCK_FACE_XM: return "BLOCK_FACE_XM";
+		case BLOCK_FACE_XP: return "BLOCK_FACE_XP";
+		case BLOCK_FACE_YM: return "BLOCK_FACE_YM";
+		case BLOCK_FACE_YP: return "BLOCK_FACE_YP";
+		case BLOCK_FACE_ZM: return "BLOCK_FACE_ZM";
+		case BLOCK_FACE_ZP: return "BLOCK_FACE_ZP";
+		case BLOCK_FACE_NONE: return "BLOCK_FACE_NONE";
+	}
+	return Printf("Unknown BLOCK_FACE: %d", a_BlockFace);
+}
+
+
+
+
+
 inline bool IsValidBlock(int a_BlockType)
 {
 	if (
@@ -469,7 +490,7 @@ inline void EulerToVector(double a_Pan, double a_Pitch, double & a_X, double & a
 
 inline void VectorToEuler(double a_X, double a_Y, double a_Z, double & a_Pan, double & a_Pitch)
 {
-	if (a_X != 0)
+	if (fabs(a_X) < std::numeric_limits<double>::epsilon())
 	{
 		a_Pan = atan2(a_Z, a_X) * 180 / PI - 90;
 	}
@@ -509,16 +530,22 @@ enum eMessageType
 	// http://forum.mc-server.org/showthread.php?tid=1212
 	// MessageType...
 
-	mtCustom, // Send raw data without any processing
-	mtFailure, // Something could not be done (i.e. command not executed due to insufficient privilege)
-	mtInformation, // Informational message (i.e. command usage)
-	mtSuccess, // Something executed successfully
-	mtWarning, // Something concerning (i.e. reload) is about to happen
-	mtFatal, // Something catastrophic occured (i.e. plugin crash)
-	mtDeath, // Denotes death of player
-	mtPrivateMessage, // Player to player messaging identifier
-	mtJoin, // A player has joined the server
-	mtLeave, // A player has left the server
+	mtCustom,          // Send raw data without any processing
+	mtFailure,         // Something could not be done (i.e. command not executed due to insufficient privilege)
+	mtInformation,     // Informational message (i.e. command usage)
+	mtSuccess,         // Something executed successfully
+	mtWarning,         // Something concerning (i.e. reload) is about to happen
+	mtFatal,           // Something catastrophic occured (i.e. plugin crash)
+	mtDeath,           // Denotes death of player
+	mtPrivateMessage,  // Player to player messaging identifier
+	mtJoin,            // A player has joined the server
+	mtLeave,           // A player has left the server
+	
+	// Common aliases:
+	mtFail  = mtFailure,
+	mtError = mtFailure,
+	mtInfo  = mtInformation,
+	mtPM    = mtPrivateMessage,
 };
 
 
diff --git a/src/Entities/Entity.cpp b/src/Entities/Entity.cpp
index 3eac0e2e8..97c8e2164 100644
--- a/src/Entities/Entity.cpp
+++ b/src/Entities/Entity.cpp
@@ -4,7 +4,7 @@
 #include "../World.h"
 #include "../Server.h"
 #include "../Root.h"
-#include "../Matrix4f.h"
+#include "../Matrix4.h"
 #include "../ClientHandle.h"
 #include "../Chunk.h"
 #include "../Simulator/FluidSimulator.h"
diff --git a/src/Entities/Entity.h b/src/Entities/Entity.h
index ee3f25cd8..df80093e5 100644
--- a/src/Entities/Entity.h
+++ b/src/Entities/Entity.h
@@ -2,9 +2,7 @@
 #pragma once
 
 #include "../Item.h"
-#include "../Vector3d.h"
-#include "../Vector3f.h"
-#include "../Vector3i.h"
+#include "../Vector3.h"
 
 
 
diff --git a/src/Entities/ExpOrb.cpp b/src/Entities/ExpOrb.cpp
index 3398f1c7b..3623c869a 100644
--- a/src/Entities/ExpOrb.cpp
+++ b/src/Entities/ExpOrb.cpp
@@ -5,20 +5,26 @@
 #include "../ClientHandle.h"
 
 
-cExpOrb::cExpOrb(double a_X, double a_Y, double a_Z, int a_Reward) :
-	cEntity(etExpOrb, a_X, a_Y, a_Z, 0.98, 0.98),
-	m_Reward(a_Reward)
+cExpOrb::cExpOrb(double a_X, double a_Y, double a_Z, int a_Reward)
+	:	cEntity(etExpOrb, a_X, a_Y, a_Z, 0.98, 0.98)
+	, m_Reward(a_Reward)
+	, m_Timer(0.f)
 {
+	SetMaxHealth(5);
+	SetHealth(5);
 }
 
 
 
 
 
-cExpOrb::cExpOrb(const Vector3d & a_Pos, int a_Reward) :
-	cEntity(etExpOrb, a_Pos.x, a_Pos.y, a_Pos.z, 0.98, 0.98),
-	m_Reward(a_Reward)
+cExpOrb::cExpOrb(const Vector3d & a_Pos, int a_Reward)
+	:	cEntity(etExpOrb, a_Pos.x, a_Pos.y, a_Pos.z, 0.98, 0.98)
+	, m_Reward(a_Reward)
+	, m_Timer(0.f)
 {
+	SetMaxHealth(5);
+	SetHealth(5);
 }
 
 
@@ -52,7 +58,7 @@ void cExpOrb::Tick(float a_Dt, cChunk & a_Chunk)
 			LOGD("Player %s picked up an ExpOrb. His reward is %i", a_ClosestPlayer->GetName().c_str(), m_Reward);
 			a_ClosestPlayer->DeltaExperience(m_Reward);
 			
-			m_World->BroadcastSoundEffect("random.orb", (int)GetPosX() * 8, (int)GetPosY() * 8, (int)GetPosZ() * 8, 0.5f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
+			m_World->BroadcastSoundEffect("random.orb", (int)(GetPosX() * 8), (int)(GetPosY() * 8), (int)(GetPosZ() * 8), 0.5f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
 			
 			Destroy();
 		}
@@ -64,4 +70,10 @@ void cExpOrb::Tick(float a_Dt, cChunk & a_Chunk)
 		BroadcastMovementUpdate();
 	}
 	HandlePhysics(a_Dt, a_Chunk);
+	
+	m_Timer += a_Dt;
+	if (m_Timer >= 1000 * 60 * 5)  // 5 minutes
+	{
+		Destroy(true);
+	}
 }
diff --git a/src/Entities/ExpOrb.h b/src/Entities/ExpOrb.h
index 47d86922c..c1150bd03 100644
--- a/src/Entities/ExpOrb.h
+++ b/src/Entities/ExpOrb.h
@@ -7,14 +7,17 @@
 
 
 
+// tolua_begin
 class cExpOrb :
 	public cEntity
 {
 	typedef cExpOrb super;
 	
 public:
+	// tolua_end
+
 	CLASS_PROTODEF(cExpOrb);
-	
+
 	cExpOrb(double a_X, double a_Y, double a_Z, int a_Reward);
 	cExpOrb(const Vector3d & a_Pos, int a_Reward);
 
@@ -22,9 +25,21 @@ public:
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void SpawnOn(cClientHandle & a_Client) override;
 
-	// cExpOrb functions
-	int GetReward(void) const { return m_Reward; }
+	/** Returns the number of ticks that this entity has existed */
+	int GetAge(void) const { return (int)(m_Timer / 50); }     // tolua_export
+
+	/** Set the number of ticks that this entity has existed */
+	void SetAge(int a_Age) { m_Timer = (float)(a_Age * 50); }  // tolua_export
+
+	/** Get the exp amount */
+	int GetReward(void) const { return m_Reward; }  // tolua_export
+
+	/** Set the exp amount */
+	void SetReward(int a_Reward) { m_Reward = a_Reward; }  // tolua_export
 
 protected:
 	int m_Reward;
-} ;
\ No newline at end of file
+	
+	/** The number of ticks that the entity has existed / timer between collect and destroy; in msec */
+	float m_Timer;
+} ;  // tolua_export
\ No newline at end of file
diff --git a/src/Entities/HangingEntity.cpp b/src/Entities/HangingEntity.cpp
new file mode 100644
index 000000000..41ac86268
--- /dev/null
+++ b/src/Entities/HangingEntity.cpp
@@ -0,0 +1,53 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "HangingEntity.h"
+#include "ClientHandle.h"
+#include "Player.h"
+
+
+
+
+
+cHangingEntity::cHangingEntity(eEntityType a_EntityType, eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z)
+	:	cEntity(a_EntityType, a_X, a_Y, a_Z, 0.8, 0.8)
+	, m_BlockFace(a_BlockFace)
+{
+	SetMaxHealth(1);
+	SetHealth(1);
+}
+
+
+
+
+
+void cHangingEntity::SpawnOn(cClientHandle & a_ClientHandle)
+{
+	int Dir = 0;
+			
+	// The client uses different values for item frame directions and block faces. Our constants are for the block faces, so we convert them here to item frame faces
+	switch (m_BlockFace)
+	{
+		case BLOCK_FACE_ZP: break; // Initialised to zero
+		case BLOCK_FACE_ZM: Dir = 2; break;
+		case BLOCK_FACE_XM: Dir = 1; break;
+		case BLOCK_FACE_XP: Dir = 3; break;
+		default: ASSERT(!"Unhandled block face when trying to spawn item frame!"); return;
+	}
+
+	if ((Dir == 0) || (Dir == 2)) // Probably a client bug, but two directions are flipped and contrary to the norm, so we do -180
+	{
+		SetYaw((Dir * 90) - 180);
+	}
+	else
+	{
+		SetYaw(Dir * 90);
+	}
+
+	a_ClientHandle.SendSpawnObject(*this, 71, Dir, (Byte)GetYaw(), (Byte)GetPitch());
+	a_ClientHandle.SendEntityMetadata(*this);
+}
+
+
+
+
diff --git a/src/Entities/HangingEntity.h b/src/Entities/HangingEntity.h
new file mode 100644
index 000000000..6498e4b5b
--- /dev/null
+++ b/src/Entities/HangingEntity.h
@@ -0,0 +1,49 @@
+
+#pragma once
+
+#include "Entity.h"
+
+
+
+
+
+// tolua_begin
+class cHangingEntity :
+	public cEntity
+{
+	// tolua_end
+	typedef cEntity super;
+
+public:
+
+	CLASS_PROTODEF(cHangingEntity);
+
+	cHangingEntity(eEntityType a_EntityType, eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z);
+	
+	/** Returns the orientation from the hanging entity */
+	eBlockFace GetDirection() const { return m_BlockFace; }  // tolua_export
+	
+	/** Set the orientation from the hanging entity */
+	void SetDirection(eBlockFace a_BlockFace) { m_BlockFace = a_BlockFace; }  // tolua_export
+	
+	/** Returns the X coord. */
+	int GetTileX() const { return POSX_TOINT; }  // tolua_export
+	
+	/** Returns the Y coord. */
+	int GetTileY() const { return POSY_TOINT; }  // tolua_export
+	
+	/** Returns the Z coord. */
+	int GetTileZ() const { return POSZ_TOINT; }  // tolua_export
+
+private:
+
+	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override {};
+
+	eBlockFace m_BlockFace;
+
+};  // tolua_export
+
+
+
+
diff --git a/src/Entities/ItemFrame.cpp b/src/Entities/ItemFrame.cpp
index 8cfa5e18d..9dd909880 100644
--- a/src/Entities/ItemFrame.cpp
+++ b/src/Entities/ItemFrame.cpp
@@ -10,43 +10,10 @@
 
 
 cItemFrame::cItemFrame(eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z)
-	: cEntity(etItemFrame, a_X, a_Y, a_Z, 0.8, 0.8),
-	m_BlockFace(a_BlockFace),
-	m_Item(E_BLOCK_AIR),
-	m_Rotation(0)
+	:	cHangingEntity(etItemFrame, a_BlockFace, a_X, a_Y, a_Z)
+	, m_Item(E_BLOCK_AIR)
+	, m_Rotation(0)
 {
-	SetMaxHealth(1);
-	SetHealth(1);
-}
-
-
-
-
-
-void cItemFrame::SpawnOn(cClientHandle & a_ClientHandle)
-{
-	int Dir = 0;
-			
-	// The client uses different values for item frame directions and block faces. Our constants are for the block faces, so we convert them here to item frame faces
-	switch (m_BlockFace)
-	{
-		case BLOCK_FACE_ZP: break; // Initialised to zero
-		case BLOCK_FACE_ZM: Dir = 2; break;
-		case BLOCK_FACE_XM: Dir = 1; break;
-		case BLOCK_FACE_XP: Dir = 3; break;
-		default: ASSERT(!"Unhandled block face when trying to spawn item frame!"); return;
-	}
-
-	if ((Dir == 0) || (Dir == 2)) // Probably a client bug, but two directions are flipped and contrary to the norm, so we do -180
-	{
-		SetYaw((Dir * 90) - 180);
-	}
-	else
-	{
-		SetYaw(Dir * 90);
-	}
-
-	a_ClientHandle.SendSpawnObject(*this, 71, Dir, (Byte)GetYaw(), (Byte)GetPitch());
 }
 
 
diff --git a/src/Entities/ItemFrame.h b/src/Entities/ItemFrame.h
index 43915e3f9..6577e7d94 100644
--- a/src/Entities/ItemFrame.h
+++ b/src/Entities/ItemFrame.h
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include "Entity.h"
+#include "HangingEntity.h"
 
 
 
@@ -9,10 +9,10 @@
 
 // tolua_begin
 class cItemFrame :
-	public cEntity
+	public cHangingEntity
 {
 	// tolua_end
-	typedef cEntity super;
+	typedef cHangingEntity super;
 
 public:
 
@@ -20,18 +20,24 @@ public:
 
 	cItemFrame(eBlockFace a_BlockFace, double a_X, double a_Y, double a_Z);
 
-	const cItem & GetItem(void) { return m_Item; }
-	Byte GetRotation(void) const { return m_Rotation; }
+	/** Returns the item in the frame */
+	const cItem & GetItem(void) { return m_Item; }                  // tolua_export
+
+	/** Set the item in the frame */
+	void SetItem(cItem & a_Item) { m_Item = a_Item; };              // tolua_export
+
+	/** Returns the rotation from the item in the frame */
+	Byte GetRotation(void) const { return m_Rotation; }             // tolua_export
+
+	/** Set the rotation from the item in the frame */
+	void SetRotation(Byte a_Rotation) { m_Rotation = a_Rotation; }  // tolua_export
 
 private:
 
-	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
-	virtual void Tick(float a_Dt, cChunk & a_Chunk) override {};
 	virtual void KilledBy(cEntity * a_Killer) override;
 	virtual void GetDrops(cItems & a_Items, cEntity * a_Killer) override;
 
-	eBlockFace m_BlockFace;
 	cItem m_Item;
 	Byte m_Rotation;
 
diff --git a/src/Entities/Pickup.cpp b/src/Entities/Pickup.cpp
index c5503c16a..7fc89b62b 100644
--- a/src/Entities/Pickup.cpp
+++ b/src/Entities/Pickup.cpp
@@ -82,7 +82,7 @@ cPickup::cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_It
 
 void cPickup::SpawnOn(cClientHandle & a_Client)
 {
-	a_Client.SendPickupSpawn(*this);	
+	a_Client.SendPickupSpawn(*this);
 }
 
 
diff --git a/src/Entities/Pickup.h b/src/Entities/Pickup.h
index c273567d1..74b917bce 100644
--- a/src/Entities/Pickup.h
+++ b/src/Entities/Pickup.h
@@ -26,31 +26,34 @@ public:
 	CLASS_PROTODEF(cPickup);
 
 	cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f);
-	
+
 	cItem &       GetItem(void)       {return m_Item; } // tolua_export
 	const cItem & GetItem(void) const {return m_Item; }
 
 	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
-	
+
 	bool CollectedBy(cPlayer * a_Dest);					// tolua_export
 
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
-	
-	/// Returns the number of ticks that this entity has existed
-	int GetAge(void) const { return (int)(m_Timer / 50); }  // tolua_export
-	
-	/// Returns true if the pickup has already been collected
+
+	/** Returns the number of ticks that this entity has existed */
+	int GetAge(void) const { return (int)(m_Timer / 50); }     // tolua_export
+
+	/** Set the number of ticks that this entity has existed */
+	void SetAge(int a_Age) { m_Timer = (float)(a_Age * 50); }  // tolua_export
+
+	/** Returns true if the pickup has already been collected */
 	bool IsCollected(void) const { return m_bCollected; }  // tolua_export
 
-	/// Returns true if created by player (i.e. vomiting), used for determining picking-up delay time
+	/** Returns true if created by player (i.e. vomiting), used for determining picking-up delay time */
 	bool IsPlayerCreated(void) const { return m_bIsPlayerCreated; } // tolua_export
-	
+
 private:
 	Vector3d   m_ResultingSpeed;	 //Can be used to modify the resulting speed for the current tick ;)
 
 	Vector3d   m_WaterSpeed;
 
-	/// The number of ticks that the entity has existed / timer between collect and destroy; in msec
+	/** The number of ticks that the entity has existed / timer between collect and destroy; in msec */
 	float m_Timer;
 
 	cItem m_Item;
diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp
index ccdd151f3..440d30595 100644
--- a/src/Entities/Player.cpp
+++ b/src/Entities/Player.cpp
@@ -14,6 +14,7 @@
 #include "../OSSupport/Timer.h"
 #include "../Chunk.h"
 #include "../Items/ItemHandler.h"
+#include "../Vector3.h"
 
 #include "inifile/iniFile.h"
 #include "json/json.h"
diff --git a/src/Entities/Player.h b/src/Entities/Player.h
index f9404dfaf..c25053c21 100644
--- a/src/Entities/Player.h
+++ b/src/Entities/Player.h
@@ -270,6 +270,9 @@ public:
 	/// Returns true if the player is currently flying.
 	bool IsFlying(void) const { return m_IsFlying; }
 
+	/** Returns if a player is sleeping in a bed */
+	bool IsInBed(void) const { return m_bIsInBed; }
+
 	/// returns true if the player has thrown out a floater.
 	bool IsFishing(void) const { return m_IsFishing; }
 
@@ -278,6 +281,9 @@ public:
 	int GetFloaterID(void) const { return m_FloaterID; }
 
 	// tolua_end
+
+	/** Sets a player's in-bed state; we can't be sure plugins will keep this value updated, so no exporting */
+	void SetIsInBed(bool a_Flag) { m_bIsInBed = a_Flag; }
 	
 	/// Starts eating the currently equipped item. Resets the eating timer and sends the proper animation packet
 	void StartEating(void);
@@ -371,8 +377,8 @@ protected:
 	GroupList m_ResolvedGroups;
 	GroupList m_Groups;
 
-	std::string m_PlayerName;
-	std::string m_LoadedWorldName;
+	AString m_PlayerName;
+	AString m_LoadedWorldName;
 
 	/// Xp Level stuff
 	enum 
@@ -456,7 +462,7 @@ protected:
 
 	int m_FloaterID;
 
-	cTeam* m_Team;
+	cTeam * m_Team;
 
 
 
@@ -479,6 +485,11 @@ protected:
 
 	/// Adds food exhaustion based on the difference between Pos and LastPos, sprinting status and swimming (in water block)
 	void ApplyFoodExhaustionFromMovement();
+
+	/** Flag representing whether the player is currently in a bed
+	Set by a right click on unoccupied bed, unset by a time fast forward or teleport */
+	bool m_bIsInBed;
+
 } ; // tolua_export
 
 
diff --git a/src/Entities/ProjectileEntity.cpp b/src/Entities/ProjectileEntity.cpp
index 12d2025ec..f4ab825f2 100644
--- a/src/Entities/ProjectileEntity.cpp
+++ b/src/Entities/ProjectileEntity.cpp
@@ -663,8 +663,6 @@ cThrownSnowballEntity::cThrownSnowballEntity(cEntity * a_Creator, double a_X, do
 
 void cThrownSnowballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
-	// TODO: Apply damage to certain mobs (blaze etc.) and anger all mobs
-	
 	Destroy();
 }
 
@@ -672,6 +670,30 @@ void cThrownSnowballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFac
 
 
 
+void cThrownSnowballEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
+{
+	int TotalDamage = 0;
+	if (a_EntityHit.IsMob())
+	{
+		cMonster::eType MobType = ((cMonster &) a_EntityHit).GetMobType();
+		if (MobType == cMonster::mtBlaze)
+		{
+			TotalDamage = 3;
+		}
+		else if (MobType == cMonster::mtEnderDragon)
+		{
+			TotalDamage = 1;
+		}
+	}
+	a_EntityHit.TakeDamage(dtRangedAttack, this, TotalDamage, 1);
+
+	Destroy(true);
+}
+
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cBottleOEnchantingEntity :
 
diff --git a/src/Entities/ProjectileEntity.h b/src/Entities/ProjectileEntity.h
index fac592d16..efb7ae783 100644
--- a/src/Entities/ProjectileEntity.h
+++ b/src/Entities/ProjectileEntity.h
@@ -259,6 +259,7 @@ protected:
 	
 	// cProjectileEntity overrides:
 	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
+	virtual void OnHitEntity    (cEntity & a_EntityHit, const Vector3d & a_HitPos) override;
 
 	// tolua_begin
 	
diff --git a/src/FurnaceRecipe.cpp b/src/FurnaceRecipe.cpp
index 2e2276981..1810d7c49 100644
--- a/src/FurnaceRecipe.cpp
+++ b/src/FurnaceRecipe.cpp
@@ -175,7 +175,7 @@ void cFurnaceRecipe::ReloadRecipes(void)
 	{
 		LOGERROR("ERROR: FurnaceRecipe, syntax error" );
 	}
-	LOG("Loaded %u furnace recipes and %u fuels", m_pState->Recipes.size(), m_pState->Fuel.size());
+	LOG("Loaded " SIZE_T_FMT " furnace recipes and " SIZE_T_FMT " fuels", m_pState->Recipes.size(), m_pState->Fuel.size());
 }
 
 
diff --git a/src/Generating/ChunkGenerator.cpp b/src/Generating/ChunkGenerator.cpp
index ef38f1399..73f0223e8 100644
--- a/src/Generating/ChunkGenerator.cpp
+++ b/src/Generating/ChunkGenerator.cpp
@@ -116,7 +116,7 @@ void cChunkGenerator::QueueGenerateChunk(int a_ChunkX, int a_ChunkY, int a_Chunk
 		// Add to queue, issue a warning if too many:
 		if (m_Queue.size() >= QUEUE_WARNING_LIMIT)
 		{
-			LOGWARN("WARNING: Adding chunk [%i, %i] to generation queue; Queue is too big! (%i)", a_ChunkX, a_ChunkZ, m_Queue.size());
+			LOGWARN("WARNING: Adding chunk [%i, %i] to generation queue; Queue is too big! (" SIZE_T_FMT ")", a_ChunkX, a_ChunkZ, m_Queue.size());
 		}
 		m_Queue.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));
 	}
@@ -180,7 +180,7 @@ BLOCKTYPE cChunkGenerator::GetIniBlock(cIniFile & a_IniFile, const AString & a_S
 	BLOCKTYPE Block = BlockStringToType(BlockType);
 	if (Block < 0)
 	{
-		LOGWARN("[&s].%s Could not parse block value \"%s\". Using default: \"%s\".", a_SectionName.c_str(), a_ValueName.c_str(), BlockType.c_str(),a_Default.c_str());
+		LOGWARN("[%s].%s Could not parse block value \"%s\". Using default: \"%s\".", a_SectionName.c_str(), a_ValueName.c_str(), BlockType.c_str(),a_Default.c_str());
 		return BlockStringToType(a_Default);
 	}
 	return Block;
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index e96e9a645..6c00b5905 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/src/Generating/ComposableGenerator.cpp
@@ -22,6 +22,7 @@
 #include "EndGen.h"
 #include "MineShafts.h"
 #include "Noise3DGenerator.h"
+#include "POCPieceGenerator.h"
 #include "Ravines.h"
 
 
@@ -364,6 +365,10 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		{
 			m_FinishGens.push_back(new cStructGenOreNests(Seed));
 		}
+		else if (NoCaseCompare(*itr, "POCPieces") == 0)
+		{
+			m_FinishGens.push_back(new cPOCPieceGenerator(Seed));
+		}
 		else if (NoCaseCompare(*itr, "PreSimulator") == 0)
 		{
 			m_FinishGens.push_back(new cFinishGenPreSimulator);
diff --git a/src/Generating/POCPieceGenerator.cpp b/src/Generating/POCPieceGenerator.cpp
new file mode 100644
index 000000000..9ed4b565e
--- /dev/null
+++ b/src/Generating/POCPieceGenerator.cpp
@@ -0,0 +1,270 @@
+
+// POCPieceGenerator.cpp
+
+// Implements the cPOCPieceGenerator class representing a Proof-Of_Concept structure generator using the cPieceGenerator technique
+// The generator generates a maze of rooms at {0, 50, 0}
+
+#include "Globals.h"
+#include "POCPieceGenerator.h"
+#include "ChunkDesc.h"
+
+
+
+
+
+/** POC pieces are simple boxes that have connectors in the middle of their walls.
+Each wall has one connector, there are 3 connector types that get assigned semi-randomly.
+The piece also knows how to imprint itself in a cChunkDesc, each piece has a different color glass
+and each connector is uses a different color wool frame. */
+class cPOCPiece :
+	public cPiece
+{
+public:
+	cPOCPiece(int a_SizeXZ, int a_Height) :
+		m_SizeXZ(a_SizeXZ),
+		m_Height(a_Height)
+	{
+		m_Connectors.push_back(cConnector(m_SizeXZ / 2, a_Height / 2, 0,            0,            BLOCK_FACE_ZM));
+		m_Connectors.push_back(cConnector(m_SizeXZ / 2, a_Height / 2, m_SizeXZ - 1, 1,            BLOCK_FACE_ZP));
+		m_Connectors.push_back(cConnector(0,            a_Height / 2, m_SizeXZ / 2, 2,            BLOCK_FACE_XM));
+		m_Connectors.push_back(cConnector(m_SizeXZ - 1, a_Height - 1, m_SizeXZ / 2, m_SizeXZ % 3, BLOCK_FACE_XP));
+	}
+	
+	
+	/** Imprints the piece in the specified chunk. Assumes they intersect. */
+	void ImprintInChunk(cChunkDesc & a_ChunkDesc, const Vector3i & a_Pos, int a_NumCCWRotations)
+	{
+		int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+		int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+		Vector3i Min = a_Pos;
+		Min.Move(-BlockX, 0, -BlockZ);
+		Vector3i Max = Min;
+		Max.Move(m_SizeXZ - 1, m_Height - 1, m_SizeXZ - 1);
+		ASSERT(Min.x < cChunkDef::Width);
+		ASSERT(Min.z < cChunkDef::Width);
+		ASSERT(Max.x >= 0);
+		ASSERT(Max.z >= 0);
+		if (Min.x >= 0)
+		{
+			// Draw the XM wall:
+			a_ChunkDesc.FillRelCuboid(Min.x, Min.x, Min.y, Max.y, Min.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		if (Min.z >= 0)
+		{
+			// Draw the ZM wall:
+			a_ChunkDesc.FillRelCuboid(Min.x, Max.x, Min.y, Max.y, Min.z, Min.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		if (Max.x < cChunkDef::Width)
+		{
+			// Draw the XP wall:
+			a_ChunkDesc.FillRelCuboid(Max.x, Max.x, Min.y, Max.y, Min.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		if (Max.z < cChunkDef::Width)
+		{
+			// Draw the ZP wall:
+			a_ChunkDesc.FillRelCuboid(Min.x, Max.x, Min.y, Max.y, Max.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
+		}
+		
+		// Draw all the connectors:
+		for (cConnectors::const_iterator itr = m_Connectors.begin(), end = m_Connectors.end(); itr != end; ++itr)
+		{
+			cConnector Conn = cPiece::RotateMoveConnector(*itr, a_NumCCWRotations, a_Pos.x, a_Pos.y, a_Pos.z);
+			Conn.m_Pos.Move(-BlockX, 0, -BlockZ);
+			if (
+				(Conn.m_Pos.x >= 0) && (Conn.m_Pos.x < cChunkDef::Width) &&
+				(Conn.m_Pos.z >= 0) && (Conn.m_Pos.z < cChunkDef::Width)
+			)
+			{
+				a_ChunkDesc.SetBlockTypeMeta(Conn.m_Pos.x, Conn.m_Pos.y, Conn.m_Pos.z, E_BLOCK_WOOL, itr->m_Type % 16);
+			}
+			
+			/*
+			// TODO: Frame the connectors
+			switch (itr->m_Direction)
+			{
+				case BLOCK_FACE_XM:
+				case BLOCK_FACE_XP:
+				{
+					// TODO
+					break;
+				}
+				
+				case BLOCK_FACE_ZM:
+				case BLOCK_FACE_ZP:
+				{
+					// TODO
+					break;
+				}
+			}
+			*/
+		}  // for itr - m_Connectors[]
+	}
+	
+protected:
+	int m_SizeXZ;
+	int m_Height;
+	cConnectors m_Connectors;
+	
+	// cPiece overrides:
+	virtual cConnectors GetConnectors(void) const override
+	{
+		return m_Connectors;
+	}
+	
+	virtual Vector3i GetSize(void) const override
+	{
+		return Vector3i(m_SizeXZ, m_Height, m_SizeXZ);
+	}
+	
+	virtual cCuboid GetHitBox(void) const override
+	{
+		return cCuboid(0, 0, 0, m_SizeXZ - 1, m_Height - 1, m_SizeXZ - 1);
+	}
+	
+	virtual bool CanRotateCCW(int a_NumRotations) const override
+	{
+		return true;
+	}
+};
+
+
+
+
+
+/*
+static void DebugPieces(const cPlacedPieces & a_Pieces)
+{
+	size_t idx = 0;
+	for (cPlacedPieces::const_iterator itr = a_Pieces.begin(), end = a_Pieces.end(); itr != end; ++itr, ++idx)
+	{
+		const cCuboid & HitBox = (*itr)->GetHitBox();
+		printf("  %u: %d rotations, {%d - %d, %d - %d}\n",
+			idx, (*itr)->GetNumCCWRotations(),
+			HitBox.p1.x, HitBox.p2.x, HitBox.p1.z, HitBox.p2.z
+		);
+	}  // for itr - a_Pieces[]
+}
+//*/
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPOCPieceGenerator:
+
+cPOCPieceGenerator::cPOCPieceGenerator(int a_Seed) :
+	m_Seed(a_Seed)
+{
+	// Prepare a vector of available pieces:
+	m_AvailPieces.push_back(new cPOCPiece(5, 3));
+	m_AvailPieces.push_back(new cPOCPiece(7, 5));
+	m_AvailPieces.push_back(new cPOCPiece(9, 5));
+	m_AvailPieces.push_back(new cPOCPiece(5, 7));
+	
+	// Generate the structure:
+	cBFSPieceGenerator Gen(*this, a_Seed);
+	Gen.PlacePieces(0, 50, 0, 6, m_Pieces);
+	
+	// DebugPieces(m_Pieces);
+	
+	// Get the smallest cuboid encompassing the entire generated structure:
+	cCuboid Bounds(0, 50, 0, 0, 50, 0);
+	for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+	{
+		Vector3i MinCoords = (*itr)->GetCoords();
+		Bounds.Engulf(MinCoords);
+		Bounds.Engulf(MinCoords + (*itr)->GetPiece().GetSize());
+	}  // for itr - m_Pieces[]
+	m_Bounds = Bounds;
+}
+
+
+
+
+
+cPOCPieceGenerator::~cPOCPieceGenerator()
+{
+	cPieceGenerator::FreePieces(m_Pieces);
+}
+
+
+
+
+
+void cPOCPieceGenerator::GenFinish(cChunkDesc & a_ChunkDesc)
+{
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	if (
+		(BlockX + 16 < m_Bounds.p1.x) || (BlockX > m_Bounds.p2.x) ||  // X coords out of bounds of the generated structure
+		(BlockZ + 16 < m_Bounds.p1.z) || (BlockZ > m_Bounds.p2.z)     // Z coords out of bounds of the generated structure
+	)
+	{
+		return;
+	}
+	
+	// Imprint each piece in the chunk:
+	for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+	{
+		const Vector3i & Pos = (*itr)->GetCoords();
+		Vector3i Size = (*itr)->GetPiece().GetSize();
+		if (((*itr)->GetNumCCWRotations() % 2) == 1)
+		{
+			std::swap(Size.x, Size.z);
+		}
+		if (
+			(Pos.x >= BlockX + 16) || (Pos.x + Size.x - 1 < BlockX) ||
+			(Pos.z >= BlockZ + 16) || (Pos.z + Size.z - 1 < BlockZ)
+		)
+		{
+			// This piece doesn't intersect the chunk
+			continue;
+		}
+			
+		((cPOCPiece &)(*itr)->GetPiece()).ImprintInChunk(a_ChunkDesc, Pos, (*itr)->GetNumCCWRotations());
+	}  // for itr - m_Pieces[]
+	a_ChunkDesc.UpdateHeightmap();
+}
+
+
+
+
+
+cPieces cPOCPieceGenerator::GetPiecesWithConnector(int a_ConnectorType)
+{
+	// Each piece has each connector
+	return m_AvailPieces;
+}
+
+
+
+
+
+cPieces cPOCPieceGenerator::GetStartingPieces(void)
+{
+	// Any piece can be a starting piece
+	return m_AvailPieces;
+}
+
+
+
+
+
+void cPOCPieceGenerator::PiecePlaced(const cPiece & a_Piece)
+{
+	UNUSED(a_Piece);
+}
+
+
+
+
+
+void cPOCPieceGenerator::Reset(void)
+{
+	// Nothing needed
+}
+
+
+
+
diff --git a/src/Generating/POCPieceGenerator.h b/src/Generating/POCPieceGenerator.h
new file mode 100644
index 000000000..de3114ce0
--- /dev/null
+++ b/src/Generating/POCPieceGenerator.h
@@ -0,0 +1,54 @@
+
+// POCPieceGenerator.h
+
+// Declares the cPOCPieceGenerator class representing a Proof-Of_Concept structure generator using the cPieceGenerator technique
+// The generator generates a maze of rooms at {0, 100, 0}
+
+
+
+
+
+#pragma once
+
+#include "PieceGenerator.h"
+#include "ComposableGenerator.h"
+
+
+
+
+
+class cPOCPieceGenerator :
+	public cFinishGen,
+	protected cPiecePool
+{
+public:
+	cPOCPieceGenerator(int a_Seed);
+	~cPOCPieceGenerator();
+	
+protected:
+	int m_Seed;
+	
+	/** The pieces from which the generated structure is built. */
+	cPieces m_AvailPieces;
+	
+	/** The placed pieces of the generated structure. */
+	cPlacedPieces m_Pieces;
+	
+	/** Bounds of the complete structure, to save on processing outside chunks. */
+	cCuboid m_Bounds;
+
+
+	// cFinishGen overrides:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+	
+	// cPiecePool overrides:
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;
+	virtual cPieces GetStartingPieces(void) override;
+	virtual void PiecePlaced(const cPiece & a_Piece) override;
+	virtual void Reset(void) override;
+} ;
+
+
+
+
+
diff --git a/src/Generating/PieceGenerator.cpp b/src/Generating/PieceGenerator.cpp
new file mode 100644
index 000000000..8999a5ff7
--- /dev/null
+++ b/src/Generating/PieceGenerator.cpp
@@ -0,0 +1,625 @@
+
+// PieceGenerator.cpp
+
+// Implements the cBFSPieceGenerator class and cDFSPieceGenerator class 
+// representing base classes for generating structures composed of individual "pieces"
+
+#include "Globals.h"
+#include "PieceGenerator.h"
+
+
+
+
+
+#ifdef SELF_TEST
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Self-test:
+
+static class cPieceGeneratorSelfTest :
+	public cPiecePool
+{
+public:
+	cPieceGeneratorSelfTest(void)
+	{
+		// Prepare the internal state:
+		InitializePieces();
+		
+		// Generate:
+		cBFSPieceGenerator Gen(*this, 0);
+		cPlacedPieces OutPieces;
+		Gen.PlacePieces(500, 50, 500, 3, OutPieces);
+		
+		// Print out the pieces:
+		printf("OutPieces.size() = " SIZE_T_FMT "\n", OutPieces.size());
+		size_t idx = 0;
+		for (cPlacedPieces::const_iterator itr = OutPieces.begin(), end = OutPieces.end(); itr != end; ++itr, ++idx)
+		{
+			const Vector3i & Coords = (*itr)->GetCoords();
+			cCuboid Hitbox = (*itr)->GetHitBox();
+			Hitbox.Sort();
+			printf(SIZE_T_FMT ": {%d, %d, %d}, rot %d, hitbox {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n", idx,
+				Coords.x, Coords.y, Coords.z,
+				(*itr)->GetNumCCWRotations(),
+				Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
+				Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
+				Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
+			);
+		}  // itr - OutPieces[]
+		printf("Done.\n");
+		
+		// Free the placed pieces properly:
+		Gen.FreePieces(OutPieces);
+	}
+	
+	~cPieceGeneratorSelfTest()
+	{
+		// Dealloc all the pieces:
+		for (cPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
+		{
+			delete *itr;
+		}
+		m_Pieces.clear();
+	}
+	
+protected:
+	class cTestPiece :
+		public cPiece
+	{
+		int m_Size;
+	public:
+		cTestPiece(int a_Size) :
+			m_Size(a_Size)
+		{
+		}
+		
+		virtual cConnectors GetConnectors(void) const override
+		{
+			// Each piece has 4 connectors, one of each type, plus one extra, at the center of its walls:
+			cConnectors res;
+			res.push_back(cConnector(m_Size / 2, 1, 0,          0, BLOCK_FACE_ZM));
+			res.push_back(cConnector(m_Size / 2, 1, m_Size - 1, 1, BLOCK_FACE_ZP));
+			res.push_back(cConnector(0,          1, m_Size / 2, 2, BLOCK_FACE_XM));
+			res.push_back(cConnector(m_Size - 1, 1, m_Size / 2, m_Size % 3, BLOCK_FACE_XP));
+			return res;
+		}
+		
+		virtual Vector3i GetSize(void) const override
+		{
+			return Vector3i(m_Size, 5, m_Size);
+		}
+		
+		virtual cCuboid GetHitBox(void) const override
+		{
+			return cCuboid(0, 0, 0, m_Size - 1, 4, m_Size - 1);
+		}
+		
+		virtual bool CanRotateCCW(int a_NumCCWRotations) const override
+		{
+			return true;
+		}
+	};
+	
+	cPieces m_Pieces;
+	
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override
+	{
+		// Each piece contains each connector
+		return m_Pieces;
+	}
+	
+	
+	virtual cPieces GetStartingPieces(void) override
+	{
+		return m_Pieces;
+	}
+	
+	
+	virtual void PiecePlaced(const cPiece & a_Piece) override
+	{
+		UNUSED(a_Piece);
+	}
+	
+	
+	virtual void Reset(void) override
+	{
+	}
+	
+	
+	void InitializePieces(void)
+	{
+		m_Pieces.push_back(new cTestPiece(5));
+		m_Pieces.push_back(new cTestPiece(7));
+		m_Pieces.push_back(new cTestPiece(9));
+	}
+} g_Test;
+
+#endif  // SELF_TEST
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPiece:
+
+	
+Vector3i cPiece::RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const
+{
+	Vector3i Size = GetSize();
+	switch (a_NumCCWRotations)
+	{
+		case 0:
+		{
+			// No rotation needed
+			return a_Pos;
+		}
+		case 1:
+		{
+			// 1 CCW rotation:
+			return Vector3i(a_Pos.z, a_Pos.y, Size.x - a_Pos.x - 1);
+		}
+		case 2:
+		{
+			// 2 rotations ( = axis flip):
+			return Vector3i(Size.x - a_Pos.x - 1, a_Pos.y, Size.z - a_Pos.z - 1);
+		}
+		case 3:
+		{
+			// 1 CW rotation:
+			return Vector3i(Size.z - a_Pos.z - 1, a_Pos.y, a_Pos.x);
+		}
+	}
+	ASSERT(!"Unhandled rotation");
+	return a_Pos;
+}
+
+
+
+
+
+cPiece::cConnector cPiece::RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const
+{
+	cPiece::cConnector res(a_Connector);
+	
+	// Rotate the res connector:
+	switch (a_NumCCWRotations)
+	{
+		case 0:
+		{
+			// No rotation needed
+			break;
+		}
+		case 1:
+		{
+			// 1 CCW rotation:
+			res.m_Direction = RotateBlockFaceCCW(res.m_Direction);
+			break;
+		}
+		case 2:
+		{
+			// 2 rotations ( = axis flip):
+			res.m_Direction = MirrorBlockFaceY(res.m_Direction);
+			break;
+		}
+		case 3:
+		{
+			// 1 CW rotation:
+			res.m_Direction = RotateBlockFaceCW(res.m_Direction);
+			break;
+		}
+	}
+	res.m_Pos = RotatePos(a_Connector.m_Pos, a_NumCCWRotations);
+	
+	// Move the res connector:
+	res.m_Pos.x += a_MoveX;
+	res.m_Pos.y += a_MoveY;
+	res.m_Pos.z += a_MoveZ;
+	
+	return res;
+}
+
+
+
+
+
+cCuboid cPiece::RotateHitBoxToConnector(
+	const cPiece::cConnector & a_MyConnector,
+	const Vector3i & a_ToConnectorPos,
+	int a_NumCCWRotations
+) const
+{
+	ASSERT(a_NumCCWRotations == (a_NumCCWRotations % 4));
+	Vector3i ConnPos = RotatePos(a_MyConnector.m_Pos, a_NumCCWRotations);
+	ConnPos = a_ToConnectorPos - ConnPos;
+	return RotateMoveHitBox(a_NumCCWRotations, ConnPos.x, ConnPos.y, ConnPos.z);
+}
+
+
+
+
+
+cCuboid cPiece::RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const
+{
+	ASSERT(a_NumCCWRotations == (a_NumCCWRotations % 4));
+	cCuboid res = GetHitBox();
+	res.p1 = RotatePos(res.p1, a_NumCCWRotations);
+	res.p2 = RotatePos(res.p2, a_NumCCWRotations);
+	res.p1.Move(a_MoveX, a_MoveY, a_MoveZ);
+	res.p2.Move(a_MoveX, a_MoveY, a_MoveZ);
+	return res;
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPiece::cConnector:
+
+cPiece::cConnector::cConnector(int a_X, int a_Y, int a_Z, int a_Type, eBlockFace a_Direction) :
+	m_Pos(a_X, a_Y, a_Z),
+	m_Type(a_Type),
+	m_Direction(a_Direction)
+{
+}
+
+
+
+
+
+cPiece::cConnector::cConnector(const Vector3i & a_Pos, int a_Type, eBlockFace a_Direction) :
+	m_Pos(a_Pos),
+	m_Type(a_Type),
+	m_Direction(a_Direction)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPlacedPiece:
+
+cPlacedPiece::cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations) :
+	m_Parent(a_Parent),
+	m_Piece(&a_Piece),
+	m_Coords(a_Coords),
+	m_NumCCWRotations(a_NumCCWRotations)
+{
+	m_Depth = (m_Parent == NULL) ? 0 : (m_Parent->GetDepth() + 1);
+	m_HitBox = a_Piece.RotateMoveHitBox(a_NumCCWRotations, a_Coords.x, a_Coords.y, a_Coords.z);
+	m_HitBox.Sort();
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPieceGenerator:
+
+cPieceGenerator::cPieceGenerator(cPiecePool & a_PiecePool, int a_Seed) :
+	m_PiecePool(a_PiecePool),
+	m_Noise(a_Seed),
+	m_Seed(a_Seed)
+{
+}
+
+
+
+
+
+void cPieceGenerator::FreePieces(cPlacedPieces & a_PlacedPieces)
+{
+	for (cPlacedPieces::iterator itr = a_PlacedPieces.begin(), end = a_PlacedPieces.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - a_PlacedPieces[]
+	a_PlacedPieces.clear();
+}
+
+
+
+
+
+cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, int a_BlockZ, cFreeConnectors & a_OutConnectors)
+{
+	m_PiecePool.Reset();
+	int rnd = m_Noise.IntNoise3DInt(a_BlockX, a_BlockY, a_BlockZ) / 7;
+	
+	// Choose a random one of the starting pieces:
+	cPieces StartingPieces = m_PiecePool.GetStartingPieces();
+	cPiece * StartingPiece = StartingPieces[rnd % StartingPieces.size()];
+	rnd = rnd >> 16;
+	
+	// Choose a random supported rotation:
+	int Rotations[4] = {0};
+	int NumRotations = 1;
+	for (size_t i = 1; i < ARRAYCOUNT(Rotations); i++)
+	{
+		if (StartingPiece->CanRotateCCW(i))
+		{
+			Rotations[NumRotations] = i;
+			NumRotations += 1;
+		}
+	}
+	int Rotation = Rotations[rnd % NumRotations];
+	
+	cPlacedPiece * res = new cPlacedPiece(NULL, *StartingPiece, Vector3i(a_BlockX, a_BlockY, a_BlockZ), Rotation);
+
+	// Place the piece's connectors into a_OutConnectors:
+	const cPiece::cConnectors & Conn = StartingPiece->GetConnectors();
+	for (cPiece::cConnectors::const_iterator itr = Conn.begin(), end = Conn.end(); itr != end; ++itr)
+	{
+		a_OutConnectors.push_back(
+			cFreeConnector(res, StartingPiece->RotateMoveConnector(*itr, Rotation, a_BlockX, a_BlockY, a_BlockZ))
+		);
+	}
+
+	return res;
+}
+
+
+
+
+
+bool cPieceGenerator::TryPlacePieceAtConnector(
+	const cPlacedPiece & a_ParentPiece,
+	const cPiece::cConnector & a_Connector,
+	cPlacedPieces & a_OutPieces,
+	cPieceGenerator::cFreeConnectors & a_OutConnectors
+)
+{
+	// Translation of direction - direction -> number of CCW rotations needed:
+	// You need DirectionRotationTable[rot1][rot2] CCW turns to connect rot1 to rot2 (they are opposite)
+	static const int DirectionRotationTable[6][6] =
+	{
+		/*         YM, YP, ZM, ZP, XM, XP */
+		/* YM */ { 0,  0,  0,  0,  0,  0},
+		/* YP */ { 0,  0,  0,  0,  0,  0},
+		/* ZM */ { 0,  0,  2,  0,  1,  3},
+		/* ZP */ { 0,  0,  0,  2,  3,  1},
+		/* XM */ { 0,  0,  3,  1,  2,  0},
+		/* XP */ { 0,  0,  1,  3,  0,  2},
+	};
+	
+	// Get a list of available connections:
+	const int * RotTable = DirectionRotationTable[a_Connector.m_Direction];
+	cConnections Connections;
+	cPieces AvailablePieces = m_PiecePool.GetPiecesWithConnector(a_Connector.m_Type);
+	Connections.reserve(AvailablePieces.size());
+	Vector3i ConnPos = a_Connector.m_Pos;  // The position at which the new connector should be placed - 1 block away from the connector
+	AddFaceDirection(ConnPos.x, ConnPos.y, ConnPos.z, a_Connector.m_Direction);
+	
+	/*
+	// DEBUG:
+	printf("Placing piece at connector pos {%d, %d, %d}, direction %s\n", ConnPos.x, ConnPos.y, ConnPos.z, BlockFaceToString(a_Connector.m_Direction).c_str());
+	//*/
+	
+	for (cPieces::iterator itrP = AvailablePieces.begin(), endP = AvailablePieces.end(); itrP != endP; ++itrP)
+	{
+		cPiece::cConnectors Connectors = (*itrP)->GetConnectors();
+		for (cPiece::cConnectors::iterator itrC = Connectors.begin(), endC = Connectors.end(); itrC != endC; ++itrC)
+		{
+			if (itrC->m_Type != a_Connector.m_Type)
+			{
+				continue;
+			}
+			// This is a same-type connector, find out how to rotate to it:
+			int NumCCWRotations = RotTable[itrC->m_Direction];
+			if (!(*itrP)->CanRotateCCW(NumCCWRotations))
+			{
+				// Doesn't support this rotation
+				continue;
+			}
+			if (!CheckConnection(a_Connector, ConnPos, **itrP, *itrC, NumCCWRotations, a_OutPieces))
+			{
+				// Doesn't fit in this rotation
+				continue;
+			}
+			Connections.push_back(cConnection(**itrP, *itrC, NumCCWRotations));
+		}  // for itrC - Connectors[]
+	}  // for itrP - AvailablePieces[]
+	if (Connections.empty())
+	{
+		// No available connections, bail out
+		return false;
+	}
+	
+	// Choose a random connection from the list:
+	int rnd = m_Noise.IntNoise3DInt(a_Connector.m_Pos.x, a_Connector.m_Pos.y, a_Connector.m_Pos.z) / 7;
+	cConnection & Conn = Connections[rnd % Connections.size()];
+	
+	// Place the piece:
+	/*
+	// DEBUG
+	printf("Chosen connector at {%d, %d, %d}, direction %s, needs %d rotations\n",
+		Conn.m_Connector.m_Pos.x, Conn.m_Connector.m_Pos.y, Conn.m_Connector.m_Pos.z,
+		BlockFaceToString(Conn.m_Connector.m_Direction).c_str(),
+		Conn.m_NumCCWRotations
+	);
+	//*/
+	
+	Vector3i NewPos = Conn.m_Piece->RotatePos(Conn.m_Connector.m_Pos, Conn.m_NumCCWRotations);
+	ConnPos -= NewPos;
+	cPlacedPiece * PlacedPiece = new cPlacedPiece(&a_ParentPiece, *(Conn.m_Piece), ConnPos, Conn.m_NumCCWRotations);
+	a_OutPieces.push_back(PlacedPiece);
+	
+	// Add the new piece's connectors to the list of free connectors:
+	cPiece::cConnectors Connectors = Conn.m_Piece->GetConnectors();
+	
+	/*
+	// DEBUG:
+	printf("Adding %u connectors to the pool\n", Connectors.size() - 1);
+	//*/
+	
+	for (cPiece::cConnectors::const_iterator itr = Connectors.begin(), end = Connectors.end(); itr != end; ++itr)
+	{
+		if (itr->m_Pos.Equals(Conn.m_Connector.m_Pos))
+		{
+			// This is the connector through which we have been connected to the parent, don't add
+			continue;
+		}
+		a_OutConnectors.push_back(cFreeConnector(PlacedPiece, Conn.m_Piece->RotateMoveConnector(*itr, Conn.m_NumCCWRotations, ConnPos.x, ConnPos.y, ConnPos.z)));
+	}
+	
+	return true;
+}
+
+
+
+
+
+bool cPieceGenerator::CheckConnection(
+	const cPiece::cConnector & a_ExistingConnector,
+	const Vector3i & a_ToPos,
+	const cPiece & a_Piece,
+	const cPiece::cConnector & a_NewConnector,
+	int a_NumCCWRotations,
+	const cPlacedPieces & a_OutPieces
+)
+{
+	// For each placed piece, test the hitbox against the new piece:
+	cCuboid RotatedHitBox = a_Piece.RotateHitBoxToConnector(a_NewConnector, a_ToPos, a_NumCCWRotations);
+	RotatedHitBox.Sort();
+	for (cPlacedPieces::const_iterator itr = a_OutPieces.begin(), end = a_OutPieces.end(); itr != end; ++itr)
+	{
+		if ((*itr)->GetHitBox().DoesIntersect(RotatedHitBox))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+
+
+
+//*
+// DEBUG:
+void cPieceGenerator::DebugConnectorPool(const cPieceGenerator::cFreeConnectors & a_ConnectorPool, size_t a_NumProcessed)
+{
+	printf("  Connector pool: " SIZE_T_FMT " items\n", a_ConnectorPool.size() - a_NumProcessed);
+	size_t idx = 0;
+	for (cPieceGenerator::cFreeConnectors::const_iterator itr = a_ConnectorPool.begin() + a_NumProcessed, end = a_ConnectorPool.end(); itr != end; ++itr, ++idx)
+	{
+		printf("    " SIZE_T_FMT ": {%d, %d, %d}, type %d, direction %s, depth %d\n",
+			idx,
+			itr->m_Connector.m_Pos.x, itr->m_Connector.m_Pos.y, itr->m_Connector.m_Pos.z,
+			itr->m_Connector.m_Type,
+			BlockFaceToString(itr->m_Connector.m_Direction).c_str(),
+			itr->m_Piece->GetDepth()
+		);
+	}  // for itr - a_ConnectorPool[]
+}
+//*/
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPieceGenerator::cConnection:
+
+cPieceGenerator::cConnection::cConnection(cPiece & a_Piece, cPiece::cConnector & a_Connector, int a_NumCCWRotations) :
+	m_Piece(&a_Piece),
+	m_Connector(a_Connector),
+	m_NumCCWRotations(a_NumCCWRotations)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cPieceGenerator::cFreeConnector:
+
+cPieceGenerator::cFreeConnector::cFreeConnector(cPlacedPiece * a_Piece, const cPiece::cConnector & a_Connector) :
+	m_Piece(a_Piece),
+	m_Connector(a_Connector)
+{
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cBFSPieceGenerator:
+
+cBFSPieceGenerator::cBFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed) :
+	super(a_PiecePool, a_Seed)
+{
+}
+
+
+
+
+
+void cBFSPieceGenerator::PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MaxDepth, cPlacedPieces & a_OutPieces)
+{
+	a_OutPieces.clear();
+	cFreeConnectors ConnectorPool;
+	
+	// Place the starting piece:
+	a_OutPieces.push_back(PlaceStartingPiece(a_BlockX, a_BlockY, a_BlockZ, ConnectorPool));
+	
+	/*
+	// DEBUG:
+	printf("Placed the starting piece at {%d, %d, %d}\n", a_BlockX, a_BlockY, a_BlockZ);
+	cCuboid Hitbox = a_OutPieces[0]->GetHitBox();
+	Hitbox.Sort();
+	printf("  Hitbox: {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n",
+		Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
+		Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
+		Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
+	);
+	DebugConnectorPool(ConnectorPool, 0);
+	//*/
+	
+	// Place pieces at the available connectors:
+	/*
+	Instead of removing them one by one from the pool, we process them sequentially and take note of the last
+	processed one. To save on memory, once the number of processed connectors reaches a big number, a chunk
+	of the connectors is removed.
+	*/
+	size_t NumProcessed = 0;
+	while (ConnectorPool.size() > NumProcessed)
+	{
+		cFreeConnector & Conn = ConnectorPool[NumProcessed];
+		if (Conn.m_Piece->GetDepth() < a_MaxDepth)
+		{
+			if (TryPlacePieceAtConnector(*Conn.m_Piece, Conn.m_Connector, a_OutPieces, ConnectorPool))
+			{
+				/*
+				// DEBUG:
+				const cPlacedPiece * NewPiece = a_OutPieces.back();
+				const Vector3i & Coords = NewPiece->GetCoords();
+				printf("Placed a new piece at {%d, %d, %d}, rotation %d\n", Coords.x, Coords.y, Coords.z, NewPiece->GetNumCCWRotations());
+				cCuboid Hitbox = NewPiece->GetHitBox();
+				Hitbox.Sort();
+				printf("  Hitbox: {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n",
+					Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
+					Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
+					Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
+				);
+				DebugConnectorPool(ConnectorPool, NumProcessed + 1);
+				//*/
+			}
+		}
+		NumProcessed++;
+		if (NumProcessed > 1000)
+		{
+			ConnectorPool.erase(ConnectorPool.begin(), ConnectorPool.begin() + NumProcessed);
+			NumProcessed = 0;
+		}
+	}
+}
+
+
+
+
diff --git a/src/Generating/PieceGenerator.h b/src/Generating/PieceGenerator.h
new file mode 100644
index 000000000..bef9d3463
--- /dev/null
+++ b/src/Generating/PieceGenerator.h
@@ -0,0 +1,247 @@
+
+// PieceGenerator.h
+
+// Declares the cBFSPieceGenerator class and cDFSPieceGenerator class 
+// representing base classes for generating structures composed of individual "pieces"
+
+/*
+Each uses a slightly different approach to generating:
+	- DFS extends pieces one by one until it hits the configured depth (or can't connect another piece anymore),
+		then starts looking at adjacent connectors (like depth-first search).
+	- BFS keeps a pool of currently-open connectors, chooses one at random and tries to place a piece on it,
+		thus possibly extending the pool of open connectors (like breadth-first search).
+*/
+
+
+
+
+
+#pragma once
+
+#include "../Defines.h"
+#include "../Cuboid.h"
+#include "../Noise.h"
+
+
+
+
+
+/** Represents a single piece. Can have multiple connectors of different types where other pieces can connect. */
+class cPiece
+{
+public:
+	// Force a virtual destructor in all descendants
+	virtual ~cPiece() {}
+	
+	struct cConnector
+	{
+		/** Position relative to the piece */
+		Vector3i m_Pos;
+		
+		/** Type of the connector. Any arbitrary number; the generator connects only connectors of the same type. */
+		int m_Type;
+		
+		/** Direction in which the connector is facing.
+		Will be matched by the opposite direction for the connecting connector. */
+		eBlockFace m_Direction;
+		
+		cConnector(int a_X, int a_Y, int a_Z, int a_Type, eBlockFace a_Direction);
+		cConnector(const Vector3i & a_Pos, int a_Type, eBlockFace a_Direction);
+	};
+	
+	typedef std::vector<cConnector> cConnectors;
+	
+	/** Returns all of the available connectors that the piece has.
+	Each connector has a (relative) position in the piece, and a type associated with it. */
+	virtual cConnectors GetConnectors(void) const = 0;
+	
+	/** Returns the dimensions of this piece.
+	The dimensions cover the entire piece, there is no block that the piece generates outside of this size. */
+	virtual Vector3i GetSize(void) const = 0;
+	
+	/** Returns the "hitbox" of this piece.
+	A hitbox is what is compared and must not intersect other pieces' hitboxes when generating. */
+	virtual cCuboid GetHitBox(void) const = 0;
+	
+	/** Returns true if the piece can be rotated CCW the specific number of 90-degree turns. */
+	virtual bool CanRotateCCW(int a_NumRotations) const = 0;
+	
+	/** Returns a copy of the a_Pos after rotating the piece the specified number of CCW rotations. */
+	Vector3i RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const;
+
+	/** Returns a copy of the connector that is rotated and then moved by the specified amounts. */
+	cConnector RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
+	
+	/** Returns the hitbox after the specified number of rotations and moved so that a_MyConnector is placed at a_ToConnectorPos. */
+	cCuboid RotateHitBoxToConnector(const cConnector & a_MyConnector, const Vector3i & a_ToConnectorPos, int a_NumCCWRotations) const;
+	
+	/** Returns the hitbox after the specified number of CCW rotations and moved by the specified amounts. */
+	cCuboid RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
+};
+
+typedef std::vector<cPiece *> cPieces;
+
+
+
+
+
+/** This class is an interface that provides pieces for the generator. It can keep track of what pieces were
+placed and adjust the returned piece vectors. */
+class cPiecePool
+{
+public:
+	// Force a virtual destructor in all descendants:
+	virtual ~cPiecePool() {}
+	
+	/** Returns a list of pieces that contain the specified connector type.
+	The cPiece pointers returned are managed by the pool and the caller doesn't free them. */
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) = 0;
+	
+	/** Returns the pieces that should be used as the starting point.
+	Multiple starting points are supported, one of the returned piece will be chosen. */
+	virtual cPieces GetStartingPieces(void) = 0;
+	
+	/** Called after a piece is placed, to notify the pool that it has been used.
+	The pool may adjust the pieces it will return the next time. */
+	virtual void PiecePlaced(const cPiece & a_Piece) = 0;
+	
+	/** Called when the pool has finished the current structure and should reset any piece-counters it has
+	for a new structure. */
+	virtual void Reset(void) = 0;
+};
+
+
+
+
+
+/** Represents a single piece that has been placed to specific coords in the world. */
+class cPlacedPiece
+{
+public:
+	cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations);
+	
+	const cPiece &   GetPiece          (void) const { return *m_Piece; }
+	const Vector3i & GetCoords         (void) const { return m_Coords; }
+	int              GetNumCCWRotations(void) const { return m_NumCCWRotations; }
+	const cCuboid &  GetHitBox         (void) const { return m_HitBox; }
+	int              GetDepth          (void) const { return m_Depth; }
+	
+protected:
+	const cPlacedPiece * m_Parent;
+	const cPiece * m_Piece;
+	Vector3i m_Coords;
+	int m_NumCCWRotations;
+	cCuboid m_HitBox;
+	int m_Depth;
+};
+
+typedef std::vector<cPlacedPiece *> cPlacedPieces;
+
+
+
+
+
+class cPieceGenerator
+{
+public:
+	cPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
+	
+	/** Cleans up all the memory used by the placed pieces.
+	Call this utility function instead of freeing the items on your own. */
+	static void FreePieces(cPlacedPieces & a_PlacedPieces);
+	
+protected:
+	/** The type used for storing a connection from one piece to another, while building the piece tree. */
+	struct cConnection
+	{
+		cPiece * m_Piece;                  // The piece being connected
+		cPiece::cConnector m_Connector;    // The piece's connector being used (relative non-rotated coords)
+		int m_NumCCWRotations;             // Number of rotations necessary to match the two connectors
+		
+		cConnection(cPiece & a_Piece, cPiece::cConnector & a_Connector, int a_NumCCWRotations);
+	};
+	typedef std::vector<cConnection> cConnections;
+	
+	/** The type used for storing a pool of connectors that will be attempted to expand by another piece. */
+	struct cFreeConnector
+	{
+		cPlacedPiece * m_Piece;
+		cPiece::cConnector m_Connector;
+		
+		cFreeConnector(cPlacedPiece * a_Piece, const cPiece::cConnector & a_Connector);
+	};
+	typedef std::vector<cFreeConnector> cFreeConnectors;
+
+
+	cPiecePool & m_PiecePool;
+	cNoise m_Noise;
+	int m_Seed;
+
+	
+	/** Selects a starting piece and places it, including the rotations.
+	Also puts the piece's connectors in a_OutConnectors. */
+	cPlacedPiece * PlaceStartingPiece(int a_BlockX, int a_BlockY, int a_BlockZ, cFreeConnectors & a_OutConnectors);
+	
+	/** Tries to place a new piece at the specified (placed) connector. Returns true if successful. */
+	bool TryPlacePieceAtConnector(
+		const cPlacedPiece & a_ParentPiece,      // The existing piece to a new piece should be placed
+		const cPiece::cConnector & a_Connector,  // The existing connector (world-coords) to which a new piece should be placed
+		cPlacedPieces & a_OutPieces,             // Already placed pieces, to be checked for intersections
+		cFreeConnectors & a_OutConnectors        // List of free connectors to which the new connectors will be placed
+	);
+
+	/** Checks if the specified piece would fit with the already-placed pieces, using the specified connector
+	and number of CCW rotations.
+	a_ExistingConnector is in world-coords and is already rotated properly
+	a_ToPos is the world-coords position on which the new connector should be placed (1 block away from a_ExistingConnector, in its Direction)
+	a_NewConnector is in the original (non-rotated) coords.
+	Returns true if the piece fits, false if not. */
+	bool CheckConnection(
+		const cPiece::cConnector & a_ExistingConnector,  // The existing connector
+		const Vector3i & a_ToPos,                        // The position on which the new connector should be placed
+		const cPiece & a_Piece,                          // The new piece
+		const cPiece::cConnector & a_NewConnector,       // The connector of the new piece 
+		int a_NumCCWRotations,                           // Number of rotations for the new piece to align the connector
+		const cPlacedPieces & a_OutPieces                // All the already-placed pieces to check
+	);
+	
+	/** DEBUG: Outputs all the connectors in the pool into stdout.
+	a_NumProcessed signals the number of connectors from the pool that should be considered processed (not listed). */
+	void DebugConnectorPool(const cPieceGenerator::cFreeConnectors & a_ConnectorPool, size_t a_NumProcessed);
+} ;
+
+
+
+
+
+class cBFSPieceGenerator :
+	public cPieceGenerator
+{
+	typedef cPieceGenerator super;
+	
+public:
+	cBFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
+	
+	/** Generates a placement for pieces at the specified coords.
+	Caller must free each individual cPlacedPiece in a_OutPieces. */
+	void PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MaxDepth, cPlacedPieces & a_OutPieces);
+};
+
+
+
+
+
+class cDFSPieceGenerator :
+	public cPieceGenerator
+{
+public:
+	cDFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
+	
+	/** Generates a placement for pieces at the specified coords.
+	Caller must free each individual cPlacedPiece in a_OutPieces. */
+	void PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, cPlacedPieces & a_OutPieces);
+};
+
+
+
+
diff --git a/src/Globals.h b/src/Globals.h
index 28805a83f..3e62832b7 100644
--- a/src/Globals.h
+++ b/src/Globals.h
@@ -38,6 +38,15 @@
 	// No alignment needed in MSVC
 	#define ALIGN_8
 	#define ALIGN_16
+	
+	#define FORMATSTRING(formatIndex, va_argsIndex)
+
+	// MSVC has its own custom version of zu format
+	#define SIZE_T_FMT "%Iu"
+	#define SIZE_T_FMT_PRECISION(x) "%" #x "Iu"
+	#define SIZE_T_FMT_HEX "%Ix"
+	
+	#define NORETURN      __declspec(noreturn)
 
 #elif defined(__GNUC__)
 
@@ -56,6 +65,14 @@
 
 	// Some portability macros :)
 	#define stricmp strcasecmp
+	
+	#define FORMATSTRING(formatIndex, va_argsIndex) __attribute__((format (printf, formatIndex, va_argsIndex)))
+
+	#define SIZE_T_FMT "%zu"
+	#define SIZE_T_FMT_PRECISION(x) "%" #x "zu"
+	#define SIZE_T_FMT_HEX "%zx"
+	
+	#define NORETURN      __attribute((__noreturn__))
 
 #else
 
@@ -81,7 +98,14 @@
 #endif
 
 
+#ifdef  _DEBUG
+	#define NORETURNDEBUG NORETURN
+#else
+	#define NORETURNDEBUG
+#endif
+
 
+#include <stddef.h>
 
 
 // Integral types with predefined sizes:
@@ -96,8 +120,23 @@ typedef unsigned short     UInt16;
 typedef unsigned char Byte;
 
 
+// If you get an error about specialization check the size of integral types
+template <typename T, size_t Size, bool x = sizeof(T) == Size>
+class SizeChecker;
 
+template <typename T, size_t Size>
+class SizeChecker<T, Size, true>
+{
+  T v;
+};
+
+template class SizeChecker<Int64, 8>;
+template class SizeChecker<Int32, 4>;
+template class SizeChecker<Int16, 2>;
 
+template class SizeChecker<UInt64, 8>;
+template class SizeChecker<UInt32, 4>;
+template class SizeChecker<UInt16, 2>;
 
 // A macro to disallow the copy constructor and operator= functions
 // This should be used in the private: declarations for any class that shouldn't allow copying itself
@@ -179,7 +218,7 @@ typedef unsigned char Byte;
 #include <memory>
 #include <set>
 #include <queue>
-
+#include <limits>
 
 
 
@@ -220,9 +259,10 @@ typedef unsigned char Byte;
 // Pretty much the same as ASSERT() but stays in Release builds
 #define VERIFY( x ) ( !!(x) || ( LOGERROR("Verification failed: %s, file %s, line %i", #x, __FILE__, __LINE__ ), exit(1), 0 ) )
 
-
-
-
+// Same as assert but in all Self test builds
+#ifdef SELF_TEST
+#define assert_test(x) ( !!(x) || (assert(!#x), exit(1), 0))
+#endif
 
 /// A generic interface used mainly in ForEach() functions
 template <typename Type> class cItemCallback
@@ -246,6 +286,14 @@ T Clamp(T a_Value, T a_Min, T a_Max)
 
 
 
+#ifndef TOLUA_TEMPLATE_BIND
+#define TOLUA_TEMPLATE_BIND(x)
+#endif
+
+
+
+
+
 // Common headers (part 2, with macros):
 #include "ChunkDef.h"
 #include "BiomeDef.h"
@@ -254,5 +302,3 @@ T Clamp(T a_Value, T a_Min, T a_Max)
 #include "Entities/Effects.h"
 
 
-
-
diff --git a/src/Item.cpp b/src/Item.cpp
index 61d57e763..856b68be6 100644
--- a/src/Item.cpp
+++ b/src/Item.cpp
@@ -216,7 +216,7 @@ cItem * cItems::Get(int a_Idx)
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to get an out-of-bounds item at index %d; there are currently %d items. Returning a nil.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to get an out-of-bounds item at index %d; there are currently " SIZE_T_FMT " items. Returning a nil.", a_Idx, size());
 		return NULL;
 	}
 	return &at(a_Idx);
@@ -230,7 +230,7 @@ void cItems::Set(int a_Idx, const cItem & a_Item)
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently %d items. Not setting.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently " SIZE_T_FMT " items. Not setting.", a_Idx, size());
 		return;
 	}
 	at(a_Idx) = a_Item;
@@ -244,7 +244,7 @@ void cItems::Delete(int a_Idx)
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to delete an item at an out-of-bounds index %d; there are currently %d items. Ignoring.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to delete an item at an out-of-bounds index %d; there are currently " SIZE_T_FMT " items. Ignoring.", a_Idx, size());
 		return;
 	}
 	erase(begin() + a_Idx);
@@ -258,7 +258,7 @@ void cItems::Set(int a_Idx, short a_ItemType, char a_ItemCount, short a_ItemDama
 {
 	if ((a_Idx < 0) || (a_Idx >= (int)size()))
 	{
-		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently %d items. Not setting.", a_Idx, size());
+		LOGWARNING("cItems: Attempt to set an item at an out-of-bounds index %d; there are currently " SIZE_T_FMT " items. Not setting.", a_Idx, size());
 		return;
 	}
 	at(a_Idx) = cItem(a_ItemType, a_ItemCount, a_ItemDamage);
diff --git a/src/Items/ItemCake.h b/src/Items/ItemCake.h
new file mode 100644
index 000000000..48e23ed59
--- /dev/null
+++ b/src/Items/ItemCake.h
@@ -0,0 +1,41 @@
+
+#pragma once
+
+#include "ItemHandler.h"
+
+
+
+
+
+class cItemCakeHandler :
+	public cItemHandler
+{
+public:
+	cItemCakeHandler(int a_ItemType) :
+		cItemHandler(a_ItemType)
+	{
+	}
+
+
+	virtual bool IsPlaceable(void) override
+	{
+		return true;
+	}
+
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = E_BLOCK_CAKE;
+		a_BlockMeta = 0;
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Items/ItemHandler.cpp b/src/Items/ItemHandler.cpp
index 1d357fcf1..454fabdd7 100644
--- a/src/Items/ItemHandler.cpp
+++ b/src/Items/ItemHandler.cpp
@@ -13,6 +13,7 @@
 #include "ItemBow.h"
 #include "ItemBrewingStand.h"
 #include "ItemBucket.h"
+#include "ItemCake.h"
 #include "ItemCauldron.h"
 #include "ItemCloth.h"
 #include "ItemComparator.h"
@@ -94,6 +95,7 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 		
 		// Single item per handler, alphabetically sorted:
 		case E_BLOCK_LEAVES:           return new cItemLeavesHandler(a_ItemType);
+		case E_BLOCK_NEW_LEAVES:       return new cItemLeavesHandler(a_ItemType);
 		case E_BLOCK_SAPLING:          return new cItemSaplingHandler(a_ItemType);
 		case E_BLOCK_WOOL:             return new cItemClothHandler(a_ItemType);
 		case E_ITEM_BED:               return new cItemBedHandler(a_ItemType);
@@ -101,12 +103,14 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 		case E_ITEM_BOTTLE_O_ENCHANTING: return new cItemBottleOEnchantingHandler();
 		case E_ITEM_BOW:               return new cItemBowHandler;
 		case E_ITEM_BREWING_STAND:     return new cItemBrewingStandHandler(a_ItemType);
+		case E_ITEM_CAKE:              return new cItemCakeHandler(a_ItemType);
 		case E_ITEM_CAULDRON:          return new cItemCauldronHandler(a_ItemType);
 		case E_ITEM_COMPARATOR:        return new cItemComparatorHandler(a_ItemType);
 		case E_ITEM_DYE:               return new cItemDyeHandler(a_ItemType);
 		case E_ITEM_EGG:               return new cItemEggHandler();
 		case E_ITEM_EMPTY_MAP:         return new cItemEmptyMapHandler();
 		case E_ITEM_ENDER_PEARL:       return new cItemEnderPearlHandler();
+		case E_ITEM_FIRE_CHARGE:       return new cItemLighterHandler(a_ItemType);
 		case E_ITEM_FIREWORK_ROCKET:   return new cItemFireworkHandler();
 		case E_ITEM_FISHING_ROD:       return new cItemFishingRodHandler(a_ItemType);
 		case E_ITEM_FLINT_AND_STEEL:   return new cItemLighterHandler(a_ItemType);
@@ -337,6 +341,7 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_BREWING_STAND:        return 64;
 		case E_ITEM_BUCKET:               return 16;
 		case E_ITEM_CARROT:               return 64;
+		case E_ITEM_CAKE:                 return 1;
 		case E_ITEM_CAULDRON:             return 64;
 		case E_ITEM_CLAY:                 return 64;
 		case E_ITEM_CLAY_BRICK:           return 64;
diff --git a/src/Items/ItemItemFrame.h b/src/Items/ItemItemFrame.h
index 74e987445..27e7dba35 100644
--- a/src/Items/ItemItemFrame.h
+++ b/src/Items/ItemItemFrame.h
@@ -34,7 +34,11 @@ public:
 		if (Block == E_BLOCK_AIR)
 		{
 			cItemFrame * ItemFrame = new cItemFrame(a_Dir, a_BlockX, a_BlockY, a_BlockZ);
-			ItemFrame->Initialize(a_World);
+			if (!ItemFrame->Initialize(a_World))
+			{
+				delete ItemFrame;
+				return false;
+			}
 
 			if (!a_Player->IsGameModeCreative())
 			{
diff --git a/src/Items/ItemLighter.h b/src/Items/ItemLighter.h
index 2d3d72bc6..32f49cab6 100644
--- a/src/Items/ItemLighter.h
+++ b/src/Items/ItemLighter.h
@@ -26,7 +26,26 @@ public:
 			return false;
 		}
 		
-		a_Player->UseEquippedItem();
+		if (!a_Player->IsGameModeCreative())
+		{
+			switch (m_ItemType)
+			{
+				case E_ITEM_FLINT_AND_STEEL:
+				{
+					a_Player->UseEquippedItem();
+					break;
+				}
+				case E_ITEM_FIRE_CHARGE:
+				{
+					a_Player->GetInventory().RemoveOneEquippedItem();
+					break;
+				}
+				default:
+				{
+					ASSERT(!"Unknown Lighter Item!");
+				}
+			}
+		}
 
 		switch (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ))
 		{
@@ -49,6 +68,7 @@ public:
 				if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_AIR)
 				{
 					a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_FIRE, 0);
+					a_World->BroadcastSoundEffect("fire.ignite", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 1.0F, 1.04F);
 					break;
 				}
 			}
diff --git a/src/Items/ItemShears.h b/src/Items/ItemShears.h
index b8f75f5ba..39d2776fa 100644
--- a/src/Items/ItemShears.h
+++ b/src/Items/ItemShears.h
@@ -28,10 +28,10 @@ public:
 	virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir) override
 	{
 		BLOCKTYPE Block = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-		if (Block == E_BLOCK_LEAVES)
+		if ((Block == E_BLOCK_LEAVES) || (Block == E_BLOCK_NEW_LEAVES))
 		{
 			cItems Drops;
-			Drops.push_back(cItem(E_BLOCK_LEAVES, 1, a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x03));
+			Drops.push_back(cItem(Block, 1, a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x03));
 			a_World->SpawnItemPickups(Drops, a_BlockX, a_BlockY, a_BlockZ);
 
 			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
@@ -49,6 +49,7 @@ public:
 			case E_BLOCK_COBWEB:
 			case E_BLOCK_VINES:
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			{
 				return true;
 			}
diff --git a/src/LightingThread.cpp b/src/LightingThread.cpp
index 44dadb8a9..302473d71 100644
--- a/src/LightingThread.cpp
+++ b/src/LightingThread.cpp
@@ -13,12 +13,6 @@
 
 
 
-/// If more than this many chunks are in the queue, a warning is printed to the log
-#define WARN_ON_QUEUE_SIZE 800
-
-
-
-
 
 /// Chunk data callback that takes the chunk data and puts them into cLightingThread's m_BlockTypes[] / m_HeightMap[]:
 class cReader :
diff --git a/src/LineBlockTracer.cpp b/src/LineBlockTracer.cpp
index da1c7f2fd..f4f29e833 100644
--- a/src/LineBlockTracer.cpp
+++ b/src/LineBlockTracer.cpp
@@ -5,7 +5,7 @@
 
 #include "Globals.h"
 #include "LineBlockTracer.h"
-#include "Vector3d.h"
+#include "Vector3.h"
 #include "World.h"
 #include "Chunk.h"
 
diff --git a/src/Log.cpp b/src/Log.cpp
index 1ea327d5d..a7be04b1a 100644
--- a/src/Log.cpp
+++ b/src/Log.cpp
@@ -118,7 +118,7 @@ void cLog::Log(const char * a_Format, va_list argList)
 
 	AString Line;
 	#ifdef _DEBUG
-	Printf(Line, "[%04x|%02d:%02d:%02d] %s", cIsThread::GetCurrentID(), timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, Message.c_str());
+	Printf(Line, "[%04lx|%02d:%02d:%02d] %s", cIsThread::GetCurrentID(), timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, Message.c_str());
 	#else
 	Printf(Line, "[%02d:%02d:%02d] %s", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, Message.c_str());
 	#endif
diff --git a/src/Log.h b/src/Log.h
index cba248dae..d6a406154 100644
--- a/src/Log.h
+++ b/src/Log.h
@@ -14,8 +14,8 @@ private:
 public:
 	cLog(const AString & a_FileName);
 	~cLog();
-	void Log(const char * a_Format, va_list argList);
-	void Log(const char * a_Format, ...);
+	void Log(const char * a_Format, va_list argList) FORMATSTRING(2, 0);
+	void Log(const char * a_Format, ...) FORMATSTRING(2, 3);
 	// tolua_begin
 	void SimpleLog(const char * a_String);
 	void OpenLog(const char * a_FileName);
diff --git a/src/MCLogger.h b/src/MCLogger.h
index c949a4cdf..996e60329 100644
--- a/src/MCLogger.h
+++ b/src/MCLogger.h
@@ -21,10 +21,10 @@ public:																// tolua_export
 	
 	~cMCLogger();													// tolua_export
 
-	void Log(const char* a_Format, va_list a_ArgList);
-	void Info(const char* a_Format, va_list a_ArgList);
-	void Warn(const char* a_Format, va_list a_ArgList);
-	void Error(const char* a_Format, va_list a_ArgList);
+	void Log(const char* a_Format, va_list a_ArgList)   FORMATSTRING(2, 0);
+	void Info(const char* a_Format, va_list a_ArgList)  FORMATSTRING(2, 0);
+	void Warn(const char* a_Format, va_list a_ArgList)  FORMATSTRING(2, 0);
+	void Error(const char* a_Format, va_list a_ArgList) FORMATSTRING(2, 0);
 
 	void LogSimple(const char* a_Text, int a_LogType = 0 );			// tolua_export
 
@@ -57,10 +57,10 @@ private:
 
 
 
-extern void LOG(const char* a_Format, ...);
-extern void LOGINFO(const char* a_Format, ...);
-extern void LOGWARN(const char* a_Format, ...);
-extern void LOGERROR(const char* a_Format, ...);
+extern void LOG(const char* a_Format, ...)      FORMATSTRING(1, 2);
+extern void LOGINFO(const char* a_Format, ...)  FORMATSTRING(1, 2);
+extern void LOGWARN(const char* a_Format, ...)  FORMATSTRING(1, 2);
+extern void LOGERROR(const char* a_Format, ...) FORMATSTRING(1, 2);
 
 
 
diff --git a/src/Map.h b/src/Map.h
index a313d5431..ee7c537b1 100644
--- a/src/Map.h
+++ b/src/Map.h
@@ -64,7 +64,7 @@ public:
 	unsigned int GetPixelX(void) const { return m_PixelX; }
 	unsigned int GetPixelZ(void) const { return m_PixelZ; }
 
-	int GetRot(void) const { return m_Rot; }
+	unsigned int GetRot(void) const { return m_Rot; }
 
 	eType GetType(void) const { return m_Type; }
 
diff --git a/src/Matrix4.h b/src/Matrix4.h
new file mode 100644
index 000000000..456677f0f
--- /dev/null
+++ b/src/Matrix4.h
@@ -0,0 +1,224 @@
+
+#pragma once
+
+
+
+#define _USE_MATH_DEFINES // Enable non-standard math defines (MSVC)
+#include <math.h>
+
+
+
+
+
+template <typename T>
+// tolua_begin
+class Matrix4
+{
+
+	TOLUA_TEMPLATE_BIND((T, float, double))
+
+	// tolua_end
+
+public:
+
+	T cell[16];
+
+	// tolua_begin
+
+	inline Matrix4(void)
+	{
+		Identity();
+	}
+
+	inline Matrix4(const Matrix4 & a_Rhs)
+	{
+		*this = a_Rhs;
+	}
+
+	inline Matrix4 & operator = (const Matrix4 & a_Rhs)
+	{
+		for (unsigned int i = 0; i < 16; ++i)
+		{
+			cell[i] = a_Rhs.cell[i];
+		}
+		return *this;
+	}
+
+	inline T & operator [] (int a_N)
+	{
+		ASSERT(a_N < 16);
+		return cell[a_N];
+	}
+
+	inline void Identity()
+	{
+		cell[1]  = cell[2]  = cell[3]  = cell[4]  = 0;
+		cell[6]  = cell[7]  = cell[8]  = cell[9]  = 0;
+		cell[11] = cell[12] = cell[13] = cell[14] = 0;
+
+		cell[0] = cell[5] = cell[10] = cell[15] = 1;
+	}
+
+	inline void Init(const Vector3<T> & a_Pos, T a_RX, T a_RY, T a_RZ)
+	{
+		Matrix4<T> t;
+		t.RotateX(a_RZ);
+		RotateY(a_RY);
+		Concatenate(t);
+		t.RotateZ(a_RX);
+		Concatenate(t);
+		Translate(a_Pos);
+	}
+
+	inline void RotateX(T a_RX)
+	{
+		T sx = (T) sin(a_RX * M_PI / 180);
+		T cx = (T) cos(a_RX * M_PI / 180);
+
+		Identity();
+
+		cell[5] = cx;  cell[6]  = sx;
+		cell[9] = -sx; cell[10] = cx;
+	}
+
+	inline void RotateY(T a_RY)
+	{
+		T sy = (T) sin(a_RY * M_PI / 180);
+		T cy = (T) cos(a_RY * M_PI / 180);
+
+		Identity();
+
+		cell[0] = cy; cell[2] = -sy;
+		cell[8] = sy; cell[10] = cy;
+	}
+
+	inline void RotateZ(T a_RZ)
+	{
+		T sz = (T) sin(a_RZ * M_PI / 180);
+		T cz = (T) cos(a_RZ * M_PI / 180);
+
+		Identity();
+
+		cell[0] = cz;  cell[1] = sz;
+		cell[4] = -sz; cell[5] = cz;
+	}
+
+	inline void Translate(const Vector3<T> & a_Pos)
+	{ 
+		cell[3]  += a_Pos.x;
+		cell[7]  += a_Pos.y;
+		cell[11] += a_Pos.z;
+	}
+
+	inline void SetTranslation(const Vector3<T> & a_Pos)
+	{
+		cell[3]  = a_Pos.x;
+		cell[7]  = a_Pos.y;
+		cell[11] = a_Pos.z;
+	}
+
+	inline void Concatenate(const Matrix4 & m2)
+	{
+		Matrix4 res;
+
+		for (unsigned int c = 0; c < 4; ++c)
+		{
+			for (unsigned int r = 0; r < 4; ++r)
+			{
+				res.cell[r * 4 + c] = (
+					cell[r * 4 + 0] * m2.cell[c + 0] +
+					cell[r * 4 + 1] * m2.cell[c + 4] +
+					cell[r * 4 + 2] * m2.cell[c + 8] +
+					cell[r * 4 + 3] * m2.cell[c + 12]
+				);
+			}
+		}
+
+		*this = res;
+	}
+
+	inline Vector3<T> Transform(const Vector3<T> & v) const
+	{
+		T x  = cell[0] * v.x + cell[1] * v.y + cell[2]  * v.z + cell[3];
+		T y  = cell[4] * v.x + cell[5] * v.y + cell[6]  * v.z + cell[7];
+		T z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
+
+		return Vector3<T>(x, y, z);
+	}
+
+	inline void Invert(void)
+	{
+		Matrix4 t;
+
+		T tx = -cell[3];
+		T ty = -cell[7];
+		T tz = -cell[11];
+
+		for (unsigned int h = 0; h < 3; ++h)
+		{
+			for (unsigned int v = 0; v < 3; ++v)
+			{
+				t.cell[h + v * 4] = cell[v + h * 4];
+			}
+		}
+
+		for (unsigned int i = 0; i < 11; ++i)
+		{
+			cell[i] = t.cell[i];
+		}
+
+		cell[3]  = tx * cell[0] + ty * cell[1] + tz * cell[2];
+		cell[7]  = tx * cell[4] + ty * cell[5] + tz * cell[6];
+		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
+	}
+
+	inline Vector3<T> GetXColumn(void) const
+	{
+		return Vector3<T>(cell[0], cell[1], cell[2]);
+	}
+
+	inline Vector3<T> GetYColumn(void) const
+	{
+		return Vector3<T>(cell[4], cell[5], cell[6]);
+	}
+
+	inline Vector3<T> GetZColumn(void) const
+	{
+		return Vector3<T>(cell[8], cell[9], cell[10]);
+	}
+
+	inline void SetXColumn(const Vector3<T> & a_X)
+	{
+		cell[0] = a_X.x;
+		cell[1] = a_X.y;
+		cell[2] = a_X.z;
+	}
+
+	inline void SetYColumn(const Vector3<T> & a_Y)
+	{
+		cell[4] = a_Y.x;
+		cell[5] = a_Y.y;
+		cell[6] = a_Y.z;
+	}
+
+	inline void SetZColumn(const Vector3<T> & a_Z)
+	{
+		cell[8]  = a_Z.x;
+		cell[9]  = a_Z.y;
+		cell[10] = a_Z.z;
+	}
+};
+// tolua_end
+
+
+
+
+// tolua_begin
+typedef Matrix4<double> Matrix4d;
+typedef Matrix4<float>  Matrix4f;
+// tolua_end
+
+
+
+
+
diff --git a/src/Matrix4f.cpp b/src/Matrix4f.cpp
deleted file mode 100644
index d0a407a99..000000000
--- a/src/Matrix4f.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-// _X: empty file??
diff --git a/src/Matrix4f.h b/src/Matrix4f.h
deleted file mode 100644
index 249c92f5f..000000000
--- a/src/Matrix4f.h
+++ /dev/null
@@ -1,225 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-#include "Vector3f.h"
-
-class Matrix4f
-{
-public:
-	enum
-	{
-		TX=3,
-		TY=7,
-		TZ=11,
-		D0=0, D1=5, D2=10, D3=15,
-		SX=D0, SY=D1, SZ=D2,
-		W=D3
-	};
-	Matrix4f() { Identity(); }
-	float& operator [] ( int a_N ) { return cell[a_N]; }
-	void Identity()
-	{
-		cell[1] = cell[2] = cell[TX] = cell[4] = cell[6] = cell[TY] =
-		cell[8] = cell[9] = cell[TZ] = cell[12] = cell[13] = cell[14] = 0;
-		cell[D0] = cell[D1] = cell[D2] = cell[W] = 1;
-	}
-	void Init( Vector3f a_Pos, float a_RX, float a_RY, float a_RZ )
-	{
-		Matrix4f t;
-		t.RotateX( a_RZ );
-		RotateY( a_RY );
-		Concatenate( t );
-		t.RotateZ( a_RX );
-		Concatenate( t );
-		Translate( a_Pos );
-	}
-	void RotateX( float a_RX )
-	{
-		float sx = (float)sin( a_RX * M_PI / 180 );
-		float cx = (float)cos( a_RX * M_PI / 180 );
-		Identity();
-		cell[5] = cx, cell[6] = sx, cell[9] = -sx, cell[10] = cx;
-	}
-	void RotateY( float a_RY )
-	{
-		float sy = (float)sin( a_RY * M_PI / 180 );
-		float cy = (float)cos( a_RY * M_PI / 180 );
-		Identity ();
-		cell[0] = cy, cell[2] = -sy, cell[8] = sy, cell[10] = cy;
-	}
-	void RotateZ( float a_RZ )
-	{
-		float sz = (float)sin( a_RZ * M_PI / 180 );
-		float cz = (float)cos( a_RZ * M_PI / 180 );
-		Identity ();
-		cell[0] = cz, cell[1] = sz, cell[4] = -sz, cell[5] = cz;
-	}
-	void Translate( Vector3f a_Pos ) { cell[TX] += a_Pos.x; cell[TY] += a_Pos.y; cell[TZ] += a_Pos.z; }
-	void SetTranslation( Vector3f a_Pos ) { cell[TX] = a_Pos.x; cell[TY] = a_Pos.y; cell[TZ] = a_Pos.z; }
-	void Concatenate( const Matrix4f& m2 )
-	{
-		Matrix4f res;
-		int c;
-		for ( c = 0; c < 4; c++ ) for ( int r = 0; r < 4; r++ )
-			res.cell[r * 4 + c] = cell[r * 4] * m2.cell[c] +
-				  				  cell[r * 4 + 1] * m2.cell[c + 4] +
-								  cell[r * 4 + 2] * m2.cell[c + 8] +
-								  cell[r * 4 + 3] * m2.cell[c + 12];
-		for ( c = 0; c < 16; c++ ) cell[c] = res.cell[c];
-	}
-	Vector3f Transform( const Vector3f& v ) const
-	{
-		float x  = cell[0] * v.x + cell[1] * v.y + cell[2] * v.z + cell[3];
-		float y  = cell[4] * v.x + cell[5] * v.y + cell[6] * v.z + cell[7];
-		float z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
-		return Vector3f( x, y, z );
-	}
-	void Invert()
-	{
-		Matrix4f t;
-		int h, i;
-		float tx = -cell[3], ty = -cell[7], tz = -cell[11];
-		for ( h = 0; h < 3; h++ ) for ( int v = 0; v < 3; v++ ) t.cell[h + v * 4] = cell[v + h * 4];
-		for ( i = 0; i < 11; i++ ) cell[i] = t.cell[i];
-		cell[3] = tx * cell[0] + ty * cell[1] + tz * cell[2];
-		cell[7] = tx * cell[4] + ty * cell[5] + tz * cell[6];
-		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
-	}
-	Vector3f GetXColumn() { return Vector3f( cell[0], cell[1], cell[2] ); }
-	Vector3f GetYColumn() { return Vector3f( cell[4], cell[5], cell[6] ); }
-	Vector3f GetZColumn() { return Vector3f( cell[8], cell[9], cell[10] ); }
-	void SetXColumn( const Vector3f & a_X )
-	{
-		cell[0] = a_X.x;
-		cell[1] = a_X.y;
-		cell[2] = a_X.z;
-	}
-	void SetYColumn( const Vector3f & a_Y )
-	{
-		cell[4] = a_Y.x;
-		cell[5] = a_Y.y;
-		cell[6] = a_Y.z;
-	}
-	void SetZColumn( const Vector3f & a_Z )
-	{
-		cell[8] = a_Z.x;
-		cell[9] = a_Z.y;
-		cell[10] = a_Z.z;
-	}
-	float cell[16];
-};
-
-
-
-
-
-class Matrix4d
-{
-public:
-	enum
-	{
-		TX=3,
-		TY=7,
-		TZ=11,
-		D0=0, D1=5, D2=10, D3=15,
-		SX=D0, SY=D1, SZ=D2,
-		W=D3
-	};
-	Matrix4d() { Identity(); }
-	double& operator [] ( int a_N ) { return cell[a_N]; }
-	void Identity()
-	{
-		cell[1] = cell[2] = cell[TX] = cell[4] = cell[6] = cell[TY] =
-		cell[8] = cell[9] = cell[TZ] = cell[12] = cell[13] = cell[14] = 0;
-		cell[D0] = cell[D1] = cell[D2] = cell[W] = 1;
-	}
-	void Init( Vector3f a_Pos, double a_RX, double a_RY, double a_RZ )
-	{
-		Matrix4d t;
-		t.RotateX( a_RZ );
-		RotateY( a_RY );
-		Concatenate( t );
-		t.RotateZ( a_RX );
-		Concatenate( t );
-		Translate( a_Pos );
-	}
-	void RotateX( double a_RX )
-	{
-		double sx = (double)sin( a_RX * M_PI / 180 );
-		double cx = (double)cos( a_RX * M_PI / 180 );
-		Identity();
-		cell[5] = cx, cell[6] = sx, cell[9] = -sx, cell[10] = cx;
-	}
-	void RotateY( double a_RY )
-	{
-		double sy = (double)sin( a_RY * M_PI / 180 );
-		double cy = (double)cos( a_RY * M_PI / 180 );
-		Identity ();
-		cell[0] = cy, cell[2] = -sy, cell[8] = sy, cell[10] = cy;
-	}
-	void RotateZ( double a_RZ )
-	{
-		double sz = (double)sin( a_RZ * M_PI / 180 );
-		double cz = (double)cos( a_RZ * M_PI / 180 );
-		Identity ();
-		cell[0] = cz, cell[1] = sz, cell[4] = -sz, cell[5] = cz;
-	}
-	void Translate( Vector3d a_Pos ) { cell[TX] += a_Pos.x; cell[TY] += a_Pos.y; cell[TZ] += a_Pos.z; }
-	void SetTranslation( Vector3d a_Pos ) { cell[TX] = a_Pos.x; cell[TY] = a_Pos.y; cell[TZ] = a_Pos.z; }
-	void Concatenate( const Matrix4d & m2 )
-	{
-		Matrix4d res;
-		int c;
-		for ( c = 0; c < 4; c++ ) for ( int r = 0; r < 4; r++ )
-			res.cell[r * 4 + c] = cell[r * 4] * m2.cell[c] +
-				  				  cell[r * 4 + 1] * m2.cell[c + 4] +
-								  cell[r * 4 + 2] * m2.cell[c + 8] +
-								  cell[r * 4 + 3] * m2.cell[c + 12];
-		for ( c = 0; c < 16; c++ ) cell[c] = res.cell[c];
-	}
-	Vector3d Transform( const Vector3d & v ) const
-	{
-		double x  = cell[0] * v.x + cell[1] * v.y + cell[2] * v.z + cell[3];
-		double y  = cell[4] * v.x + cell[5] * v.y + cell[6] * v.z + cell[7];
-		double z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
-		return Vector3d( x, y, z );
-	}
-	void Invert()
-	{
-		Matrix4d t;
-		int h, i;
-		double tx = -cell[3], ty = -cell[7], tz = -cell[11];
-		for ( h = 0; h < 3; h++ ) for ( int v = 0; v < 3; v++ ) t.cell[h + v * 4] = cell[v + h * 4];
-		for ( i = 0; i < 11; i++ ) cell[i] = t.cell[i];
-		cell[3] = tx * cell[0] + ty * cell[1] + tz * cell[2];
-		cell[7] = tx * cell[4] + ty * cell[5] + tz * cell[6];
-		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
-	}
-	Vector3d GetXColumn() { return Vector3d( cell[0], cell[1], cell[2] ); }
-	Vector3d GetYColumn() { return Vector3d( cell[4], cell[5], cell[6] ); }
-	Vector3d GetZColumn() { return Vector3d( cell[8], cell[9], cell[10] ); }
-	void SetXColumn( const Vector3d & a_X )
-	{
-		cell[0] = a_X.x;
-		cell[1] = a_X.y;
-		cell[2] = a_X.z;
-	}
-	void SetYColumn( const Vector3d & a_Y )
-	{
-		cell[4] = a_Y.x;
-		cell[5] = a_Y.y;
-		cell[6] = a_Y.z;
-	}
-	void SetZColumn( const Vector3d & a_Z )
-	{
-		cell[8] = a_Z.x;
-		cell[9] = a_Z.y;
-		cell[10] = a_Z.z;
-	}
-	double cell[16];
-} ;
-
-
-
-
diff --git a/src/MersenneTwister.h b/src/MersenneTwister.h
index f4c7b0699..759b8a1ae 100644
--- a/src/MersenneTwister.h
+++ b/src/MersenneTwister.h
@@ -62,7 +62,7 @@
 class MTRand {
 // Data
 public:
-	typedef long uint32;  // unsigned integer type, at least 32 bits
+	typedef UInt32 uint32;  // unsigned integer type, at least 32 bits
 	
 	enum { N = 624 };       // length of state vector
 	enum { SAVE = N + 1 };  // length of array for save()
@@ -72,7 +72,7 @@ protected:
 	
 	uint32 state[N];   // internal state
 	uint32 *pNext;     // next value to get from state
-	int left;          // number of values left before reload needed
+	uint32 left;       // number of values left before reload needed
 
 // Methods
 public:
@@ -164,7 +164,7 @@ inline void MTRand::initialize( const uint32 seed )
 	// only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
 	uint32 *s = state;
 	uint32 *r = state;
-	int i = 1;
+	uint32 i = 1;
 	*s++ = seed & 0xffffffffUL;
 	for( ; i < N; ++i )
 	{
@@ -205,9 +205,9 @@ inline void MTRand::seed( uint32 *const bigSeed, const uint32 seedLength )
 	// in each element are discarded.
 	// Just call seed() if you want to get array from /dev/urandom
 	initialize(19650218UL);
-	int i = 1;
+	uint32 i = 1;
 	uint32 j = 0;
-	int k = ( (uint32)N > seedLength ? (uint32)N : seedLength );
+	uint32 k = ( (uint32)N > seedLength ? (uint32)N : seedLength );
 	for( ; k; --k )
 	{
 		state[i] =
diff --git a/src/MobSpawner.cpp b/src/MobSpawner.cpp
index 7704f6cf3..a0d0f5c54 100644
--- a/src/MobSpawner.cpp
+++ b/src/MobSpawner.cpp
@@ -169,7 +169,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 					(TargetBlock == E_BLOCK_AIR) &&
 					(BlockAbove == E_BLOCK_AIR) &&
 					(
-						(BlockBelow == E_BLOCK_GRASS) || (BlockBelow == E_BLOCK_LEAVES)
+						(BlockBelow == E_BLOCK_GRASS) || (BlockBelow == E_BLOCK_LEAVES) || (BlockBelow == E_BLOCK_NEW_LEAVES)
 					) &&
 					(a_RelY >= 62) &&
 					(m_Random.NextInt(3, a_Biome) != 0)
diff --git a/src/Mobs/Bat.cpp b/src/Mobs/Bat.cpp
index b9c82996b..1417ddd9e 100644
--- a/src/Mobs/Bat.cpp
+++ b/src/Mobs/Bat.cpp
@@ -2,7 +2,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Bat.h"
-#include "../Vector3d.h"
+#include "../Vector3.h"
 #include "../Chunk.h"
 
 
diff --git a/src/Mobs/Monster.cpp b/src/Mobs/Monster.cpp
index 6e3c91d58..16d6aed1f 100644
--- a/src/Mobs/Monster.cpp
+++ b/src/Mobs/Monster.cpp
@@ -82,11 +82,11 @@ cMonster::cMonster(const AString & a_ConfigName, eType a_MobType, const AString
 	, m_AttackRange(2)
 	, m_AttackInterval(0)
 	, m_SightDistance(25)
-	, m_DropChanceWeapon(0.085)
-	, m_DropChanceHelmet(0.085)
-	, m_DropChanceChestplate(0.085)
-	, m_DropChanceLeggings(0.085)
-	, m_DropChanceBoots(0.085)
+	, m_DropChanceWeapon(0.085f)
+	, m_DropChanceHelmet(0.085f)
+	, m_DropChanceChestplate(0.085f)
+	, m_DropChanceLeggings(0.085f)
+	, m_DropChanceBoots(0.085f)
 	, m_CanPickUpLoot(true)
 	, m_BurnsInDaylight(false)
 {
diff --git a/src/Mobs/Squid.cpp b/src/Mobs/Squid.cpp
index ba9171b39..bd0e141a0 100644
--- a/src/Mobs/Squid.cpp
+++ b/src/Mobs/Squid.cpp
@@ -2,7 +2,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Squid.h"
-#include "../Vector3d.h"
+#include "../Vector3.h"
 #include "../Chunk.h"
 
 
diff --git a/src/Noise.cpp b/src/Noise.cpp
index 5f23a47f9..a97ea70c6 100644
--- a/src/Noise.cpp
+++ b/src/Noise.cpp
@@ -3,14 +3,6 @@
 
 #include "Noise.h"
 
-
-
-
-
-#if NOISE_USE_SSE
-	#include <smmintrin.h> //_mm_mul_epi32
-#endif
-
 #define FAST_FLOOR(x) (((x) < 0) ? (((int)x) - 1) : ((int)x))
 
 
diff --git a/src/OSSupport/BlockingTCPLink.cpp b/src/OSSupport/BlockingTCPLink.cpp
index e9c00d6d4..07f48b955 100644
--- a/src/OSSupport/BlockingTCPLink.cpp
+++ b/src/OSSupport/BlockingTCPLink.cpp
@@ -70,7 +70,7 @@ bool cBlockingTCPLink::Connect(const char * iAddress, unsigned int iPort)
 		}
 	}
 
-	server.sin_addr.s_addr = *((unsigned long *)hp->h_addr);
+	memcpy(&server.sin_addr.s_addr,hp->h_addr, hp->h_length);
 	server.sin_family = AF_INET;
 	server.sin_port = htons( (unsigned short)iPort);
 	if (connect(m_Socket, (struct sockaddr *)&server, sizeof(server)))
diff --git a/src/OSSupport/File.h b/src/OSSupport/File.h
index 07fce6661..b394c5cb9 100644
--- a/src/OSSupport/File.h
+++ b/src/OSSupport/File.h
@@ -131,7 +131,7 @@ public:
 	/** Returns the list of all items in the specified folder (files, folders, nix pipes, whatever's there). */
 	static AStringVector GetFolderContents(const AString & a_Folder);  // Exported in ManualBindings.cpp
 
-	int Printf(const char * a_Fmt, ...);
+	int Printf(const char * a_Fmt, ...) FORMATSTRING(2, 3);
 	
 	/** Flushes all the bufferef output into the file (only when writing) */
 	void Flush(void);
diff --git a/src/OSSupport/GZipFile.cpp b/src/OSSupport/GZipFile.cpp
index cbf6be6c4..b13e519e0 100644
--- a/src/OSSupport/GZipFile.cpp
+++ b/src/OSSupport/GZipFile.cpp
@@ -73,12 +73,15 @@ int cGZipFile::ReadRestOfFile(AString & a_Contents)
 	
 	// Since the gzip format doesn't really support getting the uncompressed length, we need to read incrementally. Yuck!
 	int NumBytesRead = 0;
+	int TotalBytes = 0;
 	char Buffer[64 KiB];
 	while ((NumBytesRead = gzread(m_File, Buffer, sizeof(Buffer))) > 0)
 	{
+		TotalBytes += NumBytesRead;
 		a_Contents.append(Buffer, NumBytesRead);
 	}
-	return NumBytesRead;
+	// NumBytesRead is < 0 on error
+	return (NumBytesRead >= 0) ? TotalBytes : NumBytesRead;
 }
 
 
diff --git a/src/OSSupport/IsThread.h b/src/OSSupport/IsThread.h
index b8784ea33..42b8bfdda 100644
--- a/src/OSSupport/IsThread.h
+++ b/src/OSSupport/IsThread.h
@@ -34,7 +34,7 @@ protected:
 	
 public:
 	cIsThread(const AString & iThreadName);
-	~cIsThread();
+	virtual ~cIsThread();
 	
 	/// Starts the thread; returns without waiting for the actual start
 	bool Start(void);
diff --git a/src/OSSupport/Socket.cpp b/src/OSSupport/Socket.cpp
index 6afaceedf..c29e495c3 100644
--- a/src/OSSupport/Socket.cpp
+++ b/src/OSSupport/Socket.cpp
@@ -307,7 +307,8 @@ bool cSocket::ConnectIPv4(const AString & a_HostNameOrAddr, unsigned short a_Por
 			CloseSocket();
 			return false;
 		}
-		addr = *((unsigned long*)hp->h_addr);
+		// Should be optimised to a single word copy
+		memcpy(&addr, hp->h_addr, hp->h_length);
 	}
 
 	sockaddr_in server;
diff --git a/src/OSSupport/SocketThreads.cpp b/src/OSSupport/SocketThreads.cpp
index a02661d2c..0bc1d6b55 100644
--- a/src/OSSupport/SocketThreads.cpp
+++ b/src/OSSupport/SocketThreads.cpp
@@ -54,7 +54,7 @@ bool cSocketThreads::AddClient(const cSocket & a_Socket, cCallback * a_Client)
 	}
 	
 	// No thread has free space, create a new one:
-	LOGD("Creating a new cSocketThread (currently have %d)", m_Threads.size());
+	LOGD("Creating a new cSocketThread (currently have " SIZE_T_FMT ")", m_Threads.size());
 	cSocketThread * Thread = new cSocketThread(this);
 	if (!Thread->Start())
 	{
diff --git a/src/Protocol/Protocol125.cpp b/src/Protocol/Protocol125.cpp
index 50ebb6d43..69f4934d8 100644
--- a/src/Protocol/Protocol125.cpp
+++ b/src/Protocol/Protocol125.cpp
@@ -1269,19 +1269,6 @@ int cProtocol125::ParsePacket(unsigned char a_PacketType)
 
 
 
-#define HANDLE_PACKET_PARSE(Packet) \
-	{ \
-		int res = Packet.Parse(m_ReceivedData); \
-		if (res < 0) \
-		{ \
-			return res; \
-		} \
-	}
-
-
-
-
-
 int cProtocol125::ParseArmAnim(void)
 {
 	HANDLE_PACKET_READ(ReadBEInt, int,  EntityID);
diff --git a/src/Protocol/Protocol132.cpp b/src/Protocol/Protocol132.cpp
index 8df550c7b..be9c503ed 100644
--- a/src/Protocol/Protocol132.cpp
+++ b/src/Protocol/Protocol132.cpp
@@ -100,7 +100,7 @@ cProtocol132::~cProtocol132()
 {
 	if (!m_DataToSend.empty())
 	{
-		LOGD("There are %d unsent bytes while deleting cProtocol132", m_DataToSend.size());
+		LOGD("There are " SIZE_T_FMT " unsent bytes while deleting cProtocol132", m_DataToSend.size());
 	}
 }
 
diff --git a/src/Protocol/Protocol17x.cpp b/src/Protocol/Protocol17x.cpp
index 8c800036e..6fc344eaf 100644
--- a/src/Protocol/Protocol17x.cpp
+++ b/src/Protocol/Protocol17x.cpp
@@ -1251,7 +1251,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
 			ASSERT(m_ReceivedData.GetReadableSpace() == OldReadableSpace);
 			AString Hex;
 			CreateHexDump(Hex, AllData.data(), AllData.size(), 16);
-			m_CommLogFile.Printf("Incoming data, %d (0x%x) unparsed bytes already present in buffer:\n%s\n",
+			m_CommLogFile.Printf("Incoming data, " SIZE_T_FMT " (0x" SIZE_T_FMT_HEX ") unparsed bytes already present in buffer:\n%s\n",
 				AllData.size(), AllData.size(), Hex.c_str()
 			);
 		}
@@ -1344,14 +1344,14 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
 		if (bb.GetReadableSpace() != 1)
 		{
 			// Read more or less than packet length, report as error
-			LOGWARNING("Protocol 1.7: Wrong number of bytes read for packet 0x%x, state %d. Read %u bytes, packet contained %u bytes",
+			LOGWARNING("Protocol 1.7: Wrong number of bytes read for packet 0x%x, state %d. Read " SIZE_T_FMT " bytes, packet contained %u bytes",
 				PacketType, m_State, bb.GetUsedSpace() - bb.GetReadableSpace(), PacketLen
 			);
 
 			// Put a message in the comm log:
 			if (g_ShouldLogCommIn)
 			{
-				m_CommLogFile.Printf("^^^^^^ Wrong number of bytes read for this packet (exp %d left, got %d left) ^^^^^^\n\n\n",
+				m_CommLogFile.Printf("^^^^^^ Wrong number of bytes read for this packet (exp %d left, got " SIZE_T_FMT " left) ^^^^^^\n\n\n",
 					1, bb.GetReadableSpace()
 				);
 				m_CommLogFile.Flush();
@@ -1373,7 +1373,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
 		ASSERT(m_ReceivedData.GetReadableSpace() == OldReadableSpace);
 		AString Hex;
 		CreateHexDump(Hex, AllData.data(), AllData.size(), 16);
-		m_CommLogFile.Printf("There are %d (0x%x) bytes of non-parse-able data left in the buffer:\n%s",
+		m_CommLogFile.Printf("There are " SIZE_T_FMT " (0x" SIZE_T_FMT_HEX ") bytes of non-parse-able data left in the buffer:\n%s",
 			m_ReceivedData.GetReadableSpace(), m_ReceivedData.GetReadableSpace(), Hex.c_str()
 		);
 		m_CommLogFile.Flush();
@@ -2062,7 +2062,7 @@ void cProtocol172::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
 	{
 		AString HexDump;
 		CreateHexDump(HexDump, a_Metadata.data(), a_Metadata.size(), 16);
-		LOGWARNING("Cannot unGZIP item metadata (%u bytes):\n%s", a_Metadata.size(), HexDump.c_str());
+		LOGWARNING("Cannot unGZIP item metadata (" SIZE_T_FMT " bytes):\n%s", a_Metadata.size(), HexDump.c_str());
 		return;
 	}
 	
@@ -2072,7 +2072,7 @@ void cProtocol172::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
 	{
 		AString HexDump;
 		CreateHexDump(HexDump, Uncompressed.data(), Uncompressed.size(), 16);
-		LOGWARNING("Cannot parse NBT item metadata: (%u bytes)\n%s", Uncompressed.size(), HexDump.c_str());
+		LOGWARNING("Cannot parse NBT item metadata: (" SIZE_T_FMT " bytes)\n%s", Uncompressed.size(), HexDump.c_str());
 		return;
 	}
 	
diff --git a/src/Root.cpp b/src/Root.cpp
index 69f18104e..3555afb45 100644
--- a/src/Root.cpp
+++ b/src/Root.cpp
@@ -778,11 +778,11 @@ void cRoot::LogChunkStats(cCommandOutputCallback & a_Output)
 		int Mem = NumValid * sizeof(cChunk);
 		a_Output.Out("  Memory used by chunks: %d KiB (%d MiB)", (Mem + 1023) / 1024, (Mem + 1024 * 1024 - 1) / (1024 * 1024));
 		a_Output.Out("  Per-chunk memory size breakdown:");
-		a_Output.Out("    block types:    %6d bytes (%3d KiB)", sizeof(cChunkDef::BlockTypes), (sizeof(cChunkDef::BlockTypes) + 1023) / 1024);
-		a_Output.Out("    block metadata: %6d bytes (%3d KiB)", sizeof(cChunkDef::BlockNibbles), (sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
-		a_Output.Out("    block lighting: %6d bytes (%3d KiB)", 2 * sizeof(cChunkDef::BlockNibbles), (2 * sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
-		a_Output.Out("    heightmap:      %6d bytes (%3d KiB)", sizeof(cChunkDef::HeightMap), (sizeof(cChunkDef::HeightMap) + 1023) / 1024);
-		a_Output.Out("    biomemap:       %6d bytes (%3d KiB)", sizeof(cChunkDef::BiomeMap), (sizeof(cChunkDef::BiomeMap) + 1023) / 1024);
+		a_Output.Out("    block types:    " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::BlockTypes), (sizeof(cChunkDef::BlockTypes) + 1023) / 1024);
+		a_Output.Out("    block metadata: " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::BlockNibbles), (sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
+		a_Output.Out("    block lighting: " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", 2 * sizeof(cChunkDef::BlockNibbles), (2 * sizeof(cChunkDef::BlockNibbles) + 1023) / 1024);
+		a_Output.Out("    heightmap:      " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::HeightMap), (sizeof(cChunkDef::HeightMap) + 1023) / 1024);
+		a_Output.Out("    biomemap:       " SIZE_T_FMT_PRECISION(6)  " bytes (" SIZE_T_FMT_PRECISION(3)  " KiB)", sizeof(cChunkDef::BiomeMap), (sizeof(cChunkDef::BiomeMap) + 1023) / 1024);
 		int Rest = sizeof(cChunk) - sizeof(cChunkDef::BlockTypes) - 3 * sizeof(cChunkDef::BlockNibbles) - sizeof(cChunkDef::HeightMap) - sizeof(cChunkDef::BiomeMap);
 		a_Output.Out("    other:          %6d bytes (%3d KiB)", Rest, (Rest + 1023) / 1024);
 		SumNumValid += NumValid;
diff --git a/src/Scoreboard.h b/src/Scoreboard.h
index e22ecaeb1..2fae5e499 100644
--- a/src/Scoreboard.h
+++ b/src/Scoreboard.h
@@ -150,6 +150,8 @@ public:
 	/** Removes all registered players */
 	void Reset(void);
 
+	// tolua_begin
+
 	/** Returns the number of registered players */
 	unsigned int GetNumPlayers(void) const;
 
diff --git a/src/Server.cpp b/src/Server.cpp
index fcbcaa919..d1e53bfff 100644
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -24,7 +24,7 @@
 #include "MersenneTwister.h"
 
 #include "inifile/iniFile.h"
-#include "Vector3f.h"
+#include "Vector3.h"
 
 #include <fstream>
 #include <sstream>
@@ -550,7 +550,7 @@ void cServer::PrintHelp(const AStringVector & a_Split, cCommandOutputCallback &
 	for (AStringPairs::const_iterator itr = Callback.m_Commands.begin(), end = Callback.m_Commands.end(); itr != end; ++itr)
 	{
 		const AStringPair & cmd = *itr;
-		a_Output.Out(Printf("%-*s%s\n", Callback.m_MaxLen, cmd.first.c_str(), cmd.second.c_str()));
+		a_Output.Out(Printf("%-*s%s\n", static_cast<int>(Callback.m_MaxLen), cmd.first.c_str(), cmd.second.c_str()));
 	}  // for itr - Callback.m_Commands[]
 	a_Output.Finished();
 }
diff --git a/src/Simulator/FireSimulator.cpp b/src/Simulator/FireSimulator.cpp
index 4967c83f9..26712e6e6 100644
--- a/src/Simulator/FireSimulator.cpp
+++ b/src/Simulator/FireSimulator.cpp
@@ -334,21 +334,33 @@ void cFireSimulator::RemoveFuelNeighbors(cChunk * a_Chunk, int a_RelX, int a_Rel
 	for (size_t i = 0; i < ARRAYCOUNT(gNeighborCoords); i++)
 	{
 		BLOCKTYPE  BlockType;
-		NIBBLETYPE BlockMeta;
-		if (!a_Chunk->UnboundedRelGetBlock(a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z, BlockType, BlockMeta))
+		int X = a_RelX + gNeighborCoords[i].x;
+		int Z = a_RelZ + gNeighborCoords[i].z;
+
+		cChunkPtr Neighbour = a_Chunk->GetRelNeighborChunkAdjustCoords(X, Z);
+		if (Neighbour == NULL)
 		{
-			// Neighbor not accessible, ignore it
 			continue;
 		}
+		BlockType = Neighbour->GetBlock(X, a_RelY + gCrossCoords[i].y, Z);
+
 		if (!IsFuel(BlockType))
 		{
 			continue;
 		}
+
+		if (BlockType == E_BLOCK_TNT)
+		{
+			int AbsX = X + Neighbour->GetPosX() * cChunkDef::Width;
+			int AbsZ = Z + Neighbour->GetPosZ() * cChunkDef::Width;
+
+			m_World.SpawnPrimedTNT(AbsX, a_RelY + gNeighborCoords[i].y, AbsZ, 0);
+			Neighbour->SetBlock(X, a_RelY + gNeighborCoords[i].y, Z, E_BLOCK_AIR, 0);
+			return;
+		}
+
 		bool ShouldReplaceFuel = (m_World.GetTickRandomNumber(MAX_CHANCE_REPLACE_FUEL) < m_ReplaceFuelChance);
-		a_Chunk->UnboundedRelSetBlock(
-			a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z,
-			ShouldReplaceFuel ? E_BLOCK_FIRE : E_BLOCK_AIR, 0
-		);
+		Neighbour->SetBlock(X, a_RelY + gNeighborCoords[i].y, Z, ShouldReplaceFuel ? E_BLOCK_FIRE : E_BLOCK_AIR, 0);
 	}  // for i - Coords[]
 }
 
diff --git a/src/Simulator/IncrementalRedstoneSimulator.cpp b/src/Simulator/IncrementalRedstoneSimulator.cpp
index bbc38259e..92659fab7 100644
--- a/src/Simulator/IncrementalRedstoneSimulator.cpp
+++ b/src/Simulator/IncrementalRedstoneSimulator.cpp
@@ -1062,7 +1062,7 @@ void cIncrementalRedstoneSimulator::HandlePressurePlate(int a_BlockX, int a_Bloc
 				{
 					Vector3f EntityPos = a_Entity->GetPosition();
 					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
-					float Distance = (EntityPos - BlockPos).Length();
+					double Distance = (EntityPos - BlockPos).Length();
 
 					if (Distance <= 0.7)
 					{
diff --git a/src/Simulator/Simulator.cpp b/src/Simulator/Simulator.cpp
index 06fd0f858..0739f0187 100644
--- a/src/Simulator/Simulator.cpp
+++ b/src/Simulator/Simulator.cpp
@@ -3,7 +3,6 @@
 
 #include "Simulator.h"
 #include "../World.h"
-#include "../Vector3i.h"
 #include "../BlockID.h"
 #include "../Defines.h"
 #include "../Chunk.h"
diff --git a/src/Simulator/Simulator.h b/src/Simulator/Simulator.h
index a25b7f1b6..a2e2a5742 100644
--- a/src/Simulator/Simulator.h
+++ b/src/Simulator/Simulator.h
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include "../Vector3i.h"
+#include "../Vector3.h"
 #include "inifile/iniFile.h"
 
 
diff --git a/src/StringUtils.cpp b/src/StringUtils.cpp
index 3fe75d611..3f9275798 100644
--- a/src/StringUtils.cpp
+++ b/src/StringUtils.cpp
@@ -288,13 +288,13 @@ void ReplaceString(AString & iHayStack, const AString & iNeedle, const AString &
 
 
 // Converts a stream of BE shorts into UTF-8 string; returns a ref to a_UTF8
-AString & RawBEToUTF8(short * a_RawData, int a_NumShorts, AString & a_UTF8)
+AString & RawBEToUTF8(const char * a_RawData, int a_NumShorts, AString & a_UTF8)
 {
 	a_UTF8.clear();
 	a_UTF8.reserve(3 * a_NumShorts / 2);  // a quick guess of the resulting size
 	for (int i = 0; i < a_NumShorts; i++)
 	{
-		int c = ntohs(*(a_RawData + i));
+		int c = GetBEShort(&a_RawData[i * 2]);
 		if (c < 0x80)
 		{
 			a_UTF8.push_back((char)c);
@@ -364,10 +364,7 @@ Notice from the original file:
 
 #define UNI_MAX_BMP         0x0000FFFF
 #define UNI_MAX_UTF16       0x0010FFFF
-#define UNI_MAX_UTF32       0x7FFFFFFF
-#define UNI_MAX_LEGAL_UTF32 0x0010FFFF
 #define UNI_SUR_HIGH_START  0xD800
-#define UNI_SUR_HIGH_END    0xDBFF
 #define UNI_SUR_LOW_START   0xDC00
 #define UNI_SUR_LOW_END     0xDFFF
 
diff --git a/src/StringUtils.h b/src/StringUtils.h
index dfbfc2a75..4feff7553 100644
--- a/src/StringUtils.h
+++ b/src/StringUtils.h
@@ -22,16 +22,16 @@ typedef std::list<AString>   AStringList;
 
 
 /** Add the formated string to the existing data in the string */
-extern AString & AppendVPrintf(AString & str, const char * format, va_list args);
+extern AString & AppendVPrintf(AString & str, const char * format, va_list args) FORMATSTRING(2, 0);
 
 /// Output the formatted text into the string
-extern AString & Printf       (AString & str, const char * format, ...);
+extern AString & Printf       (AString & str, const char * format, ...) FORMATSTRING(2, 3);
 
 /// Output the formatted text into string, return string by value
-extern AString Printf(const char * format, ...);
+extern AString Printf(const char * format, ...) FORMATSTRING(1, 2);
 
 /// Add the formatted string to the existing data in the string
-extern AString & AppendPrintf (AString & str, const char * format, ...);
+extern AString & AppendPrintf (AString & str, const char * format, ...) FORMATSTRING(2, 3);
 
 /// Split the string at any of the listed delimiters, return as a stringvector
 extern AStringVector StringSplit(const AString & str, const AString & delim);
@@ -58,7 +58,7 @@ extern unsigned int RateCompareString(const AString & s1, const AString & s2 );
 extern void ReplaceString(AString & iHayStack, const AString & iNeedle, const AString & iReplaceWith);  // tolua_export
 
 /// Converts a stream of BE shorts into UTF-8 string; returns a ref to a_UTF8
-extern AString & RawBEToUTF8(short * a_RawData, int a_NumShorts, AString & a_UTF8);
+extern AString & RawBEToUTF8(const char * a_RawData, int a_NumShorts, AString & a_UTF8);
 
 /// Converts a UTF-8 string into a UTF-16 BE string, packing that back into AString; return a ref to a_UTF16
 extern AString & UTF8ToRawBEUTF16(const char * a_UTF8, size_t a_UTF8Length, AString & a_UTF16);
diff --git a/src/Tracer.cpp b/src/Tracer.cpp
index 968a64439..6da6b2ad7 100644
--- a/src/Tracer.cpp
+++ b/src/Tracer.cpp
@@ -4,10 +4,6 @@
 #include "Tracer.h"
 #include "World.h"
 
-#include "Vector3f.h"
-#include "Vector3i.h"
-#include "Vector3d.h"
-
 #include "Entities/Entity.h"
 
 #ifndef _WIN32
diff --git a/src/Tracer.h b/src/Tracer.h
index 6c2ab6792..bdb080f0d 100644
--- a/src/Tracer.h
+++ b/src/Tracer.h
@@ -1,8 +1,7 @@
 
 #pragma once
 
-#include "Vector3i.h"
-#include "Vector3f.h"
+#include "Vector3.h"
 
 
 
diff --git a/src/UI/Window.cpp b/src/UI/Window.cpp
index 1a8456f70..aae7b99a3 100644
--- a/src/UI/Window.cpp
+++ b/src/UI/Window.cpp
@@ -637,7 +637,7 @@ int cWindow::DistributeItemToSlots(cPlayer & a_Player, const cItem & a_Item, int
 {
 	if ((size_t)(a_Item.m_ItemCount) < a_SlotNums.size())
 	{
-		LOGWARNING("%s: Distributing less items (%d) than slots (%u)", __FUNCTION__, (int)a_Item.m_ItemCount, a_SlotNums.size());
+		LOGWARNING("%s: Distributing less items (%d) than slots (" SIZE_T_FMT  ")", __FUNCTION__, (int)a_Item.m_ItemCount, a_SlotNums.size());
 		// This doesn't seem to happen with the 1.5.1 client, so we don't worry about it for now
 		return 0;
 	}
diff --git a/src/Vector3.h b/src/Vector3.h
new file mode 100644
index 000000000..ba4abe3eb
--- /dev/null
+++ b/src/Vector3.h
@@ -0,0 +1,286 @@
+
+#pragma once
+
+
+
+#define _USE_MATH_DEFINES // Enable non-standard math defines (MSVC)
+#include <math.h>
+
+
+
+
+
+template <typename T>
+// tolua_begin
+class Vector3
+{
+
+	TOLUA_TEMPLATE_BIND((T, int, float, double))
+
+public:
+
+	T x, y, z;
+
+
+	inline Vector3(void) : x(0), y(0), z(0) {}
+	inline Vector3(T a_x, T a_y, T a_z) : x(a_x), y(a_y), z(a_z) {}
+
+
+	// Hardcoded copy constructors (tolua++ does not support function templates .. yet)
+	Vector3(const Vector3<float>  & a_Rhs) : x((T) a_Rhs.x), y((T) a_Rhs.y), z((T) a_Rhs.z) {}
+	Vector3(const Vector3<double> & a_Rhs) : x((T) a_Rhs.x), y((T) a_Rhs.y), z((T) a_Rhs.z) {}
+	Vector3(const Vector3<int>    & a_Rhs) : x((T) a_Rhs.x), y((T) a_Rhs.y), z((T) a_Rhs.z) {}
+
+
+	// tolua_end
+	template <typename _T>
+	Vector3(const Vector3<_T> & a_Rhs) : x(a_Rhs.x), y(a_Rhs.y), z(a_Rhs.z) {}
+
+	template <typename _T>
+	Vector3(const Vector3<_T> * a_Rhs) : x(a_Rhs->x), y(a_Rhs->y), z(a_Rhs->z) {}
+	// tolua_begin
+
+
+	inline void Set(T a_x, T a_y, T a_z)
+	{
+		x = a_x;
+		y = a_y;
+		z = a_z;
+	}
+
+	inline void Normalize(void)
+	{
+		double Len = 1.0 / Length();
+
+		x = (T)(x * Len);
+		y = (T)(y * Len);
+		z = (T)(z * Len);
+	}
+
+	inline Vector3<T> NormalizeCopy(void) const
+	{
+		double Len = 1.0 / Length();
+
+		return Vector3<T>(
+			(T)(x * Len),
+			(T)(y * Len),
+			(T)(z * Len)
+		);
+	}
+
+	inline void NormalizeCopy(Vector3<T> & a_Rhs) const
+	{
+		double Len = 1.0 / Length();
+
+		a_Rhs.Set(
+			(T)(x * Len),
+			(T)(y * Len),
+			(T)(z * Len)
+		);
+	}
+
+	inline double Length(void) const
+	{
+		return sqrt((double)(x * x + y * y + z * z));
+	}
+
+	inline double SqrLength(void) const
+	{
+		return x * x + y * y + z * z;
+	}
+
+	inline T Dot(const Vector3<T> & a_Rhs) const
+	{
+		return x * a_Rhs.x + y * a_Rhs.y + z * a_Rhs.z;
+	}
+
+	inline Vector3<T> Cross(const Vector3<T> & a_Rhs) const
+	{
+		return Vector3<T>(
+			y * a_Rhs.z - z * a_Rhs.y,
+			z * a_Rhs.x - x * a_Rhs.z,
+			x * a_Rhs.y - y * a_Rhs.x
+		);
+	}
+
+	inline bool Equals(const Vector3<T> & a_Rhs) const
+	{
+		return x == a_Rhs.x && y == a_Rhs.y && z == a_Rhs.z;
+	}
+
+	inline bool operator < (const Vector3<T> & a_Rhs)
+	{
+		// return (x < a_Rhs.x) && (y < a_Rhs.y) && (z < a_Rhs.z); ?
+		return (x < a_Rhs.x) || (x == a_Rhs.x && y < a_Rhs.y) || (x == a_Rhs.x && y == a_Rhs.y && z < a_Rhs.z);
+	}
+
+	inline void Move(T a_X, T a_Y, T a_Z)
+	{
+		x += a_X;
+		y += a_Y;
+		z += a_Z;
+	}
+
+	// tolua_end
+
+	inline void operator += (const Vector3<T> & a_Rhs)
+	{
+		x += a_Rhs.x;
+		y += a_Rhs.y;
+		z += a_Rhs.z;
+	}
+
+	inline void operator -= (const Vector3<T> & a_Rhs)
+	{
+		x -= a_Rhs.x;
+		y -= a_Rhs.y;
+		z -= a_Rhs.z;
+	}
+
+	inline void operator *= (const Vector3<T> & a_Rhs)
+	{
+		x *= a_Rhs.x;
+		y *= a_Rhs.y;
+		z *= a_Rhs.z;
+	}
+
+	inline void operator *= (T a_v)
+	{
+		x *= a_v;
+		y *= a_v;
+		z *= a_v;
+	}
+
+	// tolua_begin
+
+	inline Vector3<T> operator + (const Vector3<T>& a_Rhs) const
+	{
+		return Vector3<T>(
+			x + a_Rhs.x,
+			y + a_Rhs.y,
+			z + a_Rhs.z
+		);
+	}
+
+	inline Vector3<T> operator - (const Vector3<T>& a_Rhs) const
+	{
+		return Vector3<T>(
+			x - a_Rhs.x,
+			y - a_Rhs.y,
+			z - a_Rhs.z
+		);
+	}
+
+	inline Vector3<T> operator * (const Vector3<T>& a_Rhs) const
+	{
+		return Vector3<T>(
+			x * a_Rhs.x,
+			y * a_Rhs.y,
+			z * a_Rhs.z
+		);
+	}
+
+	inline Vector3<T> operator * (T a_v) const
+	{
+		return Vector3<T>(
+			x * a_v,
+			y * a_v,
+			z * a_v
+		);
+	}
+
+	inline Vector3<T> operator / (T a_v) const
+	{
+		return Vector3<T>(
+			x / a_v,
+			y / a_v,
+			z / a_v
+		);
+	}
+
+	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Z coord.
+	The result satisfies the following equation:
+	(*this + Result * (a_OtherEnd - *this)).z = a_Z
+	If the line is too close to being parallel, this function returns NO_INTERSECTION
+	*/
+	inline double LineCoeffToXYPlane(const Vector3<T> & a_OtherEnd, T a_Z) const
+	{
+		if (abs(z - a_OtherEnd.z) < EPS)
+		{
+			return NO_INTERSECTION;
+		}
+
+		return (a_Z - z) / (a_OtherEnd.z - z);
+	}
+
+	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Y coord.
+	The result satisfies the following equation:
+	(*this + Result * (a_OtherEnd - *this)).y = a_Y
+	If the line is too close to being parallel, this function returns NO_INTERSECTION
+	*/
+	inline double LineCoeffToXZPlane(const Vector3<T> & a_OtherEnd, T a_Y) const
+	{
+		if (abs(y - a_OtherEnd.y) < EPS)
+		{
+			return NO_INTERSECTION;
+		}
+
+		return (a_Y - y) / (a_OtherEnd.y - y);
+	}
+
+	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified X coord.
+	The result satisfies the following equation:
+	(*this + Result * (a_OtherEnd - *this)).x = a_X
+	If the line is too close to being parallel, this function returns NO_INTERSECTION
+	*/
+	inline double LineCoeffToYZPlane(const Vector3<T> & a_OtherEnd, T a_X) const
+	{
+		if (abs(x - a_OtherEnd.x) < EPS)
+		{
+			return NO_INTERSECTION;
+		}
+
+		return (a_X - x) / (a_OtherEnd.x - x);
+	}
+
+	/** The max difference between two coords for which the coords are assumed equal. */
+	static const double EPS;
+
+	/** Return value of LineCoeffToPlane() if the line is parallel to the plane. */
+	static const double NO_INTERSECTION;
+
+};
+// tolua_end
+
+
+
+
+
+template <typename T>
+const double Vector3<T>::EPS = 0.000001;
+
+template <typename T>
+const double Vector3<T>::NO_INTERSECTION = 1e70;
+
+
+
+
+
+// tolua_begin
+typedef Vector3<double> Vector3d;
+typedef Vector3<float>  Vector3f;
+typedef Vector3<int>    Vector3i;
+// tolua_end
+
+
+
+
+
+typedef std::list<Vector3i>   cVector3iList;
+typedef std::vector<Vector3i> cVector3iArray;
+
+
+
+
+
+
diff --git a/src/Vector3d.cpp b/src/Vector3d.cpp
deleted file mode 100644
index 96ebebab5..000000000
--- a/src/Vector3d.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Vector3d.h"
-#include "Vector3f.h"
-
-
-
-
-
-const double Vector3d::EPS = 0.000001;          ///< The max difference between two coords for which the coords are assumed equal
-const double Vector3d::NO_INTERSECTION = 1e70;  ///< Return value of LineCoeffToPlane() if the line is parallel to the plane
-
-
-
-
-
-Vector3d::Vector3d(const Vector3f & v) :
-	x(v.x),
-	y(v.y),
-	z(v.z)
-{
-}
-
-
-
-
-
-Vector3d::Vector3d(const Vector3f * v) :
-	x(v->x),
-	y(v->y),
-	z(v->z)
-{
-}
-
-
-
-
-
-double Vector3d::LineCoeffToXYPlane(const Vector3d & a_OtherEnd, double a_Z) const
-{
-	if (abs(z - a_OtherEnd.z) < EPS)
-	{
-		return NO_INTERSECTION;
-	}
-	return (a_Z - z) / (a_OtherEnd.z - z);
-}
-
-
-
-
-
-double Vector3d::LineCoeffToXZPlane(const Vector3d & a_OtherEnd, double a_Y) const
-{
-	if (abs(y - a_OtherEnd.y) < EPS)
-	{
-		return NO_INTERSECTION;
-	}
-	return (a_Y - y) / (a_OtherEnd.y - y);
-}
-
-
-
-
-
-double Vector3d::LineCoeffToYZPlane(const Vector3d & a_OtherEnd, double a_X) const
-{
-	if (abs(x - a_OtherEnd.x) < EPS)
-	{
-		return NO_INTERSECTION;
-	}
-	return (a_X - x) / (a_OtherEnd.x - x);
-}
-
-
-
-
diff --git a/src/Vector3d.h b/src/Vector3d.h
deleted file mode 100644
index a06a17c09..000000000
--- a/src/Vector3d.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-class Vector3f;
-
-
-
-// tolua_begin
-
-class Vector3d
-{
-public:
-	// convert from float
-	Vector3d(const Vector3f & v);
-	Vector3d(const Vector3f * v);
-
-	Vector3d() : x(0), y(0), z(0) {}
-	Vector3d(double a_x, double a_y, double a_z) : x(a_x), y(a_y), z(a_z) {}
-
-	inline void Set(double a_x, double a_y, double a_z) { x = a_x, y = a_y, z = a_z; }
-	inline void Normalize() { double l = 1.0f / Length(); x *= l; y *= l; z *= l; }
-	inline Vector3d NormalizeCopy() { double l = 1.0f / Length(); return Vector3d( x * l, y * l, z * l ); }
-	inline void NormalizeCopy(Vector3d & a_V) { double l = 1.0f / Length(); a_V.Set(x*l, y*l, z*l ); }
-	inline double Length() const { return (double)sqrt( x * x + y * y + z * z ); }
-	inline double SqrLength() const { return x * x + y * y + z * z; }
-	inline double Dot( const Vector3d & a_V ) const { return x * a_V.x + y * a_V.y + z * a_V.z; }
-	inline Vector3d Cross( const Vector3d & v ) const { return Vector3d( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
-	
-	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Z coord
-	The result satisfies the following equation:
-	(*this + Result * (a_OtherEnd - *this)).z = a_Z
-	If the line is too close to being parallel, this function returns NO_INTERSECTION
-	*/
-	double LineCoeffToXYPlane(const Vector3d & a_OtherEnd, double a_Z) const;
-
-	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified Y coord
-	The result satisfies the following equation:
-	(*this + Result * (a_OtherEnd - *this)).y = a_Y
-	If the line is too close to being parallel, this function returns NO_INTERSECTION
-	*/
-	double LineCoeffToXZPlane(const Vector3d & a_OtherEnd, double a_Y) const;
-
-	/** Returns the coefficient for the (a_OtherEnd - this) line to reach the specified X coord
-	The result satisfies the following equation:
-	(*this + Result * (a_OtherEnd - *this)).x = a_X
-	If the line is too close to being parallel, this function returns NO_INTERSECTION
-	*/
-	double LineCoeffToYZPlane(const Vector3d & a_OtherEnd, double a_X) const;
-
-	inline bool Equals(const Vector3d & v) const { return ((x == v.x) && (y == v.y) && (z == v.z)); }
-	
-	// tolua_end
-
-	void operator += ( const Vector3d& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
-	void operator += ( Vector3d* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
-	void operator -= ( const Vector3d& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
-	void operator -= ( Vector3d* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
-	void operator *= ( double a_f ) { x *= a_f; y *= a_f; z *= a_f; }
-
-	// tolua_begin
-	
-	Vector3d operator + (const Vector3d & v2) const { return Vector3d(x + v2.x, y + v2.y, z + v2.z ); }
-	Vector3d operator + (const Vector3d * v2) const { return Vector3d(x + v2->x, y + v2->y, z + v2->z ); }
-	Vector3d operator - (const Vector3d & v2) const { return Vector3d(x - v2.x, y - v2.y, z - v2.z ); }
-	Vector3d operator - (const Vector3d * v2) const { return Vector3d(x - v2->x, y - v2->y, z - v2->z ); }
-	Vector3d operator * (const double f)      const { return Vector3d(x * f, y * f, z * f ); }
-	Vector3d operator * (const Vector3d & v2) const { return Vector3d(x * v2.x, y * v2.y, z * v2.z ); }
-	Vector3d operator / (const double f)      const { return Vector3d(x / f, y / f, z / f ); }
-
-	double x, y, z;
-
-	static const double EPS;              ///< The max difference between two coords for which the coords are assumed equal
-	static const double NO_INTERSECTION;  ///< Return value of LineCoeffToPlane() if the line is parallel to the plane
-} ;
-
-// tolua_end
-
-
-
-
diff --git a/src/Vector3f.cpp b/src/Vector3f.cpp
deleted file mode 100644
index 59d71d371..000000000
--- a/src/Vector3f.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Vector3f.h"
-#include "Vector3d.h"
-#include "Vector3i.h"
-
-Vector3f::Vector3f( const Vector3d & v )
-	: x( (float)v.x )
-	, y( (float)v.y )
-	, z( (float)v.z )
-{
-}
-
-Vector3f::Vector3f( const Vector3d * v )
-	: x( (float)v->x )
-	, y( (float)v->y )
-	, z( (float)v->z )
-{
-}
-
-Vector3f::Vector3f( const Vector3i & v )
-	: x( (float)v.x )
-	, y( (float)v.y )
-	, z( (float)v.z )
-{
-}
-
-Vector3f::Vector3f( const Vector3i * v )
-	: x( (float)v->x )
-	, y( (float)v->y )
-	, z( (float)v->z )
-{
-}
\ No newline at end of file
diff --git a/src/Vector3f.h b/src/Vector3f.h
deleted file mode 100644
index adb154ad7..000000000
--- a/src/Vector3f.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-class Vector3i;
-class Vector3d;
-class Vector3f	// tolua_export
-{				// tolua_export
-public:			// tolua_export
-	Vector3f( const Vector3d & v );	// tolua_export
-	Vector3f( const Vector3d * v );	// tolua_export
-	Vector3f( const Vector3i & v );	// tolua_export
-	Vector3f( const Vector3i * v );	// tolua_export
-
-
-	Vector3f() : x(0), y(0), z(0) {}																			// tolua_export
-	Vector3f(float a_x, float a_y, float a_z) : x(a_x), y(a_y), z(a_z) {}										// tolua_export
-
-	inline void Set(float a_x, float a_y, float a_z) { x = a_x, y = a_y, z = a_z; }								// tolua_export
-	inline void Normalize() { float l = 1.0f / Length(); x *= l; y *= l; z *= l; }								// tolua_export
-	inline Vector3f NormalizeCopy() const { float l = 1.0f / Length(); return Vector3f( x * l, y * l, z * l ); }// tolua_export
-	inline void NormalizeCopy(Vector3f & a_V) const { float l = 1.0f / Length(); a_V.Set(x*l, y*l, z*l ); }		// tolua_export
-	inline float Length() const { return (float)sqrtf( x * x + y * y + z * z ); }								// tolua_export
-	inline float SqrLength() const { return x * x + y * y + z * z; }											// tolua_export
-	inline float Dot( const Vector3f & a_V ) const { return x * a_V.x + y * a_V.y + z * a_V.z; }				// tolua_export
-	inline Vector3f Cross( const Vector3f & v ) const { return Vector3f( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }	// tolua_export
-
-	inline bool Equals( const Vector3f & v ) const { return (x == v.x && y == v.y && z == v.z ); }										// tolua_export
-
-	void operator += ( const Vector3f& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
-	void operator += ( Vector3f* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
-	void operator -= ( const Vector3f& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
-	void operator -= ( Vector3f* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
-	void operator *= ( float a_f ) { x *= a_f; y *= a_f; z *= a_f; }
-	void operator *= ( Vector3f* a_V ) { x *= a_V->x; y *= a_V->y; z *= a_V->z; }
-	void operator *= ( const Vector3f& a_V ) { x *= a_V.x; y *= a_V.y; z *= a_V.z; }
-
-	Vector3f operator + ( const Vector3f& v2 ) const { return Vector3f( x + v2.x, y + v2.y, z + v2.z ); }									// tolua_export
-	Vector3f operator + ( const Vector3f* v2 ) const { return Vector3f( x + v2->x, y + v2->y, z + v2->z ); }								// tolua_export
-	Vector3f operator - ( const Vector3f& v2 ) const { return Vector3f( x - v2.x, y - v2.y, z - v2.z ); }									// tolua_export
-	Vector3f operator - ( const Vector3f* v2 ) const { return Vector3f( x - v2->x, y - v2->y, z - v2->z ); }								// tolua_export
-	Vector3f operator * ( const float f ) const { return Vector3f( x * f, y * f, z * f ); }												// tolua_export
-	Vector3f operator * ( const Vector3f& v2 ) const { return Vector3f( x * v2.x, y * v2.y, z * v2.z ); }									// tolua_export
-
-	float x, y, z;	// tolua_export
-
-};// tolua_export
diff --git a/src/Vector3i.cpp b/src/Vector3i.cpp
deleted file mode 100644
index 4ce1e2cf3..000000000
--- a/src/Vector3i.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Vector3i.h"
-#include "Vector3d.h"
-
-
-
-
-
-Vector3i::Vector3i( const Vector3d & v )
-	: x( (int)v.x )
-	, y( (int)v.y )
-	, z( (int)v.z )
-{
-}
\ No newline at end of file
diff --git a/src/Vector3i.h b/src/Vector3i.h
deleted file mode 100644
index 7d726a7b3..000000000
--- a/src/Vector3i.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-class Vector3d;
-class Vector3i	// tolua_export
-{				// tolua_export
-public:			// tolua_export
-	Vector3i( const Vector3d & v );														// tolua_export
-
-	Vector3i() : x(0), y(0), z(0) {}													// tolua_export
-	Vector3i(int a_x, int a_y, int a_z) : x(a_x), y(a_y), z(a_z) {}						// tolua_export
-
-	inline void Set(int a_x, int a_y, int a_z) { x = a_x, y = a_y, z = a_z; }			// tolua_export
-	inline float Length() const { return sqrtf( (float)( x * x + y * y + z * z) ); }	// tolua_export
-	inline int SqrLength() const { return x * x + y * y + z * z; }						// tolua_export
-
-	inline bool Equals( const Vector3i & v ) const { return (x == v.x && y == v.y && z == v.z ); }		// tolua_export
-	inline bool Equals( const Vector3i * v ) const { return (x == v->x && y == v->y && z == v->z ); }	// tolua_export
-
-	void operator += ( const Vector3i& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
-	void operator += ( Vector3i* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
-	void operator -= ( const Vector3i& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
-	void operator -= ( Vector3i* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
-	void operator *= ( int a_f ) { x *= a_f; y *= a_f; z *= a_f; }
-
-	friend Vector3i operator + ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z ); }
-	friend Vector3i operator + ( const Vector3i& v1, Vector3i* v2 ) { return Vector3i( v1.x + v2->x, v1.y + v2->y, v1.z + v2->z ); }
-	friend Vector3i operator - ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z ); }
-	friend Vector3i operator - ( const Vector3i& v1, Vector3i* v2 ) { return Vector3i( v1.x - v2->x, v1.y - v2->y, v1.z - v2->z ); }
-	friend Vector3i operator - ( const Vector3i* v1, Vector3i& v2 ) { return Vector3i( v1->x - v2.x, v1->y - v2.y, v1->z - v2.z ); }
-	friend Vector3i operator * ( const Vector3i& v, const int f ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }
-	friend Vector3i operator * ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x * v2.x, v1.y * v2.y, v1.z * v2.z ); }
-	friend Vector3i operator * ( const int f, const Vector3i& v ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }
-	friend bool operator < ( const Vector3i& v1, const Vector3i& v2 ) { return (v1.x<v2.x)||(v1.x==v2.x && v1.y<v2.y)||(v1.x==v2.x && v1.y == v2.y && v1.z<v2.z); }
-
-	int x, y, z;	// tolua_export
-};	// tolua_export
-
-typedef std::list<Vector3i>   cVector3iList;
-typedef std::vector<Vector3i> cVector3iArray;
-
-
-
-
diff --git a/src/WebAdmin.cpp b/src/WebAdmin.cpp
index e88de5947..402cd3035 100644
--- a/src/WebAdmin.cpp
+++ b/src/WebAdmin.cpp
@@ -127,6 +127,7 @@ bool cWebAdmin::Start(void)
 
 	// Initialize the WebAdmin template script and load the file
 	m_TemplateScript.Create();
+	m_TemplateScript.RegisterAPILibs();
 	if (!m_TemplateScript.LoadFile(FILE_IO_PREFIX "webadmin/template.lua"))
 	{
 		LOGWARN("Could not load WebAdmin template \"%s\", using default template.", FILE_IO_PREFIX "webadmin/template.lua");
diff --git a/src/World.cpp b/src/World.cpp
index 18109b2af..22bc406e0 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -46,7 +46,6 @@
 #include "Generating/Trees.h"
 #include "Bindings/PluginManager.h"
 #include "Blocks/BlockHandler.h"
-#include "Vector3d.h"
 
 #include "Tracer.h"
 
@@ -103,7 +102,7 @@ protected:
 	{
 		for (;;)
 		{
-			LOG("%d chunks to load, %d chunks to generate", 
+			LOG("" SIZE_T_FMT  " chunks to load, %d chunks to generate", 
 				m_World->GetStorage().GetLoadQueueLength(),
 				m_World->GetGenerator().GetQueueLength()
 			);
@@ -155,7 +154,7 @@ protected:
 	{
 		for (;;)
 		{
-			LOG("%d chunks remaining to light", m_Lighting->GetQueueLength()
+			LOG("" SIZE_T_FMT  " chunks remaining to light", m_Lighting->GetQueueLength()
 			);
 			
 			// Wait for 2 sec, but be "reasonably wakeable" when the thread is to finish
@@ -2459,14 +2458,14 @@ cPlayer * cWorld::FindClosestPlayer(const Vector3d & a_Pos, float a_SightLimit,
 {
 	cTracer LineOfSight(this);
 
-	float ClosestDistance = a_SightLimit;
-	cPlayer* ClosestPlayer = NULL;
+	double ClosestDistance = a_SightLimit;
+	cPlayer * ClosestPlayer = NULL;
 
 	cCSLock Lock(m_CSPlayers);
 	for (cPlayerList::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
 	{
 		Vector3f Pos = (*itr)->GetPosition();
-		float Distance = (Pos - a_Pos).Length();
+		double Distance = (Pos - a_Pos).Length();
 
 		if (Distance < ClosestDistance)
 		{
diff --git a/src/World.h b/src/World.h
index 2804e8386..21c6ea01c 100644
--- a/src/World.h
+++ b/src/World.h
@@ -14,8 +14,7 @@
 #include "ChunkMap.h"
 #include "WorldStorage/WorldStorage.h"
 #include "Generating/ChunkGenerator.h"
-#include "Vector3i.h"
-#include "Vector3f.h"
+#include "Vector3.h"
 #include "ChunkSender.h"
 #include "Defines.h"
 #include "LightingThread.h"
@@ -126,15 +125,16 @@ public:
 	// tolua_begin
 
 	int GetTicksUntilWeatherChange(void) const { return m_WeatherInterval; }
-	virtual Int64 GetWorldAge(void)  const { return m_WorldAge; }
-	virtual Int64 GetTimeOfDay(void) const { return m_TimeOfDay; }
+	
+	virtual Int64 GetWorldAge (void) const { return m_WorldAge; }   // override, cannot specify due to tolua
+	virtual Int64 GetTimeOfDay(void) const { return m_TimeOfDay; }  // override, cannot specify due to tolua
 	
 	void SetTicksUntilWeatherChange(int a_WeatherInterval)
 	{
 		m_WeatherInterval = a_WeatherInterval;
 	}
 
-	void SetTimeOfDay(Int64 a_TimeOfDay)
+	virtual void SetTimeOfDay(Int64 a_TimeOfDay)  // override, cannot specify due to tolua
 	{
 		m_TimeOfDay = a_TimeOfDay;
 		m_TimeOfDaySecs = (double)a_TimeOfDay / 20.0;
@@ -192,35 +192,35 @@ public:
 	void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = NULL);
 	// tolua_end
 
-	void BroadcastChunkData          (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectPickup      (const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastDestroyEntity      (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEffect       (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEquipment    (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityHeadLook     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityMetadata     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMove      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMoveLook  (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityStatus       (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityVelocity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL);
-	void BroadcastParticleEffect     (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL); // tolua_export
-	void BroadcastPlayerListItem     (const cPlayer & a_Player, bool a_IsOnline, const cClientHandle * a_Exclude = NULL);
-	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
-	void BroadcastScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
-	void BroadcastScoreUpdate        (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
-	void BroadcastDisplayObjective   (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
-	void BroadcastSoundEffect        (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export a_Src coords are Block * 8
-	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL); // tolua_export
-	void BroadcastSpawnEntity        (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTeleportEntity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastThunderbolt        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTimeUpdate         (const cClientHandle * a_Exclude = NULL);
-	virtual void BroadcastUseBed             (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ );
-	void BroadcastWeather            (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
-	
-	virtual cBroadcastInterface & GetBroadcastManager()
+	void BroadcastChunkData              (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
+	void BroadcastCollectPickup          (const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastDestroyEntity          (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityEffect           (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityEquipment        (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityHeadLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityMetadata         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityRelMove          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityRelMoveLook      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityStatus           (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityVelocity         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) override;
+	void BroadcastParticleEffect         (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL); // tolua_export
+	void BroadcastPlayerListItem         (const cPlayer & a_Player, bool a_IsOnline, const cClientHandle * a_Exclude = NULL);
+	void BroadcastRemoveEntityEffect     (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
+	void BroadcastScoreboardObjective    (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
+	void BroadcastScoreUpdate            (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
+	void BroadcastDisplayObjective       (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
+	void BroadcastSoundEffect            (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export a_Src coords are Block * 8
+	void BroadcastSoundParticleEffect    (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL); // tolua_export
+	void BroadcastSpawnEntity            (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastTeleportEntity         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastThunderbolt            (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastTimeUpdate             (const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastUseBed         (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	void BroadcastWeather                (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
+	
+	virtual cBroadcastInterface & GetBroadcastManager(void) override
 	{
 		return *this;
 	}
@@ -274,7 +274,7 @@ public:
 	void RemovePlayer( cPlayer* a_Player );
 
 	/** Calls the callback for each player in the list; returns true if all players processed, false if the callback aborted by returning true */
-	bool ForEachPlayer(cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
+	virtual bool ForEachPlayer(cPlayerListCallback & a_Callback) override;  // >> EXPORTED IN MANUALBINDINGS <<
 
 	/** Calls the callback for the player of the given name; returns true if the player was found and the callback called, false if player not found. Callback return ignored */
 	bool DoWithPlayer(const AString & a_PlayerName, cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
@@ -366,7 +366,7 @@ public:
 	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 	
 	/** Calls the callback for each chunk in the coords specified (all cords are inclusive). Returns true if all chunks have been processed successfully */
-	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback);
+	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override;
 
 	// tolua_begin
 	
@@ -457,7 +457,7 @@ public:
 	
 	// tolua_begin
 	bool DigBlock   (int a_X, int a_Y, int a_Z);
-	virtual void SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer * a_Player);
+	virtual void SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer * a_Player);  // override, cannot specify due to tolua
 
 	double GetSpawnX(void) const { return m_SpawnX; }
 	double GetSpawnY(void) const { return m_SpawnY; }
@@ -508,7 +508,7 @@ public:
 	| esWitherBirth | TBD |
 	| esPlugin | void * |
 	*/
-	virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData);  // tolua_export
+	virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData);  // tolua_export  // override, cannot specify due to tolua
 
 	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
 	bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback & a_Callback);  // Exported in ManualBindings.cpp
@@ -707,7 +707,7 @@ public:
 	bool IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ);  // tolua_export
 	
 	/** Spawns a mob of the specified type. Returns the mob's EntityID if recognized and spawned, <0 otherwise */
-	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType);  // tolua_export
+	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType);  // tolua_export  // override, cannot specify due to tolua
 	int SpawnMobFinalize(cMonster* a_Monster);
 	
 	/** Creates a projectile of the specified type. Returns the projectile's EntityID if successful, <0 otherwise */
diff --git a/src/WorldStorage/FastNBT.cpp b/src/WorldStorage/FastNBT.cpp
index 8f80c3f75..be25fd1a4 100644
--- a/src/WorldStorage/FastNBT.cpp
+++ b/src/WorldStorage/FastNBT.cpp
@@ -506,22 +506,18 @@ void cFastNBTWriter::AddIntArray(const AString & a_Name, const int * a_Value, si
 {
 	TagCommon(a_Name, TAG_IntArray);
 	Int32 len = htonl(a_NumElements);
+	size_t cap = m_Result.capacity();
+	size_t size = m_Result.length();
+	if ((cap - size) < (4 + a_NumElements * 4))
+	{
+		m_Result.reserve(size + 4 + (a_NumElements * 4));
+	}
 	m_Result.append((const char *)&len, 4);
-#if defined(ANDROID_NDK)
-	// Android has alignment issues - cannot byteswap (htonl) an int that is not 32-bit-aligned, which happens in the regular version
 	for (size_t i = 0; i < a_NumElements; i++)
 	{
 		int Element = htonl(a_Value[i]);
 		m_Result.append((const char *)&Element, 4);
 	}
-#else
-	int * Elements = (int *)(m_Result.data() + m_Result.size());
-	m_Result.append(a_NumElements * 4, (char)0);
-	for (size_t i = 0; i < a_NumElements; i++)
-	{
-		Elements[i] = htonl(a_Value[i]);
-	}
-#endif
 }
 
 
diff --git a/src/WorldStorage/FireworksSerializer.cpp b/src/WorldStorage/FireworksSerializer.cpp
index 1f05b470d..744fc731f 100644
--- a/src/WorldStorage/FireworksSerializer.cpp
+++ b/src/WorldStorage/FireworksSerializer.cpp
@@ -20,8 +20,14 @@ void cFireworkItem::WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFa
 			a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
 			a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
 			a_Writer.AddByte("Type", a_FireworkItem.m_Type);
-			a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
-			a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
+			if (!a_FireworkItem.m_Colours.empty())
+			{
+				a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
+			}
+			if (!a_FireworkItem.m_FadeColours.empty())
+			{
+				a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
+			}
 			a_Writer.EndCompound();
 			a_Writer.EndList();
 			a_Writer.EndCompound();
@@ -90,30 +96,34 @@ void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNB
 					if (ExplosionName == "Colors")
 					{
 						// Divide by four as data length returned in bytes
-						int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
+						int DataLength = a_NBT.GetDataLength(explosiontag);
+						// round to the next highest multiple of four
+						DataLength -= DataLength % 4; 
 						if (DataLength == 0)
 						{
 							continue;
 						}
 
-						const int * ColourData = (const int *)(a_NBT.GetData(explosiontag));
-						for (int i = 0; i < DataLength; i++)
+						const char * ColourData = (a_NBT.GetData(explosiontag));
+						for (int i = 0; i < DataLength; i += 4 /* Size of network int*/)
 						{
-							a_FireworkItem.m_Colours.push_back(ntohl(ColourData[i]));
+							a_FireworkItem.m_Colours.push_back(GetBEInt(ColourData + i));
 						}
 					}
 					else if (ExplosionName == "FadeColors")
 					{
 						int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
+						// round to the next highest multiple of four
+						DataLength -= DataLength % 4; 
 						if (DataLength == 0)
 						{
 							continue;
 						}
 
-						const int * FadeColourData = (const int *)(a_NBT.GetData(explosiontag));
-						for (int i = 0; i < DataLength; i++)
+						const char * FadeColourData = (a_NBT.GetData(explosiontag));
+						for (int i = 0; i < DataLength; i += 4 /* Size of network int*/)
 						{
-							a_FireworkItem.m_FadeColours.push_back(ntohl(FadeColourData[i]));
+							a_FireworkItem.m_FadeColours.push_back(GetBEInt(FadeColourData + i));
 						}
 					}
 				}
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index 4cf3c62d7..acca96ba8 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -29,6 +29,9 @@
 #include "../Entities/Pickup.h"
 #include "../Entities/ProjectileEntity.h"
 #include "../Entities/TNTEntity.h"
+#include "../Entities/ExpOrb.h"
+#include "../Entities/HangingEntity.h"
+#include "../Entities/ItemFrame.h"
 
 #include "../Mobs/Monster.h"
 #include "../Mobs/Bat.h"
@@ -526,8 +529,8 @@ void cNBTChunkSerializer::AddPickupEntity(cPickup * a_Pickup)
 	m_Writer.BeginCompound("");
 		AddBasicEntity(a_Pickup, "Item");
 		AddItem(a_Pickup->GetItem(), -1, "Item");
-		m_Writer.AddShort("Health", a_Pickup->GetHealth());
-		m_Writer.AddShort("Age",    a_Pickup->GetAge());
+		m_Writer.AddShort("Health", (Int16)(unsigned char)a_Pickup->GetHealth());
+		m_Writer.AddShort("Age",    (Int16)a_Pickup->GetAge());
 	m_Writer.EndCompound();
 }
 
@@ -592,6 +595,25 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
 
 
 
+void cNBTChunkSerializer::AddHangingEntity(cHangingEntity * a_Hanging)
+{
+	m_Writer.AddByte("Direction", (unsigned char)a_Hanging->GetDirection());
+	m_Writer.AddInt("TileX", a_Hanging->GetTileX());
+	m_Writer.AddInt("TileY", a_Hanging->GetTileY());
+	m_Writer.AddInt("TileZ", a_Hanging->GetTileZ());
+	switch (a_Hanging->GetDirection())
+	{
+		case 0:    m_Writer.AddByte("Dir", (unsigned char)2); break;
+		case 1:    m_Writer.AddByte("Dir", (unsigned char)1); break;
+		case 2:    m_Writer.AddByte("Dir", (unsigned char)0); break;
+		case 3:    m_Writer.AddByte("Dir", (unsigned char)3); break;
+	}
+}
+
+
+
+
+
 void cNBTChunkSerializer::AddTNTEntity(cTNTEntity * a_TNT)
 {
 	m_Writer.BeginCompound("");
@@ -604,6 +626,35 @@ void cNBTChunkSerializer::AddTNTEntity(cTNTEntity * a_TNT)
 
 
 
+void cNBTChunkSerializer::AddExpOrbEntity(cExpOrb * a_ExpOrb)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_ExpOrb, "XPOrb");
+		m_Writer.AddShort("Health", (Int16)(unsigned char)a_ExpOrb->GetHealth());
+		m_Writer.AddShort("Age", (Int16)a_ExpOrb->GetAge());
+		m_Writer.AddShort("Value", (Int16)a_ExpOrb->GetReward());
+	m_Writer.EndCompound();
+}
+
+
+
+
+
+void cNBTChunkSerializer::AddItemFrameEntity(cItemFrame * a_ItemFrame)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_ItemFrame, "ItemFrame");
+		AddHangingEntity(a_ItemFrame);
+		AddItem(a_ItemFrame->GetItem(), -1, "Item");
+		m_Writer.AddByte("ItemRotation", (unsigned char)a_ItemFrame->GetRotation());
+		m_Writer.AddFloat("ItemDropChance", 1.0F);
+	m_Writer.EndCompound();
+}
+
+
+
+
+
 void cNBTChunkSerializer::AddMinecartChestContents(cMinecartWithChest * a_Minecart)
 {
 	m_Writer.BeginList("Items", TAG_Compound);
@@ -684,8 +735,8 @@ void cNBTChunkSerializer::Entity(cEntity * a_Entity)
 		case cEntity::etPickup:       AddPickupEntity      ((cPickup *)          a_Entity); break;
 		case cEntity::etProjectile:   AddProjectileEntity  ((cProjectileEntity *)a_Entity); break;
 		case cEntity::etTNT:          AddTNTEntity         ((cTNTEntity *)       a_Entity); break;
-		case cEntity::etExpOrb: /* TODO */ break;
-		case cEntity::etItemFrame: /* TODO */ break;
+		case cEntity::etExpOrb:       AddExpOrbEntity      ((cExpOrb *)          a_Entity); break;
+		case cEntity::etItemFrame:    AddItemFrameEntity   ((cItemFrame *)       a_Entity); break;
 		case cEntity::etPainting: /* TODO */ break;
 		case cEntity::etPlayer: return;  // Players aren't saved into the world
 		default:
diff --git a/src/WorldStorage/NBTChunkSerializer.h b/src/WorldStorage/NBTChunkSerializer.h
index 3b486d2bc..c1134cd00 100644
--- a/src/WorldStorage/NBTChunkSerializer.h
+++ b/src/WorldStorage/NBTChunkSerializer.h
@@ -42,6 +42,9 @@ class cPickup;
 class cItemGrid;
 class cProjectileEntity;
 class cTNTEntity;
+class cExpOrb;
+class cHangingEntity;
+class cItemFrame;
 
 
 
@@ -108,7 +111,10 @@ protected:
 	void AddMonsterEntity     (cMonster * a_Monster);
 	void AddPickupEntity      (cPickup * a_Pickup);
 	void AddProjectileEntity  (cProjectileEntity * a_Projectile);
+	void AddHangingEntity     (cHangingEntity * a_Hanging);
 	void AddTNTEntity         (cTNTEntity * a_TNT);
+	void AddExpOrbEntity      (cExpOrb * a_ExpOrb);
+	void AddItemFrameEntity   (cItemFrame * a_ItemFrame);
 	
 	void AddMinecartChestContents(cMinecartWithChest * a_Minecart);
 	
diff --git a/src/WorldStorage/SchematicFileSerializer.cpp b/src/WorldStorage/SchematicFileSerializer.cpp
index b021aeb0c..ef67fdb13 100644
--- a/src/WorldStorage/SchematicFileSerializer.cpp
+++ b/src/WorldStorage/SchematicFileSerializer.cpp
@@ -177,6 +177,25 @@ bool cSchematicFileSerializer::LoadFromSchematicNBT(cBlockArea & a_BlockArea, cP
 	a_BlockArea.Clear();
 	a_BlockArea.SetSize(SizeX, SizeY, SizeZ, AreMetasPresent ? (cBlockArea::baTypes | cBlockArea::baMetas) : cBlockArea::baTypes);
 	
+	int TOffsetX = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetX");
+	int TOffsetY = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetY");
+	int TOffsetZ = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetZ");
+	
+	if (
+		(TOffsetX < 0) || (TOffsetY < 0) || (TOffsetZ < 0) ||
+		(a_NBT.GetType(TOffsetX) != TAG_Int) ||
+		(a_NBT.GetType(TOffsetY) != TAG_Int) ||
+		(a_NBT.GetType(TOffsetZ) != TAG_Int)
+	)
+	{
+		// Not every schematic file has an offset, so we shoudn't give a warn message.
+		a_BlockArea.SetWEOffset(0, 0, 0);
+	}
+	else
+	{
+		a_BlockArea.SetWEOffset(a_NBT.GetInt(TOffsetX), a_NBT.GetInt(TOffsetY), a_NBT.GetInt(TOffsetZ));
+	}
+
 	// Copy the block types and metas:
 	int NumBytes = a_BlockArea.m_SizeX * a_BlockArea.m_SizeY * a_BlockArea.m_SizeZ;
 	if (a_NBT.GetDataLength(TBlockTypes) < NumBytes)
@@ -234,6 +253,10 @@ AString cSchematicFileSerializer::SaveToSchematicNBT(const cBlockArea & a_BlockA
 		Writer.AddByteArray("Data", Dummy.data(), Dummy.size());
 	}
 	
+	Writer.AddInt("WEOffsetX", a_BlockArea.m_WEOffset.x);
+	Writer.AddInt("WEOffsetY", a_BlockArea.m_WEOffset.y);
+	Writer.AddInt("WEOffsetZ", a_BlockArea.m_WEOffset.z);
+
 	// TODO: Save entities and block entities
 	Writer.BeginList("Entities", TAG_Compound);
 	Writer.EndList();
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index eb159f28d..7a2366755 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -37,6 +37,9 @@
 #include "../Entities/Pickup.h"
 #include "../Entities/ProjectileEntity.h"
 #include "../Entities/TNTEntity.h"
+#include "../Entities/ExpOrb.h"
+#include "../Entities/HangingEntity.h"
+#include "../Entities/ItemFrame.h"
 
 
 
@@ -366,6 +369,7 @@ bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, const cParsedNBT
 				{
 					case E_BLOCK_AIR:
 					case E_BLOCK_LEAVES:
+					case E_BLOCK_NEW_LEAVES:
 					{
 						// nothing needed
 						break;
@@ -507,10 +511,10 @@ cChunkDef::BiomeMap * cWSSAnvil::LoadBiomeMapFromNBT(cChunkDef::BiomeMap * a_Bio
 		// The biomes stored don't match in size
 		return NULL;
 	}
-	const int * BiomeData = (const int *)(a_NBT.GetData(a_TagIdx));
+	const char * BiomeData = (a_NBT.GetData(a_TagIdx));
 	for (size_t i = 0; i < ARRAYCOUNT(*a_BiomeMap); i++)
 	{
-		(*a_BiomeMap)[i] = (EMCSBiome)(ntohl(BiomeData[i]));
+		(*a_BiomeMap)[i] = (EMCSBiome)(GetBEInt(&BiomeData[i * 4]));
 		if ((*a_BiomeMap)[i] == 0xff)
 		{
 			// Unassigned biomes
@@ -1098,6 +1102,18 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadPickupFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
+	else if (strncmp(a_IDTag, "PrimedTnt", a_IDTagLength) == 0)
+	{
+		LoadTNTFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
+	else if (strncmp(a_IDTag, "XPOrb", a_IDTagLength) == 0)
+	{
+		LoadExpOrbFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
+	else if (strncmp(a_IDTag, "ItemFrame", a_IDTagLength) == 0)
+	{
+		LoadItemFrameFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
 	else if (strncmp(a_IDTag, "Arrow", a_IDTagLength) == 0)
 	{
 		LoadArrowFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
@@ -1238,10 +1254,6 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadPigZombieFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
-	else if (strncmp(a_IDTag, "PrimedTnt", a_IDTagLength) == 0)
-	{
-		LoadTNTFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
-	}
 	// TODO: other entities
 }
 
@@ -1384,6 +1396,7 @@ void cWSSAnvil::LoadMinecartHFromNBT(cEntityList & a_Entities, const cParsedNBT
 
 void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
+	// Load item:
 	int ItemTag = a_NBT.FindChildByName(a_TagIdx, "Item");
 	if ((ItemTag < 0) || (a_NBT.GetType(ItemTag) != TAG_Compound))
 	{
@@ -1394,11 +1407,27 @@ void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
+	
 	std::auto_ptr<cPickup> Pickup(new cPickup(0, 0, 0, Item, false)); // Pickup delay doesn't matter, just say false
 	if (!LoadEntityBaseFromNBT(*Pickup.get(), a_NBT, a_TagIdx))
 	{
 		return;
 	}
+
+	// Load health:
+	int Health = a_NBT.FindChildByName(a_TagIdx, "Health");
+	if (Health > 0)
+	{
+		Pickup->SetHealth((int) (a_NBT.GetShort(Health) & 0xFF));
+	}
+	
+	// Load age:
+	int Age = a_NBT.FindChildByName(a_TagIdx, "Age");
+	if (Age > 0)
+	{
+		Pickup->SetAge(a_NBT.GetShort(Age));
+	}
+
 	a_Entities.push_back(Pickup.release());
 }
 
@@ -1406,6 +1435,148 @@ void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 
 
 
+void cWSSAnvil::LoadTNTFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	std::auto_ptr<cTNTEntity> TNT(new cTNTEntity(0.0, 0.0, 0.0, 0));
+	if (!LoadEntityBaseFromNBT(*TNT.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	
+	// Load Fuse Ticks:
+	int FuseTicks = a_NBT.FindChildByName(a_TagIdx, "Fuse");
+	if (FuseTicks > 0)
+	{
+		TNT->SetFuseTicks((int) a_NBT.GetByte(FuseTicks));
+	}
+	
+	a_Entities.push_back(TNT.release());
+}
+
+
+
+
+
+void cWSSAnvil::LoadExpOrbFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	std::auto_ptr<cExpOrb> ExpOrb(new cExpOrb(0.0, 0.0, 0.0, 0));
+	if (!LoadEntityBaseFromNBT(*ExpOrb.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+
+	// Load Health:
+	int Health = a_NBT.FindChildByName(a_TagIdx, "Health");
+	if (Health > 0)
+	{
+		ExpOrb->SetHealth((int) (a_NBT.GetShort(Health) & 0xFF));
+	}
+
+	// Load Age:
+	int Age = a_NBT.FindChildByName(a_TagIdx, "Age");
+	if (Age > 0)
+	{
+		ExpOrb->SetAge(a_NBT.GetShort(Age));
+	}
+
+	// Load Reward (Value):
+	int Reward = a_NBT.FindChildByName(a_TagIdx, "Value");
+	if (Reward > 0)
+	{
+		ExpOrb->SetReward(a_NBT.GetShort(Reward));
+	}
+
+	a_Entities.push_back(ExpOrb.release());
+}
+
+
+
+
+
+void cWSSAnvil::LoadHangingFromNBT(cHangingEntity & a_Hanging, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	int Direction = a_NBT.FindChildByName(a_TagIdx, "Direction");
+	if (Direction > 0)
+	{
+		Direction = (int)a_NBT.GetByte(Direction);
+		if ((Direction < 0) || (Direction > 5))
+		{
+			a_Hanging.SetDirection(BLOCK_FACE_NORTH);
+		}
+		else
+		{
+			a_Hanging.SetDirection(static_cast<eBlockFace>(Direction));
+		}
+	}
+	else
+	{
+		Direction = a_NBT.FindChildByName(a_TagIdx, "Dir");
+		if (Direction > 0)
+		{
+			switch ((int)a_NBT.GetByte(Direction))
+			{
+				case 0:   a_Hanging.SetDirection(BLOCK_FACE_NORTH);  break;
+				case 1:   a_Hanging.SetDirection(BLOCK_FACE_TOP);    break;
+				case 2:   a_Hanging.SetDirection(BLOCK_FACE_BOTTOM); break;
+				case 3:   a_Hanging.SetDirection(BLOCK_FACE_SOUTH);  break;
+			}
+		}
+	}
+
+	int TileX = a_NBT.FindChildByName(a_TagIdx, "TileX");
+	int TileY = a_NBT.FindChildByName(a_TagIdx, "TileY");
+	int TileZ = a_NBT.FindChildByName(a_TagIdx, "TileZ");
+	if ((TileX > 0) && (TileY > 0) && (TileZ > 0))
+	{
+		a_Hanging.SetPosition(
+			(double)a_NBT.GetInt(TileX),
+			(double)a_NBT.GetInt(TileY),
+			(double)a_NBT.GetInt(TileZ)
+		);
+	}
+}
+
+
+
+
+
+void cWSSAnvil::LoadItemFrameFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	// Load item:
+	int ItemTag = a_NBT.FindChildByName(a_TagIdx, "Item");
+	if ((ItemTag < 0) || (a_NBT.GetType(ItemTag) != TAG_Compound))
+	{
+		return;
+	}
+	cItem Item;
+	if (!LoadItemFromNBT(Item, a_NBT, ItemTag))
+	{
+		return;
+	}
+	
+	std::auto_ptr<cItemFrame> ItemFrame(new cItemFrame(BLOCK_FACE_NONE, 0.0, 0.0, 0.0));
+	if (!LoadEntityBaseFromNBT(*ItemFrame.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	ItemFrame->SetItem(Item);
+
+	LoadHangingFromNBT(*ItemFrame.get(), a_NBT, a_TagIdx);
+	
+	// Load Rotation:
+	int Rotation = a_NBT.FindChildByName(a_TagIdx, "ItemRotation");
+	if (Rotation > 0)
+	{
+		ItemFrame->SetRotation((Byte)a_NBT.GetByte(Rotation));
+	}
+	
+	a_Entities.push_back(ItemFrame.release());
+}
+
+
+
+
+
 void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	std::auto_ptr<cArrowEntity> Arrow(new cArrowEntity(NULL, 0, 0, 0, Vector3d(0, 0, 0)));
@@ -2178,28 +2349,6 @@ void cWSSAnvil::LoadPigZombieFromNBT(cEntityList & a_Entities, const cParsedNBT
 
 
 
-void cWSSAnvil::LoadTNTFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
-{
-	std::auto_ptr<cTNTEntity> TNT(new cTNTEntity(0.0, 0.0, 0.0, 0));
-	if (!LoadEntityBaseFromNBT(*TNT.get(), a_NBT, a_TagIdx))
-	{
-		return;
-	}
-	
-	// Load Fuse Ticks:
-	int FuseTicks = a_NBT.FindChildByName(a_TagIdx, "Fuse");
-	if (FuseTicks > 0)
-	{
-		TNT->SetFuseTicks((int) a_NBT.GetByte(FuseTicks));
-	}
-	
-	a_Entities.push_back(TNT.release());
-}
-
-
-
-
-
 bool cWSSAnvil::LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	double Pos[3];
diff --git a/src/WorldStorage/WSSAnvil.h b/src/WorldStorage/WSSAnvil.h
index fe93d16c3..50d0e555e 100644
--- a/src/WorldStorage/WSSAnvil.h
+++ b/src/WorldStorage/WSSAnvil.h
@@ -20,6 +20,7 @@
 class cItemGrid;
 
 class cProjectileEntity;
+class cHangingEntity;
 
 
 
@@ -149,6 +150,10 @@ protected:
 	void LoadBoatFromNBT            (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadFallingBlockFromNBT    (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadPickupFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadTNTFromNBT             (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadExpOrbFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadHangingFromNBT         (cHangingEntity & a_Hanging,const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadItemFrameFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 
 	void LoadMinecartRFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadMinecartCFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
@@ -192,7 +197,6 @@ protected:
 	void LoadWolfFromNBT            (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadZombieFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadPigZombieFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
-	void LoadTNTFromNBT             (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	
 	/// Loads entity common data from the NBT compound; returns true if successful
 	bool LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx);
diff --git a/src/WorldStorage/WSSCompact.cpp b/src/WorldStorage/WSSCompact.cpp
index 5e49e4909..bb9d4b9e6 100644
--- a/src/WorldStorage/WSSCompact.cpp
+++ b/src/WorldStorage/WSSCompact.cpp
@@ -39,7 +39,7 @@ struct cWSSCompact::sChunkHeader
 
 
 /// The maximum number of PAK files that are cached
-const int MAX_PAK_FILES = 16;
+const size_t MAX_PAK_FILES = 16;
 
 /// The maximum number of unsaved chunks before the cPAKFile saves them to disk
 const int MAX_DIRTY_CHUNKS = 16;
@@ -569,7 +569,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 
 		if( ChunksConverted % 32 == 0 )
 		{
-			LOGINFO("Updating \"%s\" version 1 to version 2: %d %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
+			LOGINFO("Updating \"%s\" version 1 to version 2: " SIZE_T_FMT  " %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
 		}
 		ChunksConverted++;
 
@@ -607,7 +607,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 
 		if (UncompressedSize != (int)UncompressedData.size())
 		{
-			LOGWARNING("Uncompressed data size differs (exp %d bytes, got %d) for chunk [%d, %d]",
+			LOGWARNING("Uncompressed data size differs (exp %d bytes, got " SIZE_T_FMT  ") for chunk [%d, %d]",
 				UncompressedSize, UncompressedData.size(),
 				Header->m_ChunkX, Header->m_ChunkZ
 				);
@@ -713,7 +713,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 
 		if( ChunksConverted % 32 == 0 )
 		{
-			LOGINFO("Updating \"%s\" version 2 to version 3: %d %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
+			LOGINFO("Updating \"%s\" version 2 to version 3: " SIZE_T_FMT  " %%", m_FileName.c_str(), (ChunksConverted * 100) / m_ChunkHeaders.size() );
 		}
 		ChunksConverted++;
 
@@ -751,7 +751,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 
 		if (UncompressedSize != (int)UncompressedData.size())
 		{
-			LOGWARNING("Uncompressed data size differs (exp %d bytes, got %d) for chunk [%d, %d]",
+			LOGWARNING("Uncompressed data size differs (exp %d bytes, got " SIZE_T_FMT  ") for chunk [%d, %d]",
 				UncompressedSize, UncompressedData.size(),
 				Header->m_ChunkX, Header->m_ChunkZ
 				);
@@ -764,7 +764,6 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 
 		// Cannot use cChunk::MakeIndex because it might change again?????????
 		// For compatibility, use what we know is current
-		#define MAKE_2_INDEX( x, y, z ) ( y + (z * 256) + (x * 256 * 16) )
 		#define MAKE_3_INDEX( x, y, z ) ( x + (z * 16) + (y * 16 * 16) )
 
 		unsigned int InChunkOffset = 0;
@@ -867,7 +866,7 @@ bool cWSSCompact::LoadChunkFromData(const cChunkCoords & a_Chunk, int & a_Uncomp
 	
 	if (a_UncompressedSize != (int)UncompressedData.size())
 	{
-		LOGWARNING("Uncompressed data size differs (exp %d bytes, got %d) for chunk [%d, %d]",
+		LOGWARNING("Uncompressed data size differs (exp %d bytes, got " SIZE_T_FMT  ") for chunk [%d, %d]",
 			a_UncompressedSize, UncompressedData.size(),
 			a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ
 		);
diff --git a/src/WorldStorage/WSSCompact.h b/src/WorldStorage/WSSCompact.h
index 64b8d7f31..4df146ec3 100644
--- a/src/WorldStorage/WSSCompact.h
+++ b/src/WorldStorage/WSSCompact.h
@@ -12,7 +12,7 @@
 #define WSSCOMPACT_H_INCLUDED
 
 #include "WorldStorage.h"
-#include "../Vector3i.h"
+#include "../Vector3.h"
 #include "json/json.h"