75 files changed, 753 insertions, 706 deletions

diff --git a/src/Blocks/BlockAnvil.h b/src/Blocks/BlockAnvil.h
index 5c4661c11..20514580e 100644
--- a/src/Blocks/BlockAnvil.h
+++ b/src/Blocks/BlockAnvil.h
@@ -40,14 +40,15 @@ public:
 	) override
 	{
 		a_BlockType = m_BlockType;
-		NIBBLETYPE HighBits = a_BlockMeta & 0x0c;  // Only highest two bits are preserved
+		NIBBLETYPE Meta = (NIBBLETYPE)a_Player->GetEquippedItem().m_ItemDamage;
 		int Direction = (int)floor(a_Player->GetYaw() * 4.0 / 360.0 + 1.5) & 0x3;
+
 		switch (Direction)
 		{
-			case 0: a_BlockMeta = 0x2 | HighBits; break;
-			case 1: a_BlockMeta = 0x3 | HighBits; break;
-			case 2: a_BlockMeta = 0x0 | HighBits; break;
-			case 3: a_BlockMeta = 0x1 | HighBits; break;
+			case 0: a_BlockMeta = 0x2 | Meta << 2; break;
+			case 1: a_BlockMeta = 0x3 | Meta << 2; break;
+			case 2: a_BlockMeta = 0x0 | Meta << 2; break;
+			case 3: a_BlockMeta = 0x1 | Meta << 2; break;
 			default:
 			{
 				return false;
diff --git a/src/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index cd5783f58..3b6328b38 100644
--- a/src/Blocks/BlockBed.cpp
+++ b/src/Blocks/BlockBed.cpp
@@ -4,6 +4,15 @@
 
 
 
+#include "BroadcastInterface.h"
+#include "ChunkInterface.h"
+#include "Entities/../World.h"
+#include "Entities/Player.h"
+#include "WorldInterface.h"
+
+
+
+
 
 void cBlockBedHandler::OnPlacedByPlayer(
 	cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
@@ -15,7 +24,7 @@ void cBlockBedHandler::OnPlacedByPlayer(
 	if (a_BlockMeta < 8)
 	{
 		Vector3i Direction = MetaDataToDirection(a_BlockMeta);
-		a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z, E_BLOCK_BED, a_BlockMeta | 0x8);
+		a_ChunkInterface.SetBlock(a_BlockX + Direction.x, a_BlockY, a_BlockZ + Direction.z, E_BLOCK_BED, a_BlockMeta | 0x8);
 	}
 }
 
diff --git a/src/Blocks/BlockBed.h b/src/Blocks/BlockBed.h
index bf9d9c01d..9fd45644b 100644
--- a/src/Blocks/BlockBed.h
+++ b/src/Blocks/BlockBed.h
@@ -2,12 +2,14 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "ChunkInterface.h"
-#include "WorldInterface.h"
 #include "MetaRotator.h"
-#include "../Entities/Player.h"
+#include "Item.h"
 
 
+class cChunkInterface;
+class cPlayer;
+class cWorldInterface;
+
 
 
 
diff --git a/src/Blocks/BlockBigFlower.h b/src/Blocks/BlockBigFlower.h
index 0b6ac9d8a..3577bdd40 100644
--- a/src/Blocks/BlockBigFlower.h
+++ b/src/Blocks/BlockBigFlower.h
@@ -2,7 +2,7 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "ChunkInterface.h"
 
 
 
@@ -19,16 +19,16 @@ public:
 	}
 
 
-	virtual void DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop, bool a_DropVerbatim) override
+	virtual void DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop) override
 	{
 		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		if (Meta & 0x8)
 		{
-			super::DropBlock(a_ChunkInterface, a_WorldInterface, a_BlockPluginInterface, a_Digger, a_BlockX, a_BlockY - 1, a_BlockZ, a_CanDrop, a_DropVerbatim);
+			super::DropBlock(a_ChunkInterface, a_WorldInterface, a_BlockPluginInterface, a_Digger, a_BlockX, a_BlockY - 1, a_BlockZ, a_CanDrop);
 		}
 		else
 		{
-			super::DropBlock(a_ChunkInterface, a_WorldInterface, a_BlockPluginInterface, a_Digger, a_BlockX, a_BlockY, a_BlockZ, a_CanDrop, a_DropVerbatim);
+			super::DropBlock(a_ChunkInterface, a_WorldInterface, a_BlockPluginInterface, a_Digger, a_BlockX, a_BlockY, a_BlockZ, a_CanDrop);
 		}
 	}
 
@@ -37,7 +37,7 @@ public:
 	{
 		NIBBLETYPE Meta = a_BlockMeta & 0x7;
 		
-		if ((Meta == 2) || (Meta == 3))
+		if ((Meta == E_META_BIG_FLOWER_DOUBLE_TALL_GRASS) || (Meta == E_META_BIG_FLOWER_LARGE_FERN))
 		{
 			return;
 		}
@@ -63,11 +63,11 @@ public:
 				if (r1.randInt(10) == 5)
 				{
 					cItems Pickups;
-					if (FlowerMeta == 2)
+					if (FlowerMeta == E_META_BIG_FLOWER_DOUBLE_TALL_GRASS)
 					{
 						Pickups.Add(E_BLOCK_TALL_GRASS, 2, 1);
 					}
-					else if (FlowerMeta == 3)
+					else if (FlowerMeta == E_META_BIG_FLOWER_LARGE_FERN)
 					{
 						Pickups.Add(E_BLOCK_TALL_GRASS, 2, 2);
 					}
@@ -118,12 +118,6 @@ public:
 			}
 		}
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.grass";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockButton.h b/src/Blocks/BlockButton.h
index 3b45afff8..8e4f04740 100644
--- a/src/Blocks/BlockButton.h
+++ b/src/Blocks/BlockButton.h
@@ -57,12 +57,6 @@ public:
 	}
 
 
-	virtual const char * GetStepSound(void) override
-	{
-		return m_BlockType == E_BLOCK_WOODEN_BUTTON ? "step.wood" : "step.stone";
-	}
-
-
 	inline static NIBBLETYPE BlockFaceToMetaData(eBlockFace a_BlockFace)
 	{
 		switch (a_BlockFace)
diff --git a/src/Blocks/BlockCactus.h b/src/Blocks/BlockCactus.h
index ed441517d..910966c43 100644
--- a/src/Blocks/BlockCactus.h
+++ b/src/Blocks/BlockCactus.h
@@ -69,12 +69,6 @@ public:
 	{
 		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/src/Blocks/BlockCake.h b/src/Blocks/BlockCake.h
index 36e133388..3a754ce18 100644
--- a/src/Blocks/BlockCake.h
+++ b/src/Blocks/BlockCake.h
@@ -19,7 +19,7 @@ public:
 	{
 		NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 
-		if (!a_Player->Feed(2, 0.1))
+		if (!a_Player->Feed(2, 0.4))
 		{
 			return;
 		}
@@ -43,11 +43,6 @@ public:
 	{
 		return true;
 	}
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.cloth";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockCarpet.h b/src/Blocks/BlockCarpet.h
index d1aa52687..4b287c664 100644
--- a/src/Blocks/BlockCarpet.h
+++ b/src/Blocks/BlockCarpet.h
@@ -22,12 +22,6 @@ public:
 		cBlockHandler(a_BlockType)
 	{
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.cloth";
-	}
 	
 	
 	virtual bool GetPlacementBlockTypeMeta(
diff --git a/src/Blocks/BlockChest.h b/src/Blocks/BlockChest.h
index 28adbed4f..201f2309b 100644
--- a/src/Blocks/BlockChest.h
+++ b/src/Blocks/BlockChest.h
@@ -106,12 +106,6 @@ public:
 		// Single chest, no further processing needed
 	}
 	
-	
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
-	
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
diff --git a/src/Blocks/BlockCloth.h b/src/Blocks/BlockCloth.h
index 3c1ae7c25..525176725 100644
--- a/src/Blocks/BlockCloth.h
+++ b/src/Blocks/BlockCloth.h
@@ -15,11 +15,6 @@ public:
 		: cBlockHandler(a_BlockType)
 	{
 	}
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.cloth";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockCommandBlock.h b/src/Blocks/BlockCommandBlock.h
index cf0103765..b66def201 100644
--- a/src/Blocks/BlockCommandBlock.h
+++ b/src/Blocks/BlockCommandBlock.h
@@ -20,11 +20,6 @@ public:
 	{
 		a_Pickups.push_back(cItem(E_BLOCK_AIR, 8, 0));
 	}
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.stone";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockComparator.h b/src/Blocks/BlockComparator.h
index 6caaaab13..3443fc69e 100644
--- a/src/Blocks/BlockComparator.h
+++ b/src/Blocks/BlockComparator.h
@@ -64,12 +64,6 @@ public:
 		a_BlockMeta = cBlockRedstoneRepeaterHandler::RepeaterRotationToMetaData(a_Player->GetYaw());
 		return true;
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockCrops.h b/src/Blocks/BlockCrops.h
index ae6e490e1..53e996683 100644
--- a/src/Blocks/BlockCrops.h
+++ b/src/Blocks/BlockCrops.h
@@ -100,12 +100,6 @@ public:
 	{
 		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/BlockDirt.h b/src/Blocks/BlockDirt.h
index 2d4fccbac..19f889372 100644
--- a/src/Blocks/BlockDirt.h
+++ b/src/Blocks/BlockDirt.h
@@ -3,8 +3,8 @@
 
 #include "BlockHandler.h"
 #include "../FastRandom.h"
-
-
+#include "Root.h"
+#include "Bindings/PluginManager.h"
 
 
 
@@ -21,7 +21,15 @@ public:
 	
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		a_Pickups.push_back(cItem(E_BLOCK_DIRT, 1, 0));
+		if (a_BlockMeta == E_META_DIRT_COARSE)
+		{
+			// Drop the coarse block (dirt, meta 1)
+			a_Pickups.Add(E_BLOCK_DIRT, 1, E_META_DIRT_COARSE);
+		}
+		else
+		{
+			a_Pickups.Add(E_BLOCK_DIRT, 1, E_META_DIRT_NORMAL);
+		}
 	}
 	
 	
@@ -81,19 +89,13 @@ public:
 			Chunk->GetBlockTypeMeta(BlockX, BlockY + 1, BlockZ, AboveDest, AboveMeta);
 			if (cBlockInfo::GetHandler(AboveDest)->CanDirtGrowGrass(AboveMeta))
 			{
-				if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, BlockX * cChunkDef::Width, BlockY, BlockZ * cChunkDef::Width, ssGrassSpread))
+				if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread(Chunk->GetWorld(), Chunk->GetPosX() * cChunkDef::Width + BlockX, BlockY, Chunk->GetPosZ() * cChunkDef::Width + BlockZ, ssGrassSpread))
 				{
 					Chunk->FastSetBlock(BlockX, BlockY, BlockZ, E_BLOCK_GRASS, 0);
 				}
 			}
 		}  // for i - repeat twice
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.gravel";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockDoor.cpp b/src/Blocks/BlockDoor.cpp
index e80473cb5..96345a2df 100644
--- a/src/Blocks/BlockDoor.cpp
+++ b/src/Blocks/BlockDoor.cpp
@@ -1,7 +1,6 @@
 
 #include "Globals.h"
 #include "BlockDoor.h"
