15 files changed, 372 insertions, 437 deletions

diff --git a/src/Blocks/BlockDropSpenser.h b/src/Blocks/BlockDropSpenser.h
index 88b61a418..e2b3039fd 100644
--- a/src/Blocks/BlockDropSpenser.h
+++ b/src/Blocks/BlockDropSpenser.h
@@ -5,7 +5,7 @@
 
 #pragma once
 
-#include "../Piston.h"
+#include "../Blocks/BlockPiston.h"
 #include "MetaRotator.h"
 
 
@@ -32,7 +32,7 @@ public:
 		a_BlockType = m_BlockType;
 		
 		// FIXME: Do not use cPiston class for dispenser placement!
-		a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
+		a_BlockMeta = cBlockPistonHandler::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
 		return true;
 	}
 	
diff --git a/src/Blocks/BlockFurnace.h b/src/Blocks/BlockFurnace.h
index a7a807957..74582c3b3 100644
--- a/src/Blocks/BlockFurnace.h
+++ b/src/Blocks/BlockFurnace.h
@@ -3,7 +3,7 @@
 
 #include "BlockEntity.h"
 #include "../World.h"
-#include "../Piston.h"
+#include "../Blocks/BlockPiston.h"
 #include "MetaRotator.h"
 
 
@@ -35,7 +35,7 @@ public:
 		a_BlockType = m_BlockType;
 		
 		// FIXME: Do not use cPiston class for furnace placement!
-		a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), 0);
+		a_BlockMeta = cBlockPistonHandler::RotationPitchToMetaData(a_Player->GetYaw(), 0);
 		
 		return true;
 	}
diff --git a/src/Blocks/BlockMobHead.h b/src/Blocks/BlockMobHead.h
index b7629b07c..9855574ad 100644
--- a/src/Blocks/BlockMobHead.h
+++ b/src/Blocks/BlockMobHead.h
@@ -68,7 +68,7 @@ public:
 		public:
 			cPlayerCallback(const Vector3f & a_Pos) : m_Pos(a_Pos) {}
 
-		} PlayerCallback(Vector3f(a_BlockX, a_BlockY, a_BlockZ));
+		} PlayerCallback(Vector3f((float)a_BlockX, (float)a_BlockY, (float)a_BlockZ));
 
 		a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, CallbackA);
 
diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp
index 542eb33b5..f758013dc 100644
--- a/src/Blocks/BlockPiston.cpp
+++ b/src/Blocks/BlockPiston.cpp
@@ -4,14 +4,14 @@
 #include "../Item.h"
 #include "../World.h"
 #include "../Entities/Player.h"
-#include "../Piston.h"
+#include "BlockInServerPluginInterface.h"
 
 
 
 
 
 #define AddPistonDir(x, y, z, dir, amount) \
-	switch (dir) \
+	switch (dir & 0x07) \
 	{ \
 		case 0: (y) -= (amount); break; \
 		case 1: (y) += (amount); break; \
@@ -19,8 +19,15 @@
 		case 3: (z) += (amount); break; \
 		case 4: (x) -= (amount); break; \
 		case 5: (x) += (amount); break; \
+		default: \
+		{ \
+			LOGWARNING("%s: invalid direction %d, ignoring", __FUNCTION__, dir & 0x07); \
+			break; \
+		} \
 	}
 
+#define PISTON_TICK_DELAY 1
+
 
 
 
@@ -40,7 +47,7 @@ void cBlockPistonHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorld
 	int newX = a_BlockX;
 	int newY = a_BlockY;
 	int newZ = a_BlockZ;
