51 files changed, 1111 insertions, 444 deletions

diff --git a/src/Blocks/BlockAnvil.h b/src/Blocks/BlockAnvil.h
new file mode 100644
index 000000000..93a796ef7
--- /dev/null
+++ b/src/Blocks/BlockAnvil.h
@@ -0,0 +1,61 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cBlockAnvilHandler :
+	public cBlockHandler
+{
+public:
+	cBlockAnvilHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_ANVIL, 1, a_BlockMeta >> 2));
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		NIBBLETYPE HighBits = a_BlockMeta & 0x0c;  // Only highest two bits are preserved
+		int Direction = (int)floor(a_Player->GetYaw() * 4.0 / 360.0 + 1.5) & 0x3;
+		switch (Direction)
+		{
+			case 0: a_BlockMeta = 0x2 | HighBits; break;
+			case 1: a_BlockMeta = 0x3 | HighBits; break;
+			case 2: a_BlockMeta = 0x0 | HighBits; break;
+			case 3: a_BlockMeta = 0x1 | HighBits; break;
+			default:
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+
+	virtual bool IsUseable() override
+	{
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index 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/BlockBed.h b/src/Blocks/BlockBed.h
index caec2b56f..92804aaac 100644
--- a/src/Blocks/BlockBed.h
+++ b/src/Blocks/BlockBed.h
@@ -4,6 +4,7 @@
 #include "BlockHandler.h"
 #include "ChunkInterface.h"
 #include "WorldInterface.h"
+#include "MetaRotator.h"
 #include "../Entities/Player.h"
 
 
@@ -11,11 +12,11 @@
 
 
 class cBlockBedHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01, true>
 {
 public:
 	cBlockBedHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01,true>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockButton.h b/src/Blocks/BlockButton.h
index ca6850ced..4b2f6f618 100644
--- a/src/Blocks/BlockButton.h
+++ b/src/Blocks/BlockButton.h
@@ -2,16 +2,17 @@
 
 #include "BlockHandler.h"
 #include "Chunk.h"
+#include "MetaRotator.h"
 
 
 
 
 class cBlockButtonHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>
 {
 public:
 	cBlockButtonHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>(a_BlockType)
 	{
 	}
 
@@ -101,7 +102,7 @@ public:
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, BlockMetaDataToBlockFace(Meta), true);
 		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && (g_BlockIsSolid[BlockIsOn]);
+		return (a_RelY > 0) && (cBlockInfo::IsSolid(BlockIsOn));
 	}
 } ;
 
diff --git a/src/Blocks/BlockCactus.h b/src/Blocks/BlockCactus.h
index 83595d2b9..ed441517d 100644
--- a/src/Blocks/BlockCactus.h
+++ b/src/Blocks/BlockCactus.h
@@ -54,7 +54,7 @@ public:
 			NIBBLETYPE BlockMeta;
 			if (
 				a_Chunk.UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta) &&
-				(g_BlockIsSolid[BlockType])
+				cBlockInfo::IsSolid(BlockType)
 			)
 			{
 				return false;
diff --git a/src/Blocks/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/BlockCauldron.h b/src/Blocks/BlockCauldron.h
index 2e1032d2b..41b79b6c3 100644
--- a/src/Blocks/BlockCauldron.h
+++ b/src/Blocks/BlockCauldron.h
@@ -23,7 +23,7 @@ public:
 
 	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
-		char Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		switch (a_Player->GetEquippedItem().m_ItemType)
 		{
 			case E_ITEM_WATER_BUCKET:
diff --git a/src/Blocks/BlockChest.h b/src/Blocks/BlockChest.h
index 02ecc4346..a1ded4c26 100644
--- a/src/Blocks/BlockChest.h
+++ b/src/Blocks/BlockChest.h
@@ -4,17 +4,18 @@
 #include "BlockEntity.h"
 #include "../BlockArea.h"
 #include "../Entities/Player.h"
+#include "MetaRotator.h"
 
 
 
 
 
 class cBlockChestHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockChestHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockComparator.h b/src/Blocks/BlockComparator.h
index aba390d9d..4dd05366d 100644
--- a/src/Blocks/BlockComparator.h
+++ b/src/Blocks/BlockComparator.h
@@ -3,17 +3,18 @@
 
 #include "BlockHandler.h"
 #include "BlockRedstoneRepeater.h"
+#include "MetaRotator.h"
 
 
 
 
 
 class cBlockComparatorHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>
 {
 public:
 	cBlockComparatorHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>(a_BlockType)
 	{
 	}
 
@@ -26,6 +27,13 @@ public:
 	}
 
 
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		UNUSED(a_ChunkInterface);
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
diff --git a/src/Blocks/BlockCrops.h b/src/Blocks/BlockCrops.h
index ffc2b3f8b..8606cf3f3 100644
--- a/src/Blocks/BlockCrops.h
+++ b/src/Blocks/BlockCrops.h
@@ -2,7 +2,7 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
+#include "../FastRandom.h"
 
 
 
@@ -21,7 +21,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_Meta) override
 	{
-		MTRand rand;
+		cFastRandom rand;
 
 		if (a_Meta == 0x7)
 		{
@@ -31,18 +31,18 @@ public:
 				case E_BLOCK_CROPS:
 				{
 					a_Pickups.push_back(cItem(E_ITEM_WHEAT, 1, 0));
-					a_Pickups.push_back(cItem(E_ITEM_SEEDS, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));  // [1 .. 3] with high preference of 2
+					a_Pickups.push_back(cItem(E_ITEM_SEEDS, (char)(1 + (rand.NextInt(3) + rand.NextInt(3)) / 2), 0));  // [1 .. 3] with high preference of 2
 					break;
 				}
 				case E_BLOCK_CARROTS:
 				{
-					a_Pickups.push_back(cItem(E_ITEM_CARROT, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));  // [1 .. 3] with high preference of 2
+					a_Pickups.push_back(cItem(E_ITEM_CARROT, (char)(1 + (rand.NextInt(3) + rand.NextInt(3)) / 2), 0));  // [1 .. 3] with high preference of 2
 					break;
 				}
 				case E_BLOCK_POTATOES:
 				{
-					a_Pickups.push_back(cItem(E_ITEM_POTATO, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));  // [1 .. 3] with high preference of 2
-					if (rand.randInt(20) == 0)
+					a_Pickups.push_back(cItem(E_ITEM_POTATO, (char)(1 + (rand.NextInt(3) + rand.NextInt(3)) / 2), 0));  // [1 .. 3] with high preference of 2
+					if (rand.NextInt(21) == 0)
 					{
 						// With a 5% chance, drop a poisonous potato as well
 						a_Pickups.push_back(cItem(E_ITEM_POISONOUS_POTATO, 1, 0));
diff --git a/src/Blocks/BlockDirt.h b/src/Blocks/BlockDirt.h
index 2559f4839..bde8e4201 100644
--- a/src/Blocks/BlockDirt.h
+++ b/src/Blocks/BlockDirt.h
@@ -2,8 +2,8 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
 #include "BlockSlab.h"
+#include "../FastRandom.h"
 
 
 
@@ -39,7 +39,7 @@ public:
 			BLOCKTYPE Above;
 			NIBBLETYPE AboveMeta;
 			a_Chunk.GetBlockTypeMeta(a_RelX, a_RelY + 1, a_RelZ, Above, AboveMeta);
-			if ((!g_BlockTransparent[Above] && !g_BlockOneHitDig[Above] && !(cBlockSlabHandler::IsAnySlabType(Above) && (AboveMeta & 0x8))) || IsBlockWater(Above))
+			if ((!cBlockInfo::IsTransparent(Above) && !cBlockInfo::IsOneHitDig(Above) && !(cBlockSlabHandler::IsAnySlabType(Above) && (AboveMeta & 0x8))) || IsBlockWater(Above))
 			{
 				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, E_META_DIRT_NORMAL);
 				return;
@@ -47,12 +47,12 @@ public:
 		}
 		
 		// Grass spreads to adjacent dirt blocks:
-		MTRand rand;  // TODO: Replace with cFastRandom
+		cFastRandom rand;
 		for (int i = 0; i < 2; i++)  // Pick two blocks to grow to
 		{
-			int OfsX = rand.randInt(2) - 1;  // [-1 .. 1]
-			int OfsY = rand.randInt(4) - 3;  // [-3 .. 1]
-			int OfsZ = rand.randInt(2) - 1;  // [-1 .. 1]
+			int OfsX = rand.NextInt(3, a_RelX) - 1;  // [-1 .. 1]
+			int OfsY = rand.NextInt(5, a_RelY) - 3;  // [-3 .. 1]
+			int OfsZ = rand.NextInt(3, a_RelZ) - 1;  // [-1 .. 1]
 	
 			BLOCKTYPE  DestBlock;
 			NIBBLETYPE DestMeta;
@@ -80,9 +80,12 @@ public:
 			BLOCKTYPE AboveDest;
 			NIBBLETYPE AboveMeta;
 			Chunk->GetBlockTypeMeta(BlockX, BlockY + 1, BlockZ, AboveDest, AboveMeta);
-			if ((g_BlockOneHitDig[AboveDest] || g_BlockTransparent[AboveDest] || ((cBlockSlabHandler::IsAnySlabType(AboveDest)) && (AboveMeta & 0x8))) && !IsBlockWater(AboveDest))
+			if ((cBlockInfo::IsOneHitDig(AboveDest) || cBlockInfo::IsTransparent(AboveDest) || ((cBlockSlabHandler::IsAnySlabType(AboveDest)) && (AboveMeta & 0x8))) && !IsBlockWater(AboveDest))
 			{
-				Chunk->FastSetBlock(BlockX, BlockY, BlockZ, E_BLOCK_GRASS, 0);
+				if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, BlockX * cChunkDef::Width, BlockY, BlockZ * cChunkDef::Width, ssGrassSpread))
+				{
+					Chunk->FastSetBlock(BlockX, BlockY, BlockZ, E_BLOCK_GRASS, 0);
+				}
 			}
 		}  // for i - repeat twice
 	}
diff --git a/src/Blocks/BlockDoor.cpp b/src/Blocks/BlockDoor.cpp
index 2ff5c1c37..479c68153 100644
--- a/src/Blocks/BlockDoor.cpp
+++ b/src/Blocks/BlockDoor.cpp
@@ -9,7 +9,7 @@
 
 
 cBlockDoorHandler::cBlockDoorHandler(BLOCKTYPE a_BlockType)
-	: cBlockHandler(a_BlockType)
+	: super(a_BlockType)
 {
 }
 
@@ -55,6 +55,29 @@ void cBlockDoorHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterfac
 
 
 
+void cBlockDoorHandler::OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace)
+{
+	UNUSED(a_ChunkInterface);
+	
+	a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	
+	if (Meta & 8)
+	{
+		// Current block is top of the door
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY - 1, a_BlockZ, a_Player);
+	}
+	else
+	{
+		// Current block is bottom of the door
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, a_Player);
+	}
+}
+
+
+
+
+
 void cBlockDoorHandler::OnPlacedByPlayer(
 	cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
 	int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
@@ -87,3 +110,87 @@ const char * cBlockDoorHandler::GetStepSound(void)
 
 
 
+
+NIBBLETYPE cBlockDoorHandler::MetaRotateCCW(NIBBLETYPE a_Meta)
+{
+	if (a_Meta & 0x08)
+	{
+		return a_Meta;
+	}
+	else
+	{
+		return super::MetaRotateCCW(a_Meta);
+	}
+}
+
+
+
+NIBBLETYPE cBlockDoorHandler::MetaRotateCW(NIBBLETYPE a_Meta)
+{
+	if (a_Meta & 0x08)
+	{
+		return a_Meta;
+	}
+	else
+	{
+		return super::MetaRotateCW(a_Meta);
+	}
+}
+
+
+
+NIBBLETYPE cBlockDoorHandler::MetaMirrorXY(NIBBLETYPE a_Meta)
+{
+	// Top bit (0x08) contains door panel type (Top/Bottom panel)  Only Bottom panels contain position data
+	// Return a_Meta if panel is a top panel (0x08 bit is set to 1)
+
+	// Note: Currently, you can not properly mirror the hinges on a double door.  The orientation of the door is stored
+	// in only the bottom tile while the hinge position is in the top tile.  This function only operates on one tile at a time, 
+	// so the function can only see either the hinge position or orientation, but not both, at any given time.  The class itself
+	// needs extra datamembers.
+	if (a_Meta & 0x08) return a_Meta;
+
+	// Holds open/closed meta data. 0x0C == 1100.
+	NIBBLETYPE OtherMeta = a_Meta & 0x0C;
+
+	// Mirrors according to a table.  0x03 == 0011.
+	switch (a_Meta & 0x03)
+	{
+		case 0x03: return 0x01 + OtherMeta;  // South -> North
+		case 0x01: return 0x03 + OtherMeta;  // North -> South
+	}
+
+	// Not Facing North or South; No change.
+	return a_Meta;
+}
+
+
+
+NIBBLETYPE cBlockDoorHandler::MetaMirrorYZ(NIBBLETYPE a_Meta)
+{
+	// Top bit (0x08) contains door panel type (Top/Bottom panel)  Only Bottom panels contain position data
+	// Return a_Meta if panel is a top panel (0x08 bit is set to 1)
+
+	// Note: Currently, you can not properly mirror the hinges on a double door.  The orientation of the door is stored
+	// in only the bottom tile while the hinge position is in the top tile.  This function only operates on one tile at a time, 
+	// so the function can only see either the hinge position or orientation, but not both, at any given time.The class itself
+	// needs extra datamembers.
+
+	if (a_Meta & 0x08) return a_Meta;
+
+	// Holds open/closed meta data. 0x0C == 1100.
+	NIBBLETYPE OtherMeta = a_Meta & 0x0C;
+
+	// Mirrors according to a table.  0x03 == 0011.
+	switch (a_Meta & 0x03)
+	{
+		case 0x00: return 0x02 + OtherMeta;  // West  -> East
+		case 0x02: return 0x00 + OtherMeta;  // East  -> West
+	}
+
+	// Not Facing North or South; No change.
+	return a_Meta;
+}
+
+
+
diff --git a/src/Blocks/BlockDoor.h b/src/Blocks/BlockDoor.h
index ef0dbb787..797fe484c 100644
--- a/src/Blocks/BlockDoor.h
+++ b/src/Blocks/BlockDoor.h
@@ -4,20 +4,27 @@
 #include "BlockHandler.h"
 #include "../Entities/Player.h"
 #include "Chunk.h"
+#include "MetaRotator.h"
 
 
 
 
 class cBlockDoorHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true>
 {
+	typedef cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true> super;
 public:
 	cBlockDoorHandler(BLOCKTYPE a_BlockType);
 
 	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override;
 	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override;
 	virtual const char * GetStepSound(void) override;
 	
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override;
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta)  override;
 	
 	virtual bool GetPlacementBlockTypeMeta(
 		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
@@ -139,14 +146,14 @@ public:
 	static void ChangeDoor(cChunkInterface & a_ChunkInterface, int a_X, int a_Y, int a_Z)
 	{
 		NIBBLETYPE OldMetaData = a_ChunkInterface.GetBlockMeta(a_X, a_Y, a_Z);
-		
+
 		a_ChunkInterface.SetBlockMeta(a_X, a_Y, a_Z, ChangeStateMetaData(OldMetaData));
-		
+
 		if (OldMetaData & 8)
 		{
 			// Current block is top of the door
 			BLOCKTYPE  BottomBlock = a_ChunkInterface.GetBlock(a_X, a_Y - 1, a_Z);
-			NIBBLETYPE BottomMeta  = a_ChunkInterface.GetBlockMeta(a_X, a_Y - 1, a_Z);
+			NIBBLETYPE BottomMeta = a_ChunkInterface.GetBlockMeta(a_X, a_Y - 1, a_Z);
 
 			if (IsDoor(BottomBlock) && !(BottomMeta & 8))
 			{
@@ -165,8 +172,6 @@ public:
 			}
 		}
 	}
-	
-	
 } ;
 
 
diff --git a/src/Blocks/BlockDropSpenser.h b/src/Blocks/BlockDropSpenser.h
index 30d347ec9..88b61a418 100644
--- a/src/Blocks/BlockDropSpenser.h
+++ b/src/Blocks/BlockDropSpenser.h
@@ -6,17 +6,18 @@
 #pragma once
 
 #include "../Piston.h"
+#include "MetaRotator.h"
 
 
 
 
 
 class cBlockDropSpenserHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockDropSpenserHandler(BLOCKTYPE a_BlockType) :
-		cBlockEntityHandler(a_BlockType)
+		cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 	
@@ -34,6 +35,20 @@ public:
 		a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
 		return true;
 	}