-#include "../Item.h"
 #include "../Entities/Player.h"
 
 
@@ -102,16 +101,7 @@ void cBlockDoorHandler::OnPlacedByPlayer(
 	{
 		a_TopBlockMeta = 9;
 	}
-	a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX, a_BlockY + 1, a_BlockZ, m_BlockType, a_TopBlockMeta);
-}
-
-
-
-
-
-const char * cBlockDoorHandler::GetStepSound(void)
-{
-	return (m_BlockType == E_BLOCK_WOODEN_DOOR) ? "step.wood" : "step.stone";
+	a_ChunkInterface.SetBlock(a_BlockX, a_BlockY + 1, a_BlockZ, m_BlockType, a_TopBlockMeta);
 }
 
 
diff --git a/src/Blocks/BlockDoor.h b/src/Blocks/BlockDoor.h
index c86fe829b..92ad8da12 100644
--- a/src/Blocks/BlockDoor.h
+++ b/src/Blocks/BlockDoor.h
@@ -5,6 +5,7 @@
 #include "../Entities/Player.h"
 #include "Chunk.h"
 #include "MetaRotator.h"
+#include "ChunkInterface.h"
 
 
 
@@ -19,7 +20,6 @@ public:
 	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override;
 	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override;
 	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override;
-	virtual const char * GetStepSound(void) override;
 
 	virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override;
 	virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta)  override;
@@ -55,7 +55,49 @@ public:
 
 	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));
+		switch (m_BlockType)
+		{
+			case E_BLOCK_WOODEN_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_WOODEN_DOOR);
+				break;
+			}
+			case E_BLOCK_ACACIA_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_ACACIA_DOOR);
+				break;
+			}
+			case E_BLOCK_BIRCH_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_BIRCH_DOOR);
+				break;
+			}
+			case E_BLOCK_DARK_OAK_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_DARK_OAK_DOOR);
+				break;
+			}
+			case E_BLOCK_JUNGLE_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_JUNGLE_DOOR);
+				break;
+			}
+			case E_BLOCK_SPRUCE_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_SPRUCE_DOOR);
+				break;
+			}
+			case E_BLOCK_IRON_DOOR:
+			{
+				a_Pickups.Add(E_ITEM_IRON_DOOR);
+				break;
+			}
+			default:
+			{
+				ASSERT(!"Unhandled door type!");
+				break;
+			}
+		}
 	}
 
 
@@ -131,7 +173,23 @@ public:
 	/** 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);
+		switch (a_Block)
+		{
+			case E_BLOCK_ACACIA_DOOR:
+			case E_BLOCK_BIRCH_DOOR:
+			case E_BLOCK_DARK_OAK_DOOR:
+			case E_BLOCK_IRON_DOOR:
+			case E_BLOCK_JUNGLE_DOOR:
+			case E_BLOCK_SPRUCE_DOOR:
+			case E_BLOCK_WOODEN_DOOR:
+			{
+				return true;
+			}
+			default:
+			{
+				return false;
+			}
+		}
 	}
 
 
diff --git a/src/Blocks/BlockEnderchest.h b/src/Blocks/BlockEnderchest.h
index 4672f1459..0bc67a8f5 100644
--- a/src/Blocks/BlockEnderchest.h
+++ b/src/Blocks/BlockEnderchest.h
@@ -33,11 +33,6 @@ public:
 		a_BlockMeta = RotationToMetaData(a_Player->GetYaw());
 		return true;
 	}
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.stone";
-	}
 	
 	static NIBBLETYPE RotationToMetaData(double a_Rotation)
 	{
diff --git a/src/Blocks/BlockFarmland.h b/src/Blocks/BlockFarmland.h
index ed0592acd..02a48a4af 100644
--- a/src/Blocks/BlockFarmland.h
+++ b/src/Blocks/BlockFarmland.h
@@ -28,52 +28,12 @@ public:
 
 	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
 	{
-		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;
-			}
-
-			size_t NumBlocks = Area.GetBlockCount();
-			BLOCKTYPE * BlockTypes = Area.GetBlockTypes();
-			for (size_t 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)
+
+		if (IsWaterInNear(a_Chunk, a_RelX, a_RelY, a_RelZ))
 		{
-			// 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);
-			}
+			// Water was found, set block meta to 7
+			a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, m_BlockType, 7);
 			return;
 		}
 
@@ -83,9 +43,10 @@ public:
 			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))
+		BLOCKTYPE UpperBlock = (a_RelY >= cChunkDef::Height) ? E_BLOCK_AIR : a_Chunk.GetBlock(a_RelX, a_RelY + 1, a_RelZ);
+		switch (UpperBlock)
 		{
 			case E_BLOCK_CROPS:
 			case E_BLOCK_POTATOES:
@@ -98,16 +59,63 @@ public:
 			}
 			default:
 			{
-				a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, 0);
+				a_Chunk.SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, 0);
 				break;
 			}
 		}
 	}
 
+	virtual void OnNeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		if (a_BlockY >= cChunkDef::Height)
+		{
+			return;
+		}
+
+		BLOCKTYPE UpperBlock = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY + 1, a_BlockZ);
+		if (cBlockInfo::FullyOccupiesVoxel(UpperBlock))
+		{
+			a_ChunkInterface.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_DIRT, 0);
+		}
+	}
+
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		a_Pickups.Add(E_BLOCK_DIRT, 1, 0);  // Reset meta
 	}
+
+	bool IsWaterInNear(cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
+	{
+		if (a_Chunk.GetWorld()->IsWeatherWetAt(a_RelX, a_RelZ))
+		{
+			// Rain hydrates farmland, too, except in Desert biomes.
+			return true;
+		}
+
+		// 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
+			return false;
+		}
+
+		size_t NumBlocks = Area.GetBlockCount();
+		BLOCKTYPE * BlockTypes = Area.GetBlockTypes();
+		for (size_t i = 0; i < NumBlocks; i++)
+		{
+			if (IsBlockWater(BlockTypes[i]))
+			{
+				return true;
+			}
+		}  // for i - BlockTypes[]
+
+		return false;
+	}
 } ;
 
 
diff --git a/src/Blocks/BlockFenceGate.h b/src/Blocks/BlockFenceGate.h
index 433531275..b5c1323bd 100644
--- a/src/Blocks/BlockFenceGate.h
+++ b/src/Blocks/BlockFenceGate.h
@@ -17,6 +17,12 @@ public:
 	}
 
 
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		a_Pickups.Add(m_BlockType, 1, 0);  // Reset meta to zero
+	}
+
+
 	virtual bool GetPlacementBlockTypeMeta(
 		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
@@ -35,6 +41,7 @@ public:
 		NIBBLETYPE OldMetaData = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 		NIBBLETYPE NewMetaData = PlayerYawToMetaData(a_Player->GetYaw());
 		OldMetaData ^= 4;  // Toggle the gate
+
 		if ((OldMetaData & 1) == (NewMetaData & 1))
 		{
 			// Standing in front of the gate - apply new direction
diff --git a/src/Blocks/BlockFire.h b/src/Blocks/BlockFire.h
index f52825362..07fcefe16 100644
--- a/src/Blocks/BlockFire.h
+++ b/src/Blocks/BlockFire.h
@@ -40,11 +40,6 @@ public:
 		FindAndSetPortalFrame(a_BlockX, a_BlockY - 1, a_BlockZ, a_ChunkInterface, a_WorldInterface);
 	}
 
-	virtual void OnDigging(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
-	{
-		a_ChunkInterface.DigBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
-	}
-
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// No pickups from this block
@@ -55,13 +50,8 @@ public:
 		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
+	/** 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, cChunkInterface & a_ChunkInterface, int MaxY = 0)
 	{
 		if (a_ChunkInterface.GetBlock(X, Y, Z) != E_BLOCK_OBSIDIAN)
@@ -91,13 +81,12 @@ public:
 					return newY;
 				}
 			}
-			else { return 0; }
 		}
 
 		return 0;
 	}
 
-	/// Evaluates if coords have a valid border on top, based on MaxY
+	/** Evaluates if coords have a valid border on top, based on MaxY */
 	bool EvaluatePortalBorder(int X, int FoundObsidianY, int Z, int MaxY, cChunkInterface & a_ChunkInterface)
 	{
 		for (int checkBorder = FoundObsidianY + 1; checkBorder <= MaxY - 1; checkBorder++)  // FoundObsidianY + 1: FoundObsidianY has already been checked in FindObsidianCeiling; MaxY - 1: portal doesn't need corners
@@ -137,11 +126,11 @@ public:
 			{
 				if (Dir == 1)
 				{
-					a_ChunkInterface.SetBlock(a_WorldInterface, Width, Height, Z, E_BLOCK_NETHER_PORTAL, Dir);
+					a_ChunkInterface.SetBlock(Width, Height, Z, E_BLOCK_NETHER_PORTAL, Dir);
 				}
 				else
 				{
-					a_ChunkInterface.SetBlock(a_WorldInterface, X, Height, Width, E_BLOCK_NETHER_PORTAL, Dir);
+					a_ChunkInterface.SetBlock(X, Height, Width, E_BLOCK_NETHER_PORTAL, Dir);
 				}
 			}
 		}
@@ -149,8 +138,8 @@ public:
 		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
