27 files changed, 341 insertions, 861 deletions

diff --git a/source/Blocks/BlockRedstoneRepeater.cpp b/source/Blocks/BlockRedstoneRepeater.cpp
index 5af5edb1e..84a841fb0 100644
--- a/source/Blocks/BlockRedstoneRepeater.cpp
+++ b/source/Blocks/BlockRedstoneRepeater.cpp
@@ -4,7 +4,7 @@
 #include "../Item.h"

 #include "../World.h"

 #include "../Player.h"

-#include "../RedstoneSimulator.h"

+#include "../Simulator/RedstoneSimulator.h"

 

 

 

diff --git a/source/Chunk.cpp b/source/Chunk.cpp
index 0dec50230..aaea4bf71 100644
--- a/source/Chunk.cpp
+++ b/source/Chunk.cpp
@@ -8,8 +8,6 @@
 
 #include "Chunk.h"
 #include "World.h"
-#include "WaterSimulator.h"
-#include "LavaSimulator.h"
 #include "ClientHandle.h"
 #include "Server.h"
 #include "zlib.h"
diff --git a/source/FluidSimulator.cpp b/source/FluidSimulator.cpp
deleted file mode 100644
index 8a6a760f3..000000000
--- a/source/FluidSimulator.cpp
+++ /dev/null
@@ -1,692 +0,0 @@
-#include "Globals.h"
-
-#include <set>
-#include <queue>
-
-#include "FluidSimulator.h"
-#include "World.h"
-#include "Vector3i.h"
-#include "BlockID.h"
-#include "Defines.h"
-#include "Item.h"
-#include "Blocks/BlockHandler.h"
-
-
-
-
-
-//#define DEBUG_FLUID
-#ifdef DEBUG_FLUID
-#define LOG_FLUID(...) LOGWARN( __VA_ARGS__ )
-#else
-#define LOG_FLUID(...)
-#endif
-
-
-
-
-
-class cFluidSimulator::FluidData
-{
-public:
-	FluidData( cWorld* a_World, cFluidSimulator *a_Simulator )
-		: m_ActiveFluid( new std::set < Vector3i >() )
-		, m_Simulator (a_Simulator)
-		, m_Buffer( new std::set< Vector3i >() )
-		, m_World( a_World )
-	{}
-
-	~FluidData()
-	{
-		delete m_Buffer;
-		delete m_ActiveFluid;
-	}
-
-	void UpdateWave(Vector3i a_LeftCorner, Vector3i a_CurBlock)
-	{
-		Vector3i LevelPoints [] = {
-				Vector3i( a_CurBlock.x-1, a_CurBlock.y, a_CurBlock.z ),
-				Vector3i( a_CurBlock.x+1, a_CurBlock.y, a_CurBlock.z ),
-				Vector3i( a_CurBlock.x, a_CurBlock.y, a_CurBlock.z-1 ),
-				Vector3i( a_CurBlock.x, a_CurBlock.y, a_CurBlock.z+1 ),
-		};
-
-		for(int i=0; i<4; i++)
-		{
-			Vector3i cur = LevelPoints[i];
-			switch(m_Relief[cur.x][cur.z])
-			{
-				case E_HOLE:
-				{
-					m_StartSide[cur.x][cur.z] = m_StartSide[a_CurBlock.x][a_CurBlock.z];
-					m_CurResult|=m_StartSide[cur.x][cur.z];
-					m_NearestHole = m_WayLength[a_CurBlock.x][a_CurBlock.z] + 1;
-					LOG_FLUID("Hole found: %d	\t curResult: %d", int(m_StartSide[cur.x][cur.z]), int(m_CurResult) );
-					LOG_FLUID("Coordinates: (%d, %d)", cur.x, cur.z);
-				}break;
-
-				case E_BLOCK:
-				{}break;
-
-				case E_PLAIN:
-				{
-					if (m_WayLength[cur.x][cur.z] > m_WayLength[a_CurBlock.x][a_CurBlock.z] + 1)
-					{
-						m_WayLength[cur.x][cur.z] = m_WayLength[a_CurBlock.x][a_CurBlock.z] + 1;
-						m_StartSide[cur.x][cur.z] = m_StartSide[a_CurBlock.x][a_CurBlock.z];
-						m_WaveQueue.push(cur);
-					}
-					else if(m_WayLength[cur.x][cur.z] == m_WayLength[a_CurBlock.x][a_CurBlock.z] + 1)
-					{
-						m_StartSide[cur.x][cur.z] |= m_StartSide[a_CurBlock.x][a_CurBlock.z];
-					}
-					LOG_FLUID("Plain step: (%d, %d) from %d", cur.x, cur.z, m_StartSide[cur.x][cur.z]);
-				}
-			}
-		}
-	}
-
-	std::vector< Vector3i > GetLowestPoints( int a_X, int a_Y, int a_Z )
-	{
-
-		std::vector< Vector3i > Points; //result
-
-		Vector3i CornerGlobal(a_X - AREA_WIDTH/2, a_Y, a_Z - AREA_WIDTH/2);
-
-		//TODO: rewrite without relief, get blocks directly in algorithm
-		for(int x=0; x<AREA_WIDTH; x++) 
-		{
-			for(int z=0; z<AREA_WIDTH; z++)
-			{
-				char UpperBlock = m_World->GetBlock( CornerGlobal.x + x, CornerGlobal.y, CornerGlobal.z + z );
-				char DownBlock = m_World->GetBlock( CornerGlobal.x + x, CornerGlobal.y-1, CornerGlobal.z + z );
-
-				if(m_Simulator->IsSolidBlock(UpperBlock)||(m_Simulator->IsStationaryBlock(UpperBlock)))
-				{
-					m_Relief[x][z] = E_BLOCK;
-				}
-				else if(m_Simulator->IsSolidBlock(DownBlock))
-				{
-					m_Relief[x][z] = E_PLAIN;
-				}
-				else
-				{
-					m_Relief[x][z] = E_HOLE;
-				}
-				m_WayLength[x][z] = 255;
-				m_StartSide[x][z] = E_SIDE_NONE;
-			}
-			LOG_FLUID("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t", m_Relief[x][0], m_Relief[x][1], m_Relief[x][2], m_Relief[x][3], m_Relief[x][4], m_Relief[x][5], m_Relief[x][6], m_Relief[x][7], m_Relief[x][8], m_Relief[x][9], m_Relief[x][10]);
-		}
-
-		m_NearestHole = 5;
-		m_CurResult = 0;
-		while(!m_WaveQueue.empty()) m_WaveQueue.pop();
-
-		int left = AREA_WIDTH/2 - 1;
-		int right = AREA_WIDTH/2 + 1;
-		int center = AREA_WIDTH/2;
-
-		Vector3i r(right, 0, center); //right block
-		Vector3i l(left, 0, center); //left block
-		Vector3i f(center, 0, right); //front block
-		Vector3i b(center, 0, left); //back block
-		Vector3i c(center, 0, center); //center block
-
-		m_WayLength[c.x][c.z] = 0;
-
-		Vector3i Nearest[] = {r, l, f, b};
-		unsigned char Sides[] = {E_SIDE_RIGHT, E_SIDE_LEFT, E_SIDE_FRONT, E_SIDE_BACK};
-
-		for(int i=0; i<4; i++)
-		{
-			Vector3i cur = Nearest[i];
-			switch(m_Relief[cur.x][cur.z])
-			{
-				case E_HOLE:
-				{
-					m_StartSide[cur.x][cur.z] = Sides[i];
-					m_CurResult |= m_StartSide[cur.x][cur.z];
-					m_NearestHole = 1;
-					LOG_FLUID("Hole found: %d	\t curResult: %d", int(Sides[i]), int(m_CurResult) );
-				}break;
-
-				case E_BLOCK:
-				{}break;
-
-				case E_PLAIN:
-				{
-					m_WaveQueue.push(cur);
-					m_StartSide[cur.x][cur.z] = Sides[i];
-					m_WayLength[cur.x][cur.z] = 1;
-					LOG_FLUID("Plain found: %d", int(Sides[i]));
-				}
-			}
-		}
-
-		Vector3i curBlock;
-		
-		bool bContinue = !m_WaveQueue.empty();
-
-		if(!m_WaveQueue.empty())
-		{
-			curBlock = m_WaveQueue.front();
-			bContinue = (m_WayLength[curBlock.x][curBlock.z] < m_NearestHole);
-		}
-
-		while(bContinue)
-		{
-			LOG_FLUID("while iteration" );
-			curBlock = m_WaveQueue.front();
-			UpdateWave(CornerGlobal, curBlock);
-			m_WaveQueue.pop();
-
-			bContinue = ( (!m_WaveQueue.empty()) && (m_WayLength[m_WaveQueue.front().x][m_WaveQueue.front().z] < m_NearestHole) );
-		}
-
-		
-
-		if(m_CurResult & E_SIDE_LEFT) Points.push_back(Vector3i( a_X-1, a_Y, a_Z ));
-		if(m_CurResult & E_SIDE_RIGHT) Points.push_back(Vector3i( a_X+1, a_Y, a_Z ));
-		if(m_CurResult & E_SIDE_FRONT) Points.push_back(Vector3i( a_X, a_Y, a_Z+1 ));
-		if(m_CurResult & E_SIDE_BACK) Points.push_back(Vector3i( a_X, a_Y, a_Z-1 ));
-
-		if(Points.empty())
-		{
-			Vector3i LevelPoints [] = {
-				Vector3i( a_X-1, a_Y, a_Z ),
-				Vector3i( a_X+1, a_Y, a_Z ),
-				Vector3i( a_X, a_Y, a_Z-1 ),
-				Vector3i( a_X, a_Y, a_Z+1 ),
-			};
-			for( int i = 0; i < 4; ++i )
-			{
-				char Block = m_World->GetBlock( LevelPoints[i].x, a_Y, LevelPoints[i].z );
-				if( m_Simulator->IsPassableForFluid(Block) )
-					Points.push_back( LevelPoints[i] );
-			}
-		}
-
-		return Points;
-	}
-
-	std::set< Vector3i >* m_ActiveFluid;
-	std::set< Vector3i >* m_Buffer;
-	cWorld* m_World;
-	cFluidSimulator *m_Simulator;
-
-	const static int AREA_WIDTH = 11; 
-
-	const static unsigned char E_SIDE_RIGHT = 0x10;
-	const static unsigned char E_SIDE_LEFT = 0x20;
-	const static unsigned char E_SIDE_FRONT = 0x40;
-	const static unsigned char E_SIDE_BACK = 0x80;
-	const static unsigned char E_SIDE_NONE = 0x00;
-
-	enum eRelief {E_HOLE = 0, E_PLAIN = 1, E_BLOCK = 2};
-
-	eRelief m_Relief[AREA_WIDTH][AREA_WIDTH];
-	unsigned char m_WayLength[AREA_WIDTH][AREA_WIDTH];
-	unsigned char m_StartSide[AREA_WIDTH][AREA_WIDTH];
-
-	std::queue<Vector3i> m_WaveQueue;
-
-	int m_NearestHole;
-	unsigned char m_CurResult;
-};
-
-
-
-
-
-cFluidSimulator::cFluidSimulator( cWorld* a_World )
-	: cSimulator(a_World)
-	, m_Data(0)
-{
-	m_Data = new FluidData(a_World, this);
-}
-
-
-
-
-
-cFluidSimulator::~cFluidSimulator()
-{
-	delete m_Data;
-}
-
-
-
-
-
-void cFluidSimulator::AddBlock( int a_X, int a_Y, int a_Z )
-{
-	char BlockType = m_World->GetBlock(a_X, a_Y, a_Z);
-	if (!IsAllowedBlock(BlockType))		//This should save very much time because it doesn´t have to iterate through all blocks
-	{
-		return;
-	}
-
-	std::set< Vector3i > & ActiveFluid = *m_Data->m_ActiveFluid;
-	ActiveFluid.insert( Vector3i( a_X, a_Y, a_Z ) );
-}
-
-
-
-
-
-char cFluidSimulator::GetHighestLevelAround( int a_X, int a_Y, int a_Z )
-{
-	char Max = m_MaxHeight + m_FlowReduction;
-
-#define __HIGHLEVEL_CHECK__( x, y, z ) \
-	if( IsAllowedBlock( m_World->GetBlock( x, y, z ) ) ) \
-	{ \
-		char Meta; \
-		if( (Meta = m_World->GetBlockMeta( x, y, z ) ) < Max ) Max = Meta; \
-		else if( Meta == m_MaxHeight + m_FlowReduction ) Max = 0; \
-		if( Max == 0 ) return 0; \
-	}
-
-	__HIGHLEVEL_CHECK__( a_X-1, a_Y, a_Z );
-	__HIGHLEVEL_CHECK__( a_X+1, a_Y, a_Z );
-	__HIGHLEVEL_CHECK__( a_X, a_Y, a_Z-1 );
-	__HIGHLEVEL_CHECK__( a_X, a_Y, a_Z+1 );
-
-	return Max;
-}
-
-
-
-
-
-void cFluidSimulator::Simulate( float a_Dt )
-{
-	m_Timer += a_Dt;
-
-	if (m_Data->m_ActiveFluid->empty())	//Nothing to do if there is no active fluid ;) saves very little time ;D
-	{
-		return;
-	}
-
-	std::swap( m_Data->m_ActiveFluid, m_Data->m_Buffer );	// Swap so blocks can be added to empty ActiveFluid array
-	m_Data->m_ActiveFluid->clear();
-
-	std::set< Vector3i > & FluidBlocks = *m_Data->m_Buffer;
-	for( std::set< Vector3i >::iterator itr = FluidBlocks.begin(); itr != FluidBlocks.end(); ++itr )
-	{
-		const Vector3i & pos = *itr;
-
-		if(UniqueSituation(pos))
-		{
-			continue;
-		}
-		
-		char BlockID = m_World->GetBlock( pos.x, pos.y, pos.z );
-		if( IsAllowedBlock( BlockID ) ) // only care about own fluid
-		{
-			bool bIsFed = false;
-			char Meta = m_World->GetBlockMeta( pos.x, pos.y, pos.z );
-			char Feed = Meta;
-			if( BlockID == m_StationaryFluidBlock) Meta = 0;
-			if( Meta == 8 ) // Falling fluid
-			{
-				if( IsAllowedBlock( m_World->GetBlock(pos.x, pos.y+1, pos.z) ) )	// Block above is fluid
-				{
-					bIsFed = true;
-					Meta = 0;	// Make it a full block
-				}
-			}
-			else if( Meta < m_FlowReduction ) // It's a full block, so it's always fed
-			{
-				bIsFed = true;
-			}
-			else
-			{
-				if( (Feed = GetHighestLevelAround( pos.x, pos.y, pos.z )) < Meta )
-					bIsFed = true;
-			}
-
-
-			if( bIsFed )
-			{
-				char DownID = m_World->GetBlock(pos.x, pos.y - 1, pos.z);
-				bool bWashedAwayItem = CanWashAway(DownID);
-				if ((IsPassableForFluid(DownID) || bWashedAwayItem) && !IsStationaryBlock(DownID) ) // free for fluid 
-				{
-					if (bWashedAwayItem)
-					{
-						cBlockHandler * Handler = BlockHandler(DownID);
-						if (Handler->DoesDropOnUnsuitable())
-						{
-							Handler->DropBlock(m_World, pos.x, pos.y - 1, pos.z);
-						}
-					}
-					if (pos.y > 0)
-					{
-						m_World->FastSetBlock( pos.x, pos.y-1, pos.z, m_FluidBlock, 8 ); // falling
-						AddBlock( pos.x, pos.y-1, pos.z );
-						ApplyUniqueToNearest(pos - Vector3i(0, 1, 0));
-					}
-				}
-				if(IsSolidBlock(DownID)||( BlockID == m_StationaryFluidBlock)) // Not falling
-				{
-					if( Feed + m_FlowReduction < Meta )
-					{
-						m_World->FastSetBlock( pos.x, pos.y, pos.z, m_FluidBlock, Feed + m_FlowReduction );
-						AddBlock( pos.x, pos.y, pos.z );
-						ApplyUniqueToNearest(pos);
-					}
-					else if(( Meta < m_MaxHeight )||( BlockID == m_StationaryFluidBlock)) // max is the lowest, so it cannot spread					
-					{
-						std::vector< Vector3i > Points = m_Data->GetLowestPoints( pos.x, pos.y, pos.z );
-						for( std::vector< Vector3i >::iterator itr = Points.begin(); itr != Points.end(); ++itr )
-						{
-							Vector3i & p = *itr;
-							char BlockID = m_World->GetBlock( p.x, p.y, p.z );
-							bool bWashedAwayItem = CanWashAway( BlockID );
-
-							if (!IsPassableForFluid(BlockID)) continue;
-
-							if (!IsAllowedBlock(BlockID))
-							{
-								if (bWashedAwayItem)
-								{
-									cBlockHandler * Handler = BlockHandler(DownID);
-									if (Handler->DoesDropOnUnsuitable())
-									{
-										Handler->DropBlock(m_World, p.x, p.y, p.z);
-									}
-								}
-
-								if (p.y == pos.y)
-								{
-									m_World->FastSetBlock(p.x, p.y, p.z, m_FluidBlock, Meta + m_FlowReduction);
-								}
-								else
-								{
-									m_World->FastSetBlock(p.x, p.y, p.z, m_FluidBlock, 8);
-								}
-								AddBlock( p.x, p.y, p.z );
-								ApplyUniqueToNearest(p);
-							}
-							else // it's fluid
-							{
-								char PointMeta = m_World->GetBlockMeta( p.x, p.y, p.z );
-								if( PointMeta > Meta + m_FlowReduction )
-								{
-									AddBlock( p.x, p.y, p.z );
-									ApplyUniqueToNearest(p);
-								}
-							}
-						}
-					}
-				}
-			}
-			else// not fed
-			{
-				m_World->FastSetBlock( pos.x, pos.y, pos.z, E_BLOCK_AIR, 0 );
-				WakeUp( pos.x, pos.y, pos.z );
-			}
-		}
-	}
-}
-
-
-
-
-
-bool cFluidSimulator::IsPassableForFluid(BLOCKTYPE a_BlockType)
-{
-	return a_BlockType == E_BLOCK_AIR
-		|| a_BlockType == E_BLOCK_FIRE
-		|| IsAllowedBlock(a_BlockType)
-		|| CanWashAway(a_BlockType);
-}
-
-
-
-
-
-bool cFluidSimulator::IsStationaryBlock (BLOCKTYPE a_BlockType)
-{
-	return a_BlockType == m_StationaryFluidBlock;
-}
-
-
-
-
-
-bool cFluidSimulator::CanWashAway( BLOCKTYPE a_BlockType )
-{
-	switch( a_BlockType )
-	{
-	case E_BLOCK_YELLOW_FLOWER:
-	case E_BLOCK_RED_ROSE:
-	case E_BLOCK_RED_MUSHROOM:
-	case E_BLOCK_BROWN_MUSHROOM:
-	case E_BLOCK_CACTUS:
-		return true;
-	default:
-		return false;
-	};
-}
-
-
-
-
-
-bool cFluidSimulator::IsSolidBlock( BLOCKTYPE a_BlockType )
-{
-	return !(a_BlockType == E_BLOCK_AIR
-		|| a_BlockType == E_BLOCK_FIRE
-		|| IsBlockLava(a_BlockType)
-		|| IsBlockWater(a_BlockType)
-		|| CanWashAway(a_BlockType));
-}
-
-
-
-
-
-//TODO Not working very well yet :s
-Direction cFluidSimulator::GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over)
-{
-	char BlockID = m_World->GetBlock(a_X, a_Y, a_Z);
-	if(!IsAllowedBlock(BlockID))	//No Fluid -> No Flowing direction :D
-		return NONE;
-	
-
-	/*
-	Disabled because of causing problems and beeing useless atm
-	char BlockBelow = m_World->GetBlock(a_X, a_Y - 1, a_Z);		//If there is nothing or fluid below it -> dominating flow is down :D
-	if(BlockBelow == E_BLOCK_AIR || IsAllowedBlock(BlockBelow))
-		return Y_MINUS;
-	*/
-
-	char LowestPoint = m_World->GetBlockMeta(a_X, a_Y, a_Z);	//Current Block Meta so only lower points will be counted
-	int X = 0, Y = 0, Z = 0;									//Lowest Pos will be stored here
-
-	if(IsAllowedBlock(m_World->GetBlock(a_X, a_Y + 1, a_Z)) && a_Over)		//check for upper block to flow because this also affects the flowing direction
-	{
-		return GetFlowingDirection(a_X, a_Y + 1, a_Z, false);
-	}
-
-	std::vector< Vector3i * > Points;
-
-	Points.reserve(4);	//Already allocate 4 places :D
-
-	//add blocks around the checking pos
-	Points.push_back(new Vector3i(a_X - 1, a_Y, a_Z));
-	Points.push_back(new Vector3i(a_X + 1, a_Y, a_Z));
-	Points.push_back(new Vector3i(a_X, a_Y, a_Z + 1));
-	Points.push_back(new Vector3i(a_X, a_Y, a_Z - 1));
-
-	for(std::vector<Vector3i *>::iterator it = Points.begin(); it < Points.end(); it++)
-	{
-		Vector3i *Pos = (*it);
-		char BlockID = m_World->GetBlock(Pos->x, Pos->y, Pos->z);
-		if(IsAllowedBlock(BlockID))
-		{
-			char Meta = m_World->GetBlockMeta(Pos->x, Pos->y, Pos->z);
-
-			if(Meta > LowestPoint)
-			{
-				LowestPoint = Meta;
-				X = Pos->x;
-				Y = Pos->y;
-				Z = Pos->z;
-			}
-		}else if(BlockID == E_BLOCK_AIR)
-		{
-			LowestPoint = 9;		//This always dominates
-			X = Pos->x;
-			Y = Pos->y;
-			Z = Pos->z;
-		
-		}
-		delete Pos;
-	}
-
-	if(LowestPoint == m_World->GetBlockMeta(a_X, a_Y, a_Z))
-		return NONE;
-
-	if(a_X - X > 0)
-	{
-		return X_MINUS;
-	}
-
-	if(a_X - X < 0)
-	{
-		return X_PLUS;
-	}
-
-	if(a_Z - Z > 0)
-	{
-		return Z_MINUS;
-	}
-
-	if(a_Z - Z < 0)
-	{
-		return Z_PLUS;
-	}
-
-	return NONE;
-}
-
-
-
-
-
-bool cFluidSimulator::UniqueSituation(Vector3i a_Pos)
-{
-	bool result = false;
-
-	char BlockId = m_World->GetBlock( a_Pos.x, a_Pos.y, a_Pos.z );
-	char Meta = m_World->GetBlockMeta( a_Pos.x, a_Pos.y, a_Pos.z );
-
-	if(IsBlockWater(BlockId))
-	{
-
-		char UpperBlock = m_World->GetBlock( a_Pos.x, a_Pos.y + 1, a_Pos.z );
-		if(IsBlockLava(UpperBlock))
-		{
-			m_World->SetBlock(a_Pos.x, a_Pos.y, a_Pos.z, E_BLOCK_STONE, 0);
-		}
-
-	
-		if(BlockId != E_BLOCK_STATIONARY_WATER)
-		{
-			char DownBlockId = m_World->GetBlock( a_Pos.x, a_Pos.y-1, a_Pos.z );
-			if(IsSolidBlock(DownBlockId))
-			{
-				Vector3i LevelPoints [] = {
-						Vector3i( a_Pos.x-1, a_Pos.y, a_Pos.z ),
-						Vector3i( a_Pos.x+1, a_Pos.y, a_Pos.z ),
-						Vector3i( a_Pos.x, a_Pos.y, a_Pos.z-1 ),
-						Vector3i( a_Pos.x, a_Pos.y, a_Pos.z+1 ),
-				};
-				int SourceBlocksCount = 0;
-				for(int i=0; i<4; i++)
-				{
-					if (m_World->GetBlock(LevelPoints[i].x, LevelPoints[i].y, LevelPoints[i].z)==E_BLOCK_STATIONARY_WATER)
-					{
-						SourceBlocksCount++;
-					}
-				}
-				if(SourceBlocksCount>=2)
-				{
-					m_World->SetBlock(a_Pos.x, a_Pos.y, a_Pos.z, E_BLOCK_STATIONARY_WATER, 0);
-				}
-			}
-
-		}
-	}
-
-	if(IsBlockLava(BlockId))
-	{
-		bool bWater = false;
-
-		char UpperBlock = m_World->GetBlock( a_Pos.x, a_Pos.y + 1, a_Pos.z );
-		if (IsBlockWater(UpperBlock))
-		{
-			bWater = true;
-		}
-		else
-		{
-			Vector3i LevelPoints [] = {
-					Vector3i( a_Pos.x-1, a_Pos.y, a_Pos.z ),
-					Vector3i( a_Pos.x+1, a_Pos.y, a_Pos.z ),
-					Vector3i( a_Pos.x, a_Pos.y, a_Pos.z-1 ),
-					Vector3i( a_Pos.x, a_Pos.y, a_Pos.z+1 ),
-			};
-
-			for(int i=0; i<4; i++)
-			{
-				if (IsBlockWater(m_World->GetBlock(LevelPoints[i].x, LevelPoints[i].y, LevelPoints[i].z)))
-				{
-					bWater = true;
-				}
-			}
-		}
-
-
-		if(bWater)
-		{
-			if(BlockId == E_BLOCK_STATIONARY_LAVA)
-			{
-				m_World->SetBlock(a_Pos.x, a_Pos.y, a_Pos.z, E_BLOCK_OBSIDIAN, 0);
-			}
-			else if (Meta<m_MaxHeight)
-			{
-				m_World->SetBlock(a_Pos.x, a_Pos.y, a_Pos.z, E_BLOCK_COBBLESTONE, 0);
-			}
-		}
-	}
-
-	return result;
-}
-
-
-
-
-
-void cFluidSimulator::ApplyUniqueToNearest(Vector3i a_Pos)
-{
-	Vector3i NearPoints [] = {
-			Vector3i( a_Pos.x-1, a_Pos.y, a_Pos.z ),
-			Vector3i( a_Pos.x+1, a_Pos.y, a_Pos.z ),
-			Vector3i( a_Pos.x, a_Pos.y, a_Pos.z-1 ),
-			Vector3i( a_Pos.x, a_Pos.y, a_Pos.z+1 ),
-			Vector3i( a_Pos.x, a_Pos.y-1, a_Pos.z )
-	};
-
-	for(int i=0; i<5; i++)
-	{
-		UniqueSituation(NearPoints[i]);
-	}
-}
-
-
-
-
diff --git a/source/FluidSimulator.h b/source/FluidSimulator.h
deleted file mode 100644
index 09d9520ef..000000000
--- a/source/FluidSimulator.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include "Simulator.h"
-#include "Vector3i.h"
-
-
-//TODO This definitly needs a better naming :D but how?
-enum Direction
-{
-	X_PLUS,
-	X_MINUS,
-	Y_PLUS,
-	Y_MINUS,
-	Z_PLUS,
-	Z_MINUS,
-	NONE
-};
-
-class Vector3i;
-class cWorld;
-class cFluidSimulator : public cSimulator
-{
-public:
-	cFluidSimulator( cWorld* a_World );
-	~cFluidSimulator();
-
-	virtual void Simulate( float a_Dt );
-
-	//Gets the flowing direction. if a_Over is true also the block over the current block affects the direction (standard)
-	Direction GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over = true);
-
-	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) = 0;
-	virtual bool IsStationaryBlock( BLOCKTYPE a_BlockType);
-	virtual bool IsPassableForFluid( BLOCKTYPE a_BlockType );
-	bool CanWashAway( BLOCKTYPE a_BlockType );
-	bool IsSolidBlock(BLOCKTYPE a_BlockType);
-protected:
-	virtual void AddBlock( int a_X, int a_Y, int a_Z);
-	char GetHighestLevelAround( int a_X, int a_Y, int a_Z );
-
-	bool UniqueSituation(Vector3i a_Pos); //Applys special for this fluid rules like generation of water betwin sources, returns false if it is necessary to apply general rules
-	void ApplyUniqueToNearest(Vector3i a_Pos);
-
-	float m_Timer;
-
-	class FluidData;
-	FluidData* m_Data;
-
-	//Customize
-	BLOCKTYPE m_FluidBlock;
-	BLOCKTYPE m_StationaryFluidBlock;
-	char m_MaxHeight;
-	char m_FlowReduction;
-
-};
\ No newline at end of file
diff --git a/source/Globals.h b/source/Globals.h
index 01b118cf8..40e80bd79 100644
--- a/source/Globals.h
+++ b/source/Globals.h
@@ -159,6 +159,8 @@ typedef unsigned short     UInt16;
 #include <map>
 #include <algorithm>
 #include <memory>
+#include <set>
+#include <queue>
 
 
 
diff --git a/source/Pickup.cpp b/source/Pickup.cpp
index 8a32a328b..ea1f603a4 100644
--- a/source/Pickup.cpp
+++ b/source/Pickup.cpp
@@ -9,7 +9,7 @@
 #include "ClientHandle.h"
 #include "Inventory.h"
 #include "World.h"
-#include "WaterSimulator.h"
+#include "Simulator/FluidSimulator.h"
 #include "Server.h"
 #include "Player.h"
 #include "PluginManager.h"
@@ -157,11 +157,9 @@ void cPickup::HandlePhysics(float a_Dt)
 		if( fabs(m_Speed.z) < 0.05 ) m_Speed.z = 0;
 	}
 
-
-	//get flowing direction
+	// get flowing direction
 	Direction WaterDir = World->GetWaterSimulator()->GetFlowingDirection((int) m_Pos.x - 1, (int) m_Pos.y, (int) m_Pos.z - 1);
 
-
 	m_WaterSpeed *= 0.9f;		//Keep old speed but lower it
 
 	switch(WaterDir)
diff --git a/source/Simulator.cpp b/source/Simulator.cpp
deleted file mode 100644
index e4608e150..000000000
--- a/source/Simulator.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-
-#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_X, int a_Y, int a_Z )
-{
-	AddBlock( a_X, a_Y, a_Z );
-	AddBlock( a_X-1, a_Y, a_Z );
-	AddBlock( a_X+1, a_Y, a_Z );
-	AddBlock( a_X, a_Y-1, a_Z );
-	AddBlock( a_X, a_Y+1, a_Z );
-	AddBlock( a_X, a_Y, a_Z-1 );
-	AddBlock( a_X, a_Y, a_Z+1 );
-}
diff --git a/source/Simulator.h b/source/Simulator.h
deleted file mode 100644
index 00e1b5a0c..000000000
--- a/source/Simulator.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-class Vector3i;
-class cWorld;
-class cSimulator
-{
-public:
-	cSimulator( cWorld* a_World );
-	~cSimulator();
-
-	virtual void Simulate( float a_Dt ) = 0;
-	virtual void WakeUp( int a_X, int a_Y, int a_Z );
-
-	virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) = 0;
-
-protected:
-	virtual void AddBlock(int a_X, int a_Y, int a_Z) = 0;
-
-	cWorld * m_World;
-};
\ No newline at end of file
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/FireSimulator.cpp b/source/Simulator/FireSimulator.cpp
index 1dc104d0c..c2f22668b 100644
--- a/source/FireSimulator.cpp
+++ b/source/Simulator/FireSimulator.cpp
@@ -2,10 +2,13 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "FireSimulator.h"
-#include "World.h"
-#include "Vector3i.h"
-#include "BlockID.h"
-#include "Defines.h"
+#include "../World.h"
+#include "../BlockID.h"
+#include "../Defines.h"
+
+
+
+
 
 cFireSimulator::cFireSimulator( cWorld* a_World )
 	: cSimulator(a_World)
@@ -13,9 +16,12 @@ cFireSimulator::cFireSimulator( cWorld* a_World )
 	, m_Buffer(new BlockList)
 	, m_BurningBlocks(new BlockList)
 {
-
 }
 
+
+
+
+
 cFireSimulator::~cFireSimulator()
 {
 	delete m_Buffer;
@@ -23,6 +29,10 @@ cFireSimulator::~cFireSimulator()
 	delete m_BurningBlocks;
 }
 
+
+
+
+
 void cFireSimulator::Simulate( float a_Dt )
 {
 	m_Buffer->clear();
@@ -48,12 +58,19 @@ void cFireSimulator::Simulate( float a_Dt )
 }
 
 
+
+
+
 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);
@@ -72,17 +89,29 @@ void cFireSimulator::AddBlock(int a_X, int a_Y, int 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
@@ -95,11 +124,19 @@ bool cFireSimulator::IsBurnable( BLOCKTYPE a_BlockType )
 		|| 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)
@@ -110,6 +147,10 @@ bool cFireSimulator::BurnBlockAround(int a_X, int a_Y, int a_Z)
 		|| 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);
@@ -130,4 +171,8 @@ bool cFireSimulator::BurnBlock(int a_X, int a_Y, int a_Z)
 	}
 
 	return false;
-}
\ No newline at end of file
+}
+
+
+
+
diff --git a/source/FireSimulator.h b/source/Simulator/FireSimulator.h
index 90e6a6062..753259c2c 100644
--- a/source/FireSimulator.h
+++ b/source/Simulator/FireSimulator.h
@@ -2,14 +2,7 @@
 #pragma once
 
 #include "Simulator.h"
-#include "BlockEntity.h"
-
-
-
-
-
-class Vector3i;
-class cWorld;
+#include "../BlockEntity.h"
 
 
 
@@ -31,7 +24,7 @@ public:
 
 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);
+	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);
 
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/LavaSimulator.cpp b/source/Simulator/LavaSimulator.cpp
index 726cc37e4..726cc37e4 100644
--- a/source/LavaSimulator.cpp
+++ b/source/Simulator/LavaSimulator.cpp
diff --git a/source/LavaSimulator.h b/source/Simulator/LavaSimulator.h
index d85b335b7..d85b335b7 100644
--- a/source/LavaSimulator.h
+++ b/source/Simulator/LavaSimulator.h
diff --git a/source/RedstoneSimulator.cpp b/source/Simulator/RedstoneSimulator.cpp
index 6c3e27228..1c30be324 100644
--- a/source/RedstoneSimulator.cpp
+++ b/source/Simulator/RedstoneSimulator.cpp
@@ -2,10 +2,10 @@
 #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"
+#include "../Piston.h"
+#include "../World.h"
+#include "../BlockID.h"
+#include "../Torch.h"
 
 
 
diff --git a/source/RedstoneSimulator.h b/source/Simulator/RedstoneSimulator.h
index c1996bb4e..f26b6b46b 100644
--- a/source/RedstoneSimulator.h
+++ b/source/Simulator/RedstoneSimulator.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "Simulator.h"
-#include "Vector3i.h"
 
 
 
diff --git a/source/SandSimulator.cpp b/source/Simulator/SandSimulator.cpp
index a2e1dc4cb..69513afef 100644
--- a/source/SandSimulator.cpp
+++ b/source/Simulator/SandSimulator.cpp
@@ -2,11 +2,10 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "SandSimulator.h"
-#include "World.h"
-#include "Vector3i.h"
-#include "BlockID.h"
-#include "Defines.h"
-#include "FallingBlock.h"
+#include "../World.h"
+#include "../BlockID.h"
+#include "../Defines.h"
+#include "../FallingBlock.h"
 
 
 
diff --git a/source/SandSimulator.h b/source/Simulator/SandSimulator.h
index ff39d62b2..928ea63fc 100644
--- a/source/SandSimulator.h
+++ b/source/Simulator/SandSimulator.h
@@ -2,14 +2,8 @@
 #pragma once
 
 #include "Simulator.h"
-#include "BlockEntity.h"
-#include "Vector3i.h"
-
-
-
-
-
-class cWorld;
+#include "../BlockEntity.h"
+#include "../Vector3i.h"
 
 
 
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/SimulatorManager.cpp b/source/Simulator/SimulatorManager.cpp
index 0aef1ec6c..1ab7a51b5 100644
--- a/source/SimulatorManager.cpp
+++ b/source/Simulator/SimulatorManager.cpp
@@ -42,11 +42,11 @@ void cSimulatorManager::Simulate( float a_Dt )
 
 
 
-void cSimulatorManager::WakeUp(int a_X, int a_Y, int a_Z)
+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_X, a_Y, a_Z);
+		(*itr)->first->WakeUp(a_BlockX, a_BlockY, a_BlockZ);
 	}
 }
 
diff --git a/source/SimulatorManager.h b/source/Simulator/SimulatorManager.h
index e90acffab..e90acffab 100644
--- a/source/SimulatorManager.h
+++ b/source/Simulator/SimulatorManager.h
diff --git a/source/WaterSimulator.cpp b/source/Simulator/WaterSimulator.cpp
index c63135419..c63135419 100644
--- a/source/WaterSimulator.cpp
+++ b/source/Simulator/WaterSimulator.cpp
diff --git a/source/WaterSimulator.h b/source/Simulator/WaterSimulator.h
index 4bc35b8f7..4bc35b8f7 100644
--- a/source/WaterSimulator.h
+++ b/source/Simulator/WaterSimulator.h
diff --git a/source/World.cpp b/source/World.cpp
index 7180213fe..f932c7c04 100644
--- a/source/World.cpp
+++ b/source/World.cpp
@@ -12,12 +12,14 @@
 #include "Root.h"
 #include "../iniFile/iniFile.h"
 #include "ChunkMap.h"
-#include "SimulatorManager.h"
-#include "WaterSimulator.h"
-#include "LavaSimulator.h"
-#include "FireSimulator.h"
-#include "SandSimulator.h"
-#include "RedstoneSimulator.h"
+
+// Simulators:
+#include "Simulator/SimulatorManager.h"
+#include "Simulator/ClassicFluidSimulator.h"
+#include "Simulator/FluidSimulator.h"
+#include "Simulator/FireSimulator.h"
+#include "Simulator/SandSimulator.h"
+#include "Simulator/RedstoneSimulator.h"
 
 // Mobs:
 #include "Mobs/Chicken.h"
@@ -288,11 +290,11 @@ cWorld::cWorld( const AString & a_WorldName )
 	m_BlockTickQueue.reserve(1000);
 	m_BlockTickQueueCopy.reserve(1000);
 
-	//Simulators:
-	m_WaterSimulator = new cWaterSimulator( this );
-	m_LavaSimulator = new cLavaSimulator( this );
-	m_SandSimulator = new cSandSimulator(this);
-	m_FireSimulator = new cFireSimulator(this);
+	// Simulators:
+	m_WaterSimulator    = InitializeFluidSimulator(IniFile, "Water", E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER);
+	m_LavaSimulator     = InitializeFluidSimulator(IniFile, "Lava",  E_BLOCK_LAVA,  E_BLOCK_STATIONARY_LAVA);
+	m_SandSimulator     = new cSandSimulator(this);
+	m_FireSimulator     = new cFireSimulator(this);
 	m_RedstoneSimulator = new cRedstoneSimulator(this);
 
 	m_SimulatorManager = new cSimulatorManager();
@@ -2153,3 +2155,44 @@ bool cWorld::IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 
 
+cFluidSimulator * cWorld::InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock)
+{
+	AString SimulatorNameKey;
+	Printf(SimulatorNameKey, "%sSimulator", a_FluidName);
+	AString SimulatorSectionName;
+	Printf(SimulatorSectionName, "%sSimulator", a_FluidName);
+	AString SimulatorName = a_IniFile.GetValue("Physics", SimulatorNameKey, "");
+	if (SimulatorName.empty())
+	{
+		LOGWARNING("%s [Physics]:%s not present or empty, using the default of \"Classic\".", GetIniFileName().c_str(), SimulatorNameKey.c_str());
+		SimulatorName = "Classic";
+	}
+	
+	cFluidSimulator * res = NULL;
+	/*
+	// TODO: other fluid simulators
+	if (NoCaseCompare(SimulatorName, "floody") == 0)
+	{
+		// TODO: Floody simulator params
+		res = new cFloodyFluidSimulator(this, a_SimulateBlock, a_StationaryBlock);
+	}
+	else
+	*/
+	{
+		if (NoCaseCompare(SimulatorName, "classic") != 0)
+		{
+			// The simulator name doesn't match anything we have, issue a warning:
+			LOGWARNING("%s [Physics]:%s specifies an unknown simulator, using the default \"Classic\".", GetIniFileName().c_str(), SimulatorNameKey.c_str());
+		}
+		int DefaultFalloff   = (strcmp(a_FluidName, "Water") == 0) ? 1 : 2;
+		int DefaultMaxHeight = (strcmp(a_FluidName, "Water") == 0) ? 7 : 6;
+		int Falloff   = a_IniFile.GetValueI(SimulatorSectionName, "Falloff",   DefaultFalloff);
+		int MaxHeight = a_IniFile.GetValueI(SimulatorSectionName, "MaxHeight", DefaultMaxHeight);
+		res = new cClassicFluidSimulator(this, a_SimulateBlock, a_StationaryBlock, MaxHeight, Falloff);
+	}
+	
+	return res;
+}
+
+
+
diff --git a/source/World.h b/source/World.h
index f3117fe55..913d28f5b 100644
--- a/source/World.h
+++ b/source/World.h
@@ -9,7 +9,7 @@
 
 #define MAX_PLAYERS 65535
 
-#include "SimulatorManager.h"
+#include "Simulator/SimulatorManager.h"
 #include "MersenneTwister.h"
 #include "ChunkMap.h"
 #include "WorldStorage/WorldStorage.h"
@@ -27,8 +27,7 @@
 
 class cRedstone;
 class cFireSimulator;
-class cWaterSimulator;
-class cLavaSimulator;
+class cFluidSimulator;
 class cSandSimulator;
 class cRedstoneSimulator;
 class cItem;
@@ -279,9 +278,10 @@ public:
 	const double & GetSpawnY(void) const { return m_SpawnY; }														// tolua_export
 	const double & GetSpawnZ(void) const { return m_SpawnZ; }														// tolua_export
 
-	inline cSimulatorManager *GetSimulatorManager() { return m_SimulatorManager; }
-	inline cWaterSimulator *GetWaterSimulator() { return m_WaterSimulator; }
-	inline cLavaSimulator *GetLavaSimulator() { return m_LavaSimulator; }
+	inline cSimulatorManager * GetSimulatorManager(void) { return m_SimulatorManager; }
+	
+	inline cFluidSimulator * GetWaterSimulator(void) { return m_WaterSimulator; }
+	inline cFluidSimulator * GetLavaSimulator (void) { return m_LavaSimulator; }
 
 	/// Calls the callback for each chest in the specified chunk; returns true if all chests processed, false if the callback aborted by returning true
 	bool ForEachChestInChunk  (int a_ChunkX, int a_ChunkZ, cChestCallback &   a_Callback);  // Exported in ManualBindings.cpp
@@ -429,8 +429,8 @@ private:
 
 	cSimulatorManager *  m_SimulatorManager;
 	cSandSimulator *     m_SandSimulator;
-	cWaterSimulator *    m_WaterSimulator;
-	cLavaSimulator *     m_LavaSimulator;
+	cFluidSimulator *    m_WaterSimulator;
+	cFluidSimulator *    m_LavaSimulator;
 	cFireSimulator *     m_FireSimulator;
 	cRedstoneSimulator * m_RedstoneSimulator;
 	
@@ -488,6 +488,9 @@ private:
 	void TickSpawnMobs(float a_Dt);  // Handles mob spawning each tick
 	
 	void RemoveEntity( cEntity * a_Entity );
+	
+	/// Creates a new fluid simulator, loads its settings from the inifile (a_FluidName section)
+	cFluidSimulator * InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock);
 }; //tolua_export