+	
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag. Lowest three bits are position. 0x08 == 1000
+		NIBBLETYPE OtherMeta = a_Meta & 0x08;
+		// Mirrors defined by by a table. (Source, mincraft.gamepedia.com) 0x07 == 0111
+		switch (a_Meta & 0x07)
+		{
+			case 0x00: return 0x01 + OtherMeta; // Down -> Up
+			case 0x01: return 0x00 + OtherMeta; // Up -> Down
+		}
+		// Not Facing Up or Down; No change.
+		return a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockEnderchest.h b/src/Blocks/BlockEnderchest.h
index b4b0b995d..67955f8ce 100644
--- a/src/Blocks/BlockEnderchest.h
+++ b/src/Blocks/BlockEnderchest.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockEntity.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockEnderchestHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockEnderchestHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockFenceGate.h b/src/Blocks/BlockFenceGate.h
index fb984f345..e202c6610 100644
--- a/src/Blocks/BlockFenceGate.h
+++ b/src/Blocks/BlockFenceGate.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockFenceGateHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>
 {
 public:
 	cBlockFenceGateHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cMetaRotator<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>(a_BlockType)
 	{
 	}
 
@@ -48,6 +48,12 @@ public:
 	}
 
 
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+
+
 	virtual bool IsUseable(void) override
 	{
 		return true;
diff --git a/src/Blocks/BlockFire.h b/src/Blocks/BlockFire.h
index a25b87858..c8f158e7e 100644
--- a/src/Blocks/BlockFire.h
+++ b/src/Blocks/BlockFire.h
@@ -17,25 +17,27 @@ public:
 	}
 
 	/// Portal boundary and direction variables