+	/** 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, cChunkInterface & a_ChunkInterface)
 	{
 		Dir = 1;  // Set assumed direction (will change if portal turns out to be facing the other direction)
@@ -168,7 +157,8 @@ public:
 			{
 				return false;  // Not valid slice, no portal can be formed
 			}
-		} XZP = X1 - 1;  // Set boundary of frame interior
+		}
+		XZP = X1 - 1;  // Set boundary of frame interior
 		for (; ((a_ChunkInterface.GetBlock(X2, Y, Z) == E_BLOCK_OBSIDIAN) || (a_ChunkInterface.GetBlock(X2, Y + 1, Z) == E_BLOCK_OBSIDIAN)); X2--)  // Go the other direction (XM)
 		{
 			int Value = FindObsidianCeiling(X2, Y, Z, a_ChunkInterface, MaxY);
@@ -182,7 +172,9 @@ public:
 			{
 				return false;
 			}
-		} XZM = X2 + 1;  // Set boundary, see previous
+		}
+		XZM = X2 + 1;  // Set boundary, see previous
+
 		return (FoundFrameXP && FoundFrameXM);
 	}
 
@@ -204,7 +196,8 @@ public:
 			{
 				return false;
 			}
-		} XZP = Z1 - 1;
+		}
+		XZP = Z1 - 1;
 		for (; ((a_ChunkInterface.GetBlock(X, Y, Z2) == E_BLOCK_OBSIDIAN) || (a_ChunkInterface.GetBlock(X, Y + 1, Z2) == E_BLOCK_OBSIDIAN)); Z2--)
 		{
 			int Value = FindObsidianCeiling(X, Y, Z2, a_ChunkInterface, MaxY);
@@ -218,7 +211,9 @@ public:
 			{
 				return false;
 			}
-		} XZM = Z2 + 1;
+		}
+		XZM = Z2 + 1;
+
 		return (FoundFrameZP && FoundFrameZM);
 	}
 };
diff --git a/src/Blocks/BlockFlower.h b/src/Blocks/BlockFlower.h
index e8fd4c7f6..3eb8a0baa 100644
--- a/src/Blocks/BlockFlower.h
+++ b/src/Blocks/BlockFlower.h
@@ -19,7 +19,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
 	}
 
@@ -28,12 +28,6 @@ public:
 	{
 		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/src/Blocks/BlockGlowstone.h b/src/Blocks/BlockGlowstone.h
index 6c198efc4..d1353e29a 100644
--- a/src/Blocks/BlockGlowstone.h
+++ b/src/Blocks/BlockGlowstone.h
@@ -15,13 +15,13 @@ public:
 		: cBlockHandler(a_BlockType)
 	{
 	}
-	
+
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// Reset meta to 0
-		MTRand r1;
-		a_Pickups.push_back(cItem(E_ITEM_GLOWSTONE_DUST, (char)(2 + r1.randInt(2)), 0));
+		cFastRandom Random;
+		a_Pickups.push_back(cItem(E_ITEM_GLOWSTONE_DUST, (char)(2 + Random.NextInt(3)), 0));
 	}
 } ;
 
diff --git a/src/Blocks/BlockGravel.h b/src/Blocks/BlockGravel.h
index e1c9ff390..d076306fb 100644
--- a/src/Blocks/BlockGravel.h
+++ b/src/Blocks/BlockGravel.h
@@ -16,9 +16,17 @@ public:
 	{
 	}
 
-	virtual const char * GetStepSound(void) override
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		return "step.gravel";
+		cFastRandom Random;
+		if (Random.NextInt(30) == 0)
+		{
+			a_Pickups.Add(E_ITEM_FLINT, 1, 0);
+		}
+		else
+		{
+			a_Pickups.Add(E_BLOCK_GRAVEL, 1, 0);
+		}
 	}
 } ;
 
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index ddb0186c9..904e0a921 100644
--- a/src/Blocks/BlockHandler.cpp
+++ b/src/Blocks/BlockHandler.cpp
@@ -3,8 +3,6 @@
 #include "BlockHandler.h"
 #include "../Item.h"
 #include "../World.h"
-#include "../Root.h"
-#include "../Bindings/PluginManager.h"
 #include "../Chunk.h"
 #include "BlockAnvil.h"
 #include "BlockBed.h"
@@ -38,20 +36,18 @@
 #include "BlockGlass.h"
 #include "BlockGlowstone.h"
 #include "BlockGravel.h"
-#include "BlockHayBale.h"
 #include "BlockMobHead.h"
 #include "BlockHopper.h"
 #include "BlockIce.h"
 #include "BlockLadder.h"
 #include "BlockLeaves.h"
 #include "BlockLilypad.h"
-#include "BlockNewLeaves.h"
 #include "BlockLever.h"
 #include "BlockMelon.h"
+#include "BlockMobSpawner.h"
 #include "BlockMushroom.h"
 #include "BlockMycelium.h"
 #include "BlockNetherWart.h"
-#include "BlockNote.h"
 #include "BlockOre.h"
 #include "BlockPiston.h"
 #include "BlockPlanks.h"
@@ -69,6 +65,7 @@
 #include "BlockTripwireHook.h"
 #include "BlockSand.h"
 #include "BlockSapling.h"
+#include "BlockSeaLantern.h"
 #include "BlockSideways.h"
 #include "BlockSignPost.h"
 #include "BlockSlab.h"
@@ -85,6 +82,8 @@
 #include "BlockWorkbench.h"
 
 
+#include "BlockPluginInterface.h"
+
 
 
 
@@ -178,11 +177,16 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 	switch (a_BlockType)
 	{
 		// Block handlers, alphabetically sorted:
+		case E_BLOCK_ACACIA_DOOR:           return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_ACACIA_FENCE_GATE:     return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_ACACIA_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_ACTIVATOR_RAIL:        return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_ANVIL:                 return new cBlockAnvilHandler           (a_BlockType);
+		case E_BLOCK_BEACON:                return new cBlockEntityHandler          (a_BlockType);
 		case E_BLOCK_BED:                   return new cBlockBedHandler             (a_BlockType);
 		case E_BLOCK_BIG_FLOWER:            return new cBlockBigFlowerHandler       (a_BlockType);
+		case E_BLOCK_BIRCH_DOOR:            return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_BIRCH_FENCE_GATE:      return new cBlockFenceGateHandler       (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);
@@ -200,12 +204,15 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_COBBLESTONE_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_COBWEB:                return new cBlockCobWebHandler          (a_BlockType);
 		case E_BLOCK_CROPS:                 return new cBlockCropsHandler           (a_BlockType);
+		case E_BLOCK_DARK_OAK_DOOR:         return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_DARK_OAK_FENCE_GATE:   return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_DARK_OAK_WOOD_STAIRS:  return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_DEAD_BUSH:             return new cBlockDeadBushHandler        (a_BlockType);
 		case E_BLOCK_DETECTOR_RAIL:         return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_DIAMOND_ORE:           return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_DIRT:                  return new cBlockDirtHandler            (a_BlockType);
 		case E_BLOCK_DISPENSER:             return new cBlockDropSpenserHandler     (a_BlockType);
+		case E_BLOCK_DOUBLE_NEW_STONE_SLAB: return new cBlockDoubleSlabHandler      (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);
@@ -223,7 +230,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_GLASS_PANE:            return new cBlockGlassHandler           (a_BlockType);
 		case E_BLOCK_GRASS:                 return new cBlockDirtHandler            (a_BlockType);
 		case E_BLOCK_GRAVEL:                return new cBlockGravelHandler          (a_BlockType);
-		case E_BLOCK_HAY_BALE:              return new cBlockHayBaleHandler         (a_BlockType);
+		case E_BLOCK_HAY_BALE:              return new cBlockSidewaysHandler        (a_BlockType);
 		case E_BLOCK_HEAD:                  return new cBlockMobHeadHandler         (a_BlockType);
 		case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE: return new cBlockPressurePlateHandler(a_BlockType);
 		case E_BLOCK_HOPPER:                return new cBlockHopperHandler          (a_BlockType);
@@ -231,8 +238,11 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE 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_IRON_TRAPDOOR:         return new cBlockTrapdoorHandler        (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_DOOR:           return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_JUNGLE_FENCE_GATE:     return new cBlockFenceGateHandler       (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);
@@ -245,14 +255,16 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_LOG:                   return new cBlockSidewaysHandler        (a_BlockType);
 		case E_BLOCK_MELON:                 return new cBlockMelonHandler           (a_BlockType);
 		case E_BLOCK_MELON_STEM:            return new cBlockStemsHandler           (a_BlockType);
+		case E_BLOCK_MOB_SPAWNER:           return new cBlockMobSpawnerHandler      (a_BlockType);
 		case E_BLOCK_MYCELIUM:              return new cBlockMyceliumHandler        (a_BlockType);
 		case E_BLOCK_NETHER_BRICK_STAIRS:   return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_NETHER_PORTAL:         return new cBlockPortalHandler          (a_BlockType);
 		case E_BLOCK_NETHER_WART:           return new cBlockNetherWartHandler      (a_BlockType);
 		case E_BLOCK_NETHER_QUARTZ_ORE:     return new cBlockOreHandler             (a_BlockType);
-		case E_BLOCK_NEW_LEAVES:            return new cBlockNewLeavesHandler       (a_BlockType);
+		case E_BLOCK_NEW_LEAVES:            return new cBlockLeavesHandler          (a_BlockType);
 		case E_BLOCK_NEW_LOG:               return new cBlockSidewaysHandler        (a_BlockType);
-		case E_BLOCK_NOTE_BLOCK:            return new cBlockNoteHandler            (a_BlockType);
+		case E_BLOCK_NEW_STONE_SLAB:        return new cBlockSlabHandler            (a_BlockType);
+		case E_BLOCK_NOTE_BLOCK:            return new cBlockEntityHandler          (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);
@@ -263,6 +275,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_QUARTZ_BLOCK:          return new cBlockQuartzHandler          (a_BlockType);
 		case E_BLOCK_QUARTZ_STAIRS:         return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_RAIL:                  return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_RED_SANDSTONE_STAIRS:  return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_REDSTONE_LAMP_ON:      return new cBlockRedstoneLampHandler    (a_BlockType);
 		case E_BLOCK_REDSTONE_ORE:          return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_REDSTONE_ORE_GLOWING:  return new cBlockOreHandler             (a_BlockType);
@@ -276,8 +289,11 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE 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_SEA_LANTERN:           return new cBlockSeaLanternHandler      (a_BlockType);
 		case E_BLOCK_SIGN_POST:             return new cBlockSignPostHandler        (a_BlockType);
 		case E_BLOCK_SNOW:                  return new cBlockSnowHandler            (a_BlockType);
+		case E_BLOCK_SPRUCE_DOOR:           return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_SPRUCE_FENCE_GATE:     return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_SPRUCE_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_STAINED_GLASS:         return new cBlockGlassHandler           (a_BlockType);
 		case E_BLOCK_STAINED_GLASS_PANE:    return new cBlockGlassHandler           (a_BlockType);
@@ -418,24 +434,47 @@ void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta)
 
 
 
-void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop, bool a_DropVerbatim)
+void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop)
 {
 	cItems Pickups;
 	NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 
 	if (a_CanDrop)
 	{
-		if (!a_DropVerbatim)
+		if ((a_Digger != NULL) && (a_Digger->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchSilkTouch) > 0))
 		{
-			ConvertToPickups(Pickups, Meta);
+			switch (m_BlockType)
+			{
+				case E_BLOCK_CAKE:
+				case E_BLOCK_CARROTS:
+				case E_BLOCK_COCOA_POD:
+				case E_BLOCK_DOUBLE_STONE_SLAB:
+				case E_BLOCK_DOUBLE_WOODEN_SLAB:
+				case E_BLOCK_FIRE:
+				case E_BLOCK_FARMLAND:
+				case E_BLOCK_MELON_STEM:
+				case E_BLOCK_MOB_SPAWNER:
+				case E_BLOCK_NETHER_WART:
+				case E_BLOCK_POTATOES:
+				case E_BLOCK_PUMPKIN_STEM:
+				case E_BLOCK_SNOW:
+				case E_BLOCK_SUGARCANE:
+				case E_BLOCK_TALL_GRASS:
+				case E_BLOCK_CROPS:
+				{
+					// Silktouch can't be used for these blocks
+					ConvertToPickups(Pickups, Meta);
+					break;
+				}
+				default: Pickups.Add(m_BlockType, 1, Meta); break;
+			}
 		}
 		else
 		{
-			// TODO: Add a proper overridable function for this
-			Pickups.Add(m_BlockType, 1, Meta);
+			ConvertToPickups(Pickups, Meta);
 		}
 	}
-	
+
 	// Allow plugins to modify the pickups:
 	a_BlockPluginInterface.CallHookBlockToPickups(a_Digger, a_BlockX, a_BlockY, a_BlockZ, m_BlockType, Meta, Pickups);
 	
@@ -461,15 +500,6 @@ void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterfac
 
 
 
-const char * cBlockHandler::GetStepSound()
-{
-	return "step.stone";
-}
-
-
-
-
-
 bool cBlockHandler::CanBeAt(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, const cChunk & a_Chunk)
 {
 	return true;
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
index de90ce55b..83de836cb 100644
--- a/src/Blocks/BlockHandler.h
+++ b/src/Blocks/BlockHandler.h
@@ -2,10 +2,6 @@
 #pragma once
 
 #include "../Defines.h"
-#include "../Item.h"
-#include "WorldInterface.h"
-#include "ChunkInterface.h"
-#include "BlockPluginInterface.h"
 
 
 
@@ -14,6 +10,10 @@
 // fwd:
 class cPlayer;
 class cChunk;
+class cBlockPluginInterface;
+class cChunkInterface;
+class cWorldInterface;
+class cItems;
 
 
 
@@ -82,10 +82,7 @@ public:
 	@param a_CanDrop Informs the handler whether the block should be dropped at all. One example when this is false is when stone is destroyed by hand
 	@param a_DropVerbatim Calls ConvertToVerbatimPickups() instead of its counterpart, meaning the block itself is dropped by default (due to a speical tool or enchantment)
 	*/
