7 files changed, 338 insertions, 58 deletions

diff --git a/source/Vector3i.h b/source/Vector3i.h
index 676e7ba21..7fbd74b5a 100644
--- a/source/Vector3i.h
+++ b/source/Vector3i.h
@@ -32,6 +32,7 @@ public:			//tolua_export
 	friend Vector3i operator * ( const Vector3i& v, const int f ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }

 	friend Vector3i operator * ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x * v2.x, v1.y * v2.y, v1.z * v2.z ); }

 	friend Vector3i operator * ( const int f, const Vector3i& v ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }

+	friend bool operator < ( const Vector3i& v1, const Vector3i& v2 ) { return (v1.x<v2.x)||(v1.x==v2.x && v1.y<v2.y)||(v1.x==v2.x && v1.y == v2.y && v1.z<v2.z); }

 

 	int x, y, z;	//tolua_export

 };	//tolua_export
\ No newline at end of file
diff --git a/source/cFluidSimulator.cpp b/source/cFluidSimulator.cpp
index e4f0aa85a..2d8952a05 100644
--- a/source/cFluidSimulator.cpp
+++ b/source/cFluidSimulator.cpp
@@ -1,21 +1,29 @@
-

-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

-

+#include "Globals.h"

 #include "cFluidSimulator.h"

 #include "cWorld.h"

 #include "Vector3i.h"

 #include "BlockID.h"

 #include "Defines.h"

+#include <set>

 #include "cPickup.h"

 #include "cItem.h"

+#include <queue>

+

+//#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::list < Vector3i >() )

+		: m_ActiveFluid( new std::set < Vector3i >() )

 		, m_Simulator (a_Simulator)

-		, m_Buffer( new std::list< Vector3i >() )

+		, m_Buffer( new std::set< Vector3i >() )

 		, m_World( a_World )

 	{}

 

@@ -25,39 +33,156 @@ public:
 		delete m_ActiveFluid;

 	}

 

-	std::vector< Vector3i > GetLowestPoints( int a_X, int a_Y, int a_Z )

+	void UpdateWave(Vector3i a_LeftCorner, Vector3i a_CurBlock)

 	{

-		std::vector< Vector3i > Points;

-		if( m_World->GetBlock(a_X, a_Y-1, a_Z) == E_BLOCK_AIR )

+		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++)

 		{

-			Points.push_back( Vector3i( a_X, a_Y-1, a_Z ) );

-			return Points;

+			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]);

+				}

+			}

 		}

+	}

 

-		Vector3i LowerPoints [] = {

-			Vector3i( a_X-1, a_Y-1, a_Z ),

-			Vector3i( a_X+1, a_Y-1, a_Z ),

-			Vector3i( a_X, a_Y-1, a_Z-1 ),

-			Vector3i( a_X, a_Y-1, a_Z+1 ),

-		};

-		bool bFluidFound = false;

-		for( int i = 0; i < 4; ++i )

+	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++) 

 		{

-			char Block1 = m_World->GetBlock( LowerPoints[i].x, LowerPoints[i].y, LowerPoints[i].z );

-			char Block2 = m_World->GetBlock( LowerPoints[i].x, a_Y, LowerPoints[i].z );

-			if( Block1 == E_BLOCK_AIR && Block2 == E_BLOCK_AIR )

+			for(int z=0; z<AREA_WIDTH; z++)

 			{

-				Points.push_back( LowerPoints[i] );

-				LowerPoints[i].y = a_Y;

-				Points.push_back( LowerPoints[i] );

+				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;

 			}

-			else if( m_Simulator->IsAllowedBlock(Block2) && m_Simulator->IsPassableForFluid(Block1) )

+			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])

 			{

-				bFluidFound = true;

+				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]));

+				}

 			}

 		}

 

-		if( Points.size() == 0 && !bFluidFound )

+		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 ),

@@ -72,13 +197,35 @@ public:
 					Points.push_back( LevelPoints[i] );

 			}

 		}

+

 		return Points;

+

+

 	}

 

-	std::list< Vector3i >* m_ActiveFluid;

-	std::list< Vector3i >* m_Buffer;

+	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 )

@@ -98,28 +245,20 @@ void cFluidSimulator::AddBlock( int a_X, int a_Y, int a_Z )
 	if(!IsAllowedBlock(m_World->GetBlock(a_X, a_Y, a_Z)))		//This should save very much time because it doesn´t have to iterate through all blocks

 		return;

 

-	// Check for duplicates

-	std::list< Vector3i > & ActiveFluid = *m_Data->m_ActiveFluid;

-	for( std::list< Vector3i >::iterator itr = ActiveFluid.begin(); itr != ActiveFluid.end(); ++itr )

-	{

-		Vector3i & Pos = *itr;

-		if( Pos.x == a_X && Pos.y == a_Y && Pos.z == a_Z )

-			return;

-	}

-

-	ActiveFluid.push_back( Vector3i( a_X, a_Y, a_Z ) );

+	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 + 1;

+	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 + 1 ) Max = 0; \

+		else if( Meta == m_MaxHeight + m_FlowReduction ) Max = 0; \

 		if( Max == 0 ) return 0; \

 	}

 

@@ -141,18 +280,24 @@ void cFluidSimulator::Simulate( float a_Dt )
 	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::list< Vector3i > & FluidBlocks = *m_Data->m_Buffer;

-	for( std::list< Vector3i >::iterator itr = FluidBlocks.begin(); itr != FluidBlocks.end(); ++itr )

+	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;

+		}

 		

-		Vector3i & pos = *itr;

 		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( Meta & 8 ) // Falling fluid

+			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

 				{

@@ -175,7 +320,7 @@ void cFluidSimulator::Simulate( float a_Dt )
 			{

 				char DownID = m_World->GetBlock( pos.x, pos.y-1, pos.z );

 				bool bWashedAwayItem = CanWashAway( DownID );

-				if( IsPassableForFluid(DownID) || bWashedAwayItem ) // free for fluid 

+				if( (IsPassableForFluid(DownID) || bWashedAwayItem)&&!IsStationaryBlock(DownID) ) // free for fluid 

 				{

 					if( bWashedAwayItem )

 					{

@@ -185,15 +330,17 @@ void cFluidSimulator::Simulate( float a_Dt )
 

 					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));

 				}

-				else // Not falling

+				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 ) // max is the lowest, so it cannot spread

+					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 )

@@ -201,6 +348,9 @@ void cFluidSimulator::Simulate( float a_Dt )
 							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 )

@@ -210,10 +360,15 @@ void cFluidSimulator::Simulate( float a_Dt )
 								}

 

 								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

 							{

@@ -221,13 +376,14 @@ void cFluidSimulator::Simulate( float a_Dt )
 								if( PointMeta > Meta + m_FlowReduction )

 								{

 									AddBlock( p.x, p.y, p.z );

+									ApplyUniqueToNearest(p);

 								}

 							}

 						}

 					}

 				}

 			}

-			else // not fed

+			else// not fed

 			{

 				m_World->FastSetBlock( pos.x, pos.y, pos.z, E_BLOCK_AIR, 0 );

 				WakeUp( pos.x, pos.y, pos.z );

@@ -245,6 +401,11 @@ bool cFluidSimulator::IsPassableForFluid(char a_BlockID)
 		|| CanWashAway(a_BlockID);

 }

 

+bool cFluidSimulator::IsStationaryBlock (char a_BlockID)

+{

+	return a_BlockID == m_StationaryFluidBlock;

+}

+

 bool cFluidSimulator::CanWashAway( char a_BlockID )

 {

 	switch( a_BlockID )

@@ -260,6 +421,15 @@ bool cFluidSimulator::CanWashAway( char a_BlockID )
 	};

 }

 

+bool cFluidSimulator::IsSolidBlock( char a_BlockID )

+{

+	return !(a_BlockID == E_BLOCK_AIR

+		|| a_BlockID == E_BLOCK_FIRE

+		|| IsBlockLava(a_BlockID)

+		|| IsBlockWater(a_BlockID)

+		|| CanWashAway(a_BlockID));

+}

+

 //TODO Not working very well yet :s

 Direction cFluidSimulator::GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over)

 {

@@ -346,4 +516,109 @@ Direction cFluidSimulator::GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a
 	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]);

+	}

 }
\ No newline at end of file
diff --git a/source/cFluidSimulator.h b/source/cFluidSimulator.h
index d4379623d..afacea5f7 100644
--- a/source/cFluidSimulator.h
+++ b/source/cFluidSimulator.h
@@ -1,6 +1,7 @@
 #pragma once

 

 #include "cSimulator.h"

+#include "Vector3i.h"

 

 

 //TODO This definitly needs a better naming :D but how?

@@ -29,12 +30,16 @@ public:
 	Direction GetFlowingDirection(int a_X, int a_Y, int a_Z, bool a_Over = true);

 

 	virtual bool IsAllowedBlock( char a_BlockID ) = 0;

+	virtual bool IsStationaryBlock( char a_BlockID);

 	virtual bool IsPassableForFluid( char a_BlockID );

 	bool CanWashAway( char a_BlockID );

+	bool IsSolidBlock(char a_BlockID);

 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;

 

@@ -43,6 +48,7 @@ protected:
 

 	//Customize

 	char m_FluidBlock;

+	char m_StationaryFluidBlock;

 	char m_MaxHeight;

 	char m_FlowReduction;

 

diff --git a/source/cLavaSimulator.cpp b/source/cLavaSimulator.cpp
index ea637ce3c..ad9afcdc8 100644
--- a/source/cLavaSimulator.cpp
+++ b/source/cLavaSimulator.cpp
@@ -1,14 +1,14 @@
-

-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

-

+#include "Globals.h"

 #include "cLavaSimulator.h"

 #include "Defines.h"

+#include "cWorld.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;

 }

diff --git a/source/cLavaSimulator.h b/source/cLavaSimulator.h
index f0bfacb38..aa20b4d1d 100644
--- a/source/cLavaSimulator.h
+++ b/source/cLavaSimulator.h
@@ -7,5 +7,6 @@ public:
 	cLavaSimulator( cWorld* a_World );

 

 	virtual bool IsAllowedBlock( char a_BlockID );

+	

 

 };
\ No newline at end of file
diff --git a/source/cWaterSimulator.cpp b/source/cWaterSimulator.cpp
index 823c6c587..22f4ece00 100644
--- a/source/cWaterSimulator.cpp
+++ b/source/cWaterSimulator.cpp
@@ -1,10 +1,7 @@
-

-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

-

+#include "Globals.h"

 #include "cWaterSimulator.h"

 #include "Defines.h"

-

-

+#include "cWorld.h"

 

 

 

@@ -12,6 +9,7 @@ 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;

 }

diff --git a/source/cWaterSimulator.h b/source/cWaterSimulator.h
index f43a5eeef..c00481482 100644
--- a/source/cWaterSimulator.h
+++ b/source/cWaterSimulator.h
@@ -1,5 +1,4 @@
 #pragma once

-

 #include "cFluidSimulator.h"

 

 class cWaterSimulator : public cFluidSimulator