1 files changed, 116 insertions, 99 deletions

diff --git a/source/Simulator/FloodyFluidSimulator.cpp b/source/Simulator/FloodyFluidSimulator.cpp
index eaf16fff4..33c8ca5a2 100644
--- a/source/Simulator/FloodyFluidSimulator.cpp
+++ b/source/Simulator/FloodyFluidSimulator.cpp
@@ -8,6 +8,7 @@
 

 #include "FloodyFluidSimulator.h"

 #include "../World.h"

+#include "../Chunk.h"

 #include "../BlockArea.h"

 #include "../Blocks/BlockHandler.h"

 

@@ -44,36 +45,22 @@ cFloodyFluidSimulator::cFloodyFluidSimulator(
 

 

 

-void cFloodyFluidSimulator::SimulateBlock(int a_BlockX, int a_BlockY, int a_BlockZ)

+void cFloodyFluidSimulator::SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ)

 {

-	FLOG("Simulating block {%d, %d, %d}", a_BlockX, a_BlockY, a_BlockZ);

-	

-	cBlockArea Area;

-	int MinBlockY = std::max(0, a_BlockY - 1);

-	int MaxBlockY = std::min(+cChunkDef::Height, a_BlockY + 1);

-	if (!Area.Read(&m_World, a_BlockX - 1, a_BlockX + 1, MinBlockY, MaxBlockY, a_BlockZ - 1, a_BlockZ + 1))

-	{

-		// Cannot read the immediate neighborhood, probably too close to an unloaded chunk. Bail out.

-		// TODO: Shouldn't we re-schedule?

-		FLOG("  Cannot read area, bailing out.");

-		return;

-	}

-	int y = (a_BlockY > 0) ? 1 : 0;  // Relative y-coord of this block in Area

-	

-	NIBBLETYPE MyMeta = Area.GetRelBlockMeta(1, y, 1);

-	if (!IsAnyFluidBlock(Area.GetRelBlockType(1, y, 1)))

+	NIBBLETYPE MyMeta = a_Chunk->GetMeta(a_RelX, a_RelY, a_RelZ);

+	if (!IsAnyFluidBlock(a_Chunk->GetBlock(a_RelX, a_RelY, a_RelZ)))

 	{

 		// Can happen - if a block is scheduled for simulating and gets replaced in the meantime.

-		FLOG("  Not my type: exp %d, got %d", m_FluidBlock, Area.GetRelBlockType(1, y, 1));

 		return;

 	}

 

 	if (MyMeta != 0)

 	{

 		// Source blocks aren't checked for tributaries, others are.

-		if (CheckTributaries(a_BlockX, a_BlockY, a_BlockZ, Area, MyMeta))

+		if (CheckTributaries(a_Chunk, a_RelX, a_RelY, a_RelZ, MyMeta))

 		{

-			// Has no tributary, has been decreased, no more processing needed (neighbors have been scheduled by the decrease)

+			// Has no tributary, has been decreased (in CheckTributaries()),

+			// no more processing needed (neighbors have been scheduled by the decrease)

 			return;

 		}

 	}

@@ -82,107 +69,128 @@ void cFloodyFluidSimulator::SimulateBlock(int a_BlockX, int a_BlockY, int a_Bloc
 	// If this is a source block or was falling, the new meta is just the falloff

 	// Otherwise it is the current meta plus falloff (may be larger than max height, will be checked later)

 	NIBBLETYPE NewMeta = ((MyMeta == 0) || ((MyMeta & 0x08) != 0)) ? m_Falloff : (MyMeta + m_Falloff);

-	

-	BLOCKTYPE Below = Area.GetRelBlockType(1, 0, 1);

-	if ((a_BlockY > 0) && (IsPassableForFluid(Below) || IsBlockLava(Below) || IsBlockWater(Below)))

-	{

-		// Spread only down, possibly washing away what's there or turning lava to stone / cobble / obsidian:

-		SpreadToNeighbor(a_BlockX, a_BlockY - 1, a_BlockZ, Area, 8);

-	}

-	else if (NewMeta < 8)   // Can reach there

+	bool SpreadFurther = true;

+	if (a_RelY > 0)

 	{

+		BLOCKTYPE Below = a_Chunk->GetBlock(a_RelX, a_RelY - 1, a_RelZ);

+		if (IsPassableForFluid(Below) || IsBlockLava(Below) || IsBlockWater(Below))

+		{

+			// Spread only down, possibly washing away what's there or turning lava to stone / cobble / obsidian:

+			SpreadToNeighbor(a_Chunk, a_RelX, a_RelY - 1, a_RelZ, 8);

+			SpreadFurther = false;

+		}

 		// If source creation is on, check for it here:

-		if (

+		else if (

 			(m_NumNeighborsForSource > 0) &&  // Source creation is on

 			(MyMeta == m_Falloff) &&          // Only exactly one block away from a source (fast bail-out)

 			!IsPassableForFluid(Below) &&     // Only exactly 1 block deep

-			CheckNeighborsForSource(a_BlockX, a_BlockY, a_BlockZ, Area)  // Did we create a source?

+			CheckNeighborsForSource(a_Chunk, a_RelX, a_RelY, a_RelZ)  // Did we create a source?

 		)

 		{

 			// We created a source, no more spreading is to be done now

-			// Also has been re-scheduled for ticking in the next wave

+			// Also has been re-scheduled for ticking in the next wave, so no marking is needed

 			return;

 		}

-		

+	}

+	

+	if (SpreadFurther && (NewMeta < 8))

+	{

 		// Spread to the neighbors:

-		SpreadToNeighbor(a_BlockX - 1, a_BlockY, a_BlockZ,     Area, NewMeta);

-		SpreadToNeighbor(a_BlockX + 1, a_BlockY, a_BlockZ,     Area, NewMeta);

-		SpreadToNeighbor(a_BlockX,     a_BlockY, a_BlockZ - 1, Area, NewMeta);

-		SpreadToNeighbor(a_BlockX,     a_BlockY, a_BlockZ + 1, Area, NewMeta);

+		SpreadToNeighbor(a_Chunk, a_RelX - 1, a_RelY, a_RelZ,     NewMeta);

+		SpreadToNeighbor(a_Chunk, a_RelX + 1, a_RelY, a_RelZ,     NewMeta);

+		SpreadToNeighbor(a_Chunk, a_RelX,     a_RelY, a_RelZ - 1, NewMeta);

+		SpreadToNeighbor(a_Chunk, a_RelX,     a_RelY, a_RelZ + 1, NewMeta);

 	}

 	

 	// Mark as processed:

-	m_World.FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, m_StationaryFluidBlock, MyMeta);

+	a_Chunk->FastSetBlock(a_RelX, a_RelY, a_RelZ, m_StationaryFluidBlock, MyMeta);

 }

 

 

 

 

 

-bool cFloodyFluidSimulator::CheckTributaries(int a_BlockX, int a_BlockY, int a_BlockZ, const cBlockArea & a_Area, NIBBLETYPE a_MyMeta)

+bool cFloodyFluidSimulator::CheckTributaries(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_MyMeta)

 {

-	bool IsFed = false;

-	int y = (a_BlockY > 0) ? 1 : 0;  // Relative y-coord of this block in Area

-	

 	// If we have a section above, check if there's fluid above this block that would feed it:

-	if (a_BlockY < cChunkDef::Height - 1)

+	if (a_RelY < cChunkDef::Height - 1)

 	{

-		IsFed = IsAnyFluidBlock(a_Area.GetRelBlockType(1, 2, 1));

+		if (IsAnyFluidBlock(a_Chunk->GetBlock(a_RelX, a_RelY + 1, a_RelZ)))

+		{

+			// This block is fed from above, no more processing needed

+			return false;

+		}

 	}

 

-	// If not fed from above, check if there's a feed from the side (but not if it's a downward-flowing block):

-	if (!IsFed && (a_MyMeta != 8))

+	// Not fed from above, check if there's a feed from the side (but not if it's a downward-flowing block):

+	if (a_MyMeta != 8)

 	{

-		IsFed = (

-			(IsAllowedBlock(a_Area.GetRelBlockType(0, y, 1)) && IsHigherMeta(a_Area.GetRelBlockMeta(0, y, 1), a_MyMeta)) ||

-			(IsAllowedBlock(a_Area.GetRelBlockType(2, y, 1)) && IsHigherMeta(a_Area.GetRelBlockMeta(2, y, 1), a_MyMeta)) ||

-			(IsAllowedBlock(a_Area.GetRelBlockType(1, y, 0)) && IsHigherMeta(a_Area.GetRelBlockMeta(1, y, 0), a_MyMeta)) ||

-			(IsAllowedBlock(a_Area.GetRelBlockType(1, y, 2)) && IsHigherMeta(a_Area.GetRelBlockMeta(1, y, 2), a_MyMeta))

-		);

-	}

-	

-	// If not fed, decrease by m_Falloff levels:

-	if (!IsFed)

-	{

-		if (a_MyMeta >= 8)

+		BLOCKTYPE BlockType;

+		NIBBLETYPE BlockMeta;

+		static const Vector3i Coords[] =

 		{

-			FLOG("  Not fed and downwards, turning into non-downwards meta %d", m_Falloff);

-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, m_StationaryFluidBlock, m_Falloff);

-		}

-		else

+			Vector3i( 1, 0,  0),

+			Vector3i(-1, 0,  0),

+			Vector3i( 0, 0,  1),

+			Vector3i( 0, 0, -1),

+		} ;

+		for (int i = 0; i < ARRAYCOUNT(Coords); i++)

 		{

-			a_MyMeta += m_Falloff;

-			if (a_MyMeta < 8)

+			if (!a_Chunk->UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta))

 			{

-				FLOG("  Not fed, decreasing from %d to %d", a_MyMeta, a_MyMeta + m_Falloff);

-				m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, m_StationaryFluidBlock, a_MyMeta);

+				continue;

 			}

