flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

Floody fluid simulator has been converted to use direct chunk access

Browse Source 
git-svn-id: http://mc-server.googlecode.com/svn/trunk@1236 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com
2013-03-02 15:44:31 +00:00
parent 476cd25ade
commit 66670f5d5c
7 changed files with 236 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

221
source/Simulator/FloodyFluidSimulator.cpp
View File

@@ -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);
Vector3i( 1, 0, 0),
Vector3i(-1, 0, 0),
Vector3i( 0, 0, 1),
Vector3i( 0, 0, -1),
} ;
for (int i = 0; i < ARRAYCOUNT(Coords); i++)
{
if (!a_Chunk->UnboundedRelGetBlock(a_RelX + Coords[i].x, a_RelY, a_RelZ + Coords[i].z, BlockType, BlockMeta))
{
continue;
}
if (IsAllowedBlock(BlockType) && IsHigherMeta(BlockMeta, a_MyMeta))
{
// 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
{
a_MyMeta += m_Falloff;
if (a_MyMeta < 8)
{
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);
}
else
{
FLOG(" Not fed, meta %d, erasing altogether", a_MyMeta);
m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
}
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);
if (IsAllowedBlock(Block))
BLOCKTYPE BlockType;
NIBBLETYPE BlockMeta;
if (!a_NearChunk->UnboundedRelGetBlock(a_RelX, a_RelY, a_RelZ, BlockType, BlockMeta))
{
NIBBLETYPE Meta = a_Area.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
if ((Meta == a_NewMeta) || IsHigherMeta(Meta, a_NewMeta))
// Chunk not available
return;
}
if (IsAllowedBlock(BlockType))
{
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;
}
}