-	virtual void DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop = true, bool a_DropVerbatim = false);
-	
-	/// Returns step sound name of block
-	virtual const char * GetStepSound(void);
+	virtual void DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop = true);
 	
 	/// Checks if the block can stay at the specified relative coords in the chunk
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk);
diff --git a/src/Blocks/BlockHayBale.h b/src/Blocks/BlockHayBale.h
deleted file mode 100644
index 3c6472adb..000000000
--- a/src/Blocks/BlockHayBale.h
+++ /dev/null
@@ -1,28 +0,0 @@
-
-#pragma once
-
-#include "BlockSideways.h"
-
-
-
-
-
-class cBlockHayBaleHandler :
-	public cBlockSidewaysHandler
-{
-public:
-	cBlockHayBaleHandler(BLOCKTYPE a_BlockType)
-		: cBlockSidewaysHandler(a_BlockType)
-	{
-	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.grass";
-	}
-} ;
-
-
-
-
diff --git a/src/Blocks/BlockIce.h b/src/Blocks/BlockIce.h
index c50623594..47a84e5a7 100644
--- a/src/Blocks/BlockIce.h
+++ b/src/Blocks/BlockIce.h
@@ -24,14 +24,24 @@ public:
 	}
 	
 	
-	virtual void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	virtual void OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
 	{
-		// TODO: Ice destroyed with air below it should turn into air instead of water
-		a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_WATER, 0);
-		// This is called later than the real destroying of this ice block
+		if (a_Player->IsGameModeCreative() || (a_BlockY <= 0))
+		{
+			return;
+		}
+		
+		cEnchantments Enchantments = a_Player->GetInventory().GetEquippedItem().m_Enchantments;
+		if (Enchantments.GetLevel(cEnchantments::enchSilkTouch) == 0)
+		{
+			BLOCKTYPE BlockBelow = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ);
+			if (!cBlockInfo::FullyOccupiesVoxel(BlockBelow) && !IsBlockLiquid(BlockBelow))
+			{
+				return;
+			}
+
+			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_WATER, 0);
+			// This is called later than the real destroying of this ice block
+		}
 	}
 } ;
-
-
-
-
diff --git a/src/Blocks/BlockLadder.h b/src/Blocks/BlockLadder.h
index 284d1d732..ab3f55439 100644
--- a/src/Blocks/BlockLadder.h
+++ b/src/Blocks/BlockLadder.h
@@ -111,12 +111,6 @@ public:
 		int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
 		return LadderCanBePlacedAt(a_ChunkInterface, BlockX, a_RelY, BlockZ, BlockFace);
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockLeaves.h b/src/Blocks/BlockLeaves.h
index 972dd6232..add571675 100644
--- a/src/Blocks/BlockLeaves.h
+++ b/src/Blocks/BlockLeaves.h
@@ -112,12 +112,6 @@ public:
 		DropBlock(a_ChunkInterface, a_WorldInterface, a_PluginInterface, NULL, BlockX, a_RelY, BlockZ);
 		a_ChunkInterface.DigBlock(a_WorldInterface, BlockX, a_RelY, BlockZ);
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.grass";
-	}
 } ;
 
 
@@ -152,7 +146,7 @@ bool HasNearLog(cBlockArea & a_Area, int a_BlockX, int a_BlockY, int a_BlockZ)
 	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 y = std::max(a_BlockY - i, 0); y <= std::min(a_BlockY + i, 255); y++)
 		{
 			for (int z = a_BlockZ - i; z <= a_BlockZ + i; z++)
 			{
diff --git a/src/Blocks/BlockLever.h b/src/Blocks/BlockLever.h
index 4316fd06b..3b63b396c 100644
--- a/src/Blocks/BlockLever.h
+++ b/src/Blocks/BlockLever.h
@@ -70,12 +70,6 @@ public:
 	}
 
 
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
-
-
 	inline static eBlockFace BlockMetaDataToBlockFace(NIBBLETYPE a_Meta)
 	{
 		switch (a_Meta & 0x7)
diff --git a/src/Blocks/BlockMelon.h b/src/Blocks/BlockMelon.h
index 2f7d9a461..22cdb4d29 100644
--- a/src/Blocks/BlockMelon.h
+++ b/src/Blocks/BlockMelon.h
@@ -19,14 +19,8 @@ public:
 	
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		MTRand r1;
-		a_Pickups.push_back(cItem(E_ITEM_MELON_SLICE, (char)(3 + r1.randInt(4)), 0));
-	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
+		cFastRandom Random;
+		a_Pickups.push_back(cItem(E_ITEM_MELON_SLICE, (char)(3 + Random.NextInt(5)), 0));
 	}
 } ;
 
diff --git a/src/Blocks/BlockMobHead.h b/src/Blocks/BlockMobHead.h
index ff1ef97bf..e21e42334 100644
--- a/src/Blocks/BlockMobHead.h
+++ b/src/Blocks/BlockMobHead.h
@@ -146,12 +146,12 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
 
 			// Block entities
-			a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX + 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
-			a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX,     a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
-			a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX - 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.SetBlock(a_BlockX + 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.SetBlock(a_BlockX,     a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
+			a_ChunkInterface.SetBlock(a_BlockX - 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
 
 			// Spawn the wither:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtWither);
 
 			// Award Achievement
 			a_WorldInterface.ForEachPlayer(PlayerCallback);
@@ -176,12 +176,12 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
 
 			// Block entities
-			a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ + 1, E_BLOCK_AIR, 0);
-			a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ,     E_BLOCK_AIR, 0);
-			a_ChunkInterface.SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ - 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.SetBlock(a_BlockX, a_BlockY, a_BlockZ + 1, E_BLOCK_AIR, 0);
+			a_ChunkInterface.SetBlock(a_BlockX, a_BlockY, a_BlockZ,     E_BLOCK_AIR, 0);
+			a_ChunkInterface.SetBlock(a_BlockX, a_BlockY, a_BlockZ - 1, E_BLOCK_AIR, 0);
 
 			// Spawn the wither:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtWither);
 
 			// Award Achievement
 			a_WorldInterface.ForEachPlayer(PlayerCallback);
diff --git a/src/Blocks/BlockMobSpawner.h b/src/Blocks/BlockMobSpawner.h
new file mode 100644
index 000000000..a51fbaafc
--- /dev/null
+++ b/src/Blocks/BlockMobSpawner.h
@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+#include "../World.h"
+#include "../Items/ItemHandler.h"
+
+
+
+
+
+class cBlockMobSpawnerHandler :
+	public cBlockHandler
+{
+public:
+	cBlockMobSpawnerHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// No pickups
+	}
+	
+	
+	virtual void OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) override
+	{
+		cItemHandler * Handler = a_Player->GetEquippedItem().GetHandler();
+		if (a_Player->IsGameModeCreative() || !Handler->CanHarvestBlock(E_BLOCK_MOB_SPAWNER))
+		{
+			return;
+		}
+
+		cFastRandom Random;
+		int Reward = 15 + Random.NextInt(15) + Random.NextInt(15);
+		a_WorldInterface.SpawnExperienceOrb((double)a_BlockX, (double)a_BlockY + 1, (double)a_BlockZ, Reward);
+	}
+} ;
diff --git a/src/Blocks/BlockMushroom.h b/src/Blocks/BlockMushroom.h
index 135d418d7..7c06fcc74 100644
--- a/src/Blocks/BlockMushroom.h
+++ b/src/Blocks/BlockMushroom.h
@@ -50,12 +50,6 @@ public:
 		}
 		return true;
 	}
-	
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.grass";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockMycelium.h b/src/Blocks/BlockMycelium.h
index 2a8ef5fca..628e87181 100644
--- a/src/Blocks/BlockMycelium.h
+++ b/src/Blocks/BlockMycelium.h
@@ -22,11 +22,6 @@ public:
 	{
 		a_Pickups.push_back(cItem(E_BLOCK_DIRT, 1, 0));
 	}
-	
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.gravel";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockNewLeaves.h b/src/Blocks/BlockNewLeaves.h
deleted file mode 100644
index 5a267e8c6..000000000
--- a/src/Blocks/BlockNewLeaves.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-#include "BlockHandler.h"
-#include "BlockLeaves.h"
-#include "../World.h"
-
-
-
-
-
-
-class cBlockNewLeavesHandler :
-	public cBlockLeavesHandler
-{
-public:
-	cBlockNewLeavesHandler(BLOCKTYPE a_BlockType)
-		: cBlockLeavesHandler(a_BlockType)
-	{
-	}
-
-
-	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
-	{
-		MTRand rand;
-
-		// Only the first 2 bits contain the display information, the others are for growing
-		if (rand.randInt(5) == 0)
-		{
-			a_Pickups.push_back(cItem(E_BLOCK_SAPLING, 1, (a_BlockMeta & 3) + 4));
-		}
-	}
-
-
-	void OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) override
-	{
-		cBlockHandler::OnDestroyed(a_ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ);
-	}
-} ;
-
-
-
-
-
diff --git a/src/Blocks/BlockNote.h b/src/Blocks/BlockNote.h
deleted file mode 100644
index fef38d845..000000000
--- a/src/Blocks/BlockNote.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-#include "BlockHandler.h"
-#include "BlockEntity.h"
-
-class cBlockNoteHandler :  public cBlockEntityHandler
-{
-public:
-	cBlockNoteHandler(BLOCKTYPE a_BlockType)
-		: cBlockEntityHandler(a_BlockType)
-	{
-	}
-
-};
diff --git a/src/Blocks/BlockOre.h b/src/Blocks/BlockOre.h
index 9684dbb19..f6ea3aa3c 100644
--- a/src/Blocks/BlockOre.h
+++ b/src/Blocks/BlockOre.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "../MersenneTwister.h"
 #include "../World.h"
 
 
@@ -20,58 +19,42 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		short ItemType = m_BlockType;
-		char Count = 1;
-		short Meta = 0;
-		
-		MTRand r1;
+		cFastRandom Random;
+
 		switch (m_BlockType)
 		{
 			case E_BLOCK_LAPIS_ORE:
 			{
-				ItemType = E_ITEM_DYE;
-				Count = 4 + (char)r1.randInt(4);
-				Meta = 4;
+				a_Pickups.push_back(cItem(E_ITEM_DYE, (char)(4 + Random.NextInt(5)), 4));
 				break;
 			}
 			case E_BLOCK_REDSTONE_ORE:
 			case E_BLOCK_REDSTONE_ORE_GLOWING:
 			{
-				Count = 4 + (char)r1.randInt(1);
-				break;
-			}
-			default:
-			{
-				Count = 1;
+				a_Pickups.push_back(cItem(E_ITEM_REDSTONE_DUST, (char)(4 + Random.NextInt(2)), 0));
 				break;
 			}
-		}
-
-		switch (m_BlockType)
-		{
 			case E_BLOCK_DIAMOND_ORE:
 			{
-				ItemType = E_ITEM_DIAMOND;
+				a_Pickups.push_back(cItem(E_ITEM_DIAMOND));
 				break;
 			}
-			case E_BLOCK_REDSTONE_ORE:
-			case E_BLOCK_REDSTONE_ORE_GLOWING:
+			case E_BLOCK_EMERALD_ORE:
 			{
-				ItemType = E_ITEM_REDSTONE_DUST;
+				a_Pickups.push_back(cItem(E_ITEM_EMERALD));
 				break;
 			}
-			case E_BLOCK_EMERALD_ORE:
+			case E_BLOCK_COAL_ORE:
 			{
-				ItemType = E_ITEM_EMERALD;
+				a_Pickups.push_back(cItem(E_ITEM_COAL));
 				break;
 			}
-			case E_BLOCK_COAL_ORE:
+			default:
 			{
-				ItemType = E_ITEM_COAL;
+				a_Pickups.push_back(cItem(m_BlockType));
 				break;
 			}
 		}
-		a_Pickups.push_back(cItem(ItemType, Count, Meta));
 	}
 } ;
 
diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp
index 164967621..34d11f675 100644
--- a/src/Blocks/BlockPiston.cpp
+++ b/src/Blocks/BlockPiston.cpp
@@ -5,6 +5,7 @@
 #include "../World.h"
 #include "../Entities/Player.h"
 #include "BlockInServerPluginInterface.h"
+#include "ChunkInterface.h"
 
 
 
@@ -52,7 +53,7 @@ void cBlockPistonHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorld
 
 	if (a_ChunkInterface.GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION)
 	{
-		a_ChunkInterface.SetBlock(a_WorldInterface, newX, newY, newZ, E_BLOCK_AIR, 0);
+		a_ChunkInterface.SetBlock(newX, newY, newZ, E_BLOCK_AIR, 0);
 	}
 }
 
diff --git a/src/Blocks/BlockPiston.h b/src/Blocks/BlockPiston.h
index bbb8af75b..f868f4d8e 100644
--- a/src/Blocks/BlockPiston.h
+++ b/src/Blocks/BlockPiston.h
@@ -4,7 +4,7 @@
 #include "BlockHandler.h"
 
 
-
+class cWorld;
 
 
 class cBlockPistonHandler :
@@ -94,10 +94,13 @@ private:
 		switch (a_BlockType)
 		{
 			case E_BLOCK_ANVIL:
+			case E_BLOCK_BARRIER:
+			case E_BLOCK_BEACON:
 			case E_BLOCK_BEDROCK:
 			case E_BLOCK_BREWING_STAND:
 			case E_BLOCK_CHEST:
 			case E_BLOCK_COMMAND_BLOCK:
+			case E_BLOCK_DAYLIGHT_SENSOR:
 			case E_BLOCK_DISPENSER:
 			case E_BLOCK_DROPPER:
 			case E_BLOCK_ENCHANTMENT_TABLE:
@@ -106,6 +109,7 @@ private:
 			// Notice the lack of an E_BLOCK_ENDER_CHEST here; its because ender chests can totally be pushed/pulled in MCS :)
 			case E_BLOCK_FURNACE:
 			case E_BLOCK_LIT_FURNACE:
+			case E_BLOCK_INVERTED_DAYLIGHT_SENSOR:
 			case E_BLOCK_HOPPER:
 			case E_BLOCK_JUKEBOX:
 			case E_BLOCK_MOB_SPAWNER:
@@ -113,7 +117,9 @@ private:
 			case E_BLOCK_NOTE_BLOCK:
 			case E_BLOCK_OBSIDIAN:
 			case E_BLOCK_PISTON_EXTENSION:
+			case E_BLOCK_STANDING_BANNER:
 			case E_BLOCK_TRAPPED_CHEST:
+			case E_BLOCK_WALL_BANNER:
 			{
 				return false;
 			}
diff --git a/src/Blocks/BlockPlanks.h b/src/Blocks/BlockPlanks.h
index de84ed319..3c243ebdc 100644
--- a/src/Blocks/BlockPlanks.h
+++ b/src/Blocks/BlockPlanks.h
@@ -24,16 +24,9 @@ public:
 	) override
 	{
 		a_BlockType = m_BlockType;
-		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
-		a_BlockMeta = Meta;
+		a_BlockMeta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
 		return true;
 	}
-
-	
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockPortal.h b/src/Blocks/BlockPortal.h
index fc74e89d0..97ba26ee3 100644
--- a/src/Blocks/BlockPortal.h
+++ b/src/Blocks/BlockPortal.h
@@ -36,7 +36,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		return;  // No pickups
+		// No pickups
 	}
 
 	virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
@@ -47,15 +47,15 @@ public:
 			return;
 		}
 
-		int PosX = a_Chunk.GetPosX() * 16 + a_RelX;
-		int PosZ = a_Chunk.GetPosZ() * 16 + a_RelZ;
+		int PosX = a_Chunk.GetPosX() * cChunkDef::Width + a_RelX;
+		int PosZ = a_Chunk.GetPosZ() * cChunkDef::Width + a_RelZ;
 
-		a_WorldInterface.SpawnMob(PosX, a_RelY, PosZ, cMonster::mtZombiePigman);
+		a_WorldInterface.SpawnMob(PosX, a_RelY, PosZ, mtZombiePigman);
 	}
 
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
-		if ((a_RelY - 1 < 0) || (a_RelY + 1 > cChunkDef::Height))
+		if ((a_RelY <= 0) || (a_RelY >= 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
 		}
diff --git a/src/Blocks/BlockPressurePlate.h b/src/Blocks/BlockPressurePlate.h
index adec36eb6..a5c34a776 100644
--- a/src/Blocks/BlockPressurePlate.h
+++ b/src/Blocks/BlockPressurePlate.h
@@ -17,7 +17,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
 	}
 
@@ -29,7 +29,7 @@ public:
 		}
 
 		BLOCKTYPE BlockBelow = a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ);
-		return ((BlockBelow == E_BLOCK_FENCE_GATE) || (BlockBelow == E_BLOCK_FENCE) || cBlockInfo::IsSolid(BlockBelow));
+		return (cBlockInfo::IsSolid(BlockBelow));
 	}
 } ;
 
diff --git a/src/Blocks/BlockPumpkin.h b/src/Blocks/BlockPumpkin.h
index 15ac80fd7..275d1422a 100644
--- a/src/Blocks/BlockPumpkin.h
+++ b/src/Blocks/BlockPumpkin.h
@@ -36,7 +36,7 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY,     a_BlockZ, E_BLOCK_AIR, 0);
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtSnowGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtSnowGolem);
 			return;
 		}
 		
@@ -61,7 +61,7 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
 			
 			// Spawn the golem:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtIronGolem);
 		}
 		else if (
 			(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1) == E_BLOCK_IRON_BLOCK) &&
@@ -76,7 +76,7 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
 			
 			// Spawn the golem:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtIronGolem);
 		}
 	}
 
diff --git a/src/Blocks/BlockQuartz.h b/src/Blocks/BlockQuartz.h
index 2ce7e71e4..edc4fb9c5 100644
--- a/src/Blocks/BlockQuartz.h
+++ b/src/Blocks/BlockQuartz.h
@@ -25,6 +25,7 @@ public:
 	{
 		a_BlockType = m_BlockType;
 		NIBBLETYPE Meta = (NIBBLETYPE)(a_Player->GetEquippedItem().m_ItemDamage);
+
 		if (Meta != E_META_QUARTZ_PILLAR)  // Check if the block is a pillar block.
 		{
 			a_BlockMeta = Meta;
diff --git a/src/Blocks/BlockRedstone.h b/src/Blocks/BlockRedstone.h
index a898c9acb..37d61ed73 100644
--- a/src/Blocks/BlockRedstone.h
+++ b/src/Blocks/BlockRedstone.h
@@ -26,8 +26,8 @@ public:
 	
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
-		a_Pickups.push_back(cItem(E_ITEM_REDSTONE_DUST, 1));
+		// Reset meta to zero
+		a_Pickups.push_back(cItem(E_ITEM_REDSTONE_DUST, 1, 0));
 	}
 } ;
 
diff --git a/src/Blocks/BlockRedstoneRepeater.h b/src/Blocks/BlockRedstoneRepeater.h
index 4c8a6a087..1eb67f714 100644
--- a/src/Blocks/BlockRedstoneRepeater.h
+++ b/src/Blocks/BlockRedstoneRepeater.h
@@ -4,7 +4,7 @@
 #include "BlockHandler.h"
 #include "Chunk.h"
 #include "MetaRotator.h"
-
+#include "ChunkInterface.h"
 
 
 
@@ -23,7 +23,7 @@ public:
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
-		) override
+	) override
 	{
 		a_BlockType = m_BlockType;
 		a_BlockMeta = RepeaterRotationToMetaData(a_Player->GetYaw());
@@ -46,7 +46,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(E_ITEM_REDSTONE_REPEATER, 1, 0));
 	}
 
@@ -59,13 +59,7 @@ public:
 	
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
-		return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
-	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
+		return ((a_RelY > 0) && cBlockInfo::IsSolid(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)));
 	}
 
 
diff --git a/src/Blocks/BlockRedstoneTorch.h b/src/Blocks/BlockRedstoneTorch.h
index cb897ba3f..8416a415c 100644
--- a/src/Blocks/BlockRedstoneTorch.h
+++ b/src/Blocks/BlockRedstoneTorch.h
@@ -23,12 +23,6 @@ public:
 		// Always drop the ON torch, meta 0
 		a_Pickups.push_back(cItem(E_BLOCK_REDSTONE_TORCH_ON, 1, 0));
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockSand.h b/src/Blocks/BlockSand.h
index 3fc271483..48beab138 100644
--- a/src/Blocks/BlockSand.h
+++ b/src/Blocks/BlockSand.h
@@ -15,12 +15,6 @@ public:
 		: cBlockHandler(a_BlockType)
 	{
 	}
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.sand";
-	}
-	
 };
 
 
diff --git a/src/Blocks/BlockSapling.h b/src/Blocks/BlockSapling.h
index de28273d5..bec79c6f3 100644
--- a/src/Blocks/BlockSapling.h
+++ b/src/Blocks/BlockSapling.h
@@ -46,12 +46,6 @@ public:
 			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/BlockSeaLantern.h b/src/Blocks/BlockSeaLantern.h
new file mode 100644
index 000000000..a9259d1d6
--- /dev/null
+++ b/src/Blocks/BlockSeaLantern.h
@@ -0,0 +1,30 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockSeaLanternHandler :
+	public cBlockHandler
+{
+public:
+	cBlockSeaLanternHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		cFastRandom Random;
+		a_Pickups.push_back(cItem(E_ITEM_PRISMARINE_CRYSTALS, (char)(2 + Random.NextInt(2)), 0));
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockSideways.h b/src/Blocks/BlockSideways.h
index f5f10899d..4b1e38d6d 100644
--- a/src/Blocks/BlockSideways.h
+++ b/src/Blocks/BlockSideways.h
@@ -65,12 +65,6 @@ public:
 			}
 		}
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockSignPost.h b/src/Blocks/BlockSignPost.h
index ee65d099a..40e15c253 100644
--- a/src/Blocks/BlockSignPost.h
+++ b/src/Blocks/BlockSignPost.h
@@ -27,20 +27,15 @@ public:
 	}
 
 
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
-
-
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		if (a_RelY <= 0)
 		{
 			return false;
 		}
+		BLOCKTYPE Type = a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ);
 
-		return (cBlockInfo::IsSolid(a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ)));
+		return ((Type == E_BLOCK_SIGN_POST) || cBlockInfo::IsSolid(Type));
 	}
 
 
diff --git a/src/Blocks/BlockSlab.h b/src/Blocks/BlockSlab.h
index 214445eda..ffe2414f7 100644
--- a/src/Blocks/BlockSlab.h
+++ b/src/Blocks/BlockSlab.h
@@ -12,6 +12,7 @@
 #include "BlockHandler.h"
 #include "../Items/ItemHandler.h"
 #include "Root.h"
+#include "ChunkInterface.h"
 
 
 
@@ -85,18 +86,6 @@ public:
 
 		return true;
 	}
-	
-	
-	virtual const char * GetStepSound(void) override
-	{
-		switch (m_BlockType)
-		{
-			case E_BLOCK_WOODEN_SLAB: return "step.wood";
-			case E_BLOCK_STONE_SLAB:  return "step.stone";
-		}
-		ASSERT(!"Unhandled slab type!");
-		return "";
-	}
 
 
 	virtual bool CanDirtGrowGrass(NIBBLETYPE a_Meta) override
@@ -108,7 +97,19 @@ public:
 	/// Returns true if the specified blocktype is one of the slabs handled by this handler
 	static bool IsAnySlabType(BLOCKTYPE a_BlockType)
 	{
-		return ((a_BlockType == E_BLOCK_WOODEN_SLAB) || (a_BlockType == E_BLOCK_STONE_SLAB));
+		return ((a_BlockType == E_BLOCK_WOODEN_SLAB) || (a_BlockType == E_BLOCK_STONE_SLAB) || (a_BlockType == E_BLOCK_NEW_STONE_SLAB));
+	}
+
+
+	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
+	{
+		if ((a_BlockFace == BLOCK_FACE_NONE) || (a_Player->GetEquippedItem().m_ItemType != (short)m_BlockType))
+		{
+			return;
+		}
+
+		// Sends the slab back to the client. It's to refuse a doubleslab placement.
+		a_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
 	}
 	
 	
@@ -119,6 +120,7 @@ public:
 		{
 			case E_BLOCK_STONE_SLAB:  return E_BLOCK_DOUBLE_STONE_SLAB;
 			case E_BLOCK_WOODEN_SLAB: return E_BLOCK_DOUBLE_WOODEN_SLAB;
+			case E_BLOCK_NEW_STONE_SLAB: return E_BLOCK_DOUBLE_NEW_STONE_SLAB;
 		}
 		ASSERT(!"Unhandled slab type!");
 		return E_BLOCK_AIR;
@@ -158,21 +160,11 @@ public:
 		{
 			case E_BLOCK_DOUBLE_STONE_SLAB:  return E_BLOCK_STONE_SLAB;
 			case E_BLOCK_DOUBLE_WOODEN_SLAB: return E_BLOCK_WOODEN_SLAB;
+			case E_BLOCK_DOUBLE_NEW_STONE_SLAB: return E_BLOCK_NEW_STONE_SLAB;
 		}
 		ASSERT(!"Unhandled double slab type!");
 		return a_BlockType;
 	}
-	
-	virtual const char * GetStepSound(void) override
-	{
-		switch (m_BlockType)
-		{
-			case E_BLOCK_DOUBLE_STONE_SLAB:  return "step.stone";
-			case E_BLOCK_DOUBLE_WOODEN_SLAB: return "step.wood";
-		}
-		ASSERT(!"Unhandled double slab type!");
-		return "";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockSnow.h b/src/Blocks/BlockSnow.h
index 977f19a16..7b6094c9f 100644
--- a/src/Blocks/BlockSnow.h
+++ b/src/Blocks/BlockSnow.h
@@ -87,12 +87,6 @@ public:
 	{
 		return false;
 	}
-	
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.cloth";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockStairs.h b/src/Blocks/BlockStairs.h
index a7ccf1714..d396204e0 100644
--- a/src/Blocks/BlockStairs.h
+++ b/src/Blocks/BlockStairs.h
@@ -16,8 +16,8 @@ public:
 	{
 
 	}
-	
-	
+
+
 	virtual bool GetPlacementBlockTypeMeta(
 		cChunkInterface & a_ChunkInterface, cPlayer * a_Player,
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
@@ -53,36 +53,21 @@ public:
 		}
 		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
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
 	}
 
+
 	virtual bool CanDirtGrowGrass(NIBBLETYPE a_Meta) override
 	{
 		return true;
 	}
-	
+
+
 	static NIBBLETYPE RotationToMetaData(double a_Rotation)
 	{
 		a_Rotation += 90 + 45;  // So its not aligned with axis
@@ -108,14 +93,11 @@ public:
 		}
 	}
 
-
 	virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
 	{
 		// Toggle bit 3:
 		return (a_Meta & 0x0b) | ((~a_Meta) & 0x04);
 	}
-
-
 } ;
 
 
diff --git a/src/Blocks/BlockStems.h b/src/Blocks/BlockStems.h
index b726a0901..860c7dd45 100644
--- a/src/Blocks/BlockStems.h
+++ b/src/Blocks/BlockStems.h
@@ -47,12 +47,6 @@ public:
 	{
 		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/src/Blocks/BlockStone.h b/src/Blocks/BlockStone.h
index cd5230f49..e52599c0f 100644
--- a/src/Blocks/BlockStone.h
+++ b/src/Blocks/BlockStone.h
@@ -2,7 +2,7 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "BlockID.h"
 
 
 
@@ -18,9 +18,14 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		a_Pickups.push_back(cItem(E_BLOCK_COBBLESTONE, 1, 0));
+		if (a_BlockMeta == E_META_STONE)
+		{
+			a_Pickups.push_back(cItem(E_BLOCK_COBBLESTONE, 1, 0));
+			return;
+		}
+		a_Pickups.push_back(cItem(E_BLOCK_STONE, 1, a_BlockMeta));
 	}
-} ;
+};
 
 
 
diff --git a/src/Blocks/BlockSugarcane.h b/src/Blocks/BlockSugarcane.h
index 84d3b2e7d..c832ff218 100644
--- a/src/Blocks/BlockSugarcane.h
+++ b/src/Blocks/BlockSugarcane.h
@@ -29,6 +29,7 @@ public:
 		{
 			return false;
 		}
+
 		switch (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ))
 		{
 			case E_BLOCK_DIRT:
@@ -77,12 +78,6 @@ public:
 	{
 		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/src/Blocks/BlockTNT.h b/src/Blocks/BlockTNT.h
index 283a03730..3a573ae67 100644
--- a/src/Blocks/BlockTNT.h
+++ b/src/Blocks/BlockTNT.h
@@ -16,11 +16,6 @@ public:
 	{
 	}
 
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.grass";
-	}
-
 	virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
 	{
 		a_WorldInterface.SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, a_Player);
diff --git a/src/Blocks/BlockTallGrass.h b/src/Blocks/BlockTallGrass.h
index 9c008f793..f520414a7 100644
--- a/src/Blocks/BlockTallGrass.h
+++ b/src/Blocks/BlockTallGrass.h
@@ -53,12 +53,6 @@ public:
 	{
 		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.grass";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockTorch.h b/src/Blocks/BlockTorch.h
index c73118870..e77bbd1b8 100644
--- a/src/Blocks/BlockTorch.h
+++ b/src/Blocks/BlockTorch.h
@@ -24,32 +24,23 @@ public:
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
-		// Find proper placement of torch
+		BLOCKTYPE Block;
+		NIBBLETYPE Meta;
+		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, true);  // Set to clicked block
+		a_ChunkInterface.GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, Block, Meta);
 
-		if ((a_BlockFace == BLOCK_FACE_TOP) || (a_BlockFace == BLOCK_FACE_BOTTOM))
+		if (!CanBePlacedOn(Block, Meta, a_BlockFace))  // Try to preserve original direction
 		{
-			a_BlockFace = FindSuitableFace(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);  // Top or bottom faces clicked, find a suitable face
+			// Torch couldn't be placed on whatever face was clicked, last ditch resort - find another face
+
+			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, false);  // Reset to torch block
+			a_BlockFace = FindSuitableFace(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);  // Set a_BlockFace to a valid direction which will be converted later to a metadata
 			if (a_BlockFace == BLOCK_FACE_NONE)
 			{
-				// Client wouldn't have sent anything anyway, but whatever
+				// No attachable face found - don't place the torch
 				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);  // Set to clicked block
-			if (!CanBePlacedOn(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ), a_BlockFace))
-			{
-				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, false);  // Reset to torch block
-				// Torch couldn't be placed on whatever face was clicked, last ditch resort - find another face
-				a_BlockFace = FindSuitableFace(a_ChunkInterface, a_BlockX, a_BlockY, a_BlockZ);
-				if (a_BlockFace == BLOCK_FACE_NONE)
-				{
-					return false;
-				}
-			}
-		}
 
 		a_BlockType = m_BlockType;
 		a_BlockMeta = DirectionToMetaData(a_BlockFace);
@@ -97,42 +88,57 @@ public:
 	}
 
 
-	static bool CanBePlacedOn(BLOCKTYPE a_BlockType, eBlockFace a_BlockFace)
+	static bool CanBePlacedOn(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, eBlockFace a_BlockFace)
 	{
-		if (!cBlockInfo::FullyOccupiesVoxel(a_BlockType))
-		{
-			return (a_BlockFace == BLOCK_FACE_TOP);  // Allow placement only when torch upright (for glass, etc.); exceptions won't even be sent by client, no need to handle
-		}
-		else
+		switch (a_BlockType)
 		{
-			return true;
+			case E_BLOCK_END_PORTAL_FRAME:
+			case E_BLOCK_SOULSAND:
+			{
+				// Exceptional vanilla behaviour
+				return true;
+			}
+			case E_BLOCK_GLASS:
+			case E_BLOCK_STAINED_GLASS:
+			case E_BLOCK_FENCE:
+			case E_BLOCK_NETHER_BRICK_FENCE:
+			case E_BLOCK_COBBLESTONE_WALL:
+			{
+				// Torches can only be placed on top of these blocks
+				return (a_BlockFace == BLOCK_FACE_YP);
+			}
+			case E_BLOCK_STONE_SLAB:
+			case E_BLOCK_WOODEN_SLAB:
+			{
+				// Toches can be placed on the top of these slabs only if the occupy the top half of the voxel
+				return ((a_BlockFace == BLOCK_FACE_YP) && ((a_BlockMeta & 0x08) == 0x08));
+			}
+			default:
+			{
+				if (cBlockInfo::FullyOccupiesVoxel(a_BlockType))
+				{
+					// Torches can be placed on all sides of full blocks except the bottom
+					return (a_BlockFace != BLOCK_FACE_YM);
+				}
+				return false;
+			}
 		}
 	}
 	
 	
-	/// Finds a suitable face to place the torch, returning BLOCK_FACE_NONE on failure
+	/** Finds a suitable face to place the torch, returning BLOCK_FACE_NONE on failure */
 	static eBlockFace FindSuitableFace(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ)
 	{
 		for (int i = BLOCK_FACE_YM; i <= BLOCK_FACE_XP; i++)  // Loop through all directions
 		{
 			eBlockFace Face = static_cast<eBlockFace>(i);
 			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, Face, true);
-			BLOCKTYPE BlockInQuestion = a_ChunkInterface.GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-
-			// If on a block that can only hold a torch if torch is standing on it, return that face
-			if (
-				((BlockInQuestion == E_BLOCK_GLASS) ||
-				(BlockInQuestion == E_BLOCK_FENCE) ||
-				(BlockInQuestion == E_BLOCK_NETHER_BRICK_FENCE) ||
-				(BlockInQuestion == E_BLOCK_COBBLESTONE_WALL)) &&
-				(Face == BLOCK_FACE_TOP)
-				)
-			{
-				return Face;
-			}
-			else if (cBlockInfo::FullyOccupiesVoxel(BlockInQuestion) && (i != BLOCK_FACE_BOTTOM))
+			BLOCKTYPE BlockInQuestion;
+			NIBBLETYPE BlockInQuestionMeta;
+			a_ChunkInterface.GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockInQuestion, BlockInQuestionMeta);
+
+			if (CanBePlacedOn(BlockInQuestion, BlockInQuestionMeta, Face))
 			{
-				// Otherwise, if block in that direction is torch placeable and we haven't gotten to it via the bottom face, return that face
 				return Face;
 			}
 			else
@@ -148,34 +154,16 @@ public:
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
 	{
 		eBlockFace 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_STAINED_GLASS) ||
-			(BlockInQuestion == E_BLOCK_FENCE) ||
-			(BlockInQuestion == E_BLOCK_SOULSAND) ||
-			(BlockInQuestion == E_BLOCK_MOB_SPAWNER) ||
-			(BlockInQuestion == E_BLOCK_END_PORTAL_FRAME) ||  // Actual vanilla behaviour
-			(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 (!cBlockInfo::FullyOccupiesVoxel(BlockInQuestion))
+		NIBBLETYPE BlockInQuestionMeta;
+		if (!a_Chunk.UnboundedRelGetBlock(a_RelX, a_RelY, a_RelZ, BlockInQuestion, BlockInQuestionMeta))
 		{
 			return false;
 		}
-		else
-		{
-			return true;
-		}
+
+		return CanBePlacedOn(BlockInQuestion, BlockInQuestionMeta, Face);
 	}
 
 
@@ -184,12 +172,6 @@ public:
 		// Always drop meta = 0
 		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/BlockTrapdoor.h b/src/Blocks/BlockTrapdoor.h
index 6a36ab874..8c96de0f1 100644
--- a/src/Blocks/BlockTrapdoor.h
+++ b/src/Blocks/BlockTrapdoor.h
@@ -16,14 +16,9 @@ public:
 	{
 	}
 
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
-
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(m_BlockType, 1, 0));
 	}
 
@@ -34,6 +29,12 @@ public:
 
 	virtual void OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) override
 	{
+		if (m_BlockType == E_BLOCK_IRON_TRAPDOOR)
+		{
+			// Iron doors can only be toggled by redstone, not by right-clicking
+			return;
+		}
+
 		// Flip the ON bit on/off using the XOR bitwise operation
 		NIBBLETYPE Meta = (a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) ^ 0x04);
 		a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta);
@@ -53,7 +54,7 @@ public:
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
-		) override
+	) override
 	{
 		a_BlockType = m_BlockType;
 		a_BlockMeta = BlockFaceToMetaData(a_BlockFace);
@@ -103,9 +104,10 @@ public:
 		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);
+		BLOCKTYPE BlockIsOn;
+		a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-		return (a_RelY > 0) && cBlockInfo::IsSolid(BlockIsOn);
+		return ((a_RelY > 0) && cBlockInfo::IsSolid(BlockIsOn));
 	}
 };
 
diff --git a/src/Blocks/BlockTripwire.h b/src/Blocks/BlockTripwire.h
index 3ab17bf4a..d03f37537 100644
--- a/src/Blocks/BlockTripwire.h
+++ b/src/Blocks/BlockTripwire.h
@@ -20,11 +20,6 @@ public:
 	{
 		a_Pickups.push_back(cItem(E_ITEM_STRING, 1, 0));
 	}
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "";
-	}
 };
 
 
diff --git a/src/Blocks/BlockTripwireHook.h b/src/Blocks/BlockTripwireHook.h
index f849fb8ad..88d389711 100644
--- a/src/Blocks/BlockTripwireHook.h
+++ b/src/Blocks/BlockTripwireHook.h
@@ -21,10 +21,9 @@ public:
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
-		) override
+	) override
 	{
 		a_BlockType = m_BlockType;
-
 		a_BlockMeta = DirectionToMetadata(a_BlockFace);
 
 		return true;
@@ -56,7 +55,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(E_BLOCK_TRIPWIRE_HOOK, 1, 0));
 	}
 
@@ -66,14 +65,10 @@ public:
 		a_Chunk.UnboundedRelGetBlockMeta(a_RelX, a_RelY, a_RelZ, Meta);
 
 		AddFaceDirection(a_RelX, a_RelY, a_RelZ, MetadataToDirection(Meta), true);
-		BLOCKTYPE BlockIsOn; a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
-
-		return (a_RelY > 0) && cBlockInfo::FullyOccupiesVoxel(BlockIsOn);
-	}
+		BLOCKTYPE BlockIsOn;
+		a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, BlockIsOn);
 
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
+		return ((a_RelY > 0) && cBlockInfo::FullyOccupiesVoxel(BlockIsOn));
 	}
 };
 
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
index 1e1f6d8d2..06d84f2d4 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -2,7 +2,7 @@
 
 #include "BlockHandler.h"
 #include "MetaRotator.h"
-
+#include "Bindings/PluginManager.h"
 
 
 
@@ -46,7 +46,7 @@ public:
 
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
-		// Reset meta to 0
+		// Reset meta to zero
 		a_Pickups.push_back(cItem(E_BLOCK_VINES, 1, 0));
 	}
 
@@ -80,7 +80,7 @@ public:
 	/// Returns true if the specified block type is good for vines to attach to
 	static bool IsBlockAttachable(BLOCKTYPE a_BlockType)
 	{
-		return (a_BlockType == E_BLOCK_LEAVES) || (a_BlockType == E_BLOCK_NEW_LEAVES) || cBlockInfo::IsSolid(a_BlockType);
+		return ((a_BlockType == E_BLOCK_LEAVES) || (a_BlockType == E_BLOCK_NEW_LEAVES) || cBlockInfo::IsSolid(a_BlockType));
 	}
 
 
@@ -159,12 +159,6 @@ public:
 	{
 		return true;
 	}
-	
-	
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.grass";
-	}
 
 
 	virtual bool DoesDropOnUnsuitable(void) override
@@ -182,7 +176,7 @@ public:
 		a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY - 1, a_RelZ, Block);
 		if (Block == E_BLOCK_AIR)
 		{
-			if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, a_RelX * cChunkDef::Width, a_RelY - 1, a_RelZ * cChunkDef::Width, ssVineSpread))
+			if (!cRoot::Get()->GetPluginManager()->CallHookBlockSpread((cWorld*) &a_WorldInterface, a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY - 1, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width, ssVineSpread))
 			{
 				a_Chunk.UnboundedRelSetBlock(a_RelX, a_RelY - 1, a_RelZ, E_BLOCK_VINES, a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
 			}
diff --git a/src/Blocks/BlockWallSign.h b/src/Blocks/BlockWallSign.h
index e837b315e..0abe9c52c 100644
--- a/src/Blocks/BlockWallSign.h
+++ b/src/Blocks/BlockWallSign.h
@@ -27,12 +27,6 @@ public:
 	}
 
 
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
-
-
 	virtual void OnPlacedByPlayer(
 		cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
 		int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace,
@@ -49,8 +43,9 @@ public:
 		int BlockX = (a_Chunk.GetPosX() * cChunkDef::Width) + a_RelX;
 		int BlockZ = (a_Chunk.GetPosZ() * cChunkDef::Width) + a_RelZ;
 		GetBlockCoordsBehindTheSign(a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ), BlockX, BlockZ);
+		BLOCKTYPE Type = a_ChunkInterface.GetBlock(BlockX, a_RelY, BlockZ);
 
-		return (cBlockInfo::IsSolid(a_ChunkInterface.GetBlock(BlockX, a_RelY, BlockZ)));
+		return ((Type == E_BLOCK_WALLSIGN) || (Type == E_BLOCK_SIGN_POST) || cBlockInfo::IsSolid(Type));
 	}
 
 
diff --git a/src/Blocks/BlockWorkbench.h b/src/Blocks/BlockWorkbench.h
index 70468369c..699badaf2 100644
--- a/src/Blocks/BlockWorkbench.h
+++ b/src/Blocks/BlockWorkbench.h
@@ -30,12 +30,6 @@ public:
 	{
 		return true;
 	}
-
-
-	virtual const char * GetStepSound(void) override
-	{
-		return "step.wood";
-	}
 } ;
 
 
diff --git a/src/Blocks/CMakeLists.txt b/src/Blocks/CMakeLists.txt
index 05b7bfab4..eed949aab 100644
--- a/src/Blocks/CMakeLists.txt
+++ b/src/Blocks/CMakeLists.txt
@@ -45,7 +45,6 @@ SET (HDRS
 	BlockGlowstone.h
 	BlockGravel.h
 	BlockHandler.h
-	BlockHayBale.h
 	BlockHopper.h
 	BlockIce.h
 	BlockLadder.h
@@ -57,8 +56,6 @@ SET (HDRS
 	BlockMushroom.h
 	BlockMycelium.h
 	BlockNetherWart.h
-	BlockNewLeaves.h
-	BlockNote.h
 	BlockOre.h
 	BlockPiston.h
 	BlockPlanks.h
diff --git a/src/Blocks/ChunkInterface.cpp b/src/Blocks/ChunkInterface.cpp
index 540581ae7..817640e98 100644
--- a/src/Blocks/ChunkInterface.cpp
+++ b/src/Blocks/ChunkInterface.cpp
@@ -2,7 +2,139 @@
 #include "Globals.h"
 
 #include "ChunkInterface.h"
+#include "ChunkMap.h"
 #include "BlockHandler.h"
+#include "WorldInterface.h"
+
+
+
+
+
+
+BLOCKTYPE cChunkInterface::GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return m_ChunkMap->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+BLOCKTYPE cChunkInterface::GetBlock(const Vector3i & a_Pos)
+{
+	return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
+}
+
+
+
+
+
+NIBBLETYPE cChunkInterface::GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+
+bool cChunkInterface::GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+{
+	return m_ChunkMap->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+/** Sets the block at the specified coords to the specified value.
+Full processing, incl. updating neighbors, is performed.
+*/
+void cChunkInterface::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	m_ChunkMap->SetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+void cChunkInterface::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
+{
+	m_ChunkMap->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_MetaData);
+}
+
+
+
+
+
+
+void cChunkInterface::QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface)
+{
+	m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_WorldInterface.GetWorldAge() + a_TickDelay, a_PreviousBlockType);
+}
+
+
+
+
+
+
+/** Sets the block at the specified coords to the specified value.
+The replacement doesn't trigger block updates.
+The replaced blocks aren't checked for block entities (block entity is leaked if it exists at this block)
+*/
+void cChunkInterface::FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+void cChunkInterface::FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+void cChunkInterface::UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	m_ChunkMap->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+
+bool cChunkInterface::ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback)
+{
+	return m_ChunkMap->ForEachChunkInRect(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ, a_Callback);
+}
+
+
+
+
+
+
+bool cChunkInterface::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
+{
+	return m_ChunkMap->WriteBlockArea(a_Area, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
+}
+
+
+
+
+
 
 bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z)
 {
@@ -10,3 +142,4 @@ bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int
 	Handler->OnDestroyed(*this, a_WorldInterface, a_X, a_Y, a_Z);
 	return m_ChunkMap->DigBlock(a_X, a_Y, a_Z);
 }
+
diff --git a/src/Blocks/ChunkInterface.h b/src/Blocks/ChunkInterface.h
index dea9d7c7e..2f0cfea11 100644
--- a/src/Blocks/ChunkInterface.h
+++ b/src/Blocks/ChunkInterface.h
@@ -1,13 +1,13 @@
 
 #pragma once
 
-#include "../ChunkMap.h"
 #include "../ForEachChunkProvider.h"
-#include "WorldInterface.h"
-
 
 
 
+class cChunkMap;
+class cWorldInterface;
+class cPlayer;
 
 class cChunkInterface:
 	public cForEachChunkProvider
@@ -16,70 +16,34 @@ public:
 
 	cChunkInterface(cChunkMap * a_ChunkMap) : m_ChunkMap(a_ChunkMap) {}
 
-	BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		return m_ChunkMap->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-	}
-	BLOCKTYPE GetBlock(const Vector3i & a_Pos)
-	{
-		return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
-	}
-	NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-	}
+	BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
+	BLOCKTYPE GetBlock(const Vector3i & a_Pos);
+	NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ);
 
-	bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
-	{
-		return m_ChunkMap->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-	}
+	bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
 	
 	/** Sets the block at the specified coords to the specified value.
 	Full processing, incl. updating neighbors, is performed.
 	*/
-	void SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-	{
-		m_ChunkMap->SetBlock(a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-	}
+	void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
-	void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
-	{
-		m_ChunkMap->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_MetaData);
-	}
+	void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData);
 	
-	void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface)
-	{
-		m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_WorldInterface.GetWorldAge() + a_TickDelay, a_PreviousBlockType);
-	}
+	void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface);
 	
 	/** Sets the block at the specified coords to the specified value.
 	The replacement doesn't trigger block updates.
 	The replaced blocks aren't checked for block entities (block entity is leaked if it exists at this block)
 	*/
-	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-	{
-		m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-	}
+	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
-	void FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-	{
-		FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta);
-	}
+	void FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
-	void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		m_ChunkMap->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
-	}
+	void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
-	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override
-	{
-		return m_ChunkMap->ForEachChunkInRect(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ, a_Callback);
-	}
+	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override;
 	
-	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override
-	{
-		return m_ChunkMap->WriteBlockArea(a_Area, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
-	}
+	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override;
 	
 	bool DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z);
 	
diff --git a/src/Blocks/ClearMetaOnDrop.h b/src/Blocks/ClearMetaOnDrop.h
index f2afbc6ea..aa4f23848 100644
--- a/src/Blocks/ClearMetaOnDrop.h
+++ b/src/Blocks/ClearMetaOnDrop.h
@@ -7,7 +7,7 @@
 // For example to use in class Foo which should inherit Bar use
 // class Foo : public cClearMetaOnDrop<Bar>;
 
-template<class Base>
+template <class Base>
 class cClearMetaOnDrop : public Base
 {
 public:
diff --git a/src/Blocks/GetHandlerCompileTimeTemplate.h b/src/Blocks/GetHandlerCompileTimeTemplate.h
new file mode 100644
index 000000000..3466b5426
--- /dev/null
+++ b/src/Blocks/GetHandlerCompileTimeTemplate.h
@@ -0,0 +1,91 @@
+
+#pragma once
+
+class cBlockTorchHandler;
+class cBlockLeverHandler;
+class cBlockButtonHandler;
+class cBlockTripwireHookHandler;
+class cBlockDoorHandler;
+class cBlockPistonHandler;
+
+
+
+
+
+
+template<BLOCKTYPE T>
+class GetHandlerCompileTime;
+
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_TORCH>
+{
+public:
+	typedef cBlockTorchHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_LEVER>
+{
+public:
+	typedef cBlockLeverHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_STONE_BUTTON>
+{
+public:
+	typedef cBlockButtonHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_TRIPWIRE_HOOK>
+{
+public:
+	typedef cBlockTripwireHookHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_WOODEN_DOOR>
+{
+public:
+	typedef cBlockDoorHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_PISTON>
+{
+public:
+	typedef cBlockPistonHandler type;
+};
+
diff --git a/src/Blocks/MetaRotator.h b/src/Blocks/MetaRotator.h
index 599aa7ef9..4c268077a 100644
--- a/src/Blocks/MetaRotator.h
+++ b/src/Blocks/MetaRotator.h
@@ -20,7 +20,7 @@ Usage:
 Inherit from this class providing your base class as Base, the BitMask for the direction bits in bitmask and the masked value for the directions in North, East, South, West. There is also an aptional parameter AssertIfNotMatched. Set this if it is invalid for a block to exist in any other state.
 */
 
-template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched = false>
+template <class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched = false>
 class cMetaRotator : public Base
 {
 public:
@@ -41,7 +41,7 @@ public:
 
 
 
-template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+template <class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
 NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCW(NIBBLETYPE a_Meta)
 {
 	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
@@ -63,7 +63,7 @@ NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatc
 
 
 
-template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+template <class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
 NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCCW(NIBBLETYPE a_Meta)
 {
 	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
@@ -85,7 +85,7 @@ NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatc
 
 
 
-template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+template <class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
 NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorXY(NIBBLETYPE a_Meta)
 {
 	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
@@ -102,7 +102,7 @@ NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatc
 
 
 
-template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
+template <class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
 NIBBLETYPE cMetaRotator<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorYZ(NIBBLETYPE a_Meta)
 {
 	NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
diff --git a/src/Blocks/WorldInterface.h b/src/Blocks/WorldInterface.h
index d1c6f9bfc..106c314e7 100644
--- a/src/Blocks/WorldInterface.h
+++ b/src/Blocks/WorldInterface.h
@@ -2,14 +2,15 @@
 #pragma once
 
 #include "BroadcastInterface.h"
-#include "../Mobs/Monster.h"
+#include "../Mobs/MonsterTypes.h"
 
 class cItems;
 
 typedef cItemCallback<cBlockEntity> cBlockEntityCallback;
 
 
-
+class cMonster;
+class cPlayer;
 
 
 class cWorldInterface
@@ -17,7 +18,7 @@ class cWorldInterface
 public:
 	virtual ~cWorldInterface() {}
 	
-	virtual Int64 GetTimeOfDay(void) const = 0;
+	virtual int GetTimeOfDay(void) const = 0;
 	virtual Int64 GetWorldAge(void)  const = 0;
 	
 	virtual eDimension GetDimension(void) const = 0;
@@ -33,7 +34,10 @@ public:
 	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated = false) = 0;
 	
 	/** Spawns a mob of the specified type. Returns the mob's EntityID if recognized and spawned, <0 otherwise */
-	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType) = 0;
+	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, eMonsterType a_MonsterType) = 0;
+
+	/** Spawns an experience orb at the given location with the given reward. It returns the UniqueID of the spawned experience orb. */
+	virtual int SpawnExperienceOrb(double a_X, double a_Y, double a_Z, int a_Reward) = 0;
 
 	/** Calls the callback for the block entity at the specified coords; returns false if there's no block entity at those coords, true if found */
 	virtual bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback & a_Callback) = 0;
@@ -44,7 +48,7 @@ public:
 	/** Calls the callback for each player in the list; returns true if all players processed, false if the callback aborted by returning true */
 	virtual bool ForEachPlayer(cItemCallback<cPlayer> & a_Callback) = 0;
 
-	virtual void SetTimeOfDay(Int64 a_TimeOfDay) = 0;
+	virtual void SetTimeOfDay(int a_TimeOfDay) = 0;
 
 	/** Returns true if it is raining, stormy or snowing at the specified location. This takes into account biomes. */
 	virtual bool IsWeatherWetAt(int a_BlockX, int a_BlockZ) = 0;