-			else

+			if (IsAllowedBlock(BlockType) && IsHigherMeta(BlockMeta, a_MyMeta))

 			{

-				FLOG("  Not fed, meta %d, erasing altogether", a_MyMeta);

-				m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);

+				// This block is fed, no more processing needed

+				return false;

 			}

+		}  // for i - Coords[]

+	}  // if not fed from above

+	

+	// Block is not fed, decrease by m_Falloff levels:

+	if (a_MyMeta >= 8)

+	{

+		FLOG("  Not fed and downwards, turning into non-downwards meta %d", m_Falloff);

+		a_Chunk->SetBlock(a_RelX, a_RelY, a_RelZ, m_StationaryFluidBlock, m_Falloff);

+	}

+	else

+	{

+		a_MyMeta += m_Falloff;

+		if (a_MyMeta < 8)

+		{

+			FLOG("  Not fed, decreasing from %d to %d", a_MyMeta - m_Falloff, a_MyMeta);

+			a_Chunk->SetBlock(a_RelX, a_RelY, a_RelZ, m_StationaryFluidBlock, a_MyMeta);

+		}

+		else

+		{

+			FLOG("  Not fed, meta %d, erasing altogether", a_MyMeta);

+			a_Chunk->SetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_AIR, 0);

 		}

-		return true;

 	}