-	AddPistonDir(newX, newY, newZ, OldMeta & ~(8), 1);
+	AddPistonDir(newX, newY, newZ, OldMeta, 1);
 
 	if (a_ChunkInterface.GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION)
 	{
@@ -60,7 +67,7 @@ bool cBlockPistonHandler::GetPlacementBlockTypeMeta(
 )
 {
 	a_BlockType = m_BlockType;
-	a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
+	a_BlockMeta = RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
 	return true;
 }
 
@@ -68,6 +75,155 @@ bool cBlockPistonHandler::GetPlacementBlockTypeMeta(
 
 
 
+int cBlockPistonHandler::FirstPassthroughBlock(int pistonX, int pistonY, int pistonZ, NIBBLETYPE pistonmeta, cWorld * a_World)
+{
+	// Examine each of the 12 blocks ahead of the piston:
+	for (int ret = 0; ret < 12; ret++)
+	{
+		BLOCKTYPE currBlock;
+		NIBBLETYPE currMeta;
+		AddPistonDir(pistonX, pistonY, pistonZ, pistonmeta, 1);
+		a_World->GetBlockTypeMeta(pistonX, pistonY, pistonZ, currBlock, currMeta);
+		if (CanBreakPush(currBlock))
+		{
+			// This block breaks when pushed, extend up to here
+			return ret;
+		}
+		if (!CanPush(currBlock, currMeta))
+		{
+			// This block cannot be pushed at all, the piston can't extend
+			return -1;
+		}
+	}
+	// There is no space for the blocks to move, piston can't extend
+	return -1;
+}
+
+
+
+
+
+void cBlockPistonHandler::ExtendPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
+{
+	BLOCKTYPE pistonBlock;
+	NIBBLETYPE pistonMeta;
+	a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta);
+
+	if (IsExtended(pistonMeta))
+	{
+		// Already extended, bail out
+		return;
+	}
+
+	int dist = FirstPassthroughBlock(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, a_World);
+	if (dist < 0)
+	{
+		// FirstPassthroughBlock says piston can't push anything, bail out
+		return;
+	}
+
+	a_World->BroadcastBlockAction(a_BlockX, a_BlockY, a_BlockZ, 0, pistonMeta, pistonBlock);
+	a_World->BroadcastSoundEffect("tile.piston.out", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.7f);
+
+	// Drop the breakable block in the line, if appropriate:
+	AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, dist + 1);  // "a_Block" now at the breakable / empty block
+	BLOCKTYPE currBlock;
+	NIBBLETYPE currMeta;
+	a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, currBlock, currMeta);
+	if (currBlock != E_BLOCK_AIR)
+	{
+		cBlockHandler * Handler = BlockHandler(currBlock);
+		if (Handler->DoesDropOnUnsuitable())
+		{
+			cChunkInterface ChunkInterface(a_World->GetChunkMap());
+			cBlockInServerPluginInterface PluginInterface(*a_World);
+			Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, NULL, a_BlockX, a_BlockY, a_BlockZ);
+		}
+	}
+
+	// Push blocks, from the furthest to the nearest:
+	int oldx = a_BlockX, oldy = a_BlockY, oldz = a_BlockZ;
+	NIBBLETYPE currBlockMeta;
+	for (int i = dist + 1; i > 1; i--)
+	{
+		AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, -1);
+		a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, currBlock, currBlockMeta);
+		a_World->SetBlock(oldx, oldy, oldz, currBlock, currBlockMeta, false);
+		a_World->ScheduleTask(PISTON_TICK_DELAY, new cWorld::cTaskSendBlockToAllPlayers(oldx, oldy, oldz));
+		oldx = a_BlockX;
+		oldy = a_BlockY;
+		oldz = a_BlockZ;
+	}
+
+	int extx = a_BlockX;
+	int exty = a_BlockY;
+	int extz = a_BlockZ;
+	AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, -1);
+	// "a_Block" now at piston body, "ext" at future extension
+
+	a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta | 0x8);
+	a_World->SetBlock(extx, exty, extz, E_BLOCK_PISTON_EXTENSION, pistonMeta | (IsSticky(pistonBlock) ? 8 : 0), false);
+	a_World->ScheduleTask(PISTON_TICK_DELAY, new cWorld::cTaskSendBlockToAllPlayers(extx, exty, extz));
+}
+
+
+
+
+
+void cBlockPistonHandler::RetractPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
+{
+	BLOCKTYPE pistonBlock;
+	NIBBLETYPE pistonMeta;
+	a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta);
+
+	if (!IsExtended(pistonMeta))
+	{
+		// Already retracted, bail out
+		return;
+	}
+
+	// Check the extension:
+	AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, 1);
+	if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) != E_BLOCK_PISTON_EXTENSION)
+	{
+		LOGD("%s: Piston without an extension - still extending, or just in an invalid state?", __FUNCTION__);
+		return;
+	}
+
+	AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, -1);
+	a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta & ~(8));
+	a_World->BroadcastBlockAction(a_BlockX, a_BlockY, a_BlockZ, 1, pistonMeta & ~(8), pistonBlock);
+	a_World->BroadcastSoundEffect("tile.piston.in", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.7f);
+	AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, 1);
+
+	// Retract the extension, pull block if appropriate
+	if (IsSticky(pistonBlock))
+	{
+		int tempx = a_BlockX, tempy = a_BlockY, tempz = a_BlockZ;
+		AddPistonDir(tempx, tempy, tempz, pistonMeta, 1);
+		BLOCKTYPE tempBlock;
+		NIBBLETYPE tempMeta;
+		a_World->GetBlockTypeMeta(tempx, tempy, tempz, tempBlock, tempMeta);
+		if (CanPull(tempBlock, tempMeta))
+		{
+			// Pull the block
+			a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, tempBlock, tempMeta, false);
+			a_World->SetBlock(tempx, tempy, tempz, E_BLOCK_AIR, 0, false);
+			a_World->ScheduleTask(PISTON_TICK_DELAY + 1, new cWorld::cTaskSendBlockToAllPlayers(a_BlockX, a_BlockY, a_BlockZ));
+			a_World->ScheduleTask(PISTON_TICK_DELAY, new cWorld::cTaskSendBlockToAllPlayers(tempx, tempy, tempz));
+			return;
+		}
+	}
+	
+	// Retract without pulling
+	a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0, false);
+	a_World->ScheduleTask(PISTON_TICK_DELAY + 1, new cWorld::cTaskSendBlockToAllPlayers(a_BlockX, a_BlockY, a_BlockZ));
+}
+
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cBlockPistonHeadHandler:
 
@@ -87,7 +243,7 @@ void cBlockPistonHeadHandler::OnDestroyedByPlayer(cChunkInterface & a_ChunkInter
 	int newX = a_BlockX;
 	int newY = a_BlockY;
 	int newZ = a_BlockZ;
-	AddPistonDir(newX, newY, newZ, OldMeta & ~(8), -1);
+	AddPistonDir(newX, newY, newZ, OldMeta, -1);
 
 	BLOCKTYPE Block = a_ChunkInterface.GetBlock(newX, newY, newZ);
 	if ((Block == E_BLOCK_STICKY_PISTON) || (Block == E_BLOCK_PISTON))
diff --git a/src/Blocks/BlockPiston.h b/src/Blocks/BlockPiston.h
index 7632b5e5a..d7c92925b 100644
--- a/src/Blocks/BlockPiston.h
+++ b/src/Blocks/BlockPiston.h
@@ -21,6 +21,133 @@ public:
 		int a_CursorX, int a_CursorY, int a_CursorZ,
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override;
+
+	static NIBBLETYPE RotationPitchToMetaData(double a_Rotation, double a_Pitch)
+	{
+		if (a_Pitch >= 50)
+		{
+			return 0x1;
+		}
+		else if (a_Pitch <= -50)
+		{
+			return 0x0;
+		}
+		else
+		{
+			a_Rotation += 90 + 45;  // So its not aligned with axis
+
+			if (a_Rotation > 360)
+			{
+				a_Rotation -= 360;
+			}
+			if ((a_Rotation >= 0) && (a_Rotation < 90))
+			{
+				return 0x4;
+			}
+			else if ((a_Rotation >= 180) && (a_Rotation < 270))
+			{
+				return 0x5;
+			}
+			else if ((a_Rotation >= 90) && (a_Rotation < 180))
+			{
+				return 0x2;
+			}
+			else
+			{
+				return 0x3;
+			}
+		}
+	}
+
+	static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)
+	{
+		switch (a_MetaData)
+		{
+			case 0x0: return BLOCK_FACE_YM;
+			case 0x1: return BLOCK_FACE_YP;
+			case 0x2: return BLOCK_FACE_ZM;
+			case 0x3: return BLOCK_FACE_ZP;
+			case 0x4: return BLOCK_FACE_XM;
+			case 0x5: return BLOCK_FACE_XP;
+			default:
+			{
+				ASSERT(!"Invalid Metadata");
+				return BLOCK_FACE_NONE;
+			}
+		}
+	}	
+
+	static void ExtendPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
+	static void RetractPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
+
+private:
+
+	/// Returns true if the piston (specified by blocktype) is a sticky piston
+	static inline bool IsSticky(BLOCKTYPE a_BlockType) { return (a_BlockType == E_BLOCK_STICKY_PISTON); }
+
+	/// Returns true if the piston (with the specified meta) is extended
+	static inline bool IsExtended(NIBBLETYPE a_PistonMeta) { return ((a_PistonMeta & 0x8) != 0x0); }
+
+	/// Returns true if the specified block can be pushed by a piston (and left intact)
+	static inline bool CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+	{
+		switch (a_BlockType)
+		{
+			case E_BLOCK_ANVIL:
+			case E_BLOCK_BED:
+			case E_BLOCK_BEDROCK:
+			case E_BLOCK_BREWING_STAND:
+			case E_BLOCK_CHEST:
+			case E_BLOCK_COMMAND_BLOCK:
+			case E_BLOCK_DISPENSER:
+			case E_BLOCK_DROPPER:
+			case E_BLOCK_ENCHANTMENT_TABLE:
+			case E_BLOCK_END_PORTAL:
+			case E_BLOCK_END_PORTAL_FRAME:
+			case E_BLOCK_FURNACE:
+			case E_BLOCK_LIT_FURNACE:
+			case E_BLOCK_HOPPER:
+			case E_BLOCK_JUKEBOX:
+			case E_BLOCK_MOB_SPAWNER:
+			case E_BLOCK_NETHER_PORTAL:
+			case E_BLOCK_NOTE_BLOCK:
+			case E_BLOCK_OBSIDIAN:
+			case E_BLOCK_PISTON_EXTENSION:
+			{
+				return false;
+			}
+			case E_BLOCK_STICKY_PISTON:
+			case E_BLOCK_PISTON:
+			{
+				// A piston can only be pushed if retracted:
+				return !IsExtended(a_BlockMeta);
+			}
+		}
+		return true;
+	}
+
+	/// Returns true if the specified block can be pushed by a piston and broken / replaced
+	static inline bool CanBreakPush(BLOCKTYPE a_BlockType) { return cBlockInfo::IsPistonBreakable(a_BlockType); }
+
+	/// Returns true if the specified block can be pulled by a sticky piston
+	static inline bool CanPull(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+	{
+		switch (a_BlockType)
+		{
+			case E_BLOCK_LAVA:
+			case E_BLOCK_STATIONARY_LAVA:
+			case E_BLOCK_STATIONARY_WATER:
+			case E_BLOCK_WATER:
+			{
+				return false;
+			}
+		}
+
+		return CanBreakPush(a_BlockType) ? false /* CanBreakPush returns true, but we need false to prevent pulling */ : CanPush(a_BlockType, a_BlockMeta);
+	}
+
+	/// Returns how many blocks the piston has to push (where the first free space is); < 0 when unpushable
+	static int FirstPassthroughBlock(int a_PistonX, int a_PistonY, int a_PistonZ, NIBBLETYPE a_PistonMeta, cWorld * a_World);
 } ;
 
 
@@ -40,7 +167,7 @@ public:
 	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
 	{
 		// No pickups
-		// Also with 1.7, the item forms of these tecnical blocks have been removed, so giving someone this will crash their client...
+		// Also with 1.7, the item forms of these technical blocks have been removed, so giving someone this will crash their client...
 	}
 } ;
 
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index ca536e89a..6bd68459c 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -1462,9 +1462,9 @@ void cChunk::CalculateHeightmap(const BLOCKTYPE * a_BlockTypes)
 
 
 
-void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients)
 {
-	FastSetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);
+	FastSetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta, a_SendToClients);
 
 	const int index = MakeIndexNoCheck(a_RelX, a_RelY, a_RelZ);
 	
@@ -1565,7 +1565,7 @@ void cChunk::QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ)
 
 
 
-void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta)
+void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients)
 {
 	ASSERT(!((a_RelX < 0) || (a_RelX >= Width) || (a_RelY < 0) || (a_RelY >= Height) || (a_RelZ < 0) || (a_RelZ >= Width)));
 
@@ -1589,13 +1589,14 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
 
 	// The client doesn't need to distinguish between stationary and nonstationary fluids:
 	if (
-		(OldBlockMeta != a_BlockMeta) ||  // Different meta always gets sent to the client
+		a_SendToClients &&
+		((OldBlockMeta != a_BlockMeta) ||  // Different meta always gets sent to the client
 		!(
 			((OldBlockType == E_BLOCK_STATIONARY_WATER) && (a_BlockType == E_BLOCK_WATER)) ||             // Replacing stationary water with water
 			((OldBlockType == E_BLOCK_WATER)            && (a_BlockType == E_BLOCK_STATIONARY_WATER)) ||  // Replacing water with stationary water
 			((OldBlockType == E_BLOCK_STATIONARY_LAVA)  && (a_BlockType == E_BLOCK_LAVA)) ||              // Replacing stationary water with water
 			((OldBlockType == E_BLOCK_LAVA)             && (a_BlockType == E_BLOCK_STATIONARY_LAVA))      // Replacing water with stationary water
-		)
+		))
 	)
 	{
 		m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta));
diff --git a/src/Chunk.h b/src/Chunk.h
index 84ec35496..8eeb183e3 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -139,7 +139,7 @@ public:
 	
 	cWorld * GetWorld(void) const { return m_World; }
 
-	void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta );
+	void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true);
 	// SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense
 	void SetBlock( const Vector3i & a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta ) { SetBlock( a_RelBlockPos.x, a_RelBlockPos.y, a_RelBlockPos.z, a_BlockType, a_BlockMeta ); }
 	
@@ -152,7 +152,7 @@ public:
 	/** Queues all 6 neighbors of the specified block for ticking (m_ToTickQueue). If any are outside the chunk, relays the checking to the proper neighboring chunk */
 	void QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ);
 
-	void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta );  // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc.
+	void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true);  // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc.
 	BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const;
 	BLOCKTYPE GetBlock(int a_BlockIdx) const;
 	void      GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index d7164a6a5..3c87403ff 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -1255,7 +1255,7 @@ void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYP
 
 
 
-void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta)
+void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients)
 {
 	cChunkInterface ChunkInterface(this);
 	if (a_BlockType == E_BLOCK_AIR)
@@ -1270,7 +1270,7 @@ void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a
 	cChunkPtr Chunk = GetChunk( ChunkX, ZERO_CHUNK_Y, ChunkZ );
 	if ((Chunk != NULL) && Chunk->IsValid())
 	{
-		Chunk->SetBlock(X, Y, Z, a_BlockType, a_BlockMeta );
+		Chunk->SetBlock(X, Y, Z, a_BlockType, a_BlockMeta, a_SendToClients);
 		m_World->GetSimulatorManager()->WakeUp(a_BlockX, a_BlockY, a_BlockZ, Chunk);
 	}
 	BlockHandler(a_BlockType)->OnPlaced(ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 9d973f2a9..a64942112 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -152,7 +152,7 @@ public:
 	NIBBLETYPE GetBlockSkyLight  (int a_BlockX, int a_BlockY, int a_BlockZ);
 	NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ);
 	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockMeta);
-	void       SetBlock          (cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta);
+	void       SetBlock          (cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true);
 	void       QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, Int64 a_Tick, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR);
 	bool       GetBlockTypeMeta  (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
 	bool       GetBlockInfo      (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 83b21ae3c..433b7edf7 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -12,7 +12,6 @@
 #include "BlockEntities/SignEntity.h"
 #include "UI/Window.h"
 #include "Item.h"
-#include "Piston.h"
 #include "Mobs/Monster.h"
 #include "ChatColor.h"
 #include "OSSupport/Socket.h"
diff --git a/src/Piston.cpp b/src/Piston.cpp
deleted file mode 100644
index b21d576f3..000000000
--- a/src/Piston.cpp
+++ /dev/null
@@ -1,297 +0,0 @@
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-
-#include "Piston.h"
-#include "ChunkDef.h"
-#include "Entities/Pickup.h"
-#include "Item.h"
-#include "Root.h"
-#include "ClientHandle.h"
-#include "World.h"
-#include "Server.h"
-#include "Blocks/BlockHandler.h"
-#include "BlockInServerPluginInterface.h"
-
-
-
-
-
-/// Number of ticks that the piston extending / retracting waits before setting the block
-const int PISTON_TICK_DELAY = 1;
-
-
-
-
-
-cPiston::cPiston(cWorld * a_World)
-	: m_World(a_World)
-{
-}
-
-
-
-
-
-int cPiston::FirstPassthroughBlock(int pistonX, int pistonY, int pistonZ, NIBBLETYPE pistonmeta)
-{
-	// Examine each of the 12 blocks ahead of the piston:
-	for (int ret = 0; ret < 12; ret++)
-	{
-		BLOCKTYPE currBlock;
-		NIBBLETYPE currMeta;
-		AddDir(pistonX, pistonY, pistonZ, pistonmeta, 1);
-		m_World->GetBlockTypeMeta(pistonX, pistonY, pistonZ, currBlock, currMeta);
-		if (CanBreakPush(currBlock, currMeta))
-		{
-			// This block breaks when pushed, extend up to here
-			return ret;
-		}
-		if (!CanPush(currBlock, currMeta))
-		{
-			// This block cannot be pushed at all, the piston can't extend
-			return -1;
-		}
-	}
-	// There is no space for the blocks to move, piston can't extend
-	return -1;
-}
-
-
-
-
-
-void cPiston::ExtendPiston(int pistx, int pisty, int pistz)
-{
-	BLOCKTYPE pistonBlock;
-	NIBBLETYPE pistonMeta;
-	m_World->GetBlockTypeMeta(pistx, pisty, pistz, pistonBlock, pistonMeta);
-	
-	if (IsExtended(pistonMeta))
-	{
-		// Already extended, bail out
-		return;
-	}
-
-	int dist = FirstPassthroughBlock(pistx, pisty, pistz, pistonMeta);
-	if (dist < 0)
-	{
-		// FirstPassthroughBlock says piston can't push anything, bail out
-		return;
-	}
-
-	m_World->BroadcastBlockAction(pistx, pisty, pistz, 0, pistonMeta, pistonBlock);
-	m_World->BroadcastSoundEffect("tile.piston.out", pistx * 8, pisty * 8, pistz * 8, 0.5f, 0.7f);	
-	
-	// Drop the breakable block in the line, if appropriate:
-	AddDir(pistx, pisty, pistz, pistonMeta, dist + 1);  // "pist" now at the breakable / empty block
-	BLOCKTYPE currBlock;
-	NIBBLETYPE currMeta;
-	m_World->GetBlockTypeMeta(pistx, pisty, pistz, currBlock, currMeta);
-	if (currBlock != E_BLOCK_AIR)
-	{
-		cBlockHandler * Handler = BlockHandler(currBlock);
-		if (Handler->DoesDropOnUnsuitable())
-		{
-			cChunkInterface ChunkInterface(m_World->GetChunkMap());
-			cBlockInServerPluginInterface PluginInterface(*m_World);
-			Handler->DropBlock(ChunkInterface, *m_World, PluginInterface, NULL, pistx, pisty, pistz);
-		}
-	}
-	
-	// Push blocks, from the furthest to the nearest:
-	int oldx = pistx, oldy = pisty, oldz = pistz;
-	NIBBLETYPE currBlockMeta;
-	for (int i = dist + 1; i > 1; i--)
-	{
-		AddDir(pistx, pisty, pistz, pistonMeta, -1);
-		m_World->GetBlockTypeMeta(pistx, pisty, pistz, currBlock, currBlockMeta);
-		m_World->QueueSetBlock( oldx, oldy, oldz, currBlock, currBlockMeta, PISTON_TICK_DELAY);
-		oldx = pistx;
-		oldy = pisty;
-		oldz = pistz;
-	}
-
-	int extx = pistx;
-	int exty = pisty;
-	int extz = pistz;
-	AddDir(pistx, pisty, pistz, pistonMeta, -1);
-	// "pist" now at piston body, "ext" at future extension
-	
-	m_World->SetBlock(pistx, pisty, pistz, pistonBlock, pistonMeta | 0x8);
-	m_World->QueueSetBlock(extx, exty, extz, E_BLOCK_PISTON_EXTENSION, pistonMeta | (IsSticky(pistonBlock) ? 8 : 0), PISTON_TICK_DELAY);
-}
-
-
-
-
-
-void cPiston::RetractPiston(int pistx, int pisty, int pistz)
-{
-	BLOCKTYPE pistonBlock;
-	NIBBLETYPE pistonMeta;
-	m_World->GetBlockTypeMeta(pistx, pisty, pistz, pistonBlock, pistonMeta);
-
-	if (!IsExtended(pistonMeta))
-	{
-		// Already retracted, bail out
-		return;
-	}
-
-	// Check the extension:
-	AddDir(pistx, pisty, pistz, pistonMeta, 1);
-	if (m_World->GetBlock(pistx, pisty, pistz) != E_BLOCK_PISTON_EXTENSION)
-	{
-		LOGD("%s: Piston without an extension - still extending, or just in an invalid state?", __FUNCTION__);
-		return;
-	}
-	
-	AddDir(pistx, pisty, pistz, pistonMeta, -1);
-	m_World->SetBlock(pistx, pisty, pistz, pistonBlock, pistonMeta & ~(8));
-	m_World->BroadcastBlockAction(pistx, pisty, pistz, 1, pistonMeta & ~(8), pistonBlock);
-	m_World->BroadcastSoundEffect("tile.piston.in", pistx * 8, pisty * 8, pistz * 8, 0.5f, 0.7f);
-	AddDir(pistx, pisty, pistz, pistonMeta, 1);
-	
-	// Retract the extension, pull block if appropriate
-	if (IsSticky(pistonBlock))
-	{
-		int tempx = pistx, tempy = pisty, tempz = pistz;
-		AddDir(tempx, tempy, tempz, pistonMeta, 1);
-		BLOCKTYPE tempBlock;
-		NIBBLETYPE tempMeta;
-		m_World->GetBlockTypeMeta(tempx, tempy, tempz, tempBlock, tempMeta);
-		if (CanPull(tempBlock, tempMeta))
-		{
-			// Pull the block
-			m_World->QueueSetBlock(pistx, pisty, pistz, tempBlock, tempMeta, PISTON_TICK_DELAY);
-			m_World->QueueSetBlock(tempx, tempy, tempz, E_BLOCK_AIR, 0, PISTON_TICK_DELAY);
-		}
-		else
-		{
-			// Retract without pulling
-			m_World->QueueSetBlock(pistx, pisty, pistz, E_BLOCK_AIR, 0, PISTON_TICK_DELAY);
-		}
-	}
-	else
-	{
-		m_World->QueueSetBlock(pistx, pisty, pistz, E_BLOCK_AIR, 0, PISTON_TICK_DELAY);
-	}
-}
-
-
-
-
-
-bool cPiston::IsExtended(NIBBLETYPE a_PistonMeta)
-{
-	return ((a_PistonMeta & 0x8) != 0x0);
-}
-
-
-
-
-
-bool cPiston::IsSticky(BLOCKTYPE a_BlockType)
-{
-	return (a_BlockType == E_BLOCK_STICKY_PISTON);
-}
-
-
-
-
-
-bool cPiston::CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-{
-	switch (a_BlockType)
-	{
-		case E_BLOCK_ANVIL:
-		case E_BLOCK_BED:
-		case E_BLOCK_BEDROCK:
-		case E_BLOCK_BREWING_STAND:
-		case E_BLOCK_CHEST:
-		case E_BLOCK_COMMAND_BLOCK:
-		case E_BLOCK_DISPENSER:
-		case E_BLOCK_DROPPER:
-		case E_BLOCK_ENCHANTMENT_TABLE:
-		case E_BLOCK_END_PORTAL:
-		case E_BLOCK_END_PORTAL_FRAME:
-		case E_BLOCK_FURNACE:
-		case E_BLOCK_LIT_FURNACE:
-		case E_BLOCK_HOPPER:
-		case E_BLOCK_JUKEBOX:
-		case E_BLOCK_MOB_SPAWNER:
-		case E_BLOCK_NETHER_PORTAL:
-		case E_BLOCK_NOTE_BLOCK:
-		case E_BLOCK_OBSIDIAN:
-		case E_BLOCK_PISTON_EXTENSION:
-		{
-			return false;
-		}
-		case E_BLOCK_STICKY_PISTON:
-		case E_BLOCK_PISTON:
-		{
-			// A piston can only be pushed if retracted:
-			return !IsExtended(a_BlockMeta);
-		}
-	}
-	return true;
-}
-
-
-
-
-
-bool cPiston::CanBreakPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-{
-	UNUSED(a_BlockMeta);
-	return cBlockInfo::IsPistonBreakable(a_BlockType);
-}
-
-
-
-
-
-bool cPiston::CanPull(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-{
-	switch (a_BlockType)
-	{
-		case E_BLOCK_LAVA:
-		case E_BLOCK_STATIONARY_LAVA:
-		case E_BLOCK_STATIONARY_WATER:
-		case E_BLOCK_WATER:
-		{
-			return false;
-		}
-	}
-
-	if (CanBreakPush(a_BlockType, a_BlockMeta))
-	{
-		return false; // CanBreakPush returns true, but we need false to prevent pulling
-	}
-
-	return CanPush(a_BlockType, a_BlockMeta);
-}
-
-
-
-
-
-void cPiston::AddDir(int & a_BlockX, int & a_BlockY, int & a_BlockZ, NIBBLETYPE a_PistonMeta, int a_Amount)
-{
-	switch (a_PistonMeta & 0x07)
-	{
-		case 0: a_BlockY -= a_Amount; break;
-		case 1: a_BlockY += a_Amount; break;
-		case 2: a_BlockZ -= a_Amount; break;
-		case 3: a_BlockZ += a_Amount; break;
-		case 4: a_BlockX -= a_Amount; break;
-		case 5: a_BlockX += a_Amount; break;
-		default:
-		{
-			LOGWARNING("%s: invalid direction %d, ignoring", __FUNCTION__, a_PistonMeta & 0x07);
-			break;
-		}
-	}
-}
-
-
-
-
diff --git a/src/Piston.h b/src/Piston.h
deleted file mode 100644
index 9bbc8c6b9..000000000
--- a/src/Piston.h
+++ /dev/null
@@ -1,110 +0,0 @@
-
-#pragma once
-
-
-#include "Defines.h"
-
-
-// fwd: World.h
-class cWorld;
-
-
-
-
-
-class cPiston
-{
-public:
-
-	cPiston(cWorld * a_World);
-
-	static NIBBLETYPE RotationPitchToMetaData(double a_Rotation, double a_Pitch)
-	{
-		if (a_Pitch >= 50)
-		{
-			return 0x1;
-		}
-		else if (a_Pitch <= -50)
-		{
-			return 0x0;
-		}
-		else
-		{
-			a_Rotation += 90 + 45;  // So its not aligned with axis
-
-			if (a_Rotation > 360)
-			{
-				a_Rotation -= 360;
-			}
-			if ((a_Rotation >= 0) && (a_Rotation < 90))
-			{
-				return 0x4;
-			}
-			else if ((a_Rotation >= 180) && (a_Rotation < 270))
-			{
-				return 0x5;
-			}
-			else if ((a_Rotation >= 90) && (a_Rotation < 180))
-			{
-				return 0x2;
-			}
-			else
-			{
-				return 0x3;
-			}
-		}
-	}
-	
-	static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)
-	{
-		switch (a_MetaData)
-		{
-			//case -1:  return BLOCK_FACE_NONE; //can never happen as metadata is unsigned
-			case 0x0: return BLOCK_FACE_YM;
-			case 0x1: return BLOCK_FACE_YP;
-			case 0x2: return BLOCK_FACE_ZM;
-			case 0x3: return BLOCK_FACE_ZP;
-			case 0x4: return BLOCK_FACE_XM;
-			case 0x5: return BLOCK_FACE_XP;
-			default:
-			{
-				ASSERT(!"Invalid Metadata");
-				return BLOCK_FACE_NONE;
-			}
-		}
-	}
-
-	void ExtendPiston( int, int, int );
-	void RetractPiston( int, int, int );
-	
-	/// Returns true if the piston (specified by blocktype) is a sticky piston
-	static bool IsSticky(BLOCKTYPE a_BlockType);
-	
-	/// Returns true if the piston (with the specified meta) is extended
-	static bool IsExtended(NIBBLETYPE a_PistonMeta);
-	
-	/// Returns true if the specified block can be pushed by a piston (and left intact)
-	static bool CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
-	
-	/// Returns true if the specified block can be pushed by a piston and broken / replaced
-	static bool CanBreakPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
-	
-	/// Returns true if the specified block can be pulled by a sticky piston
-	static bool CanPull(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
-	
-	/// Updates the coords by the specified amount in the direction a piston of the specified meta is facing
-	static void AddDir(int & a_BlockX, int & a_BlockY, int & a_BlockZ, NIBBLETYPE a_PistonMeta, int a_Amount);
-	
-	
-	cWorld * m_World;
-
-private:
-	void ChainMove( int, int, int, char, unsigned short * );
-	
-	/// Returns how many blocks the piston has to push (where the first free space is); <0 when unpushable
-	int FirstPassthroughBlock(int a_PistonX, int a_PistonY, int a_PistonZ, NIBBLETYPE a_PistonMeta);
-} ;
-
-
-
-
diff --git a/src/Simulator/IncrementalRedstoneSimulator.cpp b/src/Simulator/IncrementalRedstoneSimulator.cpp
index 074063add..c24b1c4b3 100644
--- a/src/Simulator/IncrementalRedstoneSimulator.cpp
+++ b/src/Simulator/IncrementalRedstoneSimulator.cpp
@@ -11,7 +11,7 @@
 #include "../Blocks/BlockDoor.h"
 #include "../Blocks/BlockButton.h"
 #include "../Blocks/BlockLever.h"
-#include "../Piston.h"
+#include "../Blocks/BlockPiston.h"
 
 
 
@@ -814,17 +814,16 @@ void cIncrementalRedstoneSimulator::HandleRedstoneRepeater(int a_RelBlockX, int
 
 void cIncrementalRedstoneSimulator::HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
 {	
-	cPiston Piston(&m_World);
 	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
 	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
 
 	if (IsPistonPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7)) // We only want the bottom three bits (4th controls extended-ness)
 	{
-		Piston.ExtendPiston(BlockX, a_RelBlockY, BlockZ);
+		cBlockPistonHandler::ExtendPiston(BlockX, a_RelBlockY, BlockZ, &m_World);
 	}
 	else
 	{
-		Piston.RetractPiston(BlockX, a_RelBlockY, BlockZ);
+		cBlockPistonHandler::RetractPiston(BlockX, a_RelBlockY, BlockZ, &m_World);
 	}
 }
 
@@ -1491,7 +1490,7 @@ bool cIncrementalRedstoneSimulator::IsPistonPowered(int a_RelBlockX, int a_RelBl
 	// Pistons cannot be powered through their front face; this function verifies that a source meets this requirement
 
 	int OldX = a_RelBlockX, OldY = a_RelBlockY, OldZ = a_RelBlockZ;
-	eBlockFace Face = cPiston::MetaDataToDirection(a_Meta);
+	eBlockFace Face = cBlockPistonHandler::MetaDataToDirection(a_Meta);
 	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
 	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
 
diff --git a/src/World.cpp b/src/World.cpp
index 807065bfa..29046bba9 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -1551,9 +1551,9 @@ bool cWorld::SetAreaBiome(const cCuboid & a_Area, EMCSBiome a_Biome)
 
 
 
-void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients)
 {
-	m_ChunkMap->SetBlock(*this, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+	m_ChunkMap->SetBlock(*this, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_SendToClients);
 }
 
 
@@ -3128,6 +3128,50 @@ void cWorld::cTaskUnloadUnusedChunks::Run(cWorld & a_World)
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cWorld::cTaskSendBlockTo
+
+cWorld::cTaskSendBlockToAllPlayers::cTaskSendBlockToAllPlayers(int a_BlockX, int a_BlockY, int a_BlockZ) :
+	m_BlockX(a_BlockX),
+	m_BlockY(a_BlockY),
+	m_BlockZ(a_BlockZ)
+{
+}
+
+void cWorld::cTaskSendBlockToAllPlayers::Run(cWorld & a_World)
+{
+	class cPlayerCallback :
+		public cPlayerListCallback
+	{
+	public:
+		cPlayerCallback(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld & a_World) :
+			m_BlockX(a_BlockX),
+			m_BlockY(a_BlockY),
+			m_BlockZ(a_BlockZ),
+			m_World(a_World)
+		{
+		}
+
+		virtual bool Item(cPlayer * a_Player)
+		{
+			m_World.SendBlockTo(m_BlockX, m_BlockY, m_BlockZ, a_Player);
+			return false;
+		}
+
+	private:
+
+		int m_BlockX, m_BlockY, m_BlockZ;
+		cWorld & m_World;
+
+	} PlayerCallback(m_BlockX, m_BlockY, m_BlockZ, a_World);
+
+	a_World.ForEachPlayer(PlayerCallback);
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cWorld::cChunkGeneratorCallbacks:
 
 cWorld::cChunkGeneratorCallbacks::cChunkGeneratorCallbacks(cWorld & a_World) :
diff --git a/src/World.h b/src/World.h
index 86cbb3e7e..5ef63a540 100644
--- a/src/World.h
+++ b/src/World.h
@@ -117,6 +117,22 @@ public:
 	};
 
 
+	class cTaskSendBlockToAllPlayers :
+		public cTask
+	{
+	public:
+		cTaskSendBlockToAllPlayers(int a_BlockX, int a_BlockY, int a_BlockZ);
+
+	protected:
+		// cTask overrides:
+		virtual void Run(cWorld & a_World) override;
+
+		int m_BlockX;
+		int m_BlockY;
+		int m_BlockZ;
+	};
+
+
 	static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
 	{
 		return "cWorld";
@@ -373,7 +389,7 @@ public:
 	/** Sets the block at the specified coords to the specified value.
 	Full processing, incl. updating neighbors, is performed.
 	*/
-	void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
+	void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true);
 	
 	/** Sets the block at the specified coords to the specified value.
 	The replacement doesn't trigger block updates.