-	int XZP, XZM, Dir; // For wont of a better name...
+	// 2014_03_30 _X: What are these used for? Why do we need extra variables?
+	int XZP, XZM;
+	NIBBLETYPE Dir;
 
 	virtual void OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override
 	{
 		/*
 		PORTAL FINDING ALGORITH
 		=======================
-		-Get clicked base block
-		-Trace upwards to find first obsidian block; aborts if anything other than obsidian or air is encountered.
-		 Uses this value as a reference (the 'ceiling')
-		-For both directions (if one fails, try the other), BASE (clicked) block:
-		 -Go in one direction, only stop if a non obsidian block is encountered (abort) OR a portal border is encountered (FindObsidianCeiling returns -1)
-		 -If a border was encountered, go the other direction and repeat above
-		 -Write borders to XZP and XZM, write direction portal faces to Dir
-		-Loop through boundary variables, and fill with portal blocks based on Dir with meta from Dir		
+		- Get clicked base block
+		- Trace upwards to find first obsidian block; aborts if anything other than obsidian or air is encountered.
+			Uses this value as a reference (the 'ceiling')
+		- For both directions (if one fails, try the other), BASE (clicked) block:
+			- Go in one direction, only stop if a non obsidian block is encountered (abort) OR a portal border is encountered (FindObsidianCeiling returns -1)
+			- If a border was encountered, go the other direction and repeat above
+			- Write borders to XZP and XZM, write direction portal faces to Dir
+		- Loop through boundary variables, and fill with portal blocks based on Dir with meta from Dir
 		*/
 
 		a_BlockY--; // Because we want the block below the fire
-		FindAndSetPortalFrame(a_BlockX, a_BlockY, a_BlockZ, a_ChunkInterface, a_WorldInterface); // Brought to you by Aperture Science
+		FindAndSetPortalFrame(a_BlockX, a_BlockY, a_BlockZ, a_ChunkInterface, a_WorldInterface);
 	}
 
 	virtual void OnDigging(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
diff --git a/src/Blocks/BlockFlowerPot.h b/src/Blocks/BlockFlowerPot.h
index 4de85f629..fc75ef638 100644
--- a/src/Blocks/BlockFlowerPot.h
+++ b/src/Blocks/BlockFlowerPot.h
@@ -2,101 +2,24 @@
 #pragma once
 
 #include "BlockHandler.h"
+#include "BlockEntity.h"
 
 
 
 
 
 class cBlockFlowerPotHandler :
-	public cBlockHandler
+	public cBlockEntityHandler
 {
 public:
 	cBlockFlowerPotHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cBlockEntityHandler(a_BlockType)
 	{
 	}
 
-
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		a_Pickups.push_back(cItem(E_ITEM_FLOWER_POT, 1, 0));
-		if (a_BlockMeta == 0)
-		{
-			return;
-		}
-		cItem Plant;
-		switch (a_BlockMeta)
-		{
-			case 1:  Plant = cItem(E_BLOCK_RED_ROSE, 1, 0); break;
-			case 2:  Plant = cItem(E_BLOCK_YELLOW_FLOWER, 1, 0); break;
-			case 3:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_APPLE); break;
-			case 4:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_CONIFER); break;
-			case 5:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_BIRCH); break;
-			case 6:  Plant = cItem(E_BLOCK_SAPLING, 1, E_META_SAPLING_JUNGLE); break;
-			case 7:  Plant = cItem(E_BLOCK_RED_MUSHROOM, 1, 0); break;
-			case 8:  Plant = cItem(E_BLOCK_BROWN_MUSHROOM, 1, 0); break;
-			case 9:  Plant = cItem(E_BLOCK_CACTUS, 1, 0); break;
-			case 10: Plant = cItem(E_BLOCK_DEAD_BUSH, 1, 0); break;
-			case 11: Plant = cItem(E_BLOCK_TALL_GRASS, 1, E_META_TALL_GRASS_FERN); break;
-			default: return;
-		}
-		a_Pickups.push_back(Plant);
-	}
-
-
-	void OnUse(cWorld * a_World, cWorldInterface * a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		NIBBLETYPE Meta = a_World->GetBlockMeta( a_BlockX, a_BlockY, a_BlockZ );
-		if (Meta != 0)
-		{
-			// Already filled
-			return;
-		}
-		
-		switch (a_Player->GetEquippedItem().m_ItemType)
-		{
-			case E_BLOCK_RED_ROSE: Meta = 1; break;
-			case E_BLOCK_YELLOW_FLOWER: Meta = 2; break;
-			case E_BLOCK_SAPLING:
-			{
-				switch (a_Player->GetEquippedItem().m_ItemDamage)
-				{
-					case E_META_SAPLING_APPLE: Meta = 3; break;
-					case E_META_SAPLING_CONIFER: Meta = 4; break;
-					case E_META_SAPLING_BIRCH: Meta = 5; break;
-					case E_META_SAPLING_JUNGLE: Meta = 6; break;
-				}
-				break;
-			}
-			case E_BLOCK_RED_MUSHROOM: Meta = 7; break;
-			case E_BLOCK_BROWN_MUSHROOM: Meta = 8; break;
-			case E_BLOCK_CACTUS: Meta = 9; break;
-			case E_BLOCK_DEAD_BUSH: Meta = 10; break;
-			case E_BLOCK_TALL_GRASS:
-			{
-				if (a_Player->GetEquippedItem().m_ItemDamage == E_META_TALL_GRASS_FERN)
-				{
-					Meta = 11;
-				}
-				else
-				{
-					return;
-				}
-				break;
-			}
-		}
-		
-		if (a_Player->GetGameMode() != gmCreative)
-		{
-			a_Player->GetInventory().RemoveOneEquippedItem();
-		}
-		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
-	}
-
-
-	virtual bool IsUseable(void) override
-	{
-		return true;
 	}
 } ;
 
diff --git a/src/Blocks/BlockFluid.h b/src/Blocks/BlockFluid.h
index 37885e4de..d486d642d 100644
--- a/src/Blocks/BlockFluid.h
+++ b/src/Blocks/BlockFluid.h
@@ -93,6 +93,7 @@ public:
 		// Check if it's fuel:
 		BLOCKTYPE BlockType;
 		if (
+			((a_RelY + y < 0) || (a_RelY + y > cChunkDef::Height)) ||
 			!a_Chunk.UnboundedRelGetBlockType(a_RelX + x, a_RelY + y, a_RelZ + z, BlockType) ||
 			!cFireSimulator::IsFuel(BlockType)
 		)
@@ -119,6 +120,7 @@ public:
 		for (size_t i = 0; i < ARRAYCOUNT(CrossCoords); i++)
 		{
 			if (
+				((RelY + CrossCoords[i].y >= 0) && (RelY + CrossCoords[i].y <= cChunkDef::Height)) &&
 				a_Chunk.UnboundedRelGetBlockType(RelX + CrossCoords[i].x, RelY + CrossCoords[i].y, RelZ + CrossCoords[i].z, BlockType) &&
 				(BlockType == E_BLOCK_AIR)
 			)
diff --git a/src/Blocks/BlockFurnace.h b/src/Blocks/BlockFurnace.h
index 27ef2689f..a7a807957 100644
--- a/src/Blocks/BlockFurnace.h
+++ b/src/Blocks/BlockFurnace.h
@@ -4,17 +4,17 @@
 #include "BlockEntity.h"
 #include "../World.h"
 #include "../Piston.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockFurnaceHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
-	cBlockFurnaceHandler(BLOCKTYPE a_BlockType) :
-		cBlockEntityHandler(a_BlockType)
+	cBlockFurnaceHandler(BLOCKTYPE a_BlockType) 
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index 834727c9a..7fd8c183c 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"
@@ -39,6 +41,7 @@
 #include "BlockIce.h"
 #include "BlockLadder.h"
 #include "BlockLeaves.h"
+#include "BlockLilypad.h"
 #include "BlockNewLeaves.h"
 #include "BlockLever.h"
 #include "BlockMelon.h"
@@ -57,6 +60,7 @@
 #include "BlockRedstoneLamp.h"
 #include "BlockRedstoneRepeater.h"
 #include "BlockRedstoneTorch.h"
+#include "BlockTNT.h"
 #include "BlockSand.h"
 #include "BlockSapling.h"
 #include "BlockSideways.h"
@@ -77,33 +81,6 @@
 
 
 
-bool            cBlockHandler::m_HandlerInitialized = false;
-cBlockHandler * cBlockHandler::m_BlockHandler[256];
-
-
-
-
-
-cBlockHandler * cBlockHandler::GetBlockHandler(BLOCKTYPE a_BlockType)
-{
-	if (!m_HandlerInitialized)
-	{
-		// We have to initialize
-		memset(m_BlockHandler, 0, sizeof(m_BlockHandler));
-		m_HandlerInitialized = true;
-	}
-	if (m_BlockHandler[a_BlockType] != NULL)
-	{
-		return m_BlockHandler[a_BlockType];
-	}
-
-	return m_BlockHandler[a_BlockType] = CreateBlockHandler(a_BlockType);
-}
-
-
-
-
-
 cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 {
 	switch(a_BlockType)
@@ -111,12 +88,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);
@@ -164,6 +143,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_LAPIS_ORE:             return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_LAVA:                  return new cBlockLavaHandler            (a_BlockType);
 		case E_BLOCK_LEAVES:                return new cBlockLeavesHandler          (a_BlockType);
+		case E_BLOCK_LILY_PAD:              return new cBlockLilypadHandler         (a_BlockType);
 		case E_BLOCK_LIT_FURNACE:           return new cBlockFurnaceHandler         (a_BlockType);
 		case E_BLOCK_LOG:                   return new cBlockSidewaysHandler        (a_BlockType);
 		case E_BLOCK_MELON:                 return new cBlockMelonHandler           (a_BlockType);
@@ -172,6 +152,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_NETHER_BRICK_STAIRS:   return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_NETHER_PORTAL:         return new cBlockPortalHandler          (a_BlockType);
 		case E_BLOCK_NETHER_WART:           return new cBlockNetherWartHandler      (a_BlockType);
+		case E_BLOCK_NETHER_QUARTZ_ORE:     return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_NEW_LEAVES:            return new cBlockNewLeavesHandler       (a_BlockType);
 		case E_BLOCK_NEW_LOG:               return new cBlockSidewaysHandler        (a_BlockType);
 		case E_BLOCK_NOTE_BLOCK:            return new cBlockNoteHandler            (a_BlockType);
@@ -192,7 +173,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_REDSTONE_REPEATER_ON:  return new cBlockRedstoneRepeaterHandler(a_BlockType);
 		case E_BLOCK_REDSTONE_TORCH_OFF:    return new cBlockRedstoneTorchHandler   (a_BlockType);
 		case E_BLOCK_REDSTONE_TORCH_ON:     return new cBlockRedstoneTorchHandler   (a_BlockType);
-		case E_BLOCK_REDSTONE_WIRE:	        return new cBlockRedstoneHandler        (a_BlockType);
+		case E_BLOCK_REDSTONE_WIRE:         return new cBlockRedstoneHandler        (a_BlockType);
 		case E_BLOCK_RED_MUSHROOM:          return new cBlockMushroomHandler        (a_BlockType);
 		case E_BLOCK_RED_ROSE:              return new cBlockFlowerHandler          (a_BlockType);
 		case E_BLOCK_SAND:                  return new cBlockSandHandler            (a_BlockType);
@@ -212,6 +193,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_TALL_GRASS:            return new cBlockTallGrassHandler       (a_BlockType);
 		case E_BLOCK_TORCH:                 return new cBlockTorchHandler           (a_BlockType);
 		case E_BLOCK_TRAPDOOR:              return new cBlockTrapdoorHandler        (a_BlockType);
+		case E_BLOCK_TNT:                   return new cBlockTNTHandler             (a_BlockType);
 		case E_BLOCK_VINES:                 return new cBlockVineHandler            (a_BlockType);
 		case E_BLOCK_WALLSIGN:              return new cBlockSignHandler            (a_BlockType);
 		case E_BLOCK_WATER:                 return new cBlockFluidHandler           (a_BlockType);
@@ -231,20 +213,6 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 
 
 
-void cBlockHandler::Deinit()
-{
-	for (int i = 0; i < 256; i++)
-	{
-		delete m_BlockHandler[i];
-	}
-	memset(m_BlockHandler, 0, sizeof(m_BlockHandler));  // Don't leave any dangling pointers around, just in case
-	m_HandlerInitialized = false;
-}
-
-
-
-
-
 cBlockHandler::cBlockHandler(BLOCKTYPE a_BlockType)
 {
 	m_BlockType = a_BlockType;
@@ -329,7 +297,7 @@ void cBlockHandler::NeighborChanged(cChunkInterface & a_ChunkInterface, int a_Bl
 {
 	if ((a_BlockY >= 0) && (a_BlockY < cChunkDef::Height))
 	{
-		GetBlockHandler(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
+		cBlockInfo::GetHandler(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnNeighborChanged(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
 	}
 }
 
@@ -361,6 +329,14 @@ void cBlockHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface &
 
 
 
+void cBlockHandler::OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace)
+{
+}
+
+
+
+
+
 void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
 {
 	// Setting the meta to a_BlockMeta keeps most textures. The few other blocks have to override this.
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
index a2913d7f8..3a3efb3cc 100644
--- a/src/Blocks/BlockHandler.h
+++ b/src/Blocks/BlockHandler.h
@@ -23,6 +23,8 @@ class cBlockHandler
 {
 public:
 	cBlockHandler(BLOCKTYPE a_BlockType);
+	
+	virtual ~cBlockHandler() {}
 
 	/// Called when the block gets ticked either by a random tick or by a queued tick.
 	/// Note that the coords are chunk-relative!
@@ -69,6 +71,9 @@ public:
 	/// Called if the user right clicks the block and the block is useable
 	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ);
 	
+	/** Called when a Right Click to this Block is cancelled */
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace);
+	
 	/// <summary>Called when the item is mined to convert it into pickups. Pickups may specify multiple items. Appends items to a_Pickups, preserves its original contents</summary>
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta);
 	
@@ -136,30 +141,14 @@ public:
 	/// <returns>Block meta following mirroring</returns>
 	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) { return a_Meta; }
 	
-	/// <summary>Get the blockhandler for a specific block id</summary>
-	static cBlockHandler * GetBlockHandler(BLOCKTYPE a_BlockType);
-
-	/// <summary>Deletes all initialised block handlers</summary>
-	static void Deinit();
-	
 protected:
 	BLOCKTYPE m_BlockType;
 	
 	// Creates a new blockhandler for the given block type. For internal use only, use ::GetBlockHandler() instead.
-	static cBlockHandler *CreateBlockHandler(BLOCKTYPE a_BlockType);
-	static cBlockHandler *m_BlockHandler[256];
-	static bool m_HandlerInitialized;	//used to detect if the blockhandlers are initialized
-};
-
+	static cBlockHandler * CreateBlockHandler(BLOCKTYPE a_BlockType);
 
-
-
-
-// Shortcut to get the blockhandler for a specific block
-inline cBlockHandler * BlockHandler(BLOCKTYPE a_BlockType)
-{
-	return cBlockHandler::GetBlockHandler(a_BlockType);
-}
+	friend class cBlockInfo;
+};
 
 
 
diff --git a/src/Blocks/BlockHopper.h b/src/Blocks/BlockHopper.h
index 59b84aa0e..a882bb077 100644
--- a/src/Blocks/BlockHopper.h
+++ b/src/Blocks/BlockHopper.h
@@ -3,16 +3,16 @@
 
 // Declares the cBlockHopperHandler class representing the handler for the Hopper block
 
-
+#include "MetaRotator.h"
 
 
 
 class cBlockHopperHandler :
-	public cBlockEntityHandler
+	public cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockHopperHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
+		: cMetaRotator<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}
 
@@ -39,6 +39,21 @@ public:
 		}
 		return true;
 	}
+
+
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag.  Lowest three bits are position.  0x08 == 1000
+		NIBBLETYPE OtherMeta = a_Meta & 0x08;
+		// Mirrors defined by by a table. (Source, mincraft.gamepedia.com) 0x07 == 0111
+		switch (a_Meta & 0x07)
+		{
+			case 0x00: return 0x01 + OtherMeta;  // Down -> Up
+			case 0x01: return 0x00 + OtherMeta;  // Up   -> Down
+		}
+		// Not Facing Up or Down; No change.
+		return a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockLadder.h b/src/Blocks/BlockLadder.h
index 6a105d5c9..a605edf3f 100644
--- a/src/Blocks/BlockLadder.h
+++ b/src/Blocks/BlockLadder.h
@@ -9,11 +9,11 @@
 
 
 class cBlockLadderHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
 {
 public:
 	cBlockLadderHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
 	{
 	}	
 
@@ -91,7 +91,7 @@ public:
 
 		AddFaceDirection( a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true);
 
-		return g_BlockIsSolid[a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)];
+		return cBlockInfo::IsSolid(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ));
 	}
 
 
diff --git a/src/Blocks/BlockLeaves.h b/src/Blocks/BlockLeaves.h
index 7b8f0b378..8af14686e 100644
--- a/src/Blocks/BlockLeaves.h
+++ b/src/Blocks/BlockLeaves.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
+#include "../FastRandom.h"
 #include "../World.h"
 #include "../BlockArea.h"
 
@@ -16,6 +16,7 @@
 	{ \
 		case E_BLOCK_LEAVES: a_Area.SetBlockType(x, y, z, (BLOCKTYPE)(E_BLOCK_SPONGE + i + 1)); break; \
 		case E_BLOCK_LOG: return true; \
+		case E_BLOCK_NEW_LOG: return true; \
 	}
 
 bool HasNearLog(cBlockArea &a_Area, int a_BlockX, int a_BlockY, int a_BlockZ);
@@ -36,16 +37,18 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		MTRand rand;
+		cFastRandom rand;
 
 		// Only the first 2 bits contain the display information, the others are for growing
-		if (rand.randInt(5) == 0)
+		if (rand.NextInt(6) == 0)
 		{
 			a_Pickups.push_back(cItem(E_BLOCK_SAPLING, 1, a_BlockMeta & 3));
 		}