-	return false;

+	return true;

 }

 

 

 

 

 

-void cFloodyFluidSimulator::SpreadToNeighbor(int a_BlockX, int a_BlockY, int a_BlockZ, const cBlockArea & a_Area, NIBBLETYPE a_NewMeta)

+void cFloodyFluidSimulator::SpreadToNeighbor(cChunk * a_NearChunk, int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_NewMeta)

 {

 	ASSERT(a_NewMeta <= 8);  // Invalid meta values

 	ASSERT(a_NewMeta > 0);  // Source blocks aren't spread

 	

-	BLOCKTYPE Block = a_Area.GetBlockType(a_BlockX, a_BlockY, a_BlockZ);

+	BLOCKTYPE BlockType;

+	NIBBLETYPE BlockMeta;

+	if (!a_NearChunk->UnboundedRelGetBlock(a_RelX, a_RelY, a_RelZ, BlockType, BlockMeta))

+	{

+		// Chunk not available

+		return;

+	}

 	

-	if (IsAllowedBlock(Block))

+	if (IsAllowedBlock(BlockType))

 	{

-		NIBBLETYPE Meta = a_Area.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);

-		if ((Meta == a_NewMeta) || IsHigherMeta(Meta, a_NewMeta))

+		if ((BlockMeta == a_NewMeta) || IsHigherMeta(BlockMeta, a_NewMeta))

 		{

 			// Don't spread there, there's already a higher or same level there

 			return;

@@ -192,15 +200,15 @@ void cFloodyFluidSimulator::SpreadToNeighbor(int a_BlockX, int a_BlockY, int a_B
 	// Check water - lava interaction:

 	if (m_FluidBlock == E_BLOCK_LAVA)

 	{

-		if (IsBlockWater(Block))

+		if (IsBlockWater(BlockType))

 		{

 			// Lava flowing into water, change to stone / cobblestone based on direction:

 			BLOCKTYPE NewBlock = (a_NewMeta == 8) ? E_BLOCK_STONE : E_BLOCK_COBBLESTONE;

 			FLOG("  Lava flowing into water, turning water at {%d, %d, %d} into stone", 

-				a_BlockX, a_BlockY, a_BlockZ,

+				a_RelX, a_RelY, a_RelZ,

 				ItemTypeToString(NewBlock).c_str()

 			);

-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, NewBlock, 0);

+			a_NearChunk->UnboundedRelSetBlock(a_RelX, a_RelY, a_RelZ, NewBlock, 0);

 			

 			// TODO: Sound effect

 			

@@ -209,14 +217,14 @@ void cFloodyFluidSimulator::SpreadToNeighbor(int a_BlockX, int a_BlockY, int a_B
 	}

 	else if (m_FluidBlock == E_BLOCK_WATER)

 	{

-		if (IsBlockLava(Block))

+		if (IsBlockLava(BlockType))

 		{

 			// Water flowing into lava, change to cobblestone / obsidian based on dest block:

-			BLOCKTYPE NewBlock = (a_Area.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ) == 0) ? E_BLOCK_OBSIDIAN : E_BLOCK_COBBLESTONE;

+			BLOCKTYPE NewBlock = (BlockMeta == 0) ? E_BLOCK_OBSIDIAN : E_BLOCK_COBBLESTONE;

 			FLOG("  Water flowing into lava, turning lava at {%d, %d, %d} into %s", 

-				a_BlockX, a_BlockY, a_BlockZ, ItemTypeToString(NewBlock).c_str()

+				a_RelX, a_RelY, a_RelZ, ItemTypeToString(NewBlock).c_str()

 			);

-			m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, NewBlock, 0);

+			a_NearChunk->UnboundedRelSetBlock(a_RelX, a_RelY, a_RelZ, NewBlock, 0);

 			

 			// TODO: Sound effect

 			

@@ -228,52 +236,61 @@ void cFloodyFluidSimulator::SpreadToNeighbor(int a_BlockX, int a_BlockY, int a_B
 		ASSERT(!"Unknown fluid!");

 	}

 	

-	if (!IsPassableForFluid(Block))

+	if (!IsPassableForFluid(BlockType))

 	{

 		// Can't spread there

 		return;

 	}

 	

 	// Wash away the block there, if possible:

-	if (CanWashAway(Block))

+	if (CanWashAway(BlockType))

 	{

-		cBlockHandler * Handler = BlockHandler(Block);

+		cBlockHandler * Handler = BlockHandler(BlockType);

 		if (Handler->DoesDropOnUnsuitable())

 		{

-			Handler->DropBlock(&m_World, NULL, a_BlockX, a_BlockY, a_BlockZ);

+			Handler->DropBlock(

+				&m_World, NULL, 

+				a_NearChunk->GetPosX() * cChunkDef::Width + a_RelX, 

+				a_RelY,

+				a_NearChunk->GetPosZ() * cChunkDef::Width + a_RelZ

+			);

 		}

-	}

+	}  // if (CanWashAway)

 	

 	// Spread:

-	FLOG("  Spreading to {%d, %d, %d} with meta %d", a_BlockX, a_BlockY, a_BlockZ, a_NewMeta);

-	m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, m_FluidBlock, a_NewMeta);

+	FLOG("  Spreading to {%d, %d, %d} with meta %d", a_RelX, a_RelY, a_RelZ, a_NewMeta);

+	a_NearChunk->UnboundedRelSetBlock(a_RelX, a_RelY, a_RelZ, m_FluidBlock, a_NewMeta);

 }

 

 

 

 

 

-bool cFloodyFluidSimulator::CheckNeighborsForSource(int a_BlockX, int a_BlockY, int a_BlockZ, const cBlockArea & a_Area)

+bool cFloodyFluidSimulator::CheckNeighborsForSource(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ)

 {

 	FLOG("  Checking neighbors for source creation");

 	

 	static const Vector3i NeighborCoords[] =

 	{

-		Vector3i(-1, 0, 0),

-		Vector3i( 1, 0, 0),

-		Vector3i( 0, 0,-1),

-		Vector3i( 0, 0, 1),

+		Vector3i(-1, 0,  0),

+		Vector3i( 1, 0,  0),

+		Vector3i( 0, 0, -1),

+		Vector3i( 0, 0,  1),

 	} ;

 	

 	int NumNeeded = m_NumNeighborsForSource;

 	for (int i = 0; i < ARRAYCOUNT(NeighborCoords); i++)

 	{

-		int x = a_BlockX + NeighborCoords[i].x;

-		int y = a_BlockY + NeighborCoords[i].y;

-		int z = a_BlockZ + NeighborCoords[i].z;

+		int x = a_RelX + NeighborCoords[i].x;

+		int y = a_RelY + NeighborCoords[i].y;

+		int z = a_RelZ + NeighborCoords[i].z;

 		BLOCKTYPE BlockType;

 		NIBBLETYPE BlockMeta;

-		a_Area.GetBlockTypeMeta(x, y, z, BlockType, BlockMeta);

+		if (!a_Chunk->UnboundedRelGetBlock(x, y, z, BlockType, BlockMeta))

+		{

+			// Neighbor not available, skip it

+			continue;

+		}

 		FLOG("   Neighbor at {%d, %d, %d}: %s", x, y, z, ItemToFullString(cItem(BlockType, 1, BlockMeta)).c_str());

 		if ((BlockMeta == 0) && IsAnyFluidBlock(BlockType))

 		{

@@ -283,7 +300,7 @@ bool cFloodyFluidSimulator::CheckNeighborsForSource(int a_BlockX, int a_BlockY,
 			{

 				// Found enough, turn into a source and bail out

 				FLOG("    Found enough neighbor sources, turning into a source");

-				m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, m_FluidBlock, 0);

+				a_Chunk->SetBlock(a_RelX, a_RelY, a_RelZ, m_FluidBlock, 0);

 				return true;

 			}

 		}