66 files changed, 4549 insertions, 0 deletions

diff --git a/source/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index 66eb9130c..66eb9130c 100644
--- a/source/Blocks/BlockBed.cpp
+++ b/src/Blocks/BlockBed.cpp
diff --git a/src/Blocks/BlockBed.h b/src/Blocks/BlockBed.h
new file mode 100644
index 000000000..8a289b22c
--- /dev/null
+++ b/src/Blocks/BlockBed.h
@@ -0,0 +1,67 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cBlockBedHandler :
+	public cBlockHandler
+{
+public:
+	cBlockBedHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void OnPlacedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
+
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to zero
+		a_Pickups.push_back(cItem(E_ITEM_BED, 1, 0));
+	}
+
+
+	// Bed specific helper functions
+	static NIBBLETYPE RotationToMetaData(double a_Rotation)
+	{
+		a_Rotation += 180 + (180 / 4);  // So its not aligned with axis
+		if (a_Rotation > 360) a_Rotation -= 360;
+
+		a_Rotation = (a_Rotation / 360) * 4;
+
+		return ((char)a_Rotation + 2) % 4;
+	}
+
+
+	static Vector3i MetaDataToDirection(NIBBLETYPE a_MetaData)
+	{
+		switch (a_MetaData)
+		{
+			case 0: return Vector3i(0, 0, 1);
+			case 1: return Vector3i(-1, 0, 0);
+			case 2: return Vector3i(0, 0, -1);
+			case 3: return Vector3i(1, 0, 0);
+		}
+		return Vector3i();
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockBrewingStand.h b/src/Blocks/BlockBrewingStand.h
index 57642bcb6..57642bcb6 100644
--- a/source/Blocks/BlockBrewingStand.h
+++ b/src/Blocks/BlockBrewingStand.h
diff --git a/src/Blocks/BlockButton.h b/src/Blocks/BlockButton.h
new file mode 100644
index 000000000..c898a0466
--- /dev/null
+++ b/src/Blocks/BlockButton.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockButtonHandler :
+	public cBlockHandler
+{
+public:
+	cBlockButtonHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		// Set p the ON bit to on
+		NIBBLETYPE Meta = (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) | 0x08);
+
+		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+		a_World->BroadcastSoundEffect("random.click", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, (Meta & 0x08) ? 0.6f : 0.5f);
+
+		// Queue a button reset (unpress)
+		a_World->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_BlockType, (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) & 0x07), m_BlockType == E_BLOCK_STONE_BUTTON ? 20 : 30, m_BlockType);
+	}
+
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = BlockFaceToMetaData(a_BlockFace);
+		return true;
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return m_BlockType == E_BLOCK_WOODEN_BUTTON ? "step.wood" : "step.stone";
+	}
+
+
+	inline static NIBBLETYPE BlockFaceToMetaData(char a_BlockFace)
+	{
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_ZM: return 0x4;
+			case BLOCK_FACE_ZP: return 0x3;
+			case BLOCK_FACE_XM: return 0x2;
+			case BLOCK_FACE_XP: return 0x1;
+			default:
+			{
+				ASSERT(!"Unhandled block face!");
+				return 0x0; // No idea, give a special meta (button in centre of block)
+			}
+		}
+	}
+
+	inline static NIBBLETYPE BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
+	{
+		switch (a_Meta & 0x7)
+		{
+			case 0x1: return BLOCK_FACE_XP;
+			case 0x2: return BLOCK_FACE_XM;
+			case 0x3: return BLOCK_FACE_ZP;
+			case 0x4: return BLOCK_FACE_ZM;
+			default:
+			{
+				ASSERT(!"Unhandled block meta!");
+				return BLOCK_FACE_NONE;
+			}
+		}
+	}
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		NIBBLETYPE Meta;
+		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
+
+		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]);
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockCactus.h b/src/Blocks/BlockCactus.h
new file mode 100644
index 000000000..7a9088178
--- /dev/null
+++ b/src/Blocks/BlockCactus.h
@@ -0,0 +1,82 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockCactusHandler :
+	public cBlockHandler
+{
+public:
+	cBlockCactusHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		if (a_RelY <= 0)
+		{
+			return false;
+		}
+		BLOCKTYPE Surface = a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ);
+		if ((Surface != E_BLOCK_SAND) && (Surface != E_BLOCK_CACTUS))
+		{
+			// Cactus can only be placed on sand and itself
+			return false;
+		}
+
+		// Check surroundings. Cacti may ONLY be surrounded by air
+		static const struct
+		{
+			int x, z;
+		} Coords[] =
+		{
+			{-1,  0},
+			{ 1,  0},
+			{ 0, -1},
+			{ 0,  1},
+		} ;
+		for (int i = 0; i < ARRAYCOUNT(Coords); i++)
+		{
+			BLOCKTYPE BlockType;
+			NIBBLETYPE BlockMeta;
+			if (
+				a_Chunk.UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta) &&
+				(BlockType != E_BLOCK_AIR)
+			)
+			{
+				return false;
+			}
+		}  // for i - Coords[]
+
+		return true;
+	}
+	
+
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		a_Chunk.GetWorld()->GrowCactus(a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width, 1);
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.cloth";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockCarpet.h b/src/Blocks/BlockCarpet.h
index 5eafd8c21..5eafd8c21 100644
--- a/source/Blocks/BlockCarpet.h
+++ b/src/Blocks/BlockCarpet.h
diff --git a/source/Blocks/BlockCauldron.h b/src/Blocks/BlockCauldron.h
index b0e00f869..b0e00f869 100644
--- a/source/Blocks/BlockCauldron.h
+++ b/src/Blocks/BlockCauldron.h
diff --git a/source/Blocks/BlockChest.h b/src/Blocks/BlockChest.h
index 488c58ac5..488c58ac5 100644
--- a/source/Blocks/BlockChest.h
+++ b/src/Blocks/BlockChest.h
diff --git a/source/Blocks/BlockCloth.h b/src/Blocks/BlockCloth.h
index a136d3b9d..a136d3b9d 100644
--- a/source/Blocks/BlockCloth.h
+++ b/src/Blocks/BlockCloth.h
diff --git a/source/Blocks/BlockCobWeb.h b/src/Blocks/BlockCobWeb.h
index 982bfaa30..982bfaa30 100644
--- a/source/Blocks/BlockCobWeb.h
+++ b/src/Blocks/BlockCobWeb.h
diff --git a/src/Blocks/BlockComparator.h b/src/Blocks/BlockComparator.h
new file mode 100644
index 000000000..e7e18bac9
--- /dev/null
+++ b/src/Blocks/BlockComparator.h
@@ -0,0 +1,69 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "BlockRedstoneRepeater.h"
+
+
+
+
+
+class cBlockComparatorHandler :
+	public cBlockHandler
+{
+public:
+	cBlockComparatorHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		Meta ^= 0x04; // Toggle 3rd (addition/subtraction) bit with XOR
+		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(E_ITEM_COMPARATOR, 1, 0));
+	}
+
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+	
+	
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
+	}
+	
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+		) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = cBlockRedstoneRepeaterHandler::RepeaterRotationToMetaData(a_Player->GetRotation());
+		return true;
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockCrops.h b/src/Blocks/BlockCrops.h
new file mode 100644
index 000000000..9c4964e02
--- /dev/null
+++ b/src/Blocks/BlockCrops.h
@@ -0,0 +1,114 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../MersenneTwister.h"
+#include "../World.h"
+
+
+
+
+
+/// Common class that takes care of carrots, potatoes and wheat
+class cBlockCropsHandler :
+	public cBlockHandler
+{
+public:
+	cBlockCropsHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_Meta) override
+	{
+		MTRand rand;
+
+		if (a_Meta == 0x7)
+		{
+			// Is fully grown, drop the entire produce:
+			switch (m_BlockType)
+			{
+				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
+					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
+					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)
+					{
+						// With a 5% chance, drop a poisonous potato as well
+						a_Pickups.push_back(cItem(E_ITEM_POISONOUS_POTATO, 1, 0));
+					}
+					break;
+				}
+				default:
+				{
+					ASSERT(!"Unhandled block type");
+					break;
+				}
+			}  // switch (m_BlockType)
+		}
+		else
+		{
+			// Drop 1 item of whatever is growing
+			switch (m_BlockType)
+			{
+				case E_BLOCK_CROPS:    a_Pickups.push_back(cItem(E_ITEM_SEEDS,  1, 0)); break;
+				case E_BLOCK_CARROTS:  a_Pickups.push_back(cItem(E_ITEM_CARROT, 1, 0)); break;
+				case E_BLOCK_POTATOES: a_Pickups.push_back(cItem(E_ITEM_POTATO, 1, 0)); break;
+				default:
+				{
+					ASSERT(!"Unhandled block type");
+					break;
+				}
+			}
+		}
+	}	
+	
+	
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		NIBBLETYPE Meta     = a_Chunk.GetMeta      (a_RelX, a_RelY, a_RelZ);
+		NIBBLETYPE Light    = a_Chunk.GetBlockLight(a_RelX, a_RelY, a_RelZ);
+		NIBBLETYPE SkyLight = a_Chunk.GetSkyLight  (a_RelX, a_RelY, a_RelZ);
+
+		if (SkyLight > Light)
+		{
+			Light = SkyLight;
+		}
+		
+		if ((Meta < 7) && (Light > 8))
+		{
+			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_CROPS, ++Meta);
+		}
+		else if (Light < 9)
+		{
+			a_Chunk.GetWorld()->DigBlock(a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width);
+		}
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_FARMLAND));
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockDeadBush.h b/src/Blocks/BlockDeadBush.h
new file mode 100644
index 000000000..14617d006
--- /dev/null
+++ b/src/Blocks/BlockDeadBush.h
@@ -0,0 +1,35 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+
+
+
+
+
+class cBlockDeadBushHandler :
+	public cBlockHandler
+{
+public:
+	cBlockDeadBushHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Don't drop anything
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return (a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_SAND);
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockDirt.h b/src/Blocks/BlockDirt.h
new file mode 100644
index 000000000..a83dab1fd
--- /dev/null
+++ b/src/Blocks/BlockDirt.h
@@ -0,0 +1,97 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../MersenneTwister.h"
+#include "../World.h"
+
+
+
+
+
+/// Handler used for both dirt and grass
+class cBlockDirtHandler :
+	public cBlockHandler
+{
+public:
+	cBlockDirtHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_DIRT, 1, 0));
+	}
+	
+	
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		if (m_BlockType != E_BLOCK_GRASS)
+		{
+			return;
+		}
+		
+		// Grass becomes dirt if there is something on top of it:
+		if (a_RelY < cChunkDef::Height - 1)
+		{
+			BLOCKTYPE Above = a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ);
+			if ((!g_BlockTransparent[Above] && !g_BlockOneHitDig[Above]) || IsBlockWater(Above))
+			{
+				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, E_META_DIRT_NORMAL);
+				return;
+			}
+		}
+		
+		// Grass spreads to adjacent dirt blocks:
+		MTRand rand;  // TODO: Replace with cFastRandom
+		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]
+	
+			BLOCKTYPE  DestBlock;
+			NIBBLETYPE DestMeta;
+			if ((a_RelY + OfsY < 0) || (a_RelY + OfsY >= cChunkDef::Height - 1))
+			{
+				// Y Coord out of range
+				continue;
+			}
+			int BlockX = a_RelX + OfsX;
+			int BlockY = a_RelY + OfsY;
+			int BlockZ = a_RelZ + OfsZ;
+			cChunk * Chunk = a_Chunk.GetRelNeighborChunkAdjustCoords(BlockX, BlockZ);
+			if (Chunk == NULL)
+			{
+				// Unloaded chunk
+				continue;
+			}
+			Chunk->GetBlockTypeMeta(BlockX, BlockY, BlockZ, DestBlock, DestMeta);
+			if ((DestBlock != E_BLOCK_DIRT) || (DestMeta != E_META_DIRT_NORMAL))
+			{
+				// Not a regular dirt block
+				continue;
+			}
+
+			BLOCKTYPE AboveDest;
+			NIBBLETYPE AboveMeta;
+			Chunk->GetBlockTypeMeta(BlockX, BlockY + 1, BlockZ, AboveDest, AboveMeta);
+			if ((g_BlockOneHitDig[AboveDest] || g_BlockTransparent[AboveDest]) && !IsBlockWater(AboveDest))
+			{
+				Chunk->FastSetBlock(a_RelX + OfsX, a_RelY + OfsY, a_RelZ + OfsZ, E_BLOCK_GRASS, 0);
+			}
+		}  // for i - repeat twice
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.gravel";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockDoor.cpp b/src/Blocks/BlockDoor.cpp
index e71ccd368..e71ccd368 100644
--- a/source/Blocks/BlockDoor.cpp
+++ b/src/Blocks/BlockDoor.cpp
diff --git a/src/Blocks/BlockDoor.h b/src/Blocks/BlockDoor.h
new file mode 100644
index 000000000..03a79d47d
--- /dev/null
+++ b/src/Blocks/BlockDoor.h
@@ -0,0 +1,175 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cBlockDoorHandler :
+	public cBlockHandler
+{
+public:
+	cBlockDoorHandler(BLOCKTYPE a_BlockType);
+
+	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
+	virtual const char * GetStepSound(void) override;
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		// If clicking a bottom face, place the door one block lower:
+		if (a_BlockFace == BLOCK_FACE_BOTTOM)
+		{
+			a_BlockY--;
+		}
+
+		if (
+			!CanReplaceBlock(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ)) ||
+			!CanReplaceBlock(a_World->GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ))
+		)
+		{
+			return false;
+		}
+		
+		a_BlockType = m_BlockType;
+		a_BlockMeta = PlayerYawToMetaData(a_Player->GetRotation());
+		return true;
+	}
+
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem((m_BlockType == E_BLOCK_WOODEN_DOOR) ? E_ITEM_WOODEN_DOOR : E_ITEM_IRON_DOOR, 1, 0));
+	}
+
+
+	virtual void OnPlacedByPlayer(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
+	) override;
+
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
+	}
+	
+	
+	bool CanReplaceBlock(BLOCKTYPE a_BlockType)
+	{
+		switch (a_BlockType)
+		{
+			case E_BLOCK_AIR:
+			case E_BLOCK_TALL_GRASS:
+			case E_BLOCK_WATER:
+			case E_BLOCK_STATIONARY_WATER:
+			case E_BLOCK_LAVA:
+			case E_BLOCK_STATIONARY_LAVA:
+			case E_BLOCK_SNOW:
+			case E_BLOCK_FIRE:
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+
+	/// Converts the player's yaw to placed door's blockmeta
+	inline static NIBBLETYPE PlayerYawToMetaData(double a_Yaw)
+	{
+		ASSERT((a_Yaw >= -180) && (a_Yaw < 180));
+		
+		a_Yaw += 90 + 45;
+		if (a_Yaw > 360)
+		{
+			a_Yaw -= 360;
+		}
+		if ((a_Yaw >= 0) && (a_Yaw < 90))
+		{
+			return 0x0;
+		}
+		else if ((a_Yaw >= 180) && (a_Yaw < 270))
+		{
+			return 0x2;
+		}
+		else if ((a_Yaw >= 90) && (a_Yaw < 180))
+		{
+			return 0x1;
+		}
+		else
+		{
+			return 0x3;
+		}
+	}
+
+
+	/// Returns true if the specified blocktype is any kind of door
+	inline static bool IsDoor(BLOCKTYPE a_Block)
+	{
+		return (a_Block == E_BLOCK_WOODEN_DOOR) || (a_Block == E_BLOCK_IRON_DOOR);
+	}
+
+
+	/// Returns the metadata for the opposite door state (open vs closed)
+	static NIBBLETYPE ChangeStateMetaData(NIBBLETYPE a_MetaData)
+	{
+		return a_MetaData ^ 4;
+	}
+
+
+	/// Changes the door at the specified coords from open to close or vice versa
+	static void ChangeDoor(cWorld * a_World, int a_X, int a_Y, int a_Z)
+	{
+		NIBBLETYPE OldMetaData = a_World->GetBlockMeta(a_X, a_Y, a_Z);
+		
+		a_World->SetBlockMeta(a_X, a_Y, a_Z, ChangeStateMetaData(OldMetaData));
+		
+		if (OldMetaData & 8)
+		{
+			// Current block is top of the door
+			BLOCKTYPE  BottomBlock = a_World->GetBlock(a_X, a_Y - 1, a_Z);
+			NIBBLETYPE BottomMeta  = a_World->GetBlockMeta(a_X, a_Y - 1, a_Z);
+
+			if (IsDoor(BottomBlock) && !(BottomMeta & 8))
+			{
+				a_World->SetBlockMeta(a_X, a_Y - 1, a_Z, ChangeStateMetaData(BottomMeta));
+			}
+		}
+		else
+		{
+			// Current block is bottom of the door
+			BLOCKTYPE  TopBlock = a_World->GetBlock(a_X, a_Y + 1, a_Z);
+			NIBBLETYPE TopMeta = a_World->GetBlockMeta(a_X, a_Y + 1, a_Z);
+
+			if (IsDoor(TopBlock) && (TopMeta & 8))
+			{
+				a_World->SetBlockMeta(a_X, a_Y + 1, a_Z, ChangeStateMetaData(TopMeta));
+			}
+		}
+	}
+	
+	
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockDropSpenser.h b/src/Blocks/BlockDropSpenser.h
new file mode 100644
index 000000000..b7f20825d
--- /dev/null
+++ b/src/Blocks/BlockDropSpenser.h
@@ -0,0 +1,41 @@
+
+// BlockDropSpenser.h
+
+// Declares the cBlockDropSpenserHandler class representing the BlockHandler for Dropper and Dispenser blocks
+
+#pragma once
+
+#include "../Piston.h"
+
+
+
+
+
+class cBlockDropSpenserHandler :
+	public cBlockEntityHandler
+{
+public:
+	cBlockDropSpenserHandler(BLOCKTYPE a_BlockType) :
+		cBlockEntityHandler(a_BlockType)
+	{
+	}
+	
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		
+		// FIXME: Do not use cPiston class for dispenser placement!
+		a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetRotation(), a_Player->GetPitch());
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockEnderchest.h b/src/Blocks/BlockEnderchest.h
new file mode 100644
index 000000000..50d8e38e0
--- /dev/null
+++ b/src/Blocks/BlockEnderchest.h
@@ -0,0 +1,71 @@
+
+#pragma once
+
+#include "BlockEntity.h"
+
+
+
+
+
+class cBlockEnderchestHandler :
+	public cBlockEntityHandler
+{
+public:
+	cBlockEnderchestHandler(BLOCKTYPE a_BlockType)
+		: cBlockEntityHandler(a_BlockType)
+	{
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		//todo: Drop Ender Chest if using silk touch pickaxe
+		a_Pickups.push_back(cItem(E_BLOCK_OBSIDIAN, 8, 0));
+	}
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+		) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = RotationToMetaData(a_Player->GetRotation());
+		return true;
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.stone";
+	}
+	
+	static NIBBLETYPE RotationToMetaData(double a_Rotation)
+	{
+		a_Rotation += 90 + 45;  // So its not aligned with axis
+
+		if (a_Rotation > 360.f)
+		{
+			a_Rotation -= 360.f;
+		}
+		if ((a_Rotation >= 0.f) && (a_Rotation < 90.f))
+		{
+			return 0x4;
+		}
+		else if ((a_Rotation >= 180) && (a_Rotation < 270))
+		{
+			return 0x5;
+		}
+		else if ((a_Rotation >= 90) && (a_Rotation < 180))
+		{
+			return 0x2;
+		}
+		else
+		{
+			return 0x3;
+		}
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockEntity.h b/src/Blocks/BlockEntity.h
index 9c6b23665..9c6b23665 100644
--- a/source/Blocks/BlockEntity.h
+++ b/src/Blocks/BlockEntity.h
diff --git a/src/Blocks/BlockFarmland.h b/src/Blocks/BlockFarmland.h
new file mode 100644
index 000000000..a69d9b775
--- /dev/null
+++ b/src/Blocks/BlockFarmland.h
@@ -0,0 +1,110 @@
+
+// BlockFarmland.h
+
+// Declares the cBlcokFarmlandHandler representing the block handler for farmland
+
+
+
+
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../BlockArea.h"
+
+
+
+
+
+class cBlockFarmlandHandler :
+	public cBlockHandler
+{
+	typedef cBlockHandler super;
+	
+public:
+	cBlockFarmlandHandler(void) :
+		super(E_BLOCK_FARMLAND)
+	{
+	}
+
+
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		bool Found = false;
+		
+		EMCSBiome Biome = a_Chunk.GetBiomeAt(a_RelX, a_RelZ);
+		if (a_Chunk.GetWorld()->IsWeatherWet() && !IsBiomeNoDownfall(Biome))
+		{
+			// Rain hydrates farmland, too, except in Desert biomes.
+			Found = true;
+		}
+		else
+		{
+			// Search for water in a close proximity:
+			// Ref.: http://www.minecraftwiki.net/wiki/Farmland#Hydrated_Farmland_Tiles
+			// TODO: Rewrite this to use the chunk and its neighbors directly
+			cBlockArea Area;
+			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+			if (!Area.Read(a_Chunk.GetWorld(), BlockX - 4, BlockX + 4, a_RelY, a_RelY + 1, BlockZ - 4, BlockZ + 4))
+			{
+				// Too close to the world edge, cannot check surroundings; don't tick at all
+				return;
+			}
+
+			int NumBlocks = Area.GetBlockCount();
+			BLOCKTYPE * BlockTypes = Area.GetBlockTypes();
+			for (int i = 0; i < NumBlocks; i++)
+			{
+				if (
+					(BlockTypes[i] == E_BLOCK_WATER) ||
+					(BlockTypes[i] == E_BLOCK_STATIONARY_WATER)
+				)
+				{
+					Found = true;
+					break;
+				}
+			}  // for i - BlockTypes[]
+		}
+		
+		NIBBLETYPE BlockMeta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
+		
+		if (Found)
+		{
+			// Water was found, hydrate the block until hydration reaches 7:
+			if (BlockMeta < 7)
+			{
+				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, m_BlockType, ++BlockMeta);
+			}
+			return;
+		}
+
+		// Water wasn't found, de-hydrate block:
+		if (BlockMeta > 0)
+		{
+			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_FARMLAND, --BlockMeta);
+			return;
+		}
+		
+		// Farmland too dry. If nothing is growing on top, turn back to dirt:
+		switch (a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ))
+		{
+			case E_BLOCK_CROPS:
+			case E_BLOCK_MELON_STEM:
+			case E_BLOCK_PUMPKIN_STEM:
+			{
+				// Produce on top, don't revert
+				break;
+			}
+			default:
+			{
+				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, 0);
+				break;
+			}
+		}
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockFenceGate.h b/src/Blocks/BlockFenceGate.h
index 6423a7cb0..6423a7cb0 100644
--- a/source/Blocks/BlockFenceGate.h
+++ b/src/Blocks/BlockFenceGate.h
diff --git a/src/Blocks/BlockFire.h b/src/Blocks/BlockFire.h
new file mode 100644
index 000000000..46b56d7e0
--- /dev/null
+++ b/src/Blocks/BlockFire.h
@@ -0,0 +1,228 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockFireHandler :
+	public cBlockHandler
+{
+public:
+	cBlockFireHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	/// Portal boundary and direction variables
+	int XZP, XZM, Dir; // For wont of a better name...
+
+	virtual void OnPlaced(cWorld * a_World, 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		
+		*/
+
+		a_BlockY--; // Because we want the block below the fire
+		FindAndSetPortalFrame(a_BlockX, a_BlockY, a_BlockZ, a_World); // Brought to you by Aperture Science
+	}
+
+	virtual void OnDigging(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		a_World->DigBlock(a_BlockX, a_BlockY, a_BlockZ);
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// No pickups from this block
+	}
+
+	virtual bool IsClickedThrough(void) override
+	{
+		return true;
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+
+	/// Traces along YP until it finds an obsidian block, returns Y difference or 0 if no portal, and -1 for border
+	/// Takes the X, Y, and Z of the base block; with an optional MaxY for portal border finding
+	int FindObsidianCeiling(int X, int Y, int Z, cWorld * a_World, int MaxY = 0)
+	{
+		if (a_World->GetBlock(X, Y, Z) != E_BLOCK_OBSIDIAN)
+		{
+			return 0;
+		}
+
+		int newY = Y + 1;
+
+		for (newY; newY < cChunkDef::Height; newY++)
+		{
+			BLOCKTYPE Block = a_World->GetBlock(X, newY, Z);
+			if ((Block == E_BLOCK_AIR) || (Block == E_BLOCK_FIRE))
+			{
+				continue;
+			}
+			else if (Block == E_BLOCK_OBSIDIAN)
+			{
+				// We found an obsidian ceiling
+				// Make sure MaxY has a value and newY ('ceiling' location) is at one above the base block
+				// This is because the frame is a solid obsidian pillar
+				if ((MaxY != 0) && (newY == Y + 1))
+				{
+					return EvaluatePortalBorder(X, newY, Z, MaxY, a_World);
+				}
+				else
+				{
+					// Return ceiling Y, whoever called this function will decide if it's part of a portal or not
+					return newY;
+				}
+			}
+			else { return 0; }
+		}
+
+		return 0;
+	}
+
+	/// Evaluates if coords have a valid border on top, based on MaxY
+	int EvaluatePortalBorder(int X, int FoundObsidianY, int Z, int MaxY, cWorld * a_World)
+	{
+		for (int checkBorder = FoundObsidianY + 1; checkBorder <= MaxY - 1; checkBorder++) // FoundObsidianY + 1: FoundObsidianY has already been checked in FindObsidianCeiling; MaxY - 1: portal doesn't need corners
+		{
+			if (a_World->GetBlock(X, checkBorder, Z) != E_BLOCK_OBSIDIAN)
+			{
+				// Base obsidian, base + 1 obsidian, base + x NOT obsidian -> not complete portal
+				return 0;
+			}
+		}
+		// Everything was obsidian, found a border!
+		return -1; // Return -1 for a frame border
+	}
+
+	/// Finds entire frame in any direction with the coordinates of a base block and fills hole with nether portal (START HERE)
+	void FindAndSetPortalFrame(int X, int Y, int Z, cWorld * a_World)
+	{
+		int MaxY = FindObsidianCeiling(X, Y, Z, a_World); // Get topmost obsidian block as reference for all other checks
+		int X1 = X + 1, Z1 = Z + 1, X2 = X - 1, Z2 = Z - 1; // Duplicate XZ values, add/subtract one as we've checked the original already the line above
+
+		if (MaxY == 0) // Oh noes! Not a portal coordinate :(
+		{
+			return;
+		}
+
+		if (!FindPortalSliceX(X1, X2, Y, Z, MaxY, a_World))
+		{
+			if (!FindPortalSliceZ(X, Y, Z1, Z2, MaxY, a_World))
+			{
+				return; // No eligible portal construct, abort abort abort!!
+			}
+		}
+
+		for (int Height = Y + 1; Height <= MaxY - 1; Height++) // Loop through boundary to set portal blocks
+		{
+			for (int Width = XZM; Width <= XZP; Width++)
+			{
+				if (Dir == 1)
+				{
+					a_World->SetBlock(Width, Height, Z, E_BLOCK_NETHER_PORTAL, Dir);
+				}
+				else
+				{
+					a_World->SetBlock(X, Height, Width, E_BLOCK_NETHER_PORTAL, Dir);
+				}
+			}
+		}
+
+		return;
+	}
+
+	/// Evaluates if coordinates are a portal going XP/XM; returns true if so, and writes boundaries to variable
+	/// Takes coordinates of base block and Y coord of target obsidian ceiling
+	bool FindPortalSliceX(int X1, int X2, int Y, int Z, int MaxY, cWorld * a_World)
+	{
+		Dir = 1; // Set assumed direction (will change if portal turns out to be facing the other direction)
+		bool FoundFrameXP = false, FoundFrameXM = false;
+		for (X1; ((a_World->GetBlock(X1, Y, Z) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X1, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X1++) // Check XP for obsidian blocks, exempting corners
+		{
+			int Value = FindObsidianCeiling(X1, Y, Z, a_World, MaxY);
+			int ValueTwo = FindObsidianCeiling(X1, Y + 1, Z, a_World, MaxY); // For corners without obsidian
+			if ((Value == -1) || (ValueTwo == -1)) // FindObsidianCeiling returns -1 upon frame-find
+			{
+				FoundFrameXP = true; // Found a frame border in this direction, proceed in other direction (don't go further)
+				break;
+			}
+			else if ((Value != MaxY) && (ValueTwo != MaxY)) // Make sure that there is a valid portal 'slice'
+			{
+				return false; // Not valid slice, no portal can be formed
+			}
+		} XZP = X1 - 1; // Set boundary of frame interior, note that for some reason, the loop of X and the loop of Z go to different numbers, hence -1 here and -2 there
+		for (X2; ((a_World->GetBlock(X2, Y, Z) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X2, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X2--) // Go the other direction (XM)
+		{
+			int Value = FindObsidianCeiling(X2, Y, Z, a_World, MaxY);
+			int ValueTwo = FindObsidianCeiling(X2, Y + 1, Z, a_World, MaxY);
+			if ((Value == -1) || (ValueTwo == -1))
+			{
+				FoundFrameXM = true;
+				break;
+			}
+			else if ((Value != MaxY) && (ValueTwo != MaxY))
+			{
+				return false;
+			}
+		} XZM = X2 + 1; // Set boundary, see previous
+		return (FoundFrameXP && FoundFrameXM);
+	}
+
+	/// Evaluates if coords are a portal going ZP/ZM; returns true if so, and writes boundaries to variable
+	bool FindPortalSliceZ(int X, int Y, int Z1, int Z2, int MaxY, cWorld * a_World)
+	{
+		Dir = 2;
+		bool FoundFrameZP = false, FoundFrameZM = false;
+		for (Z1; ((a_World->GetBlock(X, Y, Z1) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X, Y + 1, Z1) == E_BLOCK_OBSIDIAN)); Z1++)
+		{
+			int Value = FindObsidianCeiling(X, Y, Z1, a_World, MaxY);
+			int ValueTwo = FindObsidianCeiling(X, Y + 1, Z1, a_World, MaxY);
+			if ((Value == -1) || (ValueTwo == -1))
+			{
+				FoundFrameZP = true;
+				continue;
+			}
+			else if ((Value != MaxY) && (ValueTwo != MaxY))
+			{
+				return false;
+			}
+		} XZP = Z1 - 2;
+		for (Z2; ((a_World->GetBlock(X, Y, Z2) == E_BLOCK_OBSIDIAN) || (a_World->GetBlock(X, Y + 1, Z2) == E_BLOCK_OBSIDIAN)); Z2--)
+		{
+			int Value = FindObsidianCeiling(X, Y, Z2, a_World, MaxY);
+			int ValueTwo = FindObsidianCeiling(X, Y + 1, Z2, a_World, MaxY);
+			if ((Value == -1) || (ValueTwo == -1))
+			{
+				FoundFrameZM = true;
+				continue;
+			}
+			else if ((Value != MaxY) && (ValueTwo != MaxY))
+			{
+				return false;
+			}
+		} XZM = Z2 + 2;
+		return (FoundFrameZP && FoundFrameZM);
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockFlower.h b/src/Blocks/BlockFlower.h
new file mode 100644
index 000000000..421e2d5d8
--- /dev/null
+++ b/src/Blocks/BlockFlower.h
@@ -0,0 +1,41 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockFlowerHandler :
+	public cBlockHandler
+{
+public:
+	cBlockFlowerHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return (a_RelY > 0) && IsBlockTypeOfDirt(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ));
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockFlowerPot.h b/src/Blocks/BlockFlowerPot.h
index b0faf5218..b0faf5218 100644
--- a/source/Blocks/BlockFlowerPot.h
+++ b/src/Blocks/BlockFlowerPot.h
diff --git a/src/Blocks/BlockFluid.h b/src/Blocks/BlockFluid.h
new file mode 100644
index 000000000..bce5064bc
--- /dev/null
+++ b/src/Blocks/BlockFluid.h
@@ -0,0 +1,137 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockFluidHandler :
+	public cBlockHandler
+{
+	typedef cBlockHandler super;
+	
+public:
+	cBlockFluidHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+
+	}	
+	
+		
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// No pickups
+	}
+	
+	
+	virtual bool DoesIgnoreBuildCollision(void) override
+	{
+		return true;
+	}
+	
+	
+	virtual void Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) override
+	{
+		switch (m_BlockType)
+		{
+			case E_BLOCK_STATIONARY_LAVA:
+			{
+				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_LAVA, a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+				break;
+			}
+			case E_BLOCK_STATIONARY_WATER:
+			{
+				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_WATER, a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+				break;
+			}
+		}
+		super::Check(a_RelX, a_RelY, a_RelZ, a_Chunk);
+	}
+} ;
+
+
+
+
+
+class cBlockLavaHandler :
+	public cBlockFluidHandler
+{
+	typedef cBlockFluidHandler super;
+public:
+
+	cBlockLavaHandler(BLOCKTYPE a_BlockType) :
+		super(a_BlockType)
+	{
+	}
+	
+	
+	/// Called to tick the block
+	virtual void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		if (a_Chunk.GetWorld()->ShouldLavaSpawnFire())
+		{
+			// Try to start up to 5 fires:
+			for (int i = 0; i < 5; i++)
+			{
+				TryStartFireNear(a_RelX, a_RelY, a_RelZ, a_Chunk);
+			}
+		}
+	}
+	
+	
+	/// Tries to start a fire near the lava at given coords. Returns true if fire started.
+	static bool TryStartFireNear(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk)
+	{
+		// Pick a block next to this lava block:
+		int rnd = a_Chunk.GetWorld()->GetTickRandomNumber(cChunkDef::NumBlocks * 8) / 7;
+		int x = (rnd % 3) - 1;         // -1 .. 1
+		int y = ((rnd / 4) % 4) - 1;   // -1 .. 2
+		int z = ((rnd / 16) % 3) - 1;  // -1 .. 1
+		
+		// Check if it's fuel:
+		BLOCKTYPE BlockType;
+		if (
+			!a_Chunk.UnboundedRelGetBlockType(a_RelX + x, a_RelY + y, a_RelZ + z, BlockType) ||
+			!cFireSimulator::IsFuel(BlockType)
+		)
+		{
+			return false;
+		}
+		
+		// Try to set it on fire:
+		static struct
+		{
+			int x, y, z;
+		} CrossCoords[] =
+		{
+			{-1,  0,  0},
+			{ 1,  0,  0},
+			{ 0, -1,  0},
+			{ 0,  1,  0},
+			{ 0,  0, -1},
+			{ 0,  0,  1},
+		} ;
+		int RelX = a_RelX + x;
+		int RelY = a_RelY + y;
+		int RelZ = a_RelZ + z;
+		for (size_t i = 0; i < ARRAYCOUNT(CrossCoords); i++)
+		{
+			if (
+				a_Chunk.UnboundedRelGetBlockType(RelX + CrossCoords[i].x, RelY + CrossCoords[i].y, RelZ + CrossCoords[i].z, BlockType) &&
+				(BlockType == E_BLOCK_AIR)
+			)
+			{
+				// This is an air block next to a fuel next to lava, light it up:
+				a_Chunk.UnboundedRelSetBlock(RelX + CrossCoords[i].x, RelY + CrossCoords[i].y, RelZ + CrossCoords[i].z, E_BLOCK_FIRE, 0);
+				return true;
+			}
+		}  // for i - CrossCoords[]
+		return false;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockFurnace.h b/src/Blocks/BlockFurnace.h
new file mode 100644
index 000000000..5b067d7b7
--- /dev/null
+++ b/src/Blocks/BlockFurnace.h
@@ -0,0 +1,46 @@
+
+#pragma once
+
+#include "BlockEntity.h"
+#include "../World.h"
+#include "../Piston.h"
+
+
+
+
+
+class cBlockFurnaceHandler :
+	public cBlockEntityHandler
+{
+public:
+	cBlockFurnaceHandler(BLOCKTYPE a_BlockType) :
+		cBlockEntityHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_FURNACE, 1, 0));
+	}
+
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		
+		// FIXME: Do not use cPiston class for furnace placement!
+		a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetRotation(), 0);
+		
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockGlass.h b/src/Blocks/BlockGlass.h
index f6958bbb6..f6958bbb6 100644
--- a/source/Blocks/BlockGlass.h
+++ b/src/Blocks/BlockGlass.h
diff --git a/source/Blocks/BlockGlowstone.h b/src/Blocks/BlockGlowstone.h
index 5f0d95dee..5f0d95dee 100644
--- a/source/Blocks/BlockGlowstone.h
+++ b/src/Blocks/BlockGlowstone.h
diff --git a/source/Blocks/BlockGravel.h b/src/Blocks/BlockGravel.h
index e1c9ff390..e1c9ff390 100644
--- a/source/Blocks/BlockGravel.h
+++ b/src/Blocks/BlockGravel.h
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
new file mode 100644
index 000000000..99559ed02
--- /dev/null
+++ b/src/Blocks/BlockHandler.cpp
@@ -0,0 +1,469 @@
+
+#include "Globals.h"
+#include "BlockHandler.h"
+#include "../Item.h"
+#include "../World.h"
+#include "../Root.h"
+#include "../Bindings/PluginManager.h"
+#include "BlockBed.h"
+#include "BlockBrewingStand.h"
+#include "BlockButton.h"
+#include "BlockCactus.h"
+#include "BlockCarpet.h"
+#include "BlockCauldron.h"
+#include "BlockChest.h"
+#include "BlockCloth.h"
+#include "BlockCobWeb.h"
+#include "BlockComparator.h"
+#include "BlockCrops.h"
+#include "BlockDeadBush.h"
+#include "BlockDirt.h"
+#include "BlockDoor.h"
+#include "BlockDropSpenser.h"
+#include "BlockEnderchest.h"
+#include "BlockEntity.h"
+#include "BlockFarmland.h"
+#include "BlockFenceGate.h"
+#include "BlockFire.h"
+#include "BlockFlower.h"
+#include "BlockFlowerPot.h"
+#include "BlockFluid.h"
+#include "BlockFurnace.h"
+#include "BlockGlass.h"
+#include "BlockGlowstone.h"
+#include "BlockGravel.h"
+#include "BlockHopper.h"
+#include "BlockIce.h"
+#include "BlockLadder.h"
+#include "BlockLeaves.h"
+#include "BlockLever.h"
+#include "BlockMelon.h"
+#include "BlockMushroom.h"
+#include "BlockMycelium.h"
+#include "BlockNote.h"
+#include "BlockOre.h"
+#include "BlockPiston.h"
+#include "BlockPlanks.h"
+#include "BlockPortal.h"
+#include "BlockPumpkin.h"
+#include "BlockRail.h"
+#include "BlockRedstone.h"
+#include "BlockRedstoneLamp.h"
+#include "BlockRedstoneRepeater.h"
+#include "BlockRedstoneTorch.h"
+#include "BlockSand.h"
+#include "BlockSapling.h"
+#include "BlockSign.h"
+#include "BlockSlab.h"
+#include "BlockSnow.h"
+#include "BlockStairs.h"
+#include "BlockStems.h"
+#include "BlockStone.h"
+#include "BlockSugarcane.h"
+#include "BlockTallGrass.h"
+#include "BlockTorch.h"
+#include "BlockTrapdoor.h"
+#include "BlockVine.h"
+#include "BlockWood.h"
+#include "BlockWorkbench.h"
+
+
+
+
+
+bool            cBlockHandler::m_HandlerInitialized = false;
+cBlockHandler * cBlockHandler::m_BlockHandler[256];
+
+
+
+
+
+cBlockHandler * cBlockHandler::GetBlockHandler(BLOCKTYPE a_BlockType)
+{
+	if (!m_HandlerInitialized)
+	{
+		// We have to initialize
+		memset(m_BlockHandler, 0, sizeof(m_BlockHandler));
+		m_HandlerInitialized = true;
+	}
+	if (m_BlockHandler[a_BlockType] != NULL)
+	{
+		return m_BlockHandler[a_BlockType];
+	}
+
+	return m_BlockHandler[a_BlockType] = CreateBlockHandler(a_BlockType);
+}
+
+
+
+
+
+cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
+{
+	switch(a_BlockType)
+	{
+		// Block handlers, alphabetically sorted:
+		case E_BLOCK_ACTIVATOR_RAIL:        return new cBlockRailHandler            (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_CARROTS:               return new cBlockCropsHandler           (a_BlockType);
+		case E_BLOCK_CARPET:                return new cBlockCarpetHandler          (a_BlockType);
+		case E_BLOCK_CAULDRON:              return new cBlockCauldronHandler        (a_BlockType);
+		case E_BLOCK_CHEST:                 return new cBlockChestHandler           (a_BlockType);
+		case E_BLOCK_COAL_ORE:              return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_ACTIVE_COMPARATOR:     return new cBlockComparatorHandler      (a_BlockType);
+		case E_BLOCK_COBBLESTONE:           return new cBlockStoneHandler           (a_BlockType);
+		case E_BLOCK_COBBLESTONE_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_COBWEB:                return new cBlockCobWebHandler          (a_BlockType);
+		case E_BLOCK_CROPS:                 return new cBlockCropsHandler           (a_BlockType);
+		case E_BLOCK_DEAD_BUSH:             return new cBlockDeadBushHandler        (a_BlockType);
+		case E_BLOCK_DETECTOR_RAIL:         return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_DIAMOND_ORE:           return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_DIRT:                  return new cBlockDirtHandler            (a_BlockType);
+		case E_BLOCK_DISPENSER:             return new cBlockDropSpenserHandler     (a_BlockType);
+		case E_BLOCK_DOUBLE_STONE_SLAB:     return new cBlockDoubleSlabHandler      (a_BlockType);
+		case E_BLOCK_DOUBLE_WOODEN_SLAB:    return new cBlockDoubleSlabHandler      (a_BlockType);
+		case E_BLOCK_DROPPER:               return new cBlockDropSpenserHandler     (a_BlockType);
+		case E_BLOCK_EMERALD_ORE:           return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_ENDER_CHEST:           return new cBlockEnderchestHandler      (a_BlockType);
+		case E_BLOCK_FARMLAND:              return new cBlockFarmlandHandler        (           );
+		case E_BLOCK_FENCE_GATE:            return new cBlockFenceGateHandler       (a_BlockType);
+		case E_BLOCK_FIRE:                  return new cBlockFireHandler            (a_BlockType);
+		case E_BLOCK_FLOWER_POT:            return new cBlockFlowerPotHandler       (a_BlockType);
+		case E_BLOCK_FURNACE:               return new cBlockFurnaceHandler         (a_BlockType);
+		case E_BLOCK_GLOWSTONE:             return new cBlockGlowstoneHandler       (a_BlockType);
+		case E_BLOCK_GOLD_ORE:              return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_GLASS:                 return new cBlockGlassHandler           (a_BlockType);
+		case E_BLOCK_GRASS:                 return new cBlockDirtHandler            (a_BlockType);
+		case E_BLOCK_GRAVEL:                return new cBlockGravelHandler          (a_BlockType);
+		case E_BLOCK_HOPPER:                return new cBlockHopperHandler          (a_BlockType);
+		case E_BLOCK_ICE:                   return new cBlockIceHandler             (a_BlockType);
+		case E_BLOCK_INACTIVE_COMPARATOR:   return new cBlockComparatorHandler      (a_BlockType);
+		case E_BLOCK_IRON_DOOR:             return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_IRON_ORE:              return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_JACK_O_LANTERN:        return new cBlockPumpkinHandler         (a_BlockType);
+		case E_BLOCK_JUKEBOX:               return new cBlockEntityHandler          (a_BlockType);
+		case E_BLOCK_JUNGLE_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_LADDER:                return new cBlockLadderHandler          (a_BlockType);
+		case E_BLOCK_LEVER:                 return new cBlockLeverHandler           (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_LIT_FURNACE:           return new cBlockFurnaceHandler         (a_BlockType);
+		case E_BLOCK_LOG:                   return new cBlockWoodHandler            (a_BlockType);
+		case E_BLOCK_MELON:                 return new cBlockMelonHandler           (a_BlockType);
+		case E_BLOCK_MELON_STEM:            return new cBlockStemsHandler           (a_BlockType);
+		case E_BLOCK_MYCELIUM:              return new cBlockMyceliumHandler        (a_BlockType);
+		case E_BLOCK_NETHER_BRICK_STAIRS:   return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_NETHER_PORTAL:         return new cBlockPortalHandler          (a_BlockType);
+		case E_BLOCK_NOTE_BLOCK:            return new cBlockNoteHandler            (a_BlockType);
+		case E_BLOCK_PISTON:                return new cBlockPistonHandler          (a_BlockType);
+		case E_BLOCK_PISTON_EXTENSION:      return new cBlockPistonHeadHandler      (           );
+		case E_BLOCK_PLANKS:                return new cBlockPlanksHandler          (a_BlockType);
+		case E_BLOCK_POTATOES:              return new cBlockCropsHandler           (a_BlockType);
+		case E_BLOCK_POWERED_RAIL:          return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_PUMPKIN:               return new cBlockPumpkinHandler         (a_BlockType);
+		case E_BLOCK_PUMPKIN_STEM:          return new cBlockStemsHandler           (a_BlockType);
+		case E_BLOCK_QUARTZ_STAIRS:         return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_RAIL:                  return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_REDSTONE_LAMP_ON:      return new cBlockRedstoneLampHandler    (a_BlockType); // We need this to change pickups to an off lamp; else 1.7+ clients crash
+		case E_BLOCK_REDSTONE_ORE:          return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_REDSTONE_ORE_GLOWING:  return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_REDSTONE_REPEATER_OFF: return new cBlockRedstoneRepeaterHandler(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_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);
+		case E_BLOCK_SANDSTONE_STAIRS:      return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_SAPLING:               return new cBlockSaplingHandler         (a_BlockType);
+		case E_BLOCK_SIGN_POST:             return new cBlockSignHandler            (a_BlockType);
+		case E_BLOCK_SNOW:                  return new cBlockSnowHandler            (a_BlockType);
+		case E_BLOCK_SPRUCE_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_STATIONARY_LAVA:       return new cBlockLavaHandler            (a_BlockType);
+		case E_BLOCK_STATIONARY_WATER:      return new cBlockFluidHandler           (a_BlockType);
+		case E_BLOCK_STICKY_PISTON:         return new cBlockPistonHandler          (a_BlockType);
+		case E_BLOCK_STONE:                 return new cBlockStoneHandler           (a_BlockType);
+		case E_BLOCK_STONE_BRICK_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_STONE_BUTTON:          return new cBlockButtonHandler          (a_BlockType);
+		case E_BLOCK_STONE_SLAB:            return new cBlockSlabHandler            (a_BlockType);
+		case E_BLOCK_SUGARCANE:             return new cBlockSugarcaneHandler       (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_VINES:                 return new cBlockVineHandler            (a_BlockType);
+		case E_BLOCK_WALLSIGN:              return new cBlockSignHandler            (a_BlockType);
+		case E_BLOCK_WATER:                 return new cBlockFluidHandler           (a_BlockType);
+		case E_BLOCK_WOODEN_BUTTON:         return new cBlockButtonHandler          (a_BlockType);
+		case E_BLOCK_WOODEN_DOOR:           return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_WOODEN_SLAB:           return new cBlockSlabHandler            (a_BlockType);
+		case E_BLOCK_WOODEN_STAIRS:         return new cBlockStairsHandler          (a_BlockType);
+		case E_BLOCK_WOOL:                  return new cBlockClothHandler           (a_BlockType);
+		case E_BLOCK_WORKBENCH:             return new cBlockWorkbenchHandler       (a_BlockType);
+		case E_BLOCK_YELLOW_FLOWER:         return new cBlockFlowerHandler          (a_BlockType);
+			
+		default: return new cBlockHandler(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;
+}
+
+
+
+
+
+bool cBlockHandler::GetPlacementBlockTypeMeta(
+	cWorld * a_World, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+	int a_CursorX, int a_CursorY, int a_CursorZ,
+	BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+)
+{
+	// By default, all blocks can be placed and the meta is copied over from the item's damage value:
+	a_BlockType = m_BlockType;
+	a_BlockMeta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage & 0x0f);
+	return true;
+}
+
+
+
+
+
+void cBlockHandler::OnUpdate(cChunk & a_Chunk, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnPlacedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnDestroyedByPlayer(cWorld *a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnPlaced(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	// Notify the neighbors
+	NeighborChanged(a_World, a_BlockX - 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX + 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ - 1);
+	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ + 1);
+}
+
+
+
+
+
+void cBlockHandler::OnDestroyed(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	// Notify the neighbors
+	NeighborChanged(a_World, a_BlockX - 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX + 1, a_BlockY, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX, a_BlockY - 1, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX, a_BlockY + 1, a_BlockZ);
+	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ - 1);
+	NeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ + 1);
+}
+
+
+
+
+
+void cBlockHandler::NeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	if ((a_BlockY >= 0) && (a_BlockY < cChunkDef::Height))
+	{
+		GetBlockHandler(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ))->OnNeighborChanged(a_World, a_BlockX, a_BlockY, a_BlockZ);
+	}
+}
+
+
+
+
+
+void cBlockHandler::OnNeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnDigging(cWorld *a_World, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::OnUse(cWorld *a_World, cPlayer *a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ)
+{
+}
+
+
+
+
+
+void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
+{
+	// Setting the meta to a_BlockMeta keeps most textures. The few other blocks have to override this.
+	a_Pickups.push_back(cItem(m_BlockType, 1, a_BlockMeta));
+}
+
+
+
+
+
+void cBlockHandler::DropBlock(cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	cItems Pickups;
+	NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+	ConvertToPickups(Pickups, Meta);
+	
+	// Allow plugins to modify the pickups:
+	cRoot::Get()->GetPluginManager()->CallHookBlockToPickups(a_World, a_Digger, a_BlockX, a_BlockY, a_BlockZ, m_BlockType, Meta, Pickups);
+	
+	if (!Pickups.empty())
+	{
+		MTRand r1;
+
+		// Mid-block position first
+		double MicroX, MicroY, MicroZ;
+		MicroX = a_BlockX + 0.5;
+		MicroY = a_BlockY + 0.5;
+		MicroZ = a_BlockZ + 0.5;
+
+		// Add random offset second (this causes pickups to spawn inside blocks most times, it's a little buggy)
+		//MicroX += (int)(r1.randInt(16) + r1.randInt(16) - 16);
+		//MicroY += (int)(r1.randInt(16) + r1.randInt(16) - 16);
+		//MicroZ += (int)(r1.randInt(16) + r1.randInt(16) - 16);
+
+		a_World->SpawnItemPickups(Pickups, MicroX, MicroY, MicroZ);
+	}
+}
+
+
+
+
+
+const char * cBlockHandler::GetStepSound()
+{
+	return "step.stone";
+}
+
+
+
+
+
+bool cBlockHandler::CanBeAt(int a_BlockX, int a_BlockY, int a_BlockZ, const cChunk & a_Chunk)
+{
+	return true;
+}
+
+
+
+
+
+bool cBlockHandler::IsUseable()
+{
+	return false;
+}
+
+
+
+
+
+bool cBlockHandler::IsClickedThrough(void)
+{
+	return false;
+}
+
+
+
+
+
+bool cBlockHandler::DoesIgnoreBuildCollision(void)
+{
+	return (m_BlockType == E_BLOCK_AIR);
+}
+
+
+
+
+
+bool cBlockHandler::DoesDropOnUnsuitable(void)
+{
+	return true;
+}
+
+
+
+
+
+void cBlockHandler::Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk)
+{
+	if (!CanBeAt(a_RelX, a_RelY, a_RelZ, a_Chunk))
+	{
+		if (DoesDropOnUnsuitable())
+		{
+			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+			DropBlock(a_Chunk.GetWorld(), NULL, BlockX, a_RelY, BlockZ);
+		}
+		
+		a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);
+	}
+	else
+	{
+		// Wake up the simulators for this block:
+		int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+		int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+		a_Chunk.GetWorld()->GetSimulatorManager()->WakeUp(BlockX, a_RelY, BlockZ, &a_Chunk);
+	}
+}
+
+
+
+
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
new file mode 100644
index 000000000..107d36476
--- /dev/null
+++ b/src/Blocks/BlockHandler.h
@@ -0,0 +1,160 @@
+
+#pragma once
+
+#include "../Defines.h"
+#include "../Item.h"
+#include "../Chunk.h"
+
+
+
+
+
+// fwd:
+class cWorld;
+class cPlayer;
+
+
+
+
+
+class cBlockHandler
+{
+public:
+	cBlockHandler(BLOCKTYPE a_BlockType);
+
+	/// Called when the block gets ticked either by a random tick or by a queued tick.
+	/// Note that the coords are chunk-relative!
+	virtual void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ);
+
+	/** Called before a block is placed	into a world. 
+	The handler should return true to allow placement, false to refuse.
+	Also, the handler should set a_BlockType and a_BlockMeta to correct values for the newly placed block.
+	Called by cItemHandler::GetPlacementBlockTypeMeta() if the item is a block
+	*/
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	);
+
+	/// Called by cWorld::SetBlock() after the block has been set
+	virtual void OnPlaced(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	
+	/// Called by cClientHandle::HandlePlaceBlock() after the player has placed a new block. Called after OnPlaced().
+	virtual void OnPlacedByPlayer(
+		cWorld * a_World, cPlayer * a_Player, 
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
+	);
+	
+	/// Called before the player has destroyed a block
+	virtual void OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Called before a block gets destroyed / replaced with air
+	virtual void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Called when a direct neighbor of this block has been changed (The position is the own position, not the neighbor position)
+	virtual void OnNeighborChanged(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Notifies all neighbors of the given block about a change
+	static void NeighborChanged(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Called while the player diggs the block.
+	virtual void OnDigging(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Called if the user right clicks the block and the block is useable
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ);
+	
+	/// <summary>Called when the item is mined to convert it into pickups. Pickups may specify multiple items. Appends items to a_Pickups, preserves its original contents</summary>
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta);
+	
+	/// Handles the dropping of a block based on what ConvertToDrops() returns. This will not destroy the block. a_Digger is the entity causing the drop; it may be NULL
+	virtual void DropBlock(cWorld * a_World, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ);
+	
+	/// Returns step sound name of block
+	virtual const char * GetStepSound(void);
+	
+	/// Checks if the block can stay at the specified relative coords in the chunk
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk);
+	
+	/** Checks if the block can be placed at this point.
+	Default: CanBeAt(...) 
+	NOTE: This call doesn't actually place the block
+	*/
+	// virtual bool CanBePlacedAt(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir);
+		
+	/// Called to check whether this block supports a rclk action. If it returns true, OnUse() is called
+	virtual bool IsUseable(void);
+	
+	/** Indicates whether the client will click through this block. 
+	For example digging a fire will hit the block below the fire so fire is clicked through
+	*/
+	virtual bool IsClickedThrough(void);
+	
+	/** Checks if the player can build "inside" this block. 
+	For example blocks placed "on" snow will be placed at the same position. So: Snow ignores Build collision
+	*/
+	virtual bool DoesIgnoreBuildCollision(void);
+
+	/// <summary>Similar to DoesIgnoreBuildCollision(void), but is used for cases where block meta/player item-in-hand is needed to determine collision (thin snow)</summary>
+	virtual bool DoesIgnoreBuildCollision(cPlayer * a_Player, NIBBLETYPE a_Meta) { return DoesIgnoreBuildCollision(); }
+
+	/// <summary>Returns if this block drops if it gets destroyed by an unsuitable situation. Default: true</summary>
+	virtual bool DoesDropOnUnsuitable(void);
+	
+	/** Called when one of the neighbors gets set; equivalent to MC block update. 
+	By default drops if position no more suitable (CanBeAt(), DoesDropOnUnsuitable(), Drop()),
+	and wakes up all simulators on the block.
+	*/
+	virtual void Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk);
+	
+	/// <summary>Rotates a given block meta counter-clockwise. Default: no change</summary>
+	/// <returns>Block meta following rotation</returns>
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) { return a_Meta; }
+	
+	/// <summary>Rotates a given block meta clockwise. Default: no change</summary>
+	/// <returns>Block meta following rotation</returns>
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) { return a_Meta; }
+	
+	/// <summary>Mirros a given block meta around the XY plane. Default: no change</summary>
+	/// <returns>Block meta following mirroring</returns>
+	virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) { return a_Meta; }
+
+	/// <summary>Mirros a given block meta around the XZ plane. Default: no change</summary>
+	/// <returns>Block meta following mirroring</returns>
+	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) { return a_Meta; }
+
+	/// <summary>Mirros a given block meta around the YZ plane. Default: no change</summary>
+	/// <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
+};
+
+
+
+
+
+// Shortcut to get the blockhandler for a specific block
+inline cBlockHandler * BlockHandler(BLOCKTYPE a_BlockType)
+{
+	return cBlockHandler::GetBlockHandler(a_BlockType);
+}
+
+
+
+
diff --git a/source/Blocks/BlockHopper.h b/src/Blocks/BlockHopper.h
index 3998276d7..3998276d7 100644
--- a/source/Blocks/BlockHopper.h
+++ b/src/Blocks/BlockHopper.h
diff --git a/source/Blocks/BlockIce.h b/src/Blocks/BlockIce.h
index af4961114..af4961114 100644
--- a/source/Blocks/BlockIce.h
+++ b/src/Blocks/BlockIce.h
diff --git a/source/Blocks/BlockLadder.h b/src/Blocks/BlockLadder.h
index c0aa25f60..c0aa25f60 100644
--- a/source/Blocks/BlockLadder.h
+++ b/src/Blocks/BlockLadder.h
diff --git a/src/Blocks/BlockLeaves.h b/src/Blocks/BlockLeaves.h
new file mode 100644
index 000000000..539d12a49
--- /dev/null
+++ b/src/Blocks/BlockLeaves.h
@@ -0,0 +1,185 @@
+#pragma once
+#include "BlockHandler.h"
+#include "../MersenneTwister.h"
+#include "../World.h"
+#include "../BlockArea.h"
+
+
+
+
+
+// Leaves can be this many blocks that away (inclusive) from the log not to decay
+#define LEAVES_CHECK_DISTANCE 6
+
+#define PROCESS_NEIGHBOR(x,y,z) \
+	switch (a_Area.GetBlockType(x, y, z)) \
+	{ \
+		case E_BLOCK_LEAVES: a_Area.SetBlockType(x, y, z, (BLOCKTYPE)(E_BLOCK_SPONGE + i + 1)); break; \
+		case E_BLOCK_LOG: return true; \
+	}
+
+bool HasNearLog(cBlockArea &a_Area, int a_BlockX, int a_BlockY, int a_BlockZ);
+
+
+
+
+
+class cBlockLeavesHandler :
+	public cBlockHandler
+{
+public:
+	cBlockLeavesHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		MTRand rand;
+
+		// Only the first 2 bits contain the display information, the others are for growing
+		if (rand.randInt(5) == 0)
+		{
+			a_Pickups.push_back(cItem(E_BLOCK_SAPLING, 1, a_BlockMeta & 3));
+		}
+		if ((a_BlockMeta & 3) == E_META_SAPLING_APPLE)
+		{
+			if (rand.rand(100) == 0)
+			{
+				a_Pickups.push_back(cItem(E_ITEM_RED_APPLE, 1, 0));
+			}
+		}
+	}
+
+
+	void OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		cBlockHandler::OnDestroyed(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		
+		//0.5% chance of dropping an apple
+		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		//check if Oak (0x1 and 0x2 bit not set)
+		MTRand rand;
+		if(!(Meta & 3) && rand.randInt(200) == 100)
+		{
+			cItems Drops;
+			Drops.push_back(cItem(E_ITEM_RED_APPLE, 1, 0));
+			a_World->SpawnItemPickups(Drops, a_BlockX, a_BlockY, a_BlockZ);
+		}
+	}
+	
+	
+	virtual void OnNeighborChanged(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta & 0x7);	 // Unset 0x8 bit so it gets checked for decay
+	}
+	
+	
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
+		if ((Meta & 0x04) != 0)
+		{
+			// Player-placed leaves, don't decay
+			return;
+		}
+
+		if ((Meta & 0x8) != 0)
+		{
+			// These leaves have been checked for decay lately and nothing around them changed
+			return;
+		}
+
+		// Get the data around the leaves:
+		int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+		int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+		cBlockArea Area;
+		if (!Area.Read(
+			a_Chunk.GetWorld(), 
+			BlockX - LEAVES_CHECK_DISTANCE, BlockX + LEAVES_CHECK_DISTANCE, 
+			a_RelY - LEAVES_CHECK_DISTANCE, a_RelY + LEAVES_CHECK_DISTANCE, 
+			BlockZ - LEAVES_CHECK_DISTANCE, BlockZ + LEAVES_CHECK_DISTANCE, 
+			cBlockArea::baTypes)
+		)
+		{
+			// Cannot check leaves, a chunk is missing too close
+			return;
+		}
+
+		if (HasNearLog(Area, BlockX, a_RelY, BlockZ))
+		{
+			// Wood found, the leaves stay; mark them as checked:
+			a_Chunk.SetMeta(a_RelX, a_RelY, a_RelZ, Meta | 0x8);
+			return;
+		}
+
+		// Decay the leaves:
+		DropBlock(a_Chunk.GetWorld(), NULL, BlockX, a_RelY, BlockZ);
+		a_Chunk.GetWorld()->DigBlock(BlockX, a_RelY, BlockZ);
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
+
+bool HasNearLog(cBlockArea & a_Area, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	// Filter the blocks into a {leaves, log, other (air)} set:
+	BLOCKTYPE * Types = a_Area.GetBlockTypes();
+	for (int i = a_Area.GetBlockCount() - 1; i > 0; i--)
+	{
+		switch (Types[i])
+		{
+			case E_BLOCK_LEAVES:
+			case E_BLOCK_LOG:
+			{
+				break;
+			}
+			default:
+			{
+				Types[i] = E_BLOCK_AIR;
+				break;
+			}
+		}
+	}  // for i - Types[]
+	
+	// Perform a breadth-first search to see if there's a log connected within 4 blocks of the leaves block:
+	// Simply replace all reachable leaves blocks with a sponge block plus iteration (in the Area) and see if we can reach a log in 4 iterations
+	a_Area.SetBlockType(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_SPONGE);
+	for (int i = 0; i < LEAVES_CHECK_DISTANCE; i++)
+	{
+		for (int y = a_BlockY - i; y <= a_BlockY + i; y++)
+		{
+			for (int z = a_BlockZ - i; z <= a_BlockZ + i; z++)
+			{
+				for (int x = a_BlockX - i; x <= a_BlockX + i; x++)
+				{
+					if (a_Area.GetBlockType(x, y, z) != E_BLOCK_SPONGE + i)
+					{
+						continue;
+					}
+					PROCESS_NEIGHBOR(x - 1, y,     z);
+					PROCESS_NEIGHBOR(x + 1, y,     z);
+					PROCESS_NEIGHBOR(x,     y,     z - 1);
+					PROCESS_NEIGHBOR(x,     y,     z + 1);
+					PROCESS_NEIGHBOR(x,     y + 1, z);
+					PROCESS_NEIGHBOR(x,     y - 1, z);
+				}  // for x
+			}  // for z
+		}  // for y
+	}  // for i - BFS iterations
+	return false;
+}
+
+
+
+
diff --git a/src/Blocks/BlockLever.h b/src/Blocks/BlockLever.h
new file mode 100644
index 000000000..15fe2071c
--- /dev/null
+++ b/src/Blocks/BlockLever.h
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockLeverHandler :
+	public cBlockHandler
+{
+public:
+	cBlockLeverHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		// Flip the ON bit on/off using the XOR bitwise operation
+		NIBBLETYPE Meta = (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x08);
+
+		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+		a_World->BroadcastSoundEffect("random.click", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, (Meta & 0x08) ? 0.6f : 0.5f);
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(E_BLOCK_LEVER, 1, 0));
+	}
+
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = LeverDirectionToMetaData(a_BlockFace);
+		return true;
+	}
+
+
+	inline static NIBBLETYPE LeverDirectionToMetaData(char a_Dir)
+	{
+		// Determine lever direction:
+		switch (a_Dir)
+		{
+			case BLOCK_FACE_YP: return 0x6;
+			case BLOCK_FACE_XP: return 0x1;
+			case BLOCK_FACE_XM: return 0x2;
+			case BLOCK_FACE_ZP: return 0x3;
+			case BLOCK_FACE_ZM: return 0x4;
+			case BLOCK_FACE_YM: return 0x0;
+			default:            return 0x6;
+		}
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+
+
+	inline static NIBBLETYPE BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
+	{
+		switch (a_Meta & 0x7)
+		{
+			case 0x1: return BLOCK_FACE_XP;
+			case 0x2: return BLOCK_FACE_XM;
+			case 0x3: return BLOCK_FACE_ZP;
+			case 0x4: return BLOCK_FACE_ZM;
+			case 0x5:
+			case 0x6: return BLOCK_FACE_YP;
+			case 0x7:
+			case 0x0: return BLOCK_FACE_YM;
+			default:
+			{
+				ASSERT(!"Unhandled block meta!");
+				return BLOCK_FACE_NONE;
+			}
+		}
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		NIBBLETYPE Meta;
+		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
+
+		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]);
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockMelon.h b/src/Blocks/BlockMelon.h
index 2f7d9a461..2f7d9a461 100644
--- a/source/Blocks/BlockMelon.h
+++ b/src/Blocks/BlockMelon.h
diff --git a/src/Blocks/BlockMushroom.h b/src/Blocks/BlockMushroom.h
new file mode 100644
index 000000000..2846a6317
--- /dev/null
+++ b/src/Blocks/BlockMushroom.h
@@ -0,0 +1,59 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockMushroomHandler :
+	public cBlockHandler
+{
+public:
+	cBlockMushroomHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		if (a_RelY <= 0)
+		{
+			return false;
+		}
+		
+		// TODO: Cannot be at too much daylight
+		
+		switch (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ))
+		{
+			case E_BLOCK_GLASS:
+			case E_BLOCK_CACTUS:
+			case E_BLOCK_ICE:
+			case E_BLOCK_LEAVES:
+			case E_BLOCK_AIR:
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+	
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockMycelium.h b/src/Blocks/BlockMycelium.h
new file mode 100644
index 000000000..7f897c72a
--- /dev/null
+++ b/src/Blocks/BlockMycelium.h
@@ -0,0 +1,32 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockMyceliumHandler :
+	public cBlockHandler
+{
+public:
+	cBlockMyceliumHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_DIRT, 1, 0));
+	}
+	
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.gravel";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockNote.h b/src/Blocks/BlockNote.h
index fef38d845..fef38d845 100644
--- a/source/Blocks/BlockNote.h
+++ b/src/Blocks/BlockNote.h
diff --git a/source/Blocks/BlockOre.h b/src/Blocks/BlockOre.h
index 9684dbb19..9684dbb19 100644
--- a/source/Blocks/BlockOre.h
+++ b/src/Blocks/BlockOre.h
diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp
new file mode 100644
index 000000000..3e1ca1d15
--- /dev/null
+++ b/src/Blocks/BlockPiston.cpp
@@ -0,0 +1,110 @@
+
+#include "Globals.h"
+#include "BlockPiston.h"
+#include "../Item.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+#include "../Piston.h"
+
+
+
+
+
+#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; \
+	}
+
+
+
+
+cBlockPistonHandler::cBlockPistonHandler(BLOCKTYPE a_BlockType)
+	: cBlockHandler(a_BlockType)
+{
+}
+
+
+
+
+
+void cBlockPistonHandler::OnDestroyed(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	NIBBLETYPE OldMeta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+	int newX = a_BlockX;
+	int newY = a_BlockY;
+	int newZ = a_BlockZ;
+	AddPistonDir(newX, newY, newZ, OldMeta & ~(8), 1);
+
+	if (a_World->GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION)
+	{
+		a_World->SetBlock(newX, newY, newZ, E_BLOCK_AIR, 0);
+	}
+}
+
+
+
+
+
+bool cBlockPistonHandler::GetPlacementBlockTypeMeta(
+	cWorld * a_World, cPlayer * a_Player,
+	int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+	int a_CursorX, int a_CursorY, int a_CursorZ,
+	BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+)
+{
+	a_BlockType = m_BlockType;
+	a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetRotation(), a_Player->GetPitch());
+	return true;
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cBlockPistonHeadHandler:
+
+cBlockPistonHeadHandler::cBlockPistonHeadHandler(void) :
+	super(E_BLOCK_PISTON_EXTENSION)
+{
+}
+
+
+
+
+
+void cBlockPistonHeadHandler::OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	NIBBLETYPE OldMeta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+
+	int newX = a_BlockX;
+	int newY = a_BlockY;
+	int newZ = a_BlockZ;
+	AddPistonDir(newX, newY, newZ, OldMeta & ~(8), -1);
+
+	BLOCKTYPE Block = a_World->GetBlock(newX, newY, newZ);
+	if ((Block == E_BLOCK_STICKY_PISTON) || (Block == E_BLOCK_PISTON))
+	{
+		a_World->DigBlock(newX, newY, newZ);
+		if (a_Player->IsGameModeCreative())
+		{
+			return; // No pickups if creative
+		}
+
+		cItems Pickups;
+		Pickups.push_back(cItem(Block, 1));
+		a_World->SpawnItemPickups(Pickups, a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5);
+	}
+}
+
+
+
+
+
diff --git a/src/Blocks/BlockPiston.h b/src/Blocks/BlockPiston.h
new file mode 100644
index 000000000..36fa6a572
--- /dev/null
+++ b/src/Blocks/BlockPiston.h
@@ -0,0 +1,49 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockPistonHandler :
+	public cBlockHandler
+{
+public:
+	cBlockPistonHandler(BLOCKTYPE a_BlockType);
+	
+	virtual void OnDestroyed(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override;
+} ;
+
+
+
+
+
+class cBlockPistonHeadHandler :
+	public cBlockHandler
+{
+	typedef cBlockHandler super;
+	
+public:
+	cBlockPistonHeadHandler(void);
+	
+	virtual void OnDestroyedByPlayer(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// No pickups
+		// Also with 1.7, the item forms of these tecnical blocks have been removed, so giving someone this will crash their client...
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockPlanks.h b/src/Blocks/BlockPlanks.h
new file mode 100644
index 000000000..f3b8dbfb6
--- /dev/null
+++ b/src/Blocks/BlockPlanks.h
@@ -0,0 +1,41 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockPlanksHandler : public cBlockHandler
+{
+public:
+	cBlockPlanksHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
+		a_BlockMeta = Meta;
+		return true;
+	}
+
+	
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockPortal.h b/src/Blocks/BlockPortal.h
new file mode 100644
index 000000000..c56f0cbc8
--- /dev/null
+++ b/src/Blocks/BlockPortal.h
@@ -0,0 +1,108 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockPortalHandler :
+	public cBlockHandler
+{
+public:
+	cBlockPortalHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		// We set to zero so MCS doesn't stop you from building weird portals like vanilla does
+		// CanBeAt doesn't do anything if meta is zero
+		// We set to zero because the client sends meta = 2 to the server (it calculates rotation itself)
+
+		a_BlockType = m_BlockType;
+		a_BlockMeta = 0;
+		return true;
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		return; // No pickups
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		if ((a_RelY - 1 < 0) || (a_RelY + 1 > cChunkDef::Height))
+		{
+			return false; // In case someone places a portal with meta 1 or 2 at boundaries, and server tries to get invalid coords at Y - 1 or Y + 1
+		}
+
+		switch (a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ))
+		{
+			case 0x1:
+			{
+				static const struct
+				{
+					int x, y, z;
+				} PortalCheck[] =
+				{
+					{ 0, 1,  0},
+					{ 0,-1,  0},
+					{ 1, 0,  0},
+					{-1, 0,  0},
+				} ;
+
+				for (int i = 0; i < ARRAYCOUNT(PortalCheck); i++)
+				{
+					BLOCKTYPE Block;
+					a_Chunk.UnboundedRelGetBlockType(a_RelX + PortalCheck[i].x, a_RelY + PortalCheck[i].y, a_RelZ + PortalCheck[i].z, Block);
+
+					if ((Block != E_BLOCK_NETHER_PORTAL) && (Block != E_BLOCK_OBSIDIAN))
+					{
+						return false;
+					}
+				}
+				break;
+			}
+			case 0x2:
+			{
+				static const struct
+				{
+					int x, y, z;
+				} PortalCheck[] =
+				{
+					{ 0, 1,  0},
+					{ 0,-1,  0},
+					{ 0, 0, -1},
+					{ 0, 0,  1},
+				} ;
+
+				for (int i = 0; i < ARRAYCOUNT(PortalCheck); i++)
+				{
+					BLOCKTYPE Block;
+					a_Chunk.UnboundedRelGetBlockType(a_RelX + PortalCheck[i].x, a_RelY + PortalCheck[i].y, a_RelZ + PortalCheck[i].z, Block);
+
+					if ((Block != E_BLOCK_NETHER_PORTAL) && (Block != E_BLOCK_OBSIDIAN))
+					{
+						return false;
+					}
+				}
+				break;
+			}
+		}
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockPumpkin.h b/src/Blocks/BlockPumpkin.h
new file mode 100644
index 000000000..76abc6818
--- /dev/null
+++ b/src/Blocks/BlockPumpkin.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+class cBlockPumpkinHandler :
+	public cBlockHandler
+{
+public:
+	cBlockPumpkinHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = PlayerYawToMetaData(a_Player->GetRotation());
+		return true;
+	}
+
+	inline static NIBBLETYPE PlayerYawToMetaData(double a_Yaw)
+	{
+		ASSERT((a_Yaw >= -180) && (a_Yaw < 180));
+		
+		a_Yaw += 180 + 45;
+		if (a_Yaw > 360)
+		{
+			a_Yaw -= 360;
+		}
+		if ((a_Yaw >= 0) && (a_Yaw < 90))
+		{
+			return 0x0;
+		}
+		else if ((a_Yaw >= 180) && (a_Yaw < 270))
+		{
+			return 0x2;
+		}
+		else if ((a_Yaw >= 90) && (a_Yaw < 180))
+		{
+			return 0x1;
+		}
+		else
+		{
+			return 0x3;
+		}
+	}
+
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockRail.h b/src/Blocks/BlockRail.h
new file mode 100644
index 000000000..24a101652
--- /dev/null
+++ b/src/Blocks/BlockRail.h
@@ -0,0 +1,398 @@
+
+#pragma once
+
+#include "BlockEntity.h"
+#include "../World.h"
+
+
+
+
+
+enum ENUM_PURE
+{
+	E_PURE_UPDOWN = 0,
+	E_PURE_DOWN = 1,
+	E_PURE_NONE = 2
+};
+
+
+
+
+
+class cBlockRailHandler :
+	public cBlockHandler
+{
+	typedef cBlockHandler super;
+	
+public:
+	cBlockRailHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = FindMeta(a_World, a_BlockX, a_BlockY, a_BlockZ);
+		return true;
+	}
+
+
+	virtual void OnNeighborChanged(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		if (IsUnstable(a_World, a_BlockX, a_BlockY, a_BlockZ) && (Meta != FindMeta(a_World, a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			a_World->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_BlockType, FindMeta(a_World, a_BlockX, a_BlockY, a_BlockZ));
+		}
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		super::ConvertToPickups(a_Pickups, 0);
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		if (a_RelY <= 0)
+		{
+			return false;
+		}
+		if (!g_BlockIsSolid[a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)])
+		{
+			return false;
+		}
+
+		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
+		switch (Meta)
+		{
+			case E_META_RAIL_ASCEND_XP:
+			case E_META_RAIL_ASCEND_XM:
+			case E_META_RAIL_ASCEND_ZM:
+			case E_META_RAIL_ASCEND_ZP:
+			{
+				// Mapping between the meta and the neighbors that need checking
+				Meta -= E_META_RAIL_ASCEND_XP;  // Base index at zero
+				static const struct
+				{
+					int x, z;
+				} Coords[] =
+				{
+					{ 1,  0},  // east,  XP
+					{-1,  0},  // west,  XM
+					{ 0, -1},  // north, ZM
+					{ 0,  1},  // south, ZP
+				} ;
+				BLOCKTYPE  BlockType;
+				NIBBLETYPE BlockMeta;
+				if (!a_Chunk.UnboundedRelGetBlock(a_RelX + Coords[Meta].x, a_RelY, a_RelZ + Coords[Meta].z, BlockType, BlockMeta))
+				{
+					// Too close to the edge, cannot simulate
+					return true;
+				}
+				return g_BlockIsSolid[BlockType];
+			}
+		}
+		return true;
+	}
+
+	NIBBLETYPE FindMeta(cWorld *a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		NIBBLETYPE Meta = 0;
+		char RailsCnt = 0;
+		bool Neighbors[8]; // 0 - EAST, 1 - WEST, 2 - NORTH, 3 - SOUTH, 4 - EAST UP, 5 - WEST UP, 6 - NORTH UP, 7 - SOUTH UP
+		memset(Neighbors, false, sizeof(Neighbors));
+		Neighbors[0] = (IsUnstable(a_World, a_BlockX + 1, a_BlockY, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST, E_PURE_DOWN));
+		Neighbors[1] = (IsUnstable(a_World, a_BlockX - 1, a_BlockY, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST, E_PURE_DOWN));
+		Neighbors[2] = (IsUnstable(a_World, a_BlockX, a_BlockY, a_BlockZ - 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_DOWN));
+		Neighbors[3] = (IsUnstable(a_World, a_BlockX, a_BlockY, a_BlockZ + 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_DOWN));
+		Neighbors[4] = (IsUnstable(a_World, a_BlockX + 1, a_BlockY + 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_EAST, E_PURE_NONE));
+		Neighbors[5] = (IsUnstable(a_World, a_BlockX - 1, a_BlockY + 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_WEST, E_PURE_NONE));
+		Neighbors[6] = (IsUnstable(a_World, a_BlockX, a_BlockY + 1, a_BlockZ - 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_NONE));
+		Neighbors[7] = (IsUnstable(a_World, a_BlockX, a_BlockY + 1, a_BlockZ + 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_NONE));
+		if (IsUnstable(a_World, a_BlockX + 1, a_BlockY - 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_EAST))
+			Neighbors[0] = true;
+		if (IsUnstable(a_World, a_BlockX - 1, a_BlockY - 1, a_BlockZ) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_WEST))
+			Neighbors[1] = true;
+		if (IsUnstable(a_World, a_BlockX, a_BlockY - 1, a_BlockZ - 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_NORTH))
+			Neighbors[2] = true;
+		if (IsUnstable(a_World, a_BlockX, a_BlockY - 1, a_BlockZ + 1) || !IsNotConnected(a_World, a_BlockX, a_BlockY - 1, a_BlockZ, BLOCK_FACE_SOUTH))
+			Neighbors[3] = true;
+		for (int i = 0; i < 8; i++)
+		{
+			if (Neighbors[i])
+			{
+				RailsCnt++;
+			}
+		}
+		if (RailsCnt == 1)
+		{
+			if (Neighbors[7]) return E_META_RAIL_ASCEND_ZP;
+			else if (Neighbors[6]) return E_META_RAIL_ASCEND_ZM;
+			else if (Neighbors[5]) return E_META_RAIL_ASCEND_XM;
+			else if (Neighbors[4]) return E_META_RAIL_ASCEND_XP;
+			else if (Neighbors[0] || Neighbors[1]) return E_META_RAIL_XM_XP;
+			else if (Neighbors[2] || Neighbors[3]) return E_META_RAIL_ZM_ZP;
+			ASSERT(!"Weird neighbor count");
+			return Meta;
+		}
+		for (int i = 0; i < 4; i++)
+		{
+			if (Neighbors[i + 4])
+			{
+				Neighbors[i] = true;
+			}
+		}
+		if (RailsCnt > 1)
+		{
+			if      (Neighbors[3] && Neighbors[0]) return E_META_RAIL_CURVED_ZP_XP;
+			else if (Neighbors[3] && Neighbors[1]) return E_META_RAIL_CURVED_ZP_XM;
+			else if (Neighbors[2] && Neighbors[0]) return E_META_RAIL_CURVED_ZM_XP;
+			else if (Neighbors[2] && Neighbors[1]) return E_META_RAIL_CURVED_ZM_XM;
+			else if (Neighbors[7] && Neighbors[2]) return E_META_RAIL_ASCEND_ZP;
+			else if (Neighbors[3] && Neighbors[6]) return E_META_RAIL_ASCEND_ZM;
+			else if (Neighbors[5] && Neighbors[0]) return E_META_RAIL_ASCEND_XM;
+			else if (Neighbors[4] && Neighbors[1]) return E_META_RAIL_ASCEND_XP;
+			else if (Neighbors[0] && Neighbors[1]) return E_META_RAIL_XM_XP;
+			else if (Neighbors[2] && Neighbors[3]) return E_META_RAIL_ZM_ZP;
+			ASSERT(!"Weird neighbor count");
+		}
+		return Meta;
+	}
+
+
+	bool IsUnstable(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) != E_BLOCK_RAIL)
+		{
+			return false;
+		}
+		NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		switch (Meta)
+		{
+			case E_META_RAIL_ZM_ZP:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH, E_PURE_DOWN) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH, E_PURE_DOWN)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_XM_XP:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST, E_PURE_DOWN) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST, E_PURE_DOWN)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_ASCEND_XP:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_EAST) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_ASCEND_XM:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_WEST)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_ASCEND_ZM:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_ASCEND_ZP:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY + 1, a_BlockZ, BLOCK_FACE_SOUTH)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_CURVED_ZP_XP:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_CURVED_ZP_XM:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_SOUTH) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_CURVED_ZM_XM:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_WEST)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+			
+			case E_META_RAIL_CURVED_ZM_XP:
+			{
+				if (
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_NORTH) || 
+					IsNotConnected(a_World, a_BlockX, a_BlockY, a_BlockZ, BLOCK_FACE_EAST)
+				)
+				{
+					return true;
+				}
+				break;
+			}
+		}
+		return false;
+	}
+
+
+	bool IsNotConnected(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Pure = 0)
+	{
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, false);
+		NIBBLETYPE Meta;
+		if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) != E_BLOCK_RAIL)
+		{
+			if ((a_World->GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ) != E_BLOCK_RAIL) || (a_Pure != E_PURE_UPDOWN))
+			{
+				if ((a_World->GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ) != E_BLOCK_RAIL) || (a_Pure == E_PURE_NONE))
+				{
+					return true;
+				}
+				else
+				{
+					Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY - 1, a_BlockZ);
+				}
+			}
+			else
+			{
+				Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY + 1, a_BlockZ);
+			}
+		}
+		else
+		{
+			Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+		}
+		
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_NORTH:
+			{
+				if (
+					(Meta == E_META_RAIL_ZM_ZP) ||
+					(Meta == E_META_RAIL_ASCEND_ZM) ||
+					(Meta == E_META_RAIL_ASCEND_ZP) ||
+					(Meta == E_META_RAIL_CURVED_ZP_XP) ||
+					(Meta == E_META_RAIL_CURVED_ZP_XM)
+				)
+				{
+					return false;
+				}
+				break;
+			}
+			
+			case BLOCK_FACE_SOUTH:
+			{
+				if (
+					(Meta == E_META_RAIL_ZM_ZP) ||
+					(Meta == E_META_RAIL_ASCEND_ZM) ||
+					(Meta == E_META_RAIL_ASCEND_ZP) ||
+					(Meta == E_META_RAIL_CURVED_ZM_XP) ||
+					(Meta == E_META_RAIL_CURVED_ZM_XM)
+				)
+				{
+					return false;
+				}
+				break;
+			}
+			
+			case BLOCK_FACE_EAST:
+			{
+				if (
+					(Meta == E_META_RAIL_XM_XP) ||
+					(Meta == E_META_RAIL_ASCEND_XP) ||
+					(Meta == E_META_RAIL_ASCEND_XM) ||
+					(Meta == E_META_RAIL_CURVED_ZP_XM) ||
+					(Meta == E_META_RAIL_CURVED_ZM_XM)
+				)
+				{
+					return false;
+				}
+				break;
+			}
+			case BLOCK_FACE_WEST:
+			{
+				if (
+					(Meta == E_META_RAIL_XM_XP) ||
+					(Meta == E_META_RAIL_ASCEND_XP) ||
+					(Meta == E_META_RAIL_ASCEND_XM) ||
+					(Meta == E_META_RAIL_CURVED_ZP_XP) ||
+					(Meta == E_META_RAIL_CURVED_ZM_XP)
+				)
+				{
+					return false;
+				}
+				break;
+			}
+		}
+		return true;
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockRedstone.h b/src/Blocks/BlockRedstone.h
new file mode 100644
index 000000000..57bd91b46
--- /dev/null
+++ b/src/Blocks/BlockRedstone.h
@@ -0,0 +1,36 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+
+
+
+
+
+class cBlockRedstoneHandler :
+	public cBlockHandler
+{
+public:
+	cBlockRedstoneHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && g_BlockIsSolid[a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)]);
+	}
+	
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(E_ITEM_REDSTONE_DUST, 1));
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockRedstoneLamp.h b/src/Blocks/BlockRedstoneLamp.h
new file mode 100644
index 000000000..69a2b27c2
--- /dev/null
+++ b/src/Blocks/BlockRedstoneLamp.h
@@ -0,0 +1,27 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockRedstoneLampHandler :
+	public cBlockHandler
+{
+public:
+	cBlockRedstoneLampHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_BLOCK_REDSTONE_LAMP_OFF, 1, 0));
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockRedstoneRepeater.h b/src/Blocks/BlockRedstoneRepeater.h
new file mode 100644
index 000000000..1fcddd4f8
--- /dev/null
+++ b/src/Blocks/BlockRedstoneRepeater.h
@@ -0,0 +1,93 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockRedstoneRepeaterHandler :
+	public cBlockHandler
+{
+public:
+	cBlockRedstoneRepeaterHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+		) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = RepeaterRotationToMetaData(a_Player->GetRotation());
+		return true;
+	}
+	
+
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, ((a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) + 0x04) & 0x0f));
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(E_ITEM_REDSTONE_REPEATER, 1, 0));
+	}
+
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+	
+	
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+
+
+	inline static NIBBLETYPE RepeaterRotationToMetaData(double a_Rotation)
+	{
+		a_Rotation += 90 + 45; // So its not aligned with axis
+		if (a_Rotation > 360)
+		{
+			a_Rotation -= 360;
+		}
+
+		if ((a_Rotation >= 0) && (a_Rotation < 90))
+		{
+			return 0x1;
+		}
+		else if ((a_Rotation >= 180) && (a_Rotation < 270))
+		{
+			return 0x3;
+		}
+		else if ((a_Rotation >= 90) && (a_Rotation < 180))
+		{
+			return 0x2;
+		}
+		else
+		{
+			return 0x0;
+		}
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockRedstoneTorch.h b/src/Blocks/BlockRedstoneTorch.h
index cb897ba3f..cb897ba3f 100644
--- a/source/Blocks/BlockRedstoneTorch.h
+++ b/src/Blocks/BlockRedstoneTorch.h
diff --git a/source/Blocks/BlockSand.h b/src/Blocks/BlockSand.h
index 3fc271483..3fc271483 100644
--- a/source/Blocks/BlockSand.h
+++ b/src/Blocks/BlockSand.h
diff --git a/src/Blocks/BlockSapling.h b/src/Blocks/BlockSapling.h
new file mode 100644
index 000000000..0dcae1f93
--- /dev/null
+++ b/src/Blocks/BlockSapling.h
@@ -0,0 +1,59 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+
+
+
+
+
+class cBlockSaplingHandler :
+	public cBlockHandler
+{
+public:
+	cBlockSaplingHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Only the first 2 bits contain the display information, the others are for growing
+		a_Pickups.push_back(cItem(E_BLOCK_SAPLING, 1, a_BlockMeta & 3));
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return (a_RelY > 0) && IsBlockTypeOfDirt(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ));
+	}
+	
+
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
+		
+		if ((Meta & 0x08) != 0)
+		{
+			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+			a_Chunk.GetWorld()->GrowTree(BlockX, a_RelY, BlockZ);
+		}
+		else
+		{
+			a_Chunk.SetMeta(a_RelX, a_RelY, a_RelZ, Meta | 0x08);
+		}
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockSign.h b/src/Blocks/BlockSign.h
new file mode 100644
index 000000000..7fbe61893
--- /dev/null
+++ b/src/Blocks/BlockSign.h
@@ -0,0 +1,78 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+
+
+
+
+
+class cBlockSignHandler :
+	public cBlockHandler
+{
+public:
+	cBlockSignHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_ITEM_SIGN, 1, 0));
+	}
+	
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+
+
+	static char RotationToMetaData(double a_Rotation)
+	{
+		a_Rotation += 180 + (180 / 16);  // So it's not aligned with axis
+		if (a_Rotation > 360)
+		{
+			a_Rotation -= 360;
+		}
+		
+		a_Rotation = (a_Rotation / 360) * 16;
+		
+		return ((char)a_Rotation) % 16;
+	}
+	
+	
+	static char DirectionToMetaData(char a_Direction)
+	{
+		switch (a_Direction)
+		{
+			case 0x2: return 0x2;
+			case 0x3: return 0x3;
+			case 0x4: return 0x4;
+			case 0x5: return 0x5;
+			default:
+			{
+				break;
+			}
+		}
+		return 0x2;
+	}	
+
+
+	virtual void OnPlacedByPlayer(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
+	) override
+	{
+		a_Player->GetClientHandle()->SendEditSign(a_BlockX, a_BlockY, a_BlockZ);
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockSlab.h b/src/Blocks/BlockSlab.h
index 7c1251b28..7c1251b28 100644
--- a/source/Blocks/BlockSlab.h
+++ b/src/Blocks/BlockSlab.h
diff --git a/src/Blocks/BlockSnow.h b/src/Blocks/BlockSnow.h
new file mode 100644
index 000000000..d7fd1e19e
--- /dev/null
+++ b/src/Blocks/BlockSnow.h
@@ -0,0 +1,100 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockSnowHandler :
+	public cBlockHandler
+{
+public:
+	cBlockSnowHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+
+		BLOCKTYPE BlockBeforePlacement;
+		NIBBLETYPE MetaBeforePlacement;
+		a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockBeforePlacement, MetaBeforePlacement);
+
+		if ((BlockBeforePlacement == E_BLOCK_SNOW) && (MetaBeforePlacement < 7))
+		{
+			// Only increment if:
+			//	A snow block was already there (not first time placement) AND
+			//	Height is smaller than 7, the maximum possible height
+			MetaBeforePlacement++;
+		}
+		
+		a_BlockMeta = MetaBeforePlacement;
+		return true;
+	}
+
+
+	virtual bool DoesIgnoreBuildCollision(cPlayer * a_Player, NIBBLETYPE a_Meta) override
+	{
+		if ((a_Player->GetEquippedItem().m_ItemType == E_BLOCK_SNOW) && (a_Meta < 7))
+		{
+			return true; // If a player is holding a (thin) snow block and it's size can be increased, return collision ignored
+		}
+
+		if (a_Meta == 0)
+		{
+			return true; // If at normal snowfall height (lowest), we ignore collision
+		}
+
+		return false;
+	}
+	
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_ITEM_SNOWBALL, 1, 0));
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		if (a_RelY > 0)
+		{
+			BLOCKTYPE BlockBelow = a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ);
+			NIBBLETYPE MetaBelow = a_Chunk.GetMeta(a_RelX, a_RelY - 1, a_RelZ);
+			
+			if (g_BlockIsSnowable[BlockBelow] || ((BlockBelow == E_BLOCK_SNOW) && (MetaBelow == 7)))
+			{
+				// If 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;
+			}
+		}
+		
+		return false;
+	}
+	
+	
+	virtual bool DoesDropOnUnsuitable(void) override
+	{
+		return false;
+	}
+	
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.cloth";
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockStairs.h b/src/Blocks/BlockStairs.h
new file mode 100644
index 000000000..fa378e4b5
--- /dev/null
+++ b/src/Blocks/BlockStairs.h
@@ -0,0 +1,172 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockStairsHandler :
+	public cBlockHandler
+{
+public:
+	cBlockStairsHandler(BLOCKTYPE a_BlockType) :
+		cBlockHandler(a_BlockType)
+	{
+
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = RotationToMetaData(a_Player->GetRotation());
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_TOP:    break;
+			case BLOCK_FACE_BOTTOM: a_BlockMeta = a_BlockMeta | 0x4; break;  // When placing onto a bottom face, always place an upside-down stairs block
+			case BLOCK_FACE_EAST:
+			case BLOCK_FACE_NORTH:
+			case BLOCK_FACE_SOUTH:
+			case BLOCK_FACE_WEST:
+			{
+				// When placing onto a sideways face, check cursor, if in top half, make it an upside-down stairs block
+				if (a_CursorY > 8)
+				{
+					a_BlockMeta |= 0x4;
+				}
+				break;
+			}
+		}
+		return true;
+	}
+	
+	virtual const char * GetStepSound(void) override
+	{
+		if (
+			(m_BlockType == E_BLOCK_WOODEN_STAIRS) ||
+			(m_BlockType == E_BLOCK_SPRUCE_WOOD_STAIRS) ||
+			(m_BlockType == E_BLOCK_JUNGLE_WOOD_STAIRS) ||
+			(m_BlockType == E_BLOCK_ACACIA_WOOD_STAIRS) ||
+			(m_BlockType == E_BLOCK_BIRCH_WOOD_STAIRS) ||
+			(m_BlockType == E_BLOCK_DARK_OAK_WOOD_STAIRS)
+			)
+		{
+			return "step.wood";
+		}
+
+		return "step.stone";
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+	
+	static NIBBLETYPE RotationToMetaData(double a_Rotation)
+	{
+		a_Rotation += 90 + 45; // So its not aligned with axis
+		if (a_Rotation > 360)
+		{
+			a_Rotation -= 360;
+		}
+		if ((a_Rotation >= 0) && (a_Rotation < 90))
+		{
+			return 0x0;
+		}
+		else if ((a_Rotation >= 180) && (a_Rotation < 270))
+		{
+			return 0x1;
+		}
+		else if ((a_Rotation >= 90) && (a_Rotation < 180))
+		{
+			return 0x2;
+		}
+		else
+		{
+			return 0x3;
+		}
+	}
+
+
+	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:
+		return (a_Meta & 0x0b) | ((~a_Meta) & 0x04);
+	}
+
+
+	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
new file mode 100644
index 000000000..c2dff62cf
--- /dev/null
+++ b/src/Blocks/BlockStems.h
@@ -0,0 +1,59 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+
+
+
+
+
+class cBlockStemsHandler :
+	public cBlockHandler
+{
+public:
+	cBlockStemsHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	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;
+		a_Pickups.push_back(cItem(ItemType, 1, 0));
+	}
+
+	
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
+		if (Meta >= 7)
+		{
+			// Grow the produce:
+			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+			a_Chunk.GetWorld()->GrowMelonPumpkin(BlockX, a_RelY, a_RelZ, m_BlockType);
+		}
+		else
+		{
+			// Grow the stem:
+			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, m_BlockType, Meta + 1);
+		}
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_FARMLAND));
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockStone.h b/src/Blocks/BlockStone.h
index af4c6509a..af4c6509a 100644
--- a/source/Blocks/BlockStone.h
+++ b/src/Blocks/BlockStone.h
diff --git a/src/Blocks/BlockSugarcane.h b/src/Blocks/BlockSugarcane.h
new file mode 100644
index 000000000..02d7a2fe4
--- /dev/null
+++ b/src/Blocks/BlockSugarcane.h
@@ -0,0 +1,90 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockSugarcaneHandler :
+	public cBlockHandler
+{
+public:
+	cBlockSugarcaneHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.push_back(cItem(E_ITEM_SUGARCANE, 1, 0));
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		if (a_RelY <= 0)
+		{
+			return false;
+		}
+		switch (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ))
+		{
+			case E_BLOCK_DIRT:
+			case E_BLOCK_GRASS:
+			case E_BLOCK_FARMLAND:
+			case E_BLOCK_SAND:
+			{
+				static const struct
+				{
+					int x, z;
+				} Coords[] =
+				{
+					{-1,  0},
+					{ 1,  0},
+					{ 0, -1},
+					{ 0,  1},
+				} ;
+				a_RelY -= 1;
+				for (int i = 0; i < ARRAYCOUNT(Coords); i++)
+				{
+					BLOCKTYPE BlockType;
+					NIBBLETYPE BlockMeta;
+					if (!a_Chunk.UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta))
+					{
+						// Too close to the edge, cannot simulate
+						return true;
+					}
+					if (IsBlockWater(BlockType))
+					{
+						return true;
+					}
+				}  // for i - Coords[]
+				// Not directly neighboring a water block
+				return false;
+			}
+			case E_BLOCK_SUGARCANE:
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	
+	void OnUpdate(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
+	{
+		a_Chunk.GetWorld()->GrowSugarcane(a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width, 1);
+	}
+	
+	
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockTallGrass.h b/src/Blocks/BlockTallGrass.h
index cd27ab7e6..cd27ab7e6 100644
--- a/source/Blocks/BlockTallGrass.h
+++ b/src/Blocks/BlockTallGrass.h
diff --git a/src/Blocks/BlockTorch.h b/src/Blocks/BlockTorch.h
new file mode 100644
index 000000000..9e543dfd7
--- /dev/null
+++ b/src/Blocks/BlockTorch.h
@@ -0,0 +1,251 @@
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+
+
+
+
+
+class cBlockTorchHandler :
+	public cBlockHandler
+{
+public:
+	cBlockTorchHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		// Find proper placement of torch
+
+		if ((a_BlockFace == BLOCK_FACE_TOP) || (a_BlockFace == BLOCK_FACE_BOTTOM))
+		{
+			a_BlockFace = FindSuitableFace(a_World, a_BlockX, a_BlockY, a_BlockZ); // Top or bottom faces clicked, find a suitable face
+			if (a_BlockFace == BLOCK_FACE_NONE)
+			{
+				// Client wouldn't have sent anything anyway, but whatever
+				return false;
+			}
+		}
+		else
+		{
+			// Not top or bottom faces, try to preserve whatever face was clicked
+			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true);
+			if (!CanBePlacedOn(a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ), a_BlockFace))
+			{
+				// Torch couldn't be placed on whatever face was clicked, last ditch resort - find another face
+				a_BlockFace = FindSuitableFace(a_World, a_BlockX, a_BlockY, a_BlockZ);
+				if (a_BlockFace == BLOCK_FACE_NONE)
+				{
+					return false;
+				}
+			}
+		}
+
+		a_BlockType = m_BlockType;
+		a_BlockMeta = DirectionToMetaData(a_BlockFace);
+		return true;
+	}
+	
+
+	inline static NIBBLETYPE DirectionToMetaData(char a_Direction)
+	{
+		switch (a_Direction)
+		{
+			case BLOCK_FACE_BOTTOM: ASSERT(!"Shouldn't be getting this face"); return 0;
+			case BLOCK_FACE_TOP:    return E_META_TORCH_FLOOR;
+			case BLOCK_FACE_EAST:   return E_META_TORCH_EAST;
+			case BLOCK_FACE_WEST:   return E_META_TORCH_WEST;
+			case BLOCK_FACE_NORTH:  return E_META_TORCH_NORTH;
+			case BLOCK_FACE_SOUTH:  return E_META_TORCH_SOUTH;
+			default:
+			{
+				ASSERT(!"Unhandled torch direction!");
+				break;
+			}
+		};
+		return 0x0;
+	}
+	
+
+	inline static char MetaDataToDirection(NIBBLETYPE a_MetaData)
+	{
+		switch (a_MetaData)
+		{
+			case 0:                  return BLOCK_FACE_TOP;  // By default, the torches stand on the ground
+			case E_META_TORCH_FLOOR: return BLOCK_FACE_TOP;
+			case E_META_TORCH_EAST:  return BLOCK_FACE_EAST;
+			case E_META_TORCH_WEST:  return BLOCK_FACE_WEST;
+			case E_META_TORCH_NORTH: return BLOCK_FACE_NORTH;
+			case E_META_TORCH_SOUTH: return BLOCK_FACE_SOUTH;
+			default:
+			{
+				ASSERT(!"Unhandled torch metadata");
+				break;
+			}
+		}
+		return 0;
+	}
+
+
+	static bool CanBePlacedOn(BLOCKTYPE a_BlockType, char a_BlockFace)
+	{
+		if ( !g_BlockIsTorchPlaceable[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
+		}
+		else
+		{
+			return true;
+		}
+	}
+	
+	
+	/// Finds a suitable face to place the torch, returning BLOCK_FACE_NONE on failure
+	static char FindSuitableFace(cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		for (int i = BLOCK_FACE_YM; i <= BLOCK_FACE_XP; i++) // Loop through all directions
+		{
+			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, i, true);
+			BLOCKTYPE BlockInQuestion = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+
+			if ( // If on a block that can only hold a torch if torch is standing on it, return that face
+				((BlockInQuestion == E_BLOCK_GLASS) ||
+				(BlockInQuestion == E_BLOCK_FENCE) ||
+				(BlockInQuestion == E_BLOCK_NETHER_BRICK_FENCE) ||
+				(BlockInQuestion == E_BLOCK_COBBLESTONE_WALL)) &&
+				(i == BLOCK_FACE_TOP)
+				)
+			{
+				return i;
+			}
+			else if ((g_BlockIsTorchPlaceable[BlockInQuestion]) && (i != BLOCK_FACE_BOTTOM))
+			{
+				// Otherwise, if block in that direction is torch placeable and we haven't gotten to it via the bottom face, return that face
+				return i;
+			}
+			else
+			{
+				// Reset coords in preparation for next iteration
+				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, i, false);
+			}
+		}
+		return BLOCK_FACE_NONE;
+	}
+
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		char Face = MetaDataToDirection(a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
+
+		AddFaceDirection(a_RelX, a_RelY, a_RelZ, Face, true);
+		BLOCKTYPE BlockInQuestion;
+		a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockInQuestion);
+
+		if (
+			(BlockInQuestion == E_BLOCK_GLASS) ||
+			(BlockInQuestion == E_BLOCK_FENCE) ||
+			(BlockInQuestion == E_BLOCK_NETHER_BRICK_FENCE) ||
+			(BlockInQuestion == E_BLOCK_COBBLESTONE_WALL)
+			)
+		{
+			// Torches can be placed on tops of glass and fences, despite them being 'untorcheable'
+			// No need to check for upright orientation, it was done when the torch was placed
+			return true;
+		}
+		else if ( !g_BlockIsTorchPlaceable[BlockInQuestion] )
+		{
+			return false;
+		}
+		else
+		{
+			return true;
+		}
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Always drop meta = 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		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
new file mode 100644
index 000000000..57718b45f
--- /dev/null
+++ b/src/Blocks/BlockTrapdoor.h
@@ -0,0 +1,106 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockTrapdoorHandler :
+	public cBlockHandler
+{
+public:
+	cBlockTrapdoorHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
+	}
+
+	virtual bool IsUseable(void) override
+	{
+		return true;
+	}
+
+	virtual void OnUse(cWorld * a_World, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
+	{
+		// Flip the ON bit on/off using the XOR bitwise operation
+		NIBBLETYPE Meta = (a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x04);
+
+		a_World->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
+	}
+
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+		) override
+	{
+		a_BlockType = m_BlockType;
+		a_BlockMeta = BlockFaceToMetaData(a_BlockFace);
+
+		if (a_CursorY > 7)
+		{
+			a_BlockMeta |= 0x8;
+		}
+		return true;
+	}
+	
+	inline static NIBBLETYPE BlockFaceToMetaData(char a_BlockFace)
+	{
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_ZP: return 0x1;
+			case BLOCK_FACE_ZM: return 0x0;
+			case BLOCK_FACE_XP: return 0x3;
+			case BLOCK_FACE_XM: return 0x2;
+			default:
+			{
+				ASSERT(!"Unhandled block face!");
+				return 0x0;
+			}
+		}
+	}
+
+	inline static NIBBLETYPE BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
+	{
+		switch (a_Meta & 0x3)
+		{
+			case 0x0: return BLOCK_FACE_ZM;
+			case 0x1: return BLOCK_FACE_ZP;
+			case 0x2: return BLOCK_FACE_XM;
+			case 0x3: return BLOCK_FACE_XP;
+			default:
+			{
+				ASSERT(!"Unhandled block meta!");
+				return BLOCK_FACE_NONE;
+			}
+		}
+	}
+
+	virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
+	{
+		NIBBLETYPE Meta;
+		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
+
+		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]);
+	}
+};
+
+
+
+
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
new file mode 100644
index 000000000..2c9f67cab
--- /dev/null
+++ b/src/Blocks/BlockVine.h
@@ -0,0 +1,201 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockVineHandler :
+	public cBlockHandler
+{
+public:
+	cBlockVineHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+	
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		// TODO: Disallow placement where the vine doesn't attach to something properly
+		BLOCKTYPE BlockType = 0;
+		NIBBLETYPE BlockMeta;
+		a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
+		if (BlockType == m_BlockType)
+		{
+			a_BlockMeta = BlockMeta | DirectionToMetaData(a_BlockFace);
+		}
+		else
+		{
+			a_BlockMeta = DirectionToMetaData(a_BlockFace);
+		}
+		a_BlockType = m_BlockType;
+		return true;
+	}
+
+
+	static NIBBLETYPE DirectionToMetaData(char a_BlockFace)
+	{
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_NORTH: return 0x1;
+			case BLOCK_FACE_SOUTH: return 0x4;
+			case BLOCK_FACE_WEST:  return 0x8;
+			case BLOCK_FACE_EAST:  return 0x2;
+			default: return 0x0;
+		}
+	}
+
+
+	static char MetaDataToDirection(NIBBLETYPE a_MetaData)
+	{
+		switch(a_MetaData)
+		{
+			case 0x1: return BLOCK_FACE_NORTH;
+			case 0x4: return BLOCK_FACE_SOUTH;
+			case 0x8: return BLOCK_FACE_WEST;
+			case 0x2: return BLOCK_FACE_EAST;
+			default:  return BLOCK_FACE_TOP;
+		}
+	}
+
+
+	/// 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];
+	}
+
+
+	/// Returns the meta that has the maximum allowable sides of the vine, given the surroundings
+	NIBBLETYPE GetMaxMeta(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
+	{
+		static const struct
+		{
+			int x, z;
+			int Bit;
+		} Coords[] =
+		{
+			{ 0,  1, 1},  // south, ZP
+			{-1,  0, 2},  // west,  XM
+			{ 0, -1, 4},  // north, ZM
+			{ 1,  0, 8},  // east,  XP
+		} ;
+		int res = 0;
+		for (int i = 0; i < ARRAYCOUNT(Coords); i++)
+		{
+			BLOCKTYPE  BlockType;
+			NIBBLETYPE BlockMeta;
+			if (
+				a_Chunk.UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta) &&
+				IsBlockAttachable(BlockType)
+			)
+			{
+				res |= Coords[i].Bit;
+			}
+		}
+		return res;
+	}
+	
+	
+	void Check(int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) override
+	{
+		NIBBLETYPE CurMeta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
+		NIBBLETYPE MaxMeta = GetMaxMeta(a_Chunk, a_RelX, a_RelY, a_RelZ);
+		
+		// Check if vine above us, add its meta to MaxMeta
+		if ((a_RelY < cChunkDef::Height - 1) && (a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ) == m_BlockType))
+		{
+			MaxMeta |= a_Chunk.GetMeta(a_RelX, a_RelY + 1, a_RelZ);
+		}
+		
+		NIBBLETYPE Common = CurMeta & MaxMeta;  // Neighbors that we have and are legal
+		if (Common != CurMeta)
+		{
+			// There is a neighbor missing, need to update the meta or even destroy the block
+			bool HasTop = (a_RelY < cChunkDef::Height - 1) && IsBlockAttachable(a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ));
+			if ((Common == 0) && !HasTop)
+			{
+				// The vine just lost all its support, destroy the block:
+				if (DoesDropOnUnsuitable())
+				{
+					int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+					int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+					DropBlock(a_Chunk.GetWorld(), NULL, BlockX, a_RelY, BlockZ);
+				}
+				a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);
+				return;
+			}
+			a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, m_BlockType, Common);
+		}
+		else
+		{
+			// Wake up the simulators for this block:
+			int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
+			int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
+			a_Chunk.GetWorld()->GetSimulatorManager()->WakeUp(BlockX, a_RelY, BlockZ, &a_Chunk);
+		}
+	}
+
+
+	virtual bool DoesIgnoreBuildCollision(void) override
+	{
+		return true;
+	}
+	
+	
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.grass";
+	}
+
+
+	virtual bool DoesDropOnUnsuitable(void) override
+	{
+		return false;
+	}
+	
+	virtual void OnUpdate(cWorld * a_World, int X, int Y, int Z)
+	{
+		if (a_World->GetBlock(X, Y - 1, Z) == E_BLOCK_AIR)
+		{
+			a_World->SetBlock(X, Y - 1, Z, E_BLOCK_VINES, a_World->GetBlockMeta(X, Y, Z));
+		}
+	}
+	
+	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
+	{
+		return ((a_Meta >> 1) | (a_Meta << 3)) & 0x0f;  // Rotate bits to the right
+	}
+
+
+	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
+	{
+		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));
+	}
+
+
+	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));
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockWood.h b/src/Blocks/BlockWood.h
new file mode 100644
index 000000000..cb5ee995a
--- /dev/null
+++ b/src/Blocks/BlockWood.h
@@ -0,0 +1,72 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockWoodHandler : public cBlockHandler
+{
+public:
+	cBlockWoodHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+	
+	virtual bool GetPlacementBlockTypeMeta(
+		cWorld * a_World, cPlayer * a_Player,
+		int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, 
+		int a_CursorX, int a_CursorY, int a_CursorZ,
+		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
+	) override
+	{
+		a_BlockType = m_BlockType;
+		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
+		a_BlockMeta = BlockFaceToMetaData(a_BlockFace, Meta);
+		return true;
+	}
+
+	
+	inline static NIBBLETYPE BlockFaceToMetaData(char a_BlockFace, NIBBLETYPE a_WoodMeta)
+	{
+		switch (a_BlockFace)
+		{
+			case BLOCK_FACE_YM:
+			case BLOCK_FACE_YP:
+			{
+				return a_WoodMeta; // Top or bottom, just return original
+			}
+
+			case BLOCK_FACE_ZP:
+			case BLOCK_FACE_ZM:
+			{
+				return a_WoodMeta | 0x8; // North or south
+			}
+
+			case BLOCK_FACE_XP:
+			case BLOCK_FACE_XM:
+			{
+				return a_WoodMeta | 0x4; // East or west
+			}
+
+			default:
+			{
+				ASSERT(!"Unhandled block face!");
+				return a_WoodMeta | 0xC; // No idea, give a special meta (all sides bark)
+			}
+		}
+	}
+
+
+	virtual const char * GetStepSound(void) override
+	{
+		return "step.wood";
+	}
+} ;
+
+
+
+
diff --git a/source/Blocks/BlockWorkbench.h b/src/Blocks/BlockWorkbench.h
index a2cc6119c..a2cc6119c 100644
--- a/source/Blocks/BlockWorkbench.h
+++ b/src/Blocks/BlockWorkbench.h