-		if ((a_BlockMeta & 3) == E_META_SAPLING_APPLE)
+		
+		// 1 % chance of dropping an apple, if the leaves' type is Apple Leaves
+		if ((a_BlockMeta & 3) == E_META_LEAVES_APPLE)
 		{
-			if (rand.rand(100) == 0)
+			if (rand.NextInt(101) == 0)
 			{
 				a_Pickups.push_back(cItem(E_ITEM_RED_APPLE, 1, 0));
 			}
@@ -57,11 +60,10 @@ public:
 	{
 		cBlockHandler::OnDestroyed(a_ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
 		
-		//0.5% chance of dropping an apple
+		// 0.5% chance of dropping an apple, if the leaves' type is Apple Leaves:
 		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-		//check if Oak (0x1 and 0x2 bit not set)
-		MTRand rand;
-		if(!(Meta & 3) && rand.randInt(200) == 100)
+		cFastRandom rand;
+		if (((Meta & 3) == E_META_LEAVES_APPLE) && (rand.NextInt(201) == 100))
 		{
 			cItems Drops;
 			Drops.push_back(cItem(E_ITEM_RED_APPLE, 1, 0));
diff --git a/src/Blocks/BlockLever.h b/src/Blocks/BlockLever.h
index 48c7e774b..ad2ae29e5 100644
--- a/src/Blocks/BlockLever.h
+++ b/src/Blocks/BlockLever.h
@@ -1,17 +1,18 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockLeverHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x04, 0x02, 0x03, 0x01, false>
 {
+	typedef cMetaRotator<cBlockHandler, 0x07, 0x04, 0x02, 0x03, 0x01, false> super;
 public:
 	cBlockLeverHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x04, 0x02, 0x03, 0x01, false>(a_BlockType)
 	{
 	}
 	
@@ -102,7 +103,37 @@ public:
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, BlockMetaDataToBlockFace(Meta), true);
 		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && (g_BlockIsSolid[BlockIsOn]);
+		return (a_RelY > 0) && cBlockInfo::IsSolid(BlockIsOn);
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		switch (a_Meta)
+		{
+			case 0x00: return 0x07;  // Ceiling rotation
+			case 0x07: return 0x00;
+
+			case 0x05: return 0x06;  // Ground rotation
+			case 0x06: return 0x05;
+
+			default:  return super::MetaRotateCCW(a_Meta);  // Wall Rotation
+		}
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		switch (a_Meta)
+		{
+			case 0x00: return 0x07;  // Ceiling rotation
+			case 0x07: return 0x00;
+
+			case 0x05: return 0x06;  // Ground rotation
+			case 0x06: return 0x05;
+
+			default:  return super::MetaRotateCCW(a_Meta);  // Wall Rotation
+		}
 	}
 } ;
 
diff --git a/src/Blocks/BlockLilypad.h b/src/Blocks/BlockLilypad.h
new file mode 100644
index 000000000..2dd4ec768
--- /dev/null
+++ b/src/Blocks/BlockLilypad.h
@@ -0,0 +1,28 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "Entities/Pickup.h"
+
+
+
+
+class cBlockLilypadHandler :
+	public cBlockHandler
+{
+public:
+	cBlockLilypadHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to zero
+		a_Pickups.push_back(cItem(E_BLOCK_LILY_PAD, 1, 0));
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockMobHead.h b/src/Blocks/BlockMobHead.h
index 6a00c3acd..acd1c88fb 100644
--- a/src/Blocks/BlockMobHead.h
+++ b/src/Blocks/BlockMobHead.h
@@ -21,6 +21,103 @@ public:
 	{
 		a_Pickups.push_back(cItem(E_ITEM_HEAD, 1, 0));
 	}
+
+	bool TrySpawnWither(cChunkInterface & a_ChunkInterface, cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		if (a_BlockY < 2)
+		{
+			return false;
+		}
+
+		class cCallback : public cMobHeadCallback
+		{
+			bool m_IsWither;
+			
+			virtual bool Item (cMobHeadEntity * a_MobHeadEntity)
+			{
+				m_IsWither = (a_MobHeadEntity->GetType() == SKULL_TYPE_WITHER);
+
+				return false;
+			}
+		
+		public:
+			cCallback () : m_IsWither(false) {}
+
+			bool IsWither(void) const { return m_IsWither; }
+
+			void Reset(void) { m_IsWither = false; }
+		} CallbackA, CallbackB;
+
+		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, CallbackA);
+
+		if (!CallbackA.IsWither())
+		{
+			return false;
+		}
+
+		CallbackA.Reset();
+		
+		BLOCKTYPE BlockY1 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
+		BLOCKTYPE BlockY2 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 2, a_BlockZ);
+
+		if ((BlockY1 != E_BLOCK_SOULSAND) || (BlockY2 != E_BLOCK_SOULSAND))
+		{
+			return false;
+		}
+		
+		a_World->DoWithMobHeadAt(a_BlockX - 1, a_BlockY, a_BlockZ, CallbackA);
+		a_World->DoWithMobHeadAt(a_BlockX + 1, a_BlockY, a_BlockZ, CallbackB);
+
+		BLOCKTYPE Block1 = a_ChunkInterface.GetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ);
+		BLOCKTYPE Block2 = a_ChunkInterface.GetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ);
+
+		if ((Block1 == E_BLOCK_SOULSAND) && (Block2 == E_BLOCK_SOULSAND) && CallbackA.IsWither() && CallbackB.IsWither())
+		{
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX + 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX - 1, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
+
+			// Block entities
+			a_World->SetBlock(a_BlockX + 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX,     a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX - 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+
+			// Spawn the wither:
+			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+
+			return true;
+		}
+
+		CallbackA.Reset();
+		CallbackB.Reset();
+		
+		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ - 1, CallbackA);
+		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ + 1, CallbackB);
+
+		Block1 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1);
+		Block2 = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1);
+
+		if ((Block1 == E_BLOCK_SOULSAND) && (Block2 == E_BLOCK_SOULSAND) && CallbackA.IsWither() && CallbackB.IsWither())
+		{
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ - 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
+
+			// Block entities
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ + 1, E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ - 1, E_BLOCK_AIR, 0);
+
+			// Spawn the wither:
+			a_World->SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+
+			return true;
+		}
+
+		return false;
+	}
 	
 	virtual void OnPlacedByPlayer(
 		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, 
@@ -29,7 +126,7 @@ public:
 		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
 	) override
 	{
-		class cCallback : public cMobHeadBlockCallback
+		class cCallback : public cMobHeadCallback
 		{
 			cPlayer * m_Player;
 			NIBBLETYPE m_OldBlockMeta;
@@ -45,22 +142,42 @@ public:
 				
 				a_MobHeadEntity->SetType(static_cast<eMobHeadType>(m_OldBlockMeta));
 				a_MobHeadEntity->SetRotation(static_cast<eMobHeadRotation>(Rotation));
+				a_MobHeadEntity->GetWorld()->BroadcastBlockEntity(a_MobHeadEntity->GetPosX(), a_MobHeadEntity->GetPosY(), a_MobHeadEntity->GetPosZ(), m_Player->GetClientHandle());
 				return false;
 			}
 		
 		public:
-			cCallback (cPlayer * a_Player, NIBBLETYPE a_OldBlockMeta, NIBBLETYPE a_NewBlockMeta) :
-				m_Player(a_Player),
+			cCallback (cPlayer * a_CBPlayer, NIBBLETYPE a_OldBlockMeta, NIBBLETYPE a_NewBlockMeta) :
+				m_Player(a_CBPlayer),
 				m_OldBlockMeta(a_OldBlockMeta),
 				m_NewBlockMeta(a_NewBlockMeta)
 			{}
 		};
 		cCallback Callback(a_Player, a_BlockMeta, static_cast<NIBBLETYPE>(a_BlockFace));
 		
-		a_BlockMeta = a_BlockFace;
+		a_BlockMeta = (NIBBLETYPE)a_BlockFace;
 		cWorld * World = (cWorld *) &a_WorldInterface;
-		World->DoWithMobHeadBlockAt(a_BlockX, a_BlockY, a_BlockZ, Callback);
+		World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, Callback);
 		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta);
+
+		if (a_BlockMeta == SKULL_TYPE_WITHER)
+		{
+			static const Vector3i Coords[] =
+			{
+				Vector3i( 0, 0,  0),
+				Vector3i( 1, 0,  0),
+				Vector3i(-1, 0,  0),
+				Vector3i( 0, 0,  1),
+				Vector3i( 0, 0, -1),
+			};
+			for (size_t i = 0; i < ARRAYCOUNT(Coords); ++i)
+			{
+				if (TrySpawnWither(a_ChunkInterface, World, a_BlockX + Coords[i].x, a_BlockY, a_BlockZ + Coords[i].z))
+				{
+					break;
+				}
+			}  // for i - Coords[]
+		}
 	}
 } ;
 
diff --git a/src/Blocks/BlockMushroom.h b/src/Blocks/BlockMushroom.h
index 623cfda64..135d418d7 100644
--- a/src/Blocks/BlockMushroom.h
+++ b/src/Blocks/BlockMushroom.h
@@ -17,6 +17,9 @@ public:
 	}
 
 
+	// TODO: Add Mushroom Spread
+
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
@@ -39,6 +42,7 @@ public:
 			case E_BLOCK_CACTUS:
 			case E_BLOCK_ICE:
 			case E_BLOCK_LEAVES:
+			case E_BLOCK_NEW_LEAVES:
 			case E_BLOCK_AIR:
 			{
 				return false;
diff --git a/src/Blocks/BlockMycelium.h b/src/Blocks/BlockMycelium.h
index 7f897c72a..2a8ef5fca 100644
--- a/src/Blocks/BlockMycelium.h
+++ b/src/Blocks/BlockMycelium.h
@@ -16,6 +16,8 @@ public:
 	{
 	}
 
+	// TODO: Add Mycel Spread
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		a_Pickups.push_back(cItem(E_BLOCK_DIRT, 1, 0));
diff --git a/src/Blocks/BlockNetherWart.h b/src/Blocks/BlockNetherWart.h
index 923180e19..812cf906f 100644
--- a/src/Blocks/BlockNetherWart.h
+++ b/src/Blocks/BlockNetherWart.h
@@ -2,14 +2,13 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
+#include "../FastRandom.h"
 #include "../World.h"
 
 
 
 
 
-/// Common class that takes care of carrots, potatoes and wheat
 class cBlockNetherWartHandler :
 	public cBlockHandler
 {
@@ -22,12 +21,12 @@ public:
 	
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_Meta) override
 	{
-		MTRand rand;
+		cFastRandom rand;
 
 		if (a_Meta == 0x7)
 		{
-			// Is fully grown, drop the entire produce:
-			a_Pickups.push_back(cItem(E_ITEM_NETHER_WART, 1 + (int)(rand.randInt(2) + rand.randInt(2)) / 2, 0));
+			// Fully grown, drop the entire produce:
+			a_Pickups.push_back(cItem(E_ITEM_NETHER_WART, (char)(1 + (rand.NextInt(3) + rand.NextInt(3))) / 2, 0));
 		}
 		else
 		{
@@ -35,18 +34,20 @@ public:
 		}
 	}
 
+
 	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
-		NIBBLETYPE Meta     = a_Chunk.GetMeta      (a_RelX, a_RelY, a_RelZ);
-
+		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
 		if (Meta < 7)
 		{
 			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_NETHER_WART, ++Meta);
 		}
 	}
+	
 
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
+		// Needs to be placed on top of a Soulsand block:
 		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_SOULSAND));
 	}
 } ;
diff --git a/src/Blocks/BlockPluginInterface.h b/src/Blocks/BlockPluginInterface.h
index 7428c9a7a..3a36c40b1 100644
--- a/src/Blocks/BlockPluginInterface.h
+++ b/src/Blocks/BlockPluginInterface.h
@@ -1,8 +1,14 @@
 
 #pragma once
 
+/** This interface is used to decouple block handlers from the cPluginManager dependancy through cWorld.
+The block handlers call this interface, which is then implemented by the specific classes that
+the caller provides.
+*/
 class cBlockPluginInterface
 {
 public:
+	virtual ~cBlockPluginInterface() {}
+	
 	virtual bool CallHookBlockToPickups(cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, cItems & a_Pickups) = 0;
 };
diff --git a/src/Blocks/BlockPumpkin.h b/src/Blocks/BlockPumpkin.h
index 349f52605..ac2b9817a 100644
--- a/src/Blocks/BlockPumpkin.h
+++ b/src/Blocks/BlockPumpkin.h
@@ -1,16 +1,16 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 class cBlockPumpkinHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x07, 0x02, 0x03, 0x00, 0x01, false>
 {
 public:
 	cBlockPumpkinHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x07, 0x02, 0x03, 0x00, 0x01, false>(a_BlockType)
 	{
 	}
 	
diff --git a/src/Blocks/BlockRail.h b/src/Blocks/BlockRail.h
index 52d6f60b3..ad78d290a 100644
--- a/src/Blocks/BlockRail.h
+++ b/src/Blocks/BlockRail.h
@@ -98,7 +98,7 @@ public:
 		{
 			return false;
 		}
-		if (!g_BlockIsSolid[a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)])
+		if (!cBlockInfo::IsSolid(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)))
 		{
 			return false;
 		}
@@ -130,7 +130,7 @@ public:
 					// Too close to the edge, cannot simulate
 					return true;
 				}
-				return g_BlockIsSolid[BlockType];
+				return cBlockInfo::IsSolid(BlockType);
 			}
 		}
 		return true;
@@ -431,9 +431,145 @@ public:
 				}
 				break;
 			}
+			default: break;
 		}
 		return true;
 	}
+
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag when a_Meta is in the range 0x00--0x05 and 0x0A--0x0F.
+		// Bit 0x08 specifies direction when a_Meta is in the range 0x06-0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Rotates according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x00: return 0x01 + OtherMeta;  // North/South -> East/West
+				case 0x01: return 0x00 + OtherMeta;  // East/West   -> North/South
+
+				case 0x02: return 0x04 + OtherMeta;  // Asc. East   -> Asc. North
+				case 0x04: return 0x03 + OtherMeta;  // Asc. North  -> Asc. West
+				case 0x03: return 0x05 + OtherMeta;  // Asc. West   -> Asc. South
+				case 0x05: return 0x02 + OtherMeta;  // Asc. South  -> Asc. East
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x09;  // Northwest Cnr. -> Southwest Cnr.
+				case 0x07: return 0x06;  // Northeast Cnr. -> Northwest Cnr.
+				case 0x08: return 0x07;  // Southeast Cnr. -> Northeast Cnr.
+				case 0x09: return 0x08;  // Southwest Cnr. -> Southeast Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag for value in the range 0x00--0x05 and specifies direction for values withint 0x006--0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Rotates according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x00: return 0x01 + OtherMeta;  // North/South -> East/West
+				case 0x01: return 0x00 + OtherMeta;  // East/West   -> North/South
+
+				case 0x02: return 0x05 + OtherMeta;  // Asc. East   -> Asc. South
+				case 0x05: return 0x03 + OtherMeta;  // Asc. South  -> Asc. West
+				case 0x03: return 0x04 + OtherMeta;  // Asc. West   -> Asc. North
+				case 0x04: return 0x02 + OtherMeta;  // Asc. North  -> Asc. East
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x07;  // Northwest Cnr. -> Northeast Cnr.
+				case 0x07: return 0x08;  // Northeast Cnr. -> Southeast Cnr.
+				case 0x08: return 0x09;  // Southeast Cnr. -> Southwest Cnr.
+				case 0x09: return 0x06;  // Southwest Cnr. -> Northwest Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag for value in the range 0x00--0x05 and specifies direction for values withint 0x006--0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Mirrors according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x05: return 0x04 + OtherMeta;  // Asc. South  -> Asc. North
+				case 0x04: return 0x05 + OtherMeta;  // Asc. North  -> Asc. South
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x09;  // Northwest Cnr. -> Southwest Cnr.
+				case 0x07: return 0x08;  // Northeast Cnr. -> Southeast Cnr.
+				case 0x08: return 0x07;  // Southeast Cnr. -> Northeast Cnr.
+				case 0x09: return 0x06;  // Southwest Cnr. -> Northwest Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
+	{
+		// Bit 0x08 is a flag for value in the range 0x00--0x05 and specifies direction for values withint 0x006--0x09.
+		if ((a_Meta < 0x06) || (a_Meta > 0x09))
+		{
+			//  Save powered rail flag.
+			NIBBLETYPE OtherMeta = a_Meta & 0x08;
+			// Mirrors according to table; 0x07 == 0111.
+			// Rails can either be flat (North/South) or Ascending (Asc. East)
+			switch (a_Meta & 0x07)
+			{
+				case 0x02: return 0x03 + OtherMeta;  // Asc. East   -> Asc. West
+				case 0x03: return 0x02 + OtherMeta;  // Asc. West   -> Asc. East
+			}
+		}
+		else
+		{
+			switch (a_Meta)
+			{
+				// Corner Directions
+				case 0x06: return 0x07;  // Northwest Cnr. -> Northeast Cnr.
+				case 0x07: return 0x06;  // Northeast Cnr. -> Northwest Cnr.
+				case 0x08: return 0x09;  // Southeast Cnr. -> Southwest Cnr.
+				case 0x09: return 0x08;  // Southwest Cnr. -> Southeast Cnr.
+			}
+		}
+		// To avoid a compiler warning;
+		return a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockRedstone.h b/src/Blocks/BlockRedstone.h
index 10de96197..a898c9acb 100644
--- a/src/Blocks/BlockRedstone.h
+++ b/src/Blocks/BlockRedstone.h
@@ -20,7 +20,7 @@ public:
 
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
-		return ((a_RelY > 0) && g_BlockFullyOccupiesVoxel[a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)]);
+		return ((a_RelY > 0) && cBlockInfo::FullyOccupiesVoxel(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)));
 	}
 	
 	
diff --git a/src/Blocks/BlockRedstoneRepeater.h b/src/Blocks/BlockRedstoneRepeater.h
index eb0918acf..fe6cd21b9 100644
--- a/src/Blocks/BlockRedstoneRepeater.h
+++ b/src/Blocks/BlockRedstoneRepeater.h
@@ -3,17 +3,17 @@
 
 #include "BlockHandler.h"
 #include "Chunk.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockRedstoneRepeaterHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>
 {
 public:
 	cBlockRedstoneRepeaterHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>(a_BlockType)
 	{
 	}
 
@@ -29,7 +29,7 @@ public:
 		a_BlockMeta = RepeaterRotationToMetaData(a_Player->GetYaw());
 		return true;
 	}
-	
+
 
 	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
@@ -37,6 +37,13 @@ public:
 	}
 
 
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		UNUSED(a_ChunkInterface);
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
diff --git a/src/Blocks/BlockSideways.h b/src/Blocks/BlockSideways.h
index 69c0a7230..d67c3aa24 100644
--- a/src/Blocks/BlockSideways.h
+++ b/src/Blocks/BlockSideways.h
@@ -29,7 +29,13 @@ public:
 		return true;
 	}
 
-	
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.Add(m_BlockType, 1, a_BlockMeta & 0x3);
+	}
+
+
 	inline static NIBBLETYPE BlockFaceToMetaData(eBlockFace a_BlockFace, NIBBLETYPE a_WoodMeta)
 	{
 		switch (a_BlockFace)
diff --git a/src/Blocks/BlockSign.h b/src/Blocks/BlockSign.h
index cd0c02a40..6c0becfd6 100644
--- a/src/Blocks/BlockSign.h
+++ b/src/Blocks/BlockSign.h
@@ -71,6 +71,37 @@ public:
 	{
 		a_Player->GetClientHandle()->SendEditSign(a_BlockX, a_BlockY, a_BlockZ);
 	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		return (++a_Meta) & 0x0F;
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		return (--a_Meta) & 0x0F;
+	}
+
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
+	{
+		//  Mirrors signs over the XY plane (North-South Mirroring)
+
+		//  There are 16 meta values which correspond to different directions.
+		//  These values are equated to angles on a circle; 0x08 = 180 degrees.
+		return (a_Meta < 0x08) ? 0x08 + a_Meta : 0x08 - a_Meta;
+	}
+
+
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
+	{
+		//  Mirrors signs over the YZ plane (East-West Mirroring)
+
+		//  There are 16 meta values which correspond to different directions.
+		//  These values are equated to angles on a circle; 0x10 = 360 degrees.
+		return 0x10 - a_Meta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockSlab.h b/src/Blocks/BlockSlab.h
index 7cd2c97b2..76f5ed0e7 100644
--- a/src/Blocks/BlockSlab.h
+++ b/src/Blocks/BlockSlab.h
@@ -11,8 +11,7 @@
 
 #include "BlockHandler.h"
 #include "../Items/ItemHandler.h"
-
-
+#include "Root.h"
 
 
 
@@ -40,41 +39,9 @@ public:
 	) override
 	{
 		a_BlockType = m_BlockType;
-		BLOCKTYPE  Type = (BLOCKTYPE) (a_Player->GetEquippedItem().m_ItemType);
 		NIBBLETYPE Meta = (NIBBLETYPE) a_Player->GetEquippedItem().m_ItemDamage;
 		
-		// HandlePlaceBlock wants a cItemHandler pointer thing, so let's give it one
-		cItemHandler * ItemHandler = cItemHandler::GetItemHandler(GetDoubleSlabType(Type));
-
-		// Check if the block at the coordinates is a slab. Eligibility for combining has already been processed in ClientHandle
-		if (IsAnySlabType(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			// Call the function in ClientHandle that places a block when the client sends the packet,
-			// so that plugins may interfere with the placement.
-			
-			if ((a_BlockFace == BLOCK_FACE_TOP) || (a_BlockFace == BLOCK_FACE_BOTTOM))
-			{
-				// Top and bottom faces need no parameter modification
-				a_Player->GetClientHandle()->HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
-			}
-			else
-			{
-				// The other faces need to distinguish between top and bottom cursor positions
-				if (a_CursorY > 7)
-				{
-					// Edit the call to use BLOCK_FACE_BOTTOM, otherwise it places incorrectly
-					a_Player->GetClientHandle()->HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_TOP, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
-				}
-				else
-				{
-					// Edit the call to use BLOCK_FACE_TOP, otherwise it places incorrectly
-					a_Player->GetClientHandle()->HandlePlaceBlock(a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_BOTTOM, a_CursorX, a_CursorY, a_CursorZ, *ItemHandler);
-				}
-			}
-			return false;  // Cancel the event, because dblslabs were already placed, nothing else needed
-		}
-		
-		// Place the single-slab with correct metas:
+		// Set the correct metadata based on player equipped item (i.e. a_BlockMeta not initialised yet)
 		switch (a_BlockFace)
 		{
 			case BLOCK_FACE_TOP:
@@ -105,7 +72,16 @@ public:
 					a_BlockMeta = Meta & 0x7; break;
 				}
 			}
+			case BLOCK_FACE_NONE: return false;
 		}  // switch (a_BlockFace)
+
+		// Check if the block at the coordinates is a single slab. Eligibility for combining has already been processed in ClientHandle
+		// Changed to-be-placed to a double slab if we are clicking on a single slab, as opposed to placing one for the first time
+		if (IsAnySlabType(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			a_BlockType = GetDoubleSlabType(m_BlockType);
+		}
+
 		return true;
 	}
 	
@@ -184,6 +160,15 @@ public:
 		ASSERT(!"Unhandled double slab type!");
 		return "";
 	}
+
+
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
+	{
+		NIBBLETYPE OtherMeta = a_Meta & 0x07;  // Contains unrelated meta data.
+
+		// 8th bit is up/down.  1 right-side-up, 0 is up-side-down.
+		return (a_Meta & 0x08) ? 0x00 + OtherMeta : 0x01 + OtherMeta;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockSnow.h b/src/Blocks/BlockSnow.h
index a3daf0393..b21995d3c 100644
--- a/src/Blocks/BlockSnow.h
+++ b/src/Blocks/BlockSnow.h
@@ -72,7 +72,7 @@ public:
 			BLOCKTYPE BlockBelow = a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ);
 			NIBBLETYPE MetaBelow = a_Chunk.GetMeta(a_RelX, a_RelY - 1, a_RelZ);
 			
-			if (g_BlockIsSnowable[BlockBelow] || ((BlockBelow == E_BLOCK_SNOW) && (MetaBelow == 7)))
+			if (cBlockInfo::IsSnowable(BlockBelow) || ((BlockBelow == E_BLOCK_SNOW) && (MetaBelow == 7)))
 			{
 				// If block below is snowable, or it is a thin slow block and has a meta of 7 (full thin snow block), say yay
 				return true;
diff --git a/src/Blocks/BlockStairs.h b/src/Blocks/BlockStairs.h
index c1887bc46..09ff254a6 100644
--- a/src/Blocks/BlockStairs.h
+++ b/src/Blocks/BlockStairs.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockStairsHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>
 {
 public:
 	cBlockStairsHandler(BLOCKTYPE a_BlockType) :
-		cBlockHandler(a_BlockType)
+		cMetaRotator<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>(a_BlockType)
 	{
 
 	}
@@ -25,6 +25,12 @@ public:
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
+		UNUSED(a_ChunkInterface);
+		UNUSED(a_BlockX);
+		UNUSED(a_BlockY);
+		UNUSED(a_BlockZ);
+		UNUSED(a_CursorX);
+		UNUSED(a_CursorZ);
 		a_BlockType = m_BlockType;
 		a_BlockMeta = RotationToMetaData(a_Player->GetYaw());
 		switch (a_BlockFace)
@@ -43,10 +49,12 @@ public:
 				}
 				break;
 			}
+			case BLOCK_FACE_NONE: return false;
 		}
 		return true;
 	}
 	
+	
 	virtual const char * GetStepSound(void) override
 	{
 		if (
@@ -96,54 +104,6 @@ public:
 	}
 
 
-	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x03;  // East -> North
-			case 0x01: return TopBits | 0x02;  // West -> South
-			case 0x02: return TopBits | 0x00;  // South -> East
-			case 0x03: return TopBits | 0x01;  // North -> West
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
-
-
-	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x02;  // East -> South
-			case 0x01: return TopBits | 0x03;  // West -> North
-			case 0x02: return TopBits | 0x01;  // South -> West
-			case 0x03: return TopBits | 0x00;  // North -> East
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
-
-
-	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x00;  // East -> East
-			case 0x01: return TopBits | 0x01;  // West -> West
-			case 0x02: return TopBits | 0x03;  // South -> North
-			case 0x03: return TopBits | 0x02;  // North -> South
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
-
-
 	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
 	{
 		// Toggle bit 3:
@@ -151,20 +111,6 @@ public:
 	}
 
 
-	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
-	{
-		// Bits 3 and 4 stay, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x0c);
-		switch (a_Meta & 0x03)
-		{
-			case 0x00: return TopBits | 0x01;  // East -> West
-			case 0x01: return TopBits | 0x00;  // West -> East
-			case 0x02: return TopBits | 0x02;  // South -> South
-			case 0x03: return TopBits | 0x03;  // North -> North
-		}
-		// Not reachable, but to avoid a compiler warning:
-		return 0;
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockStems.h b/src/Blocks/BlockStems.h
index 705436345..b726a0901 100644
--- a/src/Blocks/BlockStems.h
+++ b/src/Blocks/BlockStems.h
@@ -17,9 +17,10 @@ public:
 	{
 	}
 
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		int ItemType = (m_BlockType == E_BLOCK_MELON_STEM) ? E_ITEM_MELON_SEEDS : E_ITEM_PUMPKIN_SEEDS;
+		short ItemType = (m_BlockType == E_BLOCK_MELON_STEM) ? E_ITEM_MELON_SEEDS : E_ITEM_PUMPKIN_SEEDS;
 		a_Pickups.push_back(cItem(ItemType, 1, 0));
 	}
 
diff --git a/src/Blocks/BlockTNT.h b/src/Blocks/BlockTNT.h
new file mode 100644
index 000000000..283a03730
--- /dev/null
+++ b/src/Blocks/BlockTNT.h
@@ -0,0 +1,32 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockTNTHandler :
+	public cBlockHandler
+{
+public:
+	cBlockTNTHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockTorch.h b/src/Blocks/BlockTorch.h
index f2a4c8665..8ddec8de1 100644
--- a/src/Blocks/BlockTorch.h
+++ b/src/Blocks/BlockTorch.h
@@ -2,17 +2,17 @@
 
 #include "BlockHandler.h"
 #include "../Chunk.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockTorchHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>
 {
 public:
 	cBlockTorchHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>(a_BlockType)
 	{
 	}
 	
@@ -99,7 +99,7 @@ public:
 
 	static bool CanBePlacedOn(BLOCKTYPE a_BlockType, eBlockFace a_BlockFace)
 	{
-		if ( !g_BlockFullyOccupiesVoxel[a_BlockType] )
+		if ( !cBlockInfo::FullyOccupiesVoxel(a_BlockType) )
 		{
 			return (a_BlockFace == BLOCK_FACE_TOP);  // Allow placement only when torch upright (for glass, etc.); exceptions won't even be sent by client, no need to handle
 		}
@@ -129,7 +129,7 @@ public:
 			{
 				return Face;
 			}
-			else if ((g_BlockFullyOccupiesVoxel[BlockInQuestion]) && (i != BLOCK_FACE_BOTTOM))
+			else if (cBlockInfo::FullyOccupiesVoxel(BlockInQuestion) && (i != BLOCK_FACE_BOTTOM))
 			{
 				// Otherwise, if block in that direction is torch placeable and we haven't gotten to it via the bottom face, return that face
 				return Face;
@@ -163,7 +163,7 @@ public:
 			// No need to check for upright orientation, it was done when the torch was placed
 			return true;
 		}
-		else if ( !g_BlockFullyOccupiesVoxel[BlockInQuestion] )
+		else if ( !cBlockInfo::FullyOccupiesVoxel(BlockInQuestion) )
 		{
 			return false;
 		}
@@ -185,67 +185,6 @@ public:
 	{
 		return "step.wood";
 	}
-	
-	
-	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x01: return TopBits | 0x04;  // East  -> North
-			case 0x02: return TopBits | 0x03;  // West  -> South
-			case 0x03: return TopBits | 0x01;  // South -> East
-			case 0x04: return TopBits | 0x02;  // North -> West
-			default:   return a_Meta;          // Floor -> Floor
-		}
-	}
-
-
-	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x01: return TopBits | 0x03;  // East  -> South
-			case 0x02: return TopBits | 0x04;  // West  -> North
-			case 0x03: return TopBits | 0x02;  // South -> West
-			case 0x04: return TopBits | 0x01;  // North -> East
-			default:   return a_Meta;          // Floor -> Floor
-		}
-	}
-
-
-	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x03: return TopBits | 0x04;  // South -> North
-			case 0x04: return TopBits | 0x03;  // North -> South
-			default:   return a_Meta;          // Keep the rest
-		}
-	}
-
-
-	// Mirroring around the XZ plane doesn't make sense for floor torches,
-	// the others stay the same, so let's keep all the metas the same.
-	// The base class does tht for us, no need to override MetaMirrorXZ()
-
-	
-	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
-	{
-		// Bit 4 stays, the rest is swapped around according to a table:
-		NIBBLETYPE TopBits = (a_Meta & 0x08);
-		switch (a_Meta & 0x07)
-		{
-			case 0x01: return TopBits | 0x02;  // East -> West
-			case 0x02: return TopBits | 0x01;  // West -> East
-			default:   return a_Meta;          // Keep the rest
-		}
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockTrapdoor.h b/src/Blocks/BlockTrapdoor.h
index 251044afd..6a36ab874 100644
--- a/src/Blocks/BlockTrapdoor.h
+++ b/src/Blocks/BlockTrapdoor.h
@@ -2,17 +2,17 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
 
 class cBlockTrapdoorHandler :
-	public cBlockHandler
+	public cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x00, 0x03, false>
 {
 public:
 	cBlockTrapdoorHandler(BLOCKTYPE a_BlockType)
-		: cBlockHandler(a_BlockType)
+		: cMetaRotator<cBlockHandler, 0x03, 0x01, 0x02, 0x00, 0x03, false>(a_BlockType)
 	{
 	}
 
@@ -42,6 +42,12 @@ public:
 		World->BroadcastSoundParticleEffect(1003, a_BlockX, a_BlockY, a_BlockZ, 0, a_Player->GetClientHandle());
 	}
 
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		UNUSED(a_ChunkInterface);
+		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
+	}
+
 	virtual bool GetPlacementBlockTypeMeta(
 		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
@@ -99,7 +105,7 @@ public:
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, BlockMetaDataToBlockFace(Meta), true);
 		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && (g_BlockIsSolid[BlockIsOn]);
+		return (a_RelY > 0) && cBlockInfo::IsSolid(BlockIsOn);
 	}
 };
 
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
index ee7dcee8a..7bb9dc484 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -1,8 +1,7 @@
-
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "MetaRotator.h"
 
 
 
@@ -24,6 +23,10 @@ public:
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
+		UNUSED(a_Player);
+		UNUSED(a_CursorX);
+		UNUSED(a_CursorY);
+		UNUSED(a_CursorZ);
 		// TODO: Disallow placement where the vine doesn't attach to something properly
 		BLOCKTYPE BlockType = 0;
 		NIBBLETYPE BlockMeta;
@@ -70,7 +73,7 @@ public:
 	/// Returns true if the specified block type is good for vines to attach to
 	static bool IsBlockAttachable(BLOCKTYPE a_BlockType)
 	{
-		return (a_BlockType == E_BLOCK_LEAVES) || g_BlockIsSolid[a_BlockType];
+		return (a_BlockType == E_BLOCK_LEAVES) || (a_BlockType == E_BLOCK_NEW_LEAVES) || cBlockInfo::IsSolid(a_BlockType);
 	}
 
 
@@ -80,7 +83,7 @@ public:
 		static const struct
 		{
 			int x, z;
-			int Bit;
+			NIBBLETYPE Bit;
 		} Coords[] =
 		{
 			{ 0,  1, 1},  // south, ZP
@@ -88,7 +91,7 @@ public:
 			{ 0, -1, 4},  // north, ZM
 			{ 1,  0, 8},  // east,  XP
 		} ;
-		int res = 0;
+		NIBBLETYPE res = 0;
 		for (size_t i = 0; i < ARRAYCOUNT(Coords); i++)
 		{
 			BLOCKTYPE  BlockType;
@@ -162,11 +165,20 @@ public:
 		return false;
 	}
 	
-	virtual void OnUpdate(cWorld * a_World, int X, int Y, int Z)
+	virtual void OnUpdate(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
 	{
-		if (a_World->GetBlock(X, Y - 1, Z) == E_BLOCK_AIR)
+		UNUSED(a_ChunkInterface);
+		UNUSED(a_WorldInterface);
+		UNUSED(a_BlockPluginInterface);
+
+		BLOCKTYPE Block;
+		a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY - 1, a_RelZ, Block);
+		if (Block == E_BLOCK_AIR)
 		{
-			a_World->SetBlock(X, Y - 1, Z, E_BLOCK_VINES, a_World->GetBlockMeta(X, Y, Z));
+			if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, a_RelX * cChunkDef::Width, a_RelY - 1, a_RelZ * cChunkDef::Width, ssVineSpread))
+			{
+				a_Chunk.UnboundedRelSetBlock(a_RelX, a_RelY - 1, a_RelZ, E_BLOCK_VINES, a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+			}
 		}
 	}
 	
@@ -180,20 +192,21 @@ public:
 	{
 		return ((a_Meta << 1) | (a_Meta >> 3)) & 0x0f;  // Rotate bits to the left
 	}
-	
-	
+
+
 	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
 	{
 		// Bits 2 and 4 stay, bits 1 and 3 swap
-		return ((a_Meta & 0x0a) | ((a_Meta & 0x01) << 2) | ((a_Meta & 0x04) >> 2));
+		return (NIBBLETYPE)((a_Meta & 0x0a) | ((a_Meta & 0x01) << 2) | ((a_Meta & 0x04) >> 2));
 	}
 
 
 	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
 	{
 		// Bits 1 and 3 stay, bits 2 and 4 swap
-		return ((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2));
+		return (NIBBLETYPE)((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2));
 	}
+
 } ;
 
 
diff --git a/src/Blocks/BroadcastInterface.h b/src/Blocks/BroadcastInterface.h
index f6ccd580b..b1b450690 100644
--- a/src/Blocks/BroadcastInterface.h
+++ b/src/Blocks/BroadcastInterface.h
@@ -4,7 +4,9 @@
 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 ~cBroadcastInterface() {}
+	
+	virtual void BroadcastUseBed     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ ) = 0;
+	virtual void BroadcastSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL) = 0;
+	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) = 0;
 };
diff --git a/src/Blocks/ChunkInterface.cpp b/src/Blocks/ChunkInterface.cpp
index b2dda19f4..540581ae7 100644
--- a/src/Blocks/ChunkInterface.cpp
+++ b/src/Blocks/ChunkInterface.cpp
@@ -6,7 +6,7 @@
 
 bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z)
 {
-	cBlockHandler *Handler = cBlockHandler::GetBlockHandler(GetBlock(a_X, a_Y, a_Z));
+	cBlockHandler * Handler = cBlockInfo::GetHandler(GetBlock(a_X, a_Y, a_Z));
 	Handler->OnDestroyed(*this, a_WorldInterface, a_X, a_Y, a_Z);
 	return m_ChunkMap->DigBlock(a_X, a_Y, a_Z);
 }
diff --git a/src/Blocks/ChunkInterface.h b/src/Blocks/ChunkInterface.h
index b30eff1e4..be7c2e0e5 100644
--- a/src/Blocks/ChunkInterface.h
+++ b/src/Blocks/ChunkInterface.h
@@ -5,31 +5,35 @@
 #include "../ForEachChunkProvider.h"
 #include "WorldInterface.h"
 
-class cBlockHandler;
 
-class cChunkInterface : public cForEachChunkProvider
+
+
+
+class cChunkInterface:
+	public cForEachChunkProvider
 {
 public:
 
 	cChunkInterface(cChunkMap * a_ChunkMap) : m_ChunkMap(a_ChunkMap) {}
 
-	BLOCKTYPE  GetBlock          (int a_BlockX, int a_BlockY, int a_BlockZ)
+	BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		return m_ChunkMap->GetBlock(a_BlockX,a_BlockY,a_BlockZ);
 	}
-	BLOCKTYPE  GetBlock    (const Vector3i & a_Pos ) 
+	BLOCKTYPE GetBlock(const Vector3i & a_Pos)
 	{ 
-		return GetBlock( a_Pos.x, a_Pos.y, a_Pos.z ); 
+		return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
 	}
-	NIBBLETYPE GetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ)
+	NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 	}
 
-	bool GetBlockTypeMeta  (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+	bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
 	{
 		return m_ChunkMap->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 	}
+	
 	/** Sets the block at the specified coords to the specified value.
 	Full processing, incl. updating neighbors, is performed.
 	*/
@@ -37,7 +41,8 @@ public:
 	{
 		m_ChunkMap->SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 	}
-	void SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
+	
+	void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
 	{
 		m_ChunkMap->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_MetaData);
 	}
@@ -55,7 +60,11 @@ public:
 	{
 		m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
 	}
-	void       FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta ) { FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta ); }
+	
+	void FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta )
+	{
+		FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta );
+	}
 
 	void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
@@ -77,3 +86,7 @@ public:
 private:
 	cChunkMap * m_ChunkMap;
 };
+
+
+
+
diff --git a/src/Blocks/MetaRotator.h b/src/Blocks/MetaRotator.h
new file mode 100644
index 000000000..899c583e1
--- /dev/null
+++ b/src/Blocks/MetaRotator.h
@@ -0,0 +1,120 @@
+// MetaRotator.h
+
+// Provides a mixin for rotations and reflections
+
+#pragma once
+
+// MSVC generates warnings for the templated AssertIfNotMatched parameter conditions, so disable it:
+#ifdef _MSC_VER
+	#pragma warning(disable: 4127) // Conditional expression is constant
+#endif
+
+
+
+
+
+/*
+Provides a mixin for rotations and reflections following the standard pattern of apply mask then use case.
+
+Usage:
+Inherit from this class providing your base class as Base, the BitMask for the direction bits in bitmask and the masked value for the directions in North, East, South, West. There is also an aptional parameter AssertIfNotMatched. Set this if it is invalid for a block to exist in any other state.
+*/
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched = false>
+class cMetaRotator : public Base
+{
+public:
+
+	cMetaRotator(BLOCKTYPE a_BlockType) :
+		Base(a_BlockType)
+	{}
+	
+	virtual ~cMetaRotator() {}
+
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta)  override;
+	virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta)  override;
+};
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCW(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case South: return West  | OtherMeta; 
+		case West:  return North | OtherMeta; 
+		case North: return East  | OtherMeta;
+		case East:  return South | OtherMeta;
+	}
+	if (AssertIfNotMatched)
+	{
+		ASSERT(!"Invalid Meta value");
+	}
+	return a_Meta;
+}
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCCW(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case South: return East  | OtherMeta; 
+		case East:  return North | OtherMeta;
+		case North: return West  | OtherMeta;
+		case West:  return South | OtherMeta;
+	}
+	if (AssertIfNotMatched)
+	{
+		ASSERT(!"Invalid Meta value");
+	}
+	return a_Meta;
+}
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorXY(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case South: return North | OtherMeta;
+		case North: return South | OtherMeta;
+	}
+	// Not Facing North or South; No change.
+	return a_Meta;
+}
+
+
+
+
+
+template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorYZ(NIBBLETYPE a_Meta)
+{
+	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
+	switch (a_Meta & BitMask)
+	{
+		case West: return East | OtherMeta;
+		case East: return West | OtherMeta;
+	}
+	// Not Facing East or West; No change.
+	return a_Meta;
+}
+
+
+
+
diff --git a/src/Blocks/WorldInterface.h b/src/Blocks/WorldInterface.h
index b6f2f55a7..bfbb053d9 100644
--- a/src/Blocks/WorldInterface.h
+++ b/src/Blocks/WorldInterface.h
@@ -9,7 +9,8 @@ class cItems;
 class cWorldInterface
 {
 public:
-
+	virtual ~cWorldInterface() {}
+	
 	virtual Int64 GetTimeOfDay(void) const = 0;
 	virtual Int64 GetWorldAge(void)  const = 0;
 	
@@ -27,4 +28,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;
+
 };