17 files changed, 1696 insertions, 0 deletions
diff --git a/source/Simulator/ClassicFluidSimulator.h b/source/Simulator/ClassicFluidSimulator.h
new file mode 100644
index 000000000..ebccda487
--- /dev/null
+++ b/source/Simulator/ClassicFluidSimulator.h
@@ -0,0 +1,58 @@
+
+// ClassicFluidSimulator.h
+
+// Interfaces to the cClassicFluidSimulator class representing the original MCServer's fluid simulator
+
+
+
+
+
+#pragma once
+
+#include "FluidSimulator.h"
+
+
+
+
+
+class cClassicFluidSimulator :
+	public cFluidSimulator
+{
+public:
+	cClassicFluidSimulator(cWorld * a_World, BLOCKTYPE a_Fluid, BLOCKTYPE a_StationaryFluid, NIBBLETYPE a_MaxHeight, NIBBLETYPE a_Falloff);
+	~cClassicFluidSimulator();
+
+	// cSimulator overrides:
+	virtual void Simulate(float a_Dt) override;
+	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) override;
+
+	// cFluidSimulator overrides:
+	virtual Direction GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over = true) override;
+	
+	bool CanWashAway (BLOCKTYPE a_BlockType);
+	bool IsSolidBlock(BLOCKTYPE a_BlockType);
+	bool IsPassableForFluid(BLOCKTYPE a_BlockType);
+	
+protected:
+	NIBBLETYPE GetHighestLevelAround(int a_BlockX, int a_BlockY, int a_BlockZ);
+
+	/// Applies special rules such as generation of water between sources, returns false if it is necessary to apply general rules
+	bool UniqueSituation(Vector3i a_Pos);
+	
+	void ApplyUniqueToNearest(Vector3i a_Pos);
+
+	float m_Timer;
+
+	// fwd: ClassicFluidSimulator.cpp
+	class FluidData;
+	
+	FluidData * m_Data;
+
+	NIBBLETYPE m_MaxHeight;
+	NIBBLETYPE m_Falloff;
+} ;
+
+
+
+
diff --git a/source/Simulator/FireSimulator.cpp b/source/Simulator/FireSimulator.cpp
new file mode 100644
index 000000000..c2f22668b
--- /dev/null
+++ b/source/Simulator/FireSimulator.cpp
@@ -0,0 +1,178 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "FireSimulator.h"
+#include "../World.h"
+#include "../BlockID.h"
+#include "../Defines.h"
+
+
+
+
+
+cFireSimulator::cFireSimulator( cWorld* a_World )
+	: cSimulator(a_World)
+	, m_Blocks(new BlockList)
+	, m_Buffer(new BlockList)
+	, m_BurningBlocks(new BlockList)
+{
+}
+
+
+
+
+
+cFireSimulator::~cFireSimulator()
+{
+	delete m_Buffer;
+	delete m_Blocks;
+	delete m_BurningBlocks;
+}
+
+
+
+
+
+void cFireSimulator::Simulate( float a_Dt )
+{
+	m_Buffer->clear();
+	std::swap( m_Blocks, m_Buffer );
+
+	for( BlockList::iterator itr = m_Buffer->begin(); itr != m_Buffer->end(); ++itr )
+	{
+		Vector3i Pos = *itr;
+
+		char BlockID = m_World->GetBlock(Pos.x, Pos.y, Pos.z);
+
+		if(!IsAllowedBlock(BlockID))	//Check wheather the block is still burning
+			continue;
+
+		if(BurnBlockAround(Pos.x, Pos.y, Pos.z))	//Burn single block and if there was one -> next time again
+			_AddBlock(Pos.x, Pos.y, Pos.z);
+		else
+			if(!IsForeverBurnable(m_World->GetBlock(Pos.x, Pos.y - 1, Pos.z)) && !FiresForever(BlockID))
+				m_World->SetBlock(Pos.x, Pos.y, Pos.z, E_BLOCK_AIR, 0);
+
+	}
+		
+}
+
+
+
+
+
+bool cFireSimulator::IsAllowedBlock( BLOCKTYPE a_BlockType )
+{
+	return a_BlockType == E_BLOCK_FIRE
+		|| IsBlockLava(a_BlockType);
+}
+
+
+
+
+
+void cFireSimulator::AddBlock(int a_X, int a_Y, int a_Z)
+{
+	char BlockID = m_World->GetBlock(a_X, a_Y, a_Z);
+	if(!IsAllowedBlock(BlockID))		//This should save very much time because it doesn�t have to iterate through all blocks
+		return;
+	
+	//check for duplicates
+	for( BlockList::iterator itr = m_Blocks->begin(); itr != m_Blocks->end(); ++itr )
+	{
+		Vector3i Pos = *itr;
+		if( Pos.x == a_X && Pos.y == a_Y && Pos.z == a_Z )
+			return;
+	}
+
+	_AddBlock(a_X, a_Y, a_Z);
+
+}
+
+
+
+
+
+void cFireSimulator::_AddBlock(int a_X, int a_Y, int a_Z)
+{
+	m_Blocks->push_back( Vector3i(a_X, a_Y, a_Z) );
+
+}
+
+
+
+
+
+bool cFireSimulator::IsForeverBurnable( BLOCKTYPE a_BlockType )
+{
+	return a_BlockType == E_BLOCK_BLOODSTONE;
+}
+
+
+
+
+
+bool cFireSimulator::IsBurnable( BLOCKTYPE a_BlockType )
+{
+	return a_BlockType == E_BLOCK_PLANKS
+		|| a_BlockType == E_BLOCK_LEAVES
+		|| a_BlockType == E_BLOCK_LOG
+		|| a_BlockType == E_BLOCK_WOOL
+		|| a_BlockType == E_BLOCK_BOOKCASE
+		|| a_BlockType == E_BLOCK_FENCE
+		|| a_BlockType == E_BLOCK_TNT
+		|| a_BlockType == E_BLOCK_VINES;
+}
+
+
+
+
+
+bool cFireSimulator::FiresForever( BLOCKTYPE a_BlockType )
+{
+	return a_BlockType != E_BLOCK_FIRE;
+}
+
+
+
+
+
+bool cFireSimulator::BurnBlockAround(int a_X, int a_Y, int a_Z)
+{
+	return BurnBlock(a_X + 1, a_Y, a_Z)
+		|| BurnBlock(a_X - 1, a_Y, a_Z)
+		|| BurnBlock(a_X, a_Y + 1, a_Z)
+		|| BurnBlock(a_X, a_Y - 1, a_Z)
+		|| BurnBlock(a_X, a_Y, a_Z + 1)
+		|| BurnBlock(a_X, a_Y, a_Z - 1);
+}
+
+
+
+
+
+bool cFireSimulator::BurnBlock(int a_X, int a_Y, int a_Z)
+{
+	char BlockID = m_World->GetBlock(a_X, a_Y, a_Z);
+	if(IsBurnable(BlockID))
+	{
+		m_World->SetBlock(a_X, a_Y, a_Z, E_BLOCK_FIRE, 0);
+		return true;
+	}
+	if(IsForeverBurnable(BlockID))
+	{
+		char BlockAbove = m_World->GetBlock(a_X, a_Y + 1, a_Z);
+		if(BlockAbove == E_BLOCK_AIR)
+		{
+			m_World->SetBlock(a_X, a_Y + 1, a_Z, E_BLOCK_FIRE, 0);	//Doesn�t notify the simulator so it won�t go off
+			return true;
+		}
+		return false;
+	}
+
+	return false;
+}
+
+
+
+
diff --git a/source/Simulator/FireSimulator.h b/source/Simulator/FireSimulator.h
new file mode 100644
index 000000000..753259c2c
--- /dev/null
+++ b/source/Simulator/FireSimulator.h
@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include "Simulator.h"
+#include "../BlockEntity.h"
+
+
+
+
+
+class cFireSimulator : public cSimulator
+{
+public:
+	cFireSimulator( cWorld* a_World );
+	~cFireSimulator();
+
+	virtual void Simulate( float a_Dt ) override;
+
+	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override;
+
+	virtual bool IsBurnable( BLOCKTYPE a_BlockType );
+	virtual bool IsForeverBurnable( BLOCKTYPE a_BlockType );
+	virtual bool FiresForever( BLOCKTYPE a_BlockType );
+
+protected:
+	virtual void AddBlock(int a_X, int a_Y, int a_Z) override;
+	virtual void _AddBlock(int a_X, int a_Y, int a_Z);  // _X 2012_10_13: WTF? what kind of naming is this? Use proper names!
+	virtual bool BurnBlockAround(int a_X, int a_Y, int a_Z);
+	virtual bool BurnBlock(int a_X, int a_Y, int a_Z);
+
+	typedef std::list <Vector3i> BlockList;
+	BlockList *m_Blocks;
+	BlockList *m_Buffer;
+
+	BlockList *m_BurningBlocks;
+};
+
+
+
+
diff --git a/source/Simulator/FluidSimulator.cpp b/source/Simulator/FluidSimulator.cpp
new file mode 100644
index 000000000..d352d5d4d
--- /dev/null
+++ b/source/Simulator/FluidSimulator.cpp
@@ -0,0 +1,19 @@
+
+#include "Globals.h"
+
+#include "FluidSimulator.h"
+
+
+
+
+
+cFluidSimulator::cFluidSimulator(cWorld * a_World, BLOCKTYPE a_Fluid, BLOCKTYPE a_StationaryFluid) :
+	super(a_World),
+	m_FluidBlock(a_Fluid),
+	m_StationaryFluidBlock(a_StationaryFluid)
+{
+}
+
+
+
+
diff --git a/source/Simulator/FluidSimulator.h b/source/Simulator/FluidSimulator.h
new file mode 100644
index 000000000..f0b2b23ba
--- /dev/null
+++ b/source/Simulator/FluidSimulator.h
@@ -0,0 +1,47 @@
+
+#pragma once
+
+#include "Simulator.h"
+
+
+
+
+
+enum Direction
+{
+	X_PLUS,
+	X_MINUS,
+	Y_PLUS,
+	Y_MINUS,
+	Z_PLUS,
+	Z_MINUS,
+	NONE
+};
+
+
+
+
+
+class cFluidSimulator :
+	public cSimulator
+{
+	typedef cSimulator super;
+	
+public:
+	cFluidSimulator(cWorld * a_World, BLOCKTYPE a_Fluid, BLOCKTYPE a_StationaryFluid);
+
+	// Gets the flowing direction. If a_Over is true also the block over the current block affects the direction (standard)
+	virtual Direction GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over = true) = 0;
+	
+	bool IsFluidBlock          (BLOCKTYPE a_BlockType) const { return (a_BlockType == m_FluidBlock); }
+	bool IsStationaryFluidBlock(BLOCKTYPE a_BlockType) const { return (a_BlockType == m_StationaryFluidBlock); }
+	
+protected:
+	BLOCKTYPE m_FluidBlock;            // The fluid block type that needs simulating
+	BLOCKTYPE m_StationaryFluidBlock;  // The fluid block type that indicates no simulation is needed
+} ;
+
+
+
+
+
diff --git a/source/Simulator/LavaSimulator.cpp b/source/Simulator/LavaSimulator.cpp
new file mode 100644
index 000000000..726cc37e4
--- /dev/null
+++ b/source/Simulator/LavaSimulator.cpp
@@ -0,0 +1,20 @@
+#include "Globals.h"
+#include "LavaSimulator.h"
+#include "Defines.h"
+#include "World.h"
+
+
+cLavaSimulator::cLavaSimulator(cWorld *a_World)
+	: cFluidSimulator(a_World)
+{
+	m_FluidBlock = E_BLOCK_LAVA;
+	m_StationaryFluidBlock = E_BLOCK_STATIONARY_LAVA;
+	m_MaxHeight = 6;
+	m_FlowReduction = 2;
+}
+
+
+bool cLavaSimulator::IsAllowedBlock(BLOCKTYPE a_BlockType)
+{
+	return IsBlockLava(a_BlockType);
+}
+\ No newline at end of file
diff --git a/source/Simulator/LavaSimulator.h b/source/Simulator/LavaSimulator.h
new file mode 100644
index 000000000..d85b335b7
--- /dev/null
+++ b/source/Simulator/LavaSimulator.h
@@ -0,0 +1,12 @@
+#pragma once
+#include "FluidSimulator.h"
+
+class cLavaSimulator : public cFluidSimulator
+{
+public:
+	cLavaSimulator( cWorld* a_World );
+
+	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override;
+	
+
+};
+\ No newline at end of file
diff --git a/source/Simulator/RedstoneSimulator.cpp b/source/Simulator/RedstoneSimulator.cpp
new file mode 100644
index 000000000..1c30be324
--- /dev/null
+++ b/source/Simulator/RedstoneSimulator.cpp
@@ -0,0 +1,886 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "RedstoneSimulator.h"
+#include "../Piston.h"
+#include "../World.h"
+#include "../BlockID.h"
+#include "../Torch.h"
+
+
+
+
+
+cRedstoneSimulator::cRedstoneSimulator( cWorld* a_World )
+	: super(a_World)
+{
+}
+
+
+
+
+
+cRedstoneSimulator::~cRedstoneSimulator()
+{
+}
+
+
+
+
+
+void cRedstoneSimulator::WakeUp( int a_X, int a_Y, int a_Z )
+{
+	cCSLock Lock( m_CS );
+	m_Blocks.push_back( Vector3i( a_X, a_Y, a_Z ) );
+}
+
+
+
+
+
+void cRedstoneSimulator::Simulate( float a_Dt )
+{
+	// Toggle torches on/off
+	while( !m_RefreshTorchesAround.empty() )
+	{
+		Vector3i pos = m_RefreshTorchesAround.front();
+		m_RefreshTorchesAround.pop_front();
+
+		RefreshTorchesAround( pos );
+	}
+
+	// Set repeaters to correct values, and decrement ticks
+	for( RepeaterList::iterator itr = m_SetRepeaters.begin(); itr != m_SetRepeaters.end(); )
+	{
+		(*itr).Ticks--;
+		if( (*itr).Ticks <= 0 )
+		{
+			char Block = m_World->GetBlock( (*itr).Position );
+			if( (*itr).bPowerOn == true && Block == E_BLOCK_REDSTONE_REPEATER_OFF )
+			{
+				m_World->FastSetBlock( (*itr).Position.x, (*itr).Position.y, (*itr).Position.z, E_BLOCK_REDSTONE_REPEATER_ON, m_World->GetBlockMeta( (*itr).Position ) );
+				m_Blocks.push_back( (*itr).Position );
+			}
+			else if( (*itr).bPowerOn == false && Block == E_BLOCK_REDSTONE_REPEATER_ON )
+			{
+				m_World->FastSetBlock( (*itr).Position.x, (*itr).Position.y, (*itr).Position.z, E_BLOCK_REDSTONE_REPEATER_OFF, m_World->GetBlockMeta( (*itr).Position ) );
+				m_Blocks.push_back( (*itr).Position );
+			}
+
+			if( (*itr).bPowerOffNextTime )
+			{
+				(*itr).bPowerOn = false;
+				(*itr).bPowerOffNextTime = false;
+				(*itr).Ticks = 10; // TODO: Look up actual ticks from block metadata
+				++itr;
+			}
+			else
+			{
+				itr = m_SetRepeaters.erase( itr );
+			}
+		}
+		else
+		{
+			++itr;
+		}
+	}
+
+	// Handle changed blocks
+	{
+		cCSLock Lock( m_CS );
+		std::swap( m_Blocks, m_BlocksBuffer );
+	}
+	for( BlockList::iterator itr = m_BlocksBuffer.begin(); itr != m_BlocksBuffer.end(); ++itr )
+	{
+		HandleChange( *itr );
+	}
+	m_BlocksBuffer.clear();
+}
+
+
+
+
+
+void cRedstoneSimulator::RefreshTorchesAround( const Vector3i & a_BlockPos )
+{
+	static Vector3i Surroundings [] = {
+		Vector3i(-1, 0, 0),
+		Vector3i( 1, 0, 0),
+		Vector3i( 0, 0,-1),
+		Vector3i( 0, 0, 1),
+		Vector3i( 0, 1, 0), // Also toggle torch on top
+	};
+	char TargetBlockID = E_BLOCK_REDSTONE_TORCH_ON;
+	char TargetRepeaterID = E_BLOCK_REDSTONE_REPEATER_OFF;
+	if( IsPowered( a_BlockPos, true ) )
+	{
+		TargetBlockID = E_BLOCK_REDSTONE_TORCH_OFF;
+		TargetRepeaterID = E_BLOCK_REDSTONE_REPEATER_ON;
+		//if( m_World->GetBlock( a_BlockPos ) == E_BLOCK_DIRT )
+		//{
+		//	m_World->FastSetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, E_BLOCK_STONE, 0 );
+		//}
+	}
+	else
+	{
+		//if( m_World->GetBlock( a_BlockPos ) == E_BLOCK_STONE )
+		//{
+		//	m_World->FastSetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, E_BLOCK_DIRT, 0 );
+		//}
+	}
+
+	for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+	{
+		Vector3i TorchPos = a_BlockPos + Surroundings[i];
+		const char Block = m_World->GetBlock( TorchPos );
+		switch( Block )
+		{
+		case E_BLOCK_REDSTONE_TORCH_ON:
+		case E_BLOCK_REDSTONE_TORCH_OFF:
+			if( Block != TargetBlockID )
+			{
+				char TorchMeta = m_World->GetBlockMeta( TorchPos );
+				if( cTorch::IsAttachedTo( TorchPos, TorchMeta, a_BlockPos ) )
+				{
+					m_World->FastSetBlock( TorchPos.x, TorchPos.y, TorchPos.z, TargetBlockID, m_World->GetBlockMeta( TorchPos ) );
+					m_Blocks.push_back( TorchPos );
+				}
+			}
+			break;
+		case E_BLOCK_REDSTONE_REPEATER_ON:
+		case E_BLOCK_REDSTONE_REPEATER_OFF:
+			if ((Block != TargetRepeaterID) && IsRepeaterPointingAway( TorchPos, m_World->GetBlockMeta( TorchPos ), a_BlockPos ) )
+			{
+				SetRepeater( TorchPos, 10, TargetRepeaterID == E_BLOCK_REDSTONE_REPEATER_ON );
+			}
+			break;
+		default:
+			break;
+		};
+	}
+}
+
+
+
+
+
+void cRedstoneSimulator::HandleChange( const Vector3i & a_BlockPos )
+{
+	std::deque< Vector3i > SpreadStack;
+
+	Vector3i Surroundings[] = {
+		Vector3i( 1, 0, 0 ),
+		Vector3i( 1, 1, 0 ),
+		Vector3i( 1,-1, 0 ),
+		Vector3i(-1, 0, 0 ),
+		Vector3i(-1, 1, 0 ),
+		Vector3i(-1,-1, 0 ),
+		Vector3i( 0, 0, 1 ),
+		Vector3i( 0, 1, 1 ),
+		Vector3i( 0,-1, 1 ),
+		Vector3i( 0, 0,-1 ),
+		Vector3i( 0, 1,-1 ),
+		Vector3i( 0,-1,-1 ),
+		Vector3i( 0,-1, 0 ),
+	};
+
+	char Block = m_World->GetBlock( a_BlockPos );
+
+	// First check whether torch should be on or off
+	if( Block == E_BLOCK_REDSTONE_TORCH_ON || Block == E_BLOCK_REDSTONE_TORCH_OFF )
+	{
+		static Vector3i Surroundings [] = {
+			Vector3i(-1, 0, 0),
+			Vector3i( 1, 0, 0),
+			Vector3i( 0, 0,-1),
+			Vector3i( 0, 0, 1),
+			Vector3i( 0,-1, 0),
+		};
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i pos = a_BlockPos + Surroundings[i];
+			char OtherBlock = m_World->GetBlock( pos );
+			if( (OtherBlock != E_BLOCK_AIR) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_ON) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_OFF) )
+			{
+				RefreshTorchesAround( pos );
+			}
+		}
+		Block = m_World->GetBlock( a_BlockPos ); // Make sure we got the updated block
+	}
+	else if( Block == E_BLOCK_REDSTONE_REPEATER_ON || Block == E_BLOCK_REDSTONE_REPEATER_OFF ) // Check if repeater is powered by a 'powered block' (not wires/torch)
+	{
+		Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) );
+		Vector3i pos = a_BlockPos - Direction; // NOTE: It's minus Direction
+		char OtherBlock = m_World->GetBlock( pos );
+		if( (OtherBlock != E_BLOCK_AIR) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_ON) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_OFF) && (OtherBlock != E_BLOCK_REDSTONE_WIRE) )
+		{
+			RefreshTorchesAround( pos );
+		}
+		else
+		{
+			SetRepeater( a_BlockPos, 10, IsPowered( a_BlockPos, false ) );
+		}
+		Block = m_World->GetBlock( a_BlockPos );
+	}
+
+	BlockList Sources;
+	// If torch is still on, use it as a source
+	if( Block == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		Sources.push_back( a_BlockPos );
+	}
+	else if( Block == E_BLOCK_REDSTONE_REPEATER_ON )
+	{
+		static Vector3i Surroundings [] = { // It only spreads right in front, and one block up
+			Vector3i( 0, 0, 0),
+			Vector3i( 0, 1, 0),
+		};
+		Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) );
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i pos = a_BlockPos + Direction + Surroundings[i];
+			if( PowerBlock( pos, a_BlockPos, 0xf ) )
+			{
+				SpreadStack.push_back( pos );
+			}
+		}
+	}
+
+	// Power all blocks legally connected to the sources
+	if( Block != E_BLOCK_REDSTONE_REPEATER_ON )
+	{
+		BlockList NewSources = RemoveCurrent( a_BlockPos );
+		Sources.insert( Sources.end(), NewSources.begin(), NewSources.end() );
+		while( !Sources.empty() )
+		{
+			Vector3i SourcePos = Sources.back();
+			Sources.pop_back();
+
+			char Block = m_World->GetBlock( SourcePos );
+			switch( Block )
+			{
+			case E_BLOCK_REDSTONE_TORCH_OFF:
+			case E_BLOCK_REDSTONE_TORCH_ON:
+				{
+					static Vector3i Surroundings [] = {
+						Vector3i(-1, 0, 0),
+						Vector3i( 1, 0, 0),
+						Vector3i( 0, 0,-1),
+						Vector3i( 0, 0, 1),
+					};
+					for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+					{
+						Vector3i OtherPos =  SourcePos + Surroundings[i];
+						if( PowerBlock( OtherPos, a_BlockPos, 0xf ) )
+						{
+							SpreadStack.push_back( OtherPos ); // Changed, so add to stack
+						}
+					}
+				}
+				break;
+			case E_BLOCK_REDSTONE_REPEATER_OFF:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+				{
+					static Vector3i Surroundings [] = {
+						Vector3i( 0, 0, 0),
+						Vector3i( 0, 1, 0),
+					};
+					Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( SourcePos ) );
+					for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+					{
+						Vector3i pos = SourcePos + Direction + Surroundings[i];
+						if( PowerBlock( pos, a_BlockPos, 0xf ) )
+						{
+							SpreadStack.push_back( pos );
+						}
+					}
+				}
+				break;
+			};
+
+			
+		}
+	}
+
+
+	// Do a floodfill
+	while( !SpreadStack.empty() )
+	{
+		Vector3i pos = SpreadStack.back();
+		SpreadStack.pop_back();
+
+		char Meta = m_World->GetBlockMeta( pos );
+
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i OtherPos =  pos + Surroundings[i];
+			if( PowerBlock( OtherPos, pos, Meta-1 ) )
+			{
+				SpreadStack.push_back( OtherPos ); // Changed, so add to stack
+			}
+		}
+	}
+
+	// Only after a redstone area has been completely simulated the redstone entities can react
+	while( !m_RefreshPistons.empty() )
+	{
+		Vector3i pos = m_RefreshPistons.back();
+		m_RefreshPistons.pop_back();
+
+		char Block = m_World->GetBlock( pos );
+		switch( Block )
+		{
+		case E_BLOCK_PISTON:
+		case E_BLOCK_STICKY_PISTON:
+			if( IsPowered( pos ) )
+			{
+				cPiston Piston( m_World );
+				Piston.ExtendPiston( pos.x, pos.y, pos.z );
+			}
+			else
+			{
+				cPiston Piston( m_World );
+				Piston.RetractPiston( pos.x, pos.y, pos.z );
+			}
+			break;
+		default:
+			break;
+		};
+	}
+}
+
+
+
+
+
+bool cRedstoneSimulator::PowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock, char a_Power )
+{
+	char Block = m_World->GetBlock( a_BlockPos );
+	switch( Block )
+	{
+	case E_BLOCK_REDSTONE_WIRE:
+		{
+			if( m_World->GetBlockMeta( a_BlockPos ) < a_Power )
+			{
+				m_World->SetBlockMeta( a_BlockPos, a_Power );
+				return true;
+			}
+		}
+		break;
+	case E_BLOCK_PISTON:
+	case E_BLOCK_STICKY_PISTON:
+		{
+			m_RefreshPistons.push_back( a_BlockPos );
+		}
+		break;
+	case E_BLOCK_REDSTONE_REPEATER_OFF:
+	case E_BLOCK_REDSTONE_REPEATER_ON:
+		{
+			if (IsRepeaterPointingAway( a_BlockPos, m_World->GetBlockMeta( a_BlockPos ), a_FromBlock ))
+			{
+				SetRepeater( a_BlockPos, 10, true );
+			}
+		}
+		break;
+	default:
+		{
+			if( Block != E_BLOCK_AIR && Block != E_BLOCK_REDSTONE_TORCH_ON && Block != E_BLOCK_REDSTONE_TORCH_OFF )
+			{
+				if( IsPowered( a_BlockPos, true ) )
+				{
+					m_RefreshTorchesAround.push_back( a_BlockPos );
+				}
+			}
+		}
+		break;
+	};
+
+	return false;
+}
+
+
+
+
+
+int cRedstoneSimulator::UnPowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock)
+{
+	BLOCKTYPE BlockType = m_World->GetBlock(a_BlockPos);
+	switch (BlockType)
+	{
+		case E_BLOCK_REDSTONE_WIRE:
+		{
+			if( m_World->GetBlockMeta( a_BlockPos ) > 0 )
+			{
+				m_World->SetBlockMeta( a_BlockPos, 0 );
+				return 1;
+			}
+			break;
+		}
+		
+		case E_BLOCK_PISTON:
+		case E_BLOCK_STICKY_PISTON:
+		{
+			m_RefreshPistons.push_back( a_BlockPos );
+			break;
+		}
+		
+		case E_BLOCK_REDSTONE_TORCH_ON:
+		{
+			return 2;
+			break;
+		}
+		
+		case E_BLOCK_REDSTONE_REPEATER_ON:
+		{
+			if (
+				IsRepeaterPointingTo(a_BlockPos, m_World->GetBlockMeta(a_BlockPos), a_FromBlock ) ||  // Repeater is next to wire
+				IsRepeaterPointingTo(a_BlockPos, m_World->GetBlockMeta(a_BlockPos), a_FromBlock - Vector3i(0, 1, 0))  // Repeater is below wire
+			)
+			{
+				return 2;
+			}
+			else if (IsRepeaterPointingAway( a_BlockPos, m_World->GetBlockMeta( a_BlockPos ), a_FromBlock ) )
+			{
+				SetRepeater( a_BlockPos, 10, false );
+			}
+			// fall-through:
+		}
+		
+		case E_BLOCK_REDSTONE_REPEATER_OFF:
+		{
+			if (IsRepeaterPointingAway( a_BlockPos, m_World->GetBlockMeta( a_BlockPos ), a_FromBlock ))
+			{
+				SetRepeater( a_BlockPos, 10, false );
+			}
+			break;
+		}
+		
+		default:
+		{
+			if ((BlockType != E_BLOCK_AIR) && (BlockType != E_BLOCK_REDSTONE_TORCH_ON) && (BlockType != E_BLOCK_REDSTONE_TORCH_OFF))
+			{
+				if (!IsPowered(a_BlockPos, true))
+				{
+					m_RefreshTorchesAround.push_back( a_BlockPos );
+				}
+			}
+			break;
+		}
+	}  // switch (BlockType)
+
+	return 0;
+}
+
+
+
+
+
+// Removes current from all powered redstone wires until it reaches an energy source.
+// Also returns all energy sources it encountered
+cRedstoneSimulator::BlockList cRedstoneSimulator::RemoveCurrent( const Vector3i & a_BlockPos )
+{
+
+
+	std::deque< Vector3i > SpreadStack;
+	std::deque< Vector3i > FoundSources;
+
+	Vector3i Surroundings[] = {
+		Vector3i( 1, 0, 0 ),
+		Vector3i( 1, 1, 0 ),
+		Vector3i( 1,-1, 0 ),
+		Vector3i(-1, 0, 0 ),
+		Vector3i(-1, 1, 0 ),
+		Vector3i(-1,-1, 0 ),
+		Vector3i( 0, 0, 1 ),
+		Vector3i( 0, 1, 1 ),
+		Vector3i( 0,-1, 1 ),
+		Vector3i( 0, 0,-1 ),
+		Vector3i( 0, 1,-1 ),
+		Vector3i( 0,-1,-1 ),
+		Vector3i( 0,-1, 0 ),
+	};
+
+	char Block = m_World->GetBlock( a_BlockPos );
+	if( Block == E_BLOCK_REDSTONE_REPEATER_ON || Block == E_BLOCK_REDSTONE_REPEATER_OFF )
+	{
+		static Vector3i Surroundings [] = { // Repeaters only spread right in front and 1 block up
+			Vector3i( 0, 0, 0),
+			Vector3i( 0, 1, 0),
+		};
+		Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) );
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i pos = a_BlockPos + Direction + Surroundings[i];
+			int RetVal = UnPowerBlock( pos, a_BlockPos );
+			if( RetVal == 1 )
+			{
+				SpreadStack.push_back( pos ); // Changed, so add to stack
+			}
+			else if( RetVal == 2 )
+			{
+				FoundSources.push_back( pos );
+			}
+		}
+	}
+	else if( Block == E_BLOCK_REDSTONE_TORCH_OFF || Block == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		static Vector3i Surroundings [] = {	// Torches only spread on the same level
+			Vector3i(-1, 0, 0),
+			Vector3i( 1, 0, 0),
+			Vector3i( 0, 0,-1),
+			Vector3i( 0, 0, 1),
+		};
+
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i pos = Vector3i( a_BlockPos ) + Surroundings[i];
+			int RetVal = UnPowerBlock( pos, a_BlockPos );
+			if( RetVal == 1 )
+			{
+				SpreadStack.push_back( pos ); // Changed, so add to stack
+			}
+			else if( RetVal == 2 )
+			{
+				FoundSources.push_back( pos );
+			}
+		}
+	}
+	else
+	{
+		SpreadStack.push_back( a_BlockPos );
+	}
+
+
+	while( !SpreadStack.empty() )
+	{
+		Vector3i pos = SpreadStack.back();
+		SpreadStack.pop_back();
+
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i OtherPos =  pos + Surroundings[i];
+			int RetVal = UnPowerBlock( OtherPos, pos );
+			if( RetVal == 1 )
+			{
+				SpreadStack.push_back( OtherPos ); // Changed, so add to stack
+			}
+			else if( RetVal == 2 )
+			{
+				FoundSources.push_back( OtherPos );
+			}
+		}
+	}
+
+	return FoundSources;
+}
+
+
+
+
+
+bool cRedstoneSimulator::IsPowering( const Vector3i & a_PowerPos, const Vector3i & a_BlockPos, eRedstoneDirection a_WireDirection, bool a_bOnlyByWire )
+{
+	BLOCKTYPE PowerBlock = m_World->GetBlock( a_PowerPos );
+	if (!a_bOnlyByWire && (PowerBlock == E_BLOCK_REDSTONE_TORCH_ON))	return true;
+	if (PowerBlock == E_BLOCK_REDSTONE_REPEATER_ON ) // A repeater pointing towards block is regarded as wire
+	{
+		if (IsRepeaterPointingTo( a_PowerPos, m_World->GetBlockMeta( a_PowerPos ), a_BlockPos ) )
+		{
+			return true;
+		}
+	}
+	if (PowerBlock == E_BLOCK_REDSTONE_WIRE)
+	{
+		if (m_World->GetBlockMeta(a_PowerPos) > 0)
+		{
+			if (GetDirection(a_PowerPos) == a_WireDirection)
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+
+
+
+bool cRedstoneSimulator::IsPowered( const Vector3i & a_BlockPos, bool a_bOnlyByWire /* = false */ )
+{
+	BLOCKTYPE Block = m_World->GetBlock( a_BlockPos );
+	if ((Block == E_BLOCK_REDSTONE_REPEATER_OFF) || (Block == E_BLOCK_REDSTONE_REPEATER_ON))
+	{
+		Vector3i Behind = a_BlockPos - GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) );
+		BLOCKTYPE BehindBlock = m_World->GetBlock( Behind );
+		if (BehindBlock == E_BLOCK_REDSTONE_TORCH_ON)
+		{
+			return true;
+		}
+		if (BehindBlock == E_BLOCK_REDSTONE_WIRE)
+		{
+			if( m_World->GetBlockMeta( Behind ) > 0 )
+			{
+				return true;
+			}
+		}
+		if (BehindBlock == E_BLOCK_REDSTONE_REPEATER_ON)
+		{
+			if (IsRepeaterPointingTo( Behind, m_World->GetBlockMeta( Behind ), a_BlockPos))
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	if( IsPowering( Vector3i( a_BlockPos.x-1, a_BlockPos.y, a_BlockPos.z ), a_BlockPos, REDSTONE_X_POS, a_bOnlyByWire ) )
+		return true;
+	if( IsPowering( Vector3i( a_BlockPos.x+1, a_BlockPos.y, a_BlockPos.z ), a_BlockPos, REDSTONE_X_NEG, a_bOnlyByWire ) )
+		return true;
+	if( IsPowering( Vector3i( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z-1 ), a_BlockPos, REDSTONE_Z_POS, a_bOnlyByWire ) )
+		return true;
+	if( IsPowering( Vector3i( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z+1 ), a_BlockPos, REDSTONE_Z_NEG, a_bOnlyByWire ) )
+		return true;
+
+	// Only wires can power the bottom block
+	char PosY = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y+1, a_BlockPos.z );
+	if( PosY == E_BLOCK_REDSTONE_WIRE )
+	{
+		if( m_World->GetBlockMeta( a_BlockPos.x, a_BlockPos.y+1, a_BlockPos.z ) > 0 )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+
+// Believe me, it works!! TODO: Add repeaters and low/high wires
+cRedstoneSimulator::eRedstoneDirection cRedstoneSimulator::GetDirection( int a_X, int a_Y, int a_Z )
+{
+	int Dir = REDSTONE_NONE;
+
+	char NegX = m_World->GetBlock( a_X-1, a_Y, a_Z );
+	if( NegX == E_BLOCK_REDSTONE_WIRE || NegX == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		Dir |= (REDSTONE_X_POS);
+	}
+	char PosX = m_World->GetBlock( a_X+1, a_Y, a_Z );
+	if( PosX == E_BLOCK_REDSTONE_WIRE || PosX == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		Dir |= (REDSTONE_X_NEG);
+	}
+	char NegZ = m_World->GetBlock( a_X, a_Y, a_Z-1 );
+	if( NegZ == E_BLOCK_REDSTONE_WIRE || NegZ == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		if( (Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG ) ) //corner
+		{
+			Dir ^= REDSTONE_X_POS;
+			Dir |= REDSTONE_X_NEG;
+		}
+		if( (Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS ) ) //corner
+		{
+			Dir ^= REDSTONE_X_NEG;
+			Dir |= REDSTONE_X_POS;
+		}
+		Dir |= REDSTONE_Z_POS;
+	}
+	char PosZ = m_World->GetBlock( a_X, a_Y, a_Z+1 );
+	if( PosZ == E_BLOCK_REDSTONE_WIRE || PosZ == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		if( (Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG ) ) //corner
+		{
+			Dir ^= REDSTONE_X_POS;
+			Dir |= REDSTONE_X_NEG;
+		}
+		if( (Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS ) ) //corner
+		{
+			Dir ^= REDSTONE_X_NEG;
+			Dir |= REDSTONE_X_POS;
+		}
+		Dir |= REDSTONE_Z_NEG;
+	}
+
+	return (eRedstoneDirection)Dir;
+}
+
+
+
+
+
+bool cRedstoneSimulator::IsRepeaterPointingTo(const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos)
+{
+	switch (a_MetaData & 0x3)
+	{
+		case 0x0:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0, 1 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+		
+		case 0x1:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i(-1, 0, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+		
+		case 0x2:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0,-1 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+		
+		case 0x3:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 1, 0, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+bool cRedstoneSimulator::IsRepeaterPointingAway( const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos )
+{
+	switch (a_MetaData & 0x3)
+	{
+		case 0x0:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0,-1 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+		
+		case 0x1:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 1, 0, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+		
+		case 0x2:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0, 1 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+		
+		case 0x3:
+		{
+			if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i(-1, 0, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+NIBBLETYPE cRedstoneSimulator::RepeaterRotationToMetaData(float a_Rotation)
+{
+	a_Rotation += 90 + 45; // So its not aligned with axis
+	if (a_Rotation > 360.f)
+	{
+		a_Rotation -= 360.f;
+	}
+	
+	if ((a_Rotation >= 0.f) && (a_Rotation < 90.f))
+	{
+		return 0x1;
+	}
+	else if ((a_Rotation >= 180) && (a_Rotation < 270))
+	{
+		return 0x3;
+	}
+	else if ((a_Rotation >= 90) && (a_Rotation < 180))
+	{
+		return 0x2;
+	}
+	else
+	{
+		return 0x0;
+	}
+}
+
+
+
+
+
+Vector3i cRedstoneSimulator::GetRepeaterDirection(NIBBLETYPE a_MetaData)
+{
+	switch (a_MetaData & 0x3)
+	{
+		case 0x0: return Vector3i( 0, 0,-1);
+		case 0x1: return Vector3i( 1, 0, 0);
+		case 0x2: return Vector3i( 0, 0, 1);
+		case 0x3: return Vector3i(-1, 0, 0);
+	}
+	return Vector3i();
+}
+
+
+
+
+
+void cRedstoneSimulator::SetRepeater( const Vector3i & a_Position, int a_Ticks, bool a_bPowerOn )
+{
+	for( RepeaterList::iterator itr = m_SetRepeaters.begin(); itr != m_SetRepeaters.end(); ++itr )
+	{
+		sRepeaterChange & Change = *itr;
+		if( Change.Position.Equals( a_Position ) )
+		{
+			if( Change.bPowerOn && a_bPowerOn == false )
+			{
+				Change.bPowerOffNextTime = true;
+			}
+			if( a_bPowerOn == true )
+			{
+				Change.bPowerOffNextTime = false;
+			}
+			Change.bPowerOn |= a_bPowerOn;
+			return;
+		}
+	}
+
+	sRepeaterChange RC;
+	RC.Position = a_Position;
+	RC.Ticks = a_Ticks;
+	RC.bPowerOn = a_bPowerOn;
+	RC.bPowerOffNextTime = false;
+	m_SetRepeaters.push_back( RC );
+}
+
+
+
+
diff --git a/source/Simulator/RedstoneSimulator.h b/source/Simulator/RedstoneSimulator.h
new file mode 100644
index 000000000..f26b6b46b
--- /dev/null
+++ b/source/Simulator/RedstoneSimulator.h
@@ -0,0 +1,81 @@
+
+#pragma once
+
+#include "Simulator.h"
+
+
+
+
+
+class cRedstoneSimulator :
+	public cSimulator
+{
+	typedef cSimulator super;
+public:
+	cRedstoneSimulator( cWorld* a_World );
+	~cRedstoneSimulator();
+
+	virtual void Simulate( float a_Dt ) override;
+	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override { return true; }
+
+	virtual void WakeUp( int a_X, int a_Y, int a_Z ) override;
+
+	enum eRedstoneDirection
+	{
+		REDSTONE_NONE =  0,
+		REDSTONE_X_POS = 0x1,
+		REDSTONE_X_NEG = 0x2,
+		REDSTONE_Z_POS = 0x4,
+		REDSTONE_Z_NEG = 0x8,
+	};
+	eRedstoneDirection GetDirection( int a_X, int a_Y, int a_Z );
+	eRedstoneDirection GetDirection( const Vector3i & a_Pos ) { return GetDirection( a_Pos.x, a_Pos.y, a_Pos.z ); }
+
+	static bool IsRepeaterPointingTo  (const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos);
+	static bool IsRepeaterPointingAway(const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos);
+	static NIBBLETYPE RepeaterRotationToMetaData(float a_Rotation);
+	static Vector3i GetRepeaterDirection(NIBBLETYPE a_MetaData);
+
+
+private:
+	struct sRepeaterChange
+	{
+		Vector3i Position;
+		int Ticks;
+		bool bPowerOn;
+		bool bPowerOffNextTime;
+	};
+
+	typedef std::deque <Vector3i> BlockList;
+
+	typedef std::deque< sRepeaterChange > RepeaterList;
+	RepeaterList m_SetRepeaters;
+	
+	void SetRepeater(const Vector3i & a_Position, int a_Ticks, bool a_bPowerOn);
+
+	virtual void AddBlock(int a_X, int a_Y, int a_Z) {}
+
+	void HandleChange( const Vector3i & a_BlockPos );
+	BlockList RemoveCurrent( const Vector3i & a_BlockPos );
+
+	bool PowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock, char a_Power );
+	int UnPowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock );
+
+	bool IsPowered( const Vector3i & a_BlockPos, bool a_bOnlyByWire = false );
+	bool IsPowering( const Vector3i & a_PowerPos, const Vector3i & a_BlockPos, eRedstoneDirection a_WireDirection, bool a_bOnlyByWire );
+	
+	BlockList m_Blocks;
+	BlockList m_BlocksBuffer;
+
+	BlockList m_RefreshPistons;
+
+	BlockList m_RefreshTorchesAround;
+	
+	void RefreshTorchesAround( const Vector3i & a_BlockPos );
+
+	cCriticalSection m_CS;
+};
+
+
+
+
diff --git a/source/Simulator/SandSimulator.cpp b/source/Simulator/SandSimulator.cpp
new file mode 100644
index 000000000..69513afef
--- /dev/null
+++ b/source/Simulator/SandSimulator.cpp
@@ -0,0 +1,101 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "SandSimulator.h"
+#include "../World.h"
+#include "../BlockID.h"
+#include "../Defines.h"
+#include "../FallingBlock.h"
+
+
+
+
+cSandSimulator::cSandSimulator( cWorld* a_World )
+	: cSimulator(a_World)
+	, m_Blocks(new BlockList)
+	, m_Buffer(new BlockList)
+{
+
+}
+
+
+
+
+
+cSandSimulator::~cSandSimulator()
+{
+	delete m_Buffer;
+	delete m_Blocks;
+}
+
+
+
+
+
+void cSandSimulator::Simulate( float a_Dt )
+{
+	m_Buffer->clear();
+	std::swap( m_Blocks, m_Buffer );
+
+	for( BlockList::iterator itr = m_Buffer->begin(); itr != m_Buffer->end(); ++itr )
+	{
+		Vector3i Pos = *itr;
+		BLOCKTYPE BlockID = m_World->GetBlock(Pos.x, Pos.y, Pos.z);
+		if(!IsAllowedBlock(BlockID))
+			continue;
+
+		BLOCKTYPE BottomBlock = m_World->GetBlock( Pos.x, Pos.y - 1, Pos.z );
+		
+		if( IsPassable(BottomBlock) )
+		{
+			cFallingBlock * FallingBlock = new cFallingBlock( Pos, BlockID );
+			FallingBlock->Initialize( m_World );
+ 			m_World->SetBlock( Pos.x, Pos.y, Pos.z, E_BLOCK_AIR, 0 );
+		}
+	}
+		
+}
+
+
+
+
+
+bool cSandSimulator::IsAllowedBlock( BLOCKTYPE a_BlockType )
+{
+	return a_BlockType == E_BLOCK_SAND
+		|| a_BlockType == E_BLOCK_GRAVEL;
+}
+
+
+
+
+
+void cSandSimulator::AddBlock(int a_X, int a_Y, int a_Z)
+{
+	if(!IsAllowedBlock(m_World->GetBlock(a_X, a_Y, a_Z)))
+		return;
+
+	Vector3i Block(a_X, a_Y, a_Z);
+	
+	//check for duplicates
+	for( BlockList::iterator itr = m_Blocks->begin(); itr != m_Blocks->end(); ++itr )
+	{
+		Vector3i Pos = *itr;
+		if( Pos.x == a_X && Pos.y == a_Y && Pos.z == a_Z )
+			return;
+	}
+
+	m_Blocks->push_back(Block);
+}
+
+
+
+
+
+bool cSandSimulator::IsPassable( BLOCKTYPE a_BlockType )
+{
+	return a_BlockType == E_BLOCK_AIR
+		|| IsBlockWater(a_BlockType)
+		|| IsBlockLava(a_BlockType)
+		|| a_BlockType == E_BLOCK_FIRE;
+}
diff --git a/source/Simulator/SandSimulator.h b/source/Simulator/SandSimulator.h
new file mode 100644
index 000000000..928ea63fc
--- /dev/null
+++ b/source/Simulator/SandSimulator.h
@@ -0,0 +1,33 @@
+
+#pragma once
+
+#include "Simulator.h"
+#include "../BlockEntity.h"
+#include "../Vector3i.h"
+
+
+
+
+
+class cSandSimulator : public cSimulator
+{
+public:
+	cSandSimulator( cWorld* a_World );
+	~cSandSimulator();
+
+	virtual void Simulate( float a_Dt ) override;
+
+	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override;
+	virtual bool IsPassable( BLOCKTYPE a_BlockType );
+
+protected:
+	virtual void AddBlock(int a_X, int a_Y, int a_Z) override;
+
+	typedef std::list <Vector3i> BlockList;
+	BlockList * m_Blocks;
+	BlockList * m_Buffer;
+};
+
+
+
+
diff --git a/source/Simulator/Simulator.cpp b/source/Simulator/Simulator.cpp
new file mode 100644
index 000000000..86b37e989
--- /dev/null
+++ b/source/Simulator/Simulator.cpp
@@ -0,0 +1,44 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "Simulator.h"
+#include "../World.h"
+#include "../Vector3i.h"
+#include "../BlockID.h"
+#include "../Defines.h"
+
+
+
+
+
+cSimulator::cSimulator( cWorld* a_World )
+	: m_World(a_World)
+{
+}
+
+
+
+
+
+cSimulator::~cSimulator()
+{
+}
+
+
+
+
+
+void cSimulator::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ);
+	AddBlock(a_BlockX - 1, a_BlockY,     a_BlockZ);
+	AddBlock(a_BlockX + 1, a_BlockY,     a_BlockZ);
+	AddBlock(a_BlockX,     a_BlockY - 1, a_BlockZ);
+	AddBlock(a_BlockX,     a_BlockY + 1, a_BlockZ);
+	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ - 1);
+	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ + 1);
+}
+
+
+
+
diff --git a/source/Simulator/Simulator.h b/source/Simulator/Simulator.h
new file mode 100644
index 000000000..84a1630c2
--- /dev/null
+++ b/source/Simulator/Simulator.h
@@ -0,0 +1,38 @@
+
+#pragma once
+
+#include "../Vector3i.h"
+
+
+
+
+
+class cWorld;
+
+
+
+
+
+class cSimulator
+{
+public:
+	cSimulator(cWorld * a_World);
+	virtual ~cSimulator();
+
+	/// Called in each tick, a_Dt is the time passed since the last tick
+	virtual void Simulate(float a_Dt) = 0;
+	
+	/// Called when a block changes via cWorld::SetBlock()
+	virtual void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ);
+
+	virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) = 0;
+
+protected:
+	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ) = 0;
+
+	cWorld * m_World;
+} ;
+
+
+
+
diff --git a/source/Simulator/SimulatorManager.cpp b/source/Simulator/SimulatorManager.cpp
new file mode 100644
index 000000000..1ab7a51b5
--- /dev/null
+++ b/source/Simulator/SimulatorManager.cpp
@@ -0,0 +1,67 @@
+
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "SimulatorManager.h"
+
+
+
+
+
+cSimulatorManager::cSimulatorManager()
+{
+
+}
+
+
+
+
+
+cSimulatorManager::~cSimulatorManager()
+{
+	for (cSimulators::iterator itr = m_Simulators.begin(); itr != m_Simulators.end(); ++itr )
+	{
+		delete *itr;
+	}  // for itr - m_Simulators[]
+}
+
+
+
+
+
+void cSimulatorManager::Simulate( float a_Dt )
+{
+	m_Ticks++;
+	for (cSimulators::iterator itr = m_Simulators.begin(); itr != m_Simulators.end(); ++itr )
+	{
+		if(m_Ticks % (*itr)->second == 0)
+			(*itr)->first->Simulate(a_Dt);
+	}
+}
+
+
+
+
+
+void cSimulatorManager::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	for (cSimulators::iterator itr = m_Simulators.begin(); itr != m_Simulators.end(); ++itr )
+	{
+		(*itr)->first->WakeUp(a_BlockX, a_BlockY, a_BlockZ);
+	}
+}
+
+
+
+
+
+void cSimulatorManager::RegisterSimulator(cSimulator *a_Simulator, short a_Rate)
+{
+	//TODO needs some checking
+	std::pair<cSimulator *, short> *Pair = new std::pair<cSimulator *, short>(a_Simulator, a_Rate);
+
+	m_Simulators.push_back(Pair);
+}
+
+
+
+
diff --git a/source/Simulator/SimulatorManager.h b/source/Simulator/SimulatorManager.h
new file mode 100644
index 000000000..e90acffab
--- /dev/null
+++ b/source/Simulator/SimulatorManager.h
@@ -0,0 +1,39 @@
+
+// cSimulatorManager.h
+
+
+
+
+#pragma once
+
+
+
+
+#include "Simulator.h"
+
+
+
+
+
+class cSimulatorManager
+{
+public:
+	cSimulatorManager();
+	~cSimulatorManager();
+
+	void Simulate( float a_Dt );
+	void WakeUp(int a_X, int a_Y, int a_Z);
+
+	void RegisterSimulator(cSimulator * a_Simulator, short a_Rate);  // Takes ownership of the simulator object!
+
+protected:
+
+	typedef std::vector <std::pair<cSimulator *, short> *> cSimulators;
+	
+	cSimulators m_Simulators;
+	long long   m_Ticks;
+};
+
+
+
+
diff --git a/source/Simulator/WaterSimulator.cpp b/source/Simulator/WaterSimulator.cpp
new file mode 100644
index 000000000..c63135419
--- /dev/null
+++ b/source/Simulator/WaterSimulator.cpp
@@ -0,0 +1,22 @@
+#include "Globals.h"
+#include "WaterSimulator.h"
+#include "Defines.h"
+#include "World.h"
+
+
+
+cWaterSimulator::cWaterSimulator(cWorld *a_World)
+	: cFluidSimulator(a_World)
+{
+	m_FluidBlock = E_BLOCK_WATER;
+	m_StationaryFluidBlock = E_BLOCK_STATIONARY_WATER;
+	m_MaxHeight = 7;
+	m_FlowReduction = 1;
+}
+
+
+bool cWaterSimulator::IsAllowedBlock(BLOCKTYPE a_BlockType)
+{
+	return IsBlockWater(a_BlockType);
+}
+
diff --git a/source/Simulator/WaterSimulator.h b/source/Simulator/WaterSimulator.h
new file mode 100644
index 000000000..4bc35b8f7
--- /dev/null
+++ b/source/Simulator/WaterSimulator.h
@@ -0,0 +1,11 @@
+#pragma once
+#include "FluidSimulator.h"
+
+class cWaterSimulator : public cFluidSimulator
+{
+public:
+	cWaterSimulator( cWorld* a_World );
+
+	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override;
+
+};
+\ No newline at end of file