From f7da7c2536b438db92bc28b88c4139d9af15e44f Mon Sep 17 00:00:00 2001 From: "madmaxoft@gmail.com" Date: Sat, 13 Oct 2012 09:53:28 +0000 Subject: [PATCH] Preparation for multiple fluid simulators. Moved all simulators into a subfolder. Replaced cWaterSimulator and cLavaSimulator with a generic cFluidSimulator. Moved original fluid simulation into cClassicFluidSimulator. Fluid simulator parameters (MaxHeight, Falloff) are read from the world.ini file (can have nether-like lava with lower falloff) git-svn-id: http://mc-server.googlecode.com/svn/trunk@956 0a769ca7-a7f5-676a-18bf-c427514a06d6 --- VC2008/MCServer.vcproj | 38 +- source/Blocks/BlockRedstoneRepeater.cpp | 2 +- source/Chunk.cpp | 2 - source/FluidSimulator.cpp | 692 ------------------- source/FluidSimulator.h | 55 -- source/Globals.h | 2 + source/Pickup.cpp | 6 +- source/Simulator.cpp | 33 - source/Simulator.h | 20 - source/Simulator/ClassicFluidSimulator.h | 58 ++ source/{ => Simulator}/FireSimulator.cpp | 57 +- source/{ => Simulator}/FireSimulator.h | 11 +- source/Simulator/FluidSimulator.cpp | 19 + source/Simulator/FluidSimulator.h | 47 ++ source/{ => Simulator}/LavaSimulator.cpp | 0 source/{ => Simulator}/LavaSimulator.h | 0 source/{ => Simulator}/RedstoneSimulator.cpp | 8 +- source/{ => Simulator}/RedstoneSimulator.h | 1 - source/{ => Simulator}/SandSimulator.cpp | 9 +- source/{ => Simulator}/SandSimulator.h | 10 +- source/Simulator/Simulator.cpp | 44 ++ source/Simulator/Simulator.h | 38 + source/{ => Simulator}/SimulatorManager.cpp | 4 +- source/{ => Simulator}/SimulatorManager.h | 0 source/{ => Simulator}/WaterSimulator.cpp | 0 source/{ => Simulator}/WaterSimulator.h | 0 source/World.cpp | 65 +- source/World.h | 19 +- 28 files changed, 356 insertions(+), 884 deletions(-) delete mode 100644 source/FluidSimulator.cpp delete mode 100644 source/FluidSimulator.h delete mode 100644 source/Simulator.cpp delete mode 100644 source/Simulator.h create mode 100644 source/Simulator/ClassicFluidSimulator.h rename source/{ => Simulator}/FireSimulator.cpp (96%) rename source/{ => Simulator}/FireSimulator.h (82%) create mode 100644 source/Simulator/FluidSimulator.cpp create mode 100644 source/Simulator/FluidSimulator.h rename source/{ => Simulator}/LavaSimulator.cpp (100%) rename source/{ => Simulator}/LavaSimulator.h (100%) rename source/{ => Simulator}/RedstoneSimulator.cpp (99%) rename source/{ => Simulator}/RedstoneSimulator.h (98%) rename source/{ => Simulator}/SandSimulator.cpp (93%) rename source/{ => Simulator}/SandSimulator.h (87%) create mode 100644 source/Simulator/Simulator.cpp create mode 100644 source/Simulator/Simulator.h rename source/{ => Simulator}/SimulatorManager.cpp (88%) rename source/{ => Simulator}/SimulatorManager.h (100%) rename source/{ => Simulator}/WaterSimulator.cpp (100%) rename source/{ => Simulator}/WaterSimulator.h (100%) diff --git a/VC2008/MCServer.vcproj b/VC2008/MCServer.vcproj index 059b4b453..5ef341980 100644 --- a/VC2008/MCServer.vcproj +++ b/VC2008/MCServer.vcproj @@ -1008,70 +1008,62 @@ - - - - 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 -#include - -#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; xGetBlock( 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 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::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 (MetaSetBlock(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 #include #include +#include +#include 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 similarity index 96% rename from source/FireSimulator.cpp rename to 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 similarity index 82% rename from source/FireSimulator.h rename to 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 similarity index 100% rename from source/LavaSimulator.cpp rename to source/Simulator/LavaSimulator.cpp diff --git a/source/LavaSimulator.h b/source/Simulator/LavaSimulator.h similarity index 100% rename from source/LavaSimulator.h rename to source/Simulator/LavaSimulator.h diff --git a/source/RedstoneSimulator.cpp b/source/Simulator/RedstoneSimulator.cpp similarity index 99% rename from source/RedstoneSimulator.cpp rename to 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 similarity index 98% rename from source/RedstoneSimulator.h rename to 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 similarity index 93% rename from source/SandSimulator.cpp rename to 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 similarity index 87% rename from source/SandSimulator.h rename to 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 similarity index 88% rename from source/SimulatorManager.cpp rename to 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 similarity index 100% rename from source/SimulatorManager.h rename to source/Simulator/SimulatorManager.h diff --git a/source/WaterSimulator.cpp b/source/Simulator/WaterSimulator.cpp similarity index 100% rename from source/WaterSimulator.cpp rename to source/Simulator/WaterSimulator.cpp diff --git a/source/WaterSimulator.h b/source/Simulator/WaterSimulator.h similarity index 100% rename from source/WaterSimulator.h rename to 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