From f7da7c2536b438db92bc28b88c4139d9af15e44f Mon Sep 17 00:00:00 2001 From: "madmaxoft@gmail.com" Date: Sat, 13 Oct 2012 09:53:28 +0000 Subject: 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 --- source/Simulator/ClassicFluidSimulator.h | 58 ++ source/Simulator/FireSimulator.cpp | 178 +++++++ source/Simulator/FireSimulator.h | 40 ++ source/Simulator/FluidSimulator.cpp | 19 + source/Simulator/FluidSimulator.h | 47 ++ source/Simulator/LavaSimulator.cpp | 20 + source/Simulator/LavaSimulator.h | 12 + source/Simulator/RedstoneSimulator.cpp | 886 +++++++++++++++++++++++++++++++ source/Simulator/RedstoneSimulator.h | 81 +++ source/Simulator/SandSimulator.cpp | 101 ++++ source/Simulator/SandSimulator.h | 33 ++ source/Simulator/Simulator.cpp | 44 ++ source/Simulator/Simulator.h | 38 ++ source/Simulator/SimulatorManager.cpp | 67 +++ source/Simulator/SimulatorManager.h | 39 ++ source/Simulator/WaterSimulator.cpp | 22 + source/Simulator/WaterSimulator.h | 11 + 17 files changed, 1696 insertions(+) create mode 100644 source/Simulator/ClassicFluidSimulator.h create mode 100644 source/Simulator/FireSimulator.cpp create mode 100644 source/Simulator/FireSimulator.h create mode 100644 source/Simulator/FluidSimulator.cpp create mode 100644 source/Simulator/FluidSimulator.h create mode 100644 source/Simulator/LavaSimulator.cpp create mode 100644 source/Simulator/LavaSimulator.h create mode 100644 source/Simulator/RedstoneSimulator.cpp create mode 100644 source/Simulator/RedstoneSimulator.h create mode 100644 source/Simulator/SandSimulator.cpp create mode 100644 source/Simulator/SandSimulator.h create mode 100644 source/Simulator/Simulator.cpp create mode 100644 source/Simulator/Simulator.h create mode 100644 source/Simulator/SimulatorManager.cpp create mode 100644 source/Simulator/SimulatorManager.h create mode 100644 source/Simulator/WaterSimulator.cpp create mode 100644 source/Simulator/WaterSimulator.h (limited to 'source/Simulator') 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/Simulator/FireSimulator.cpp b/source/Simulator/FireSimulator.cpp new file mode 100644 index 000000000..c2f22668b --- /dev/null +++ b/source/Simulator/FireSimulator.cpp @@ -0,0 +1,178 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "FireSimulator.h" +#include "../World.h" +#include "../BlockID.h" +#include "../Defines.h" + + + + + +cFireSimulator::cFireSimulator( cWorld* a_World ) + : cSimulator(a_World) + , m_Blocks(new BlockList) + , m_Buffer(new BlockList) + , m_BurningBlocks(new BlockList) +{ +} + + + + + +cFireSimulator::~cFireSimulator() +{ + delete m_Buffer; + delete m_Blocks; + delete m_BurningBlocks; +} + + + + + +void cFireSimulator::Simulate( float a_Dt ) +{ + m_Buffer->clear(); + std::swap( m_Blocks, m_Buffer ); + + for( BlockList::iterator itr = m_Buffer->begin(); itr != m_Buffer->end(); ++itr ) + { + Vector3i Pos = *itr; + + char BlockID = m_World->GetBlock(Pos.x, Pos.y, Pos.z); + + if(!IsAllowedBlock(BlockID)) //Check wheather the block is still burning + continue; + + if(BurnBlockAround(Pos.x, Pos.y, Pos.z)) //Burn single block and if there was one -> next time again + _AddBlock(Pos.x, Pos.y, Pos.z); + else + if(!IsForeverBurnable(m_World->GetBlock(Pos.x, Pos.y - 1, Pos.z)) && !FiresForever(BlockID)) + m_World->SetBlock(Pos.x, Pos.y, Pos.z, E_BLOCK_AIR, 0); + + } + +} + + + + + +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); + if(!IsAllowedBlock(BlockID)) //This should save very much time because it doesn´t have to iterate through all blocks + return; + + //check for duplicates + for( BlockList::iterator itr = m_Blocks->begin(); itr != m_Blocks->end(); ++itr ) + { + Vector3i Pos = *itr; + if( Pos.x == a_X && Pos.y == a_Y && Pos.z == a_Z ) + return; + } + + _AddBlock(a_X, a_Y, 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 + || a_BlockType == E_BLOCK_LEAVES + || a_BlockType == E_BLOCK_LOG + || a_BlockType == E_BLOCK_WOOL + || a_BlockType == E_BLOCK_BOOKCASE + || a_BlockType == E_BLOCK_FENCE + || a_BlockType == E_BLOCK_TNT + || 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) + || BurnBlock(a_X - 1, a_Y, a_Z) + || BurnBlock(a_X, a_Y + 1, a_Z) + || BurnBlock(a_X, a_Y - 1, a_Z) + || BurnBlock(a_X, a_Y, a_Z + 1) + || 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); + if(IsBurnable(BlockID)) + { + m_World->SetBlock(a_X, a_Y, a_Z, E_BLOCK_FIRE, 0); + return true; + } + if(IsForeverBurnable(BlockID)) + { + char BlockAbove = m_World->GetBlock(a_X, a_Y + 1, a_Z); + if(BlockAbove == E_BLOCK_AIR) + { + m_World->SetBlock(a_X, a_Y + 1, a_Z, E_BLOCK_FIRE, 0); //Doesn´t notify the simulator so it won´t go off + return true; + } + return false; + } + + return false; +} + + + + diff --git a/source/Simulator/FireSimulator.h b/source/Simulator/FireSimulator.h new file mode 100644 index 000000000..753259c2c --- /dev/null +++ b/source/Simulator/FireSimulator.h @@ -0,0 +1,40 @@ + +#pragma once + +#include "Simulator.h" +#include "../BlockEntity.h" + + + + + +class cFireSimulator : public cSimulator +{ +public: + cFireSimulator( cWorld* a_World ); + ~cFireSimulator(); + + virtual void Simulate( float a_Dt ) override; + + virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override; + + virtual bool IsBurnable( BLOCKTYPE a_BlockType ); + virtual bool IsForeverBurnable( BLOCKTYPE a_BlockType ); + virtual bool FiresForever( BLOCKTYPE a_BlockType ); + +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); // _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); + + typedef std::list BlockList; + BlockList *m_Blocks; + BlockList *m_Buffer; + + BlockList *m_BurningBlocks; +}; + + + + 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/Simulator/LavaSimulator.cpp b/source/Simulator/LavaSimulator.cpp new file mode 100644 index 000000000..726cc37e4 --- /dev/null +++ b/source/Simulator/LavaSimulator.cpp @@ -0,0 +1,20 @@ +#include "Globals.h" +#include "LavaSimulator.h" +#include "Defines.h" +#include "World.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; +} + + +bool cLavaSimulator::IsAllowedBlock(BLOCKTYPE a_BlockType) +{ + return IsBlockLava(a_BlockType); +} \ No newline at end of file diff --git a/source/Simulator/LavaSimulator.h b/source/Simulator/LavaSimulator.h new file mode 100644 index 000000000..d85b335b7 --- /dev/null +++ b/source/Simulator/LavaSimulator.h @@ -0,0 +1,12 @@ +#pragma once +#include "FluidSimulator.h" + +class cLavaSimulator : public cFluidSimulator +{ +public: + cLavaSimulator( cWorld* a_World ); + + virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override; + + +}; \ No newline at end of file diff --git a/source/Simulator/RedstoneSimulator.cpp b/source/Simulator/RedstoneSimulator.cpp new file mode 100644 index 000000000..1c30be324 --- /dev/null +++ b/source/Simulator/RedstoneSimulator.cpp @@ -0,0 +1,886 @@ + +#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" + + + + + +cRedstoneSimulator::cRedstoneSimulator( cWorld* a_World ) + : super(a_World) +{ +} + + + + + +cRedstoneSimulator::~cRedstoneSimulator() +{ +} + + + + + +void cRedstoneSimulator::WakeUp( int a_X, int a_Y, int a_Z ) +{ + cCSLock Lock( m_CS ); + m_Blocks.push_back( Vector3i( a_X, a_Y, a_Z ) ); +} + + + + + +void cRedstoneSimulator::Simulate( float a_Dt ) +{ + // Toggle torches on/off + while( !m_RefreshTorchesAround.empty() ) + { + Vector3i pos = m_RefreshTorchesAround.front(); + m_RefreshTorchesAround.pop_front(); + + RefreshTorchesAround( pos ); + } + + // Set repeaters to correct values, and decrement ticks + for( RepeaterList::iterator itr = m_SetRepeaters.begin(); itr != m_SetRepeaters.end(); ) + { + (*itr).Ticks--; + if( (*itr).Ticks <= 0 ) + { + char Block = m_World->GetBlock( (*itr).Position ); + if( (*itr).bPowerOn == true && Block == E_BLOCK_REDSTONE_REPEATER_OFF ) + { + m_World->FastSetBlock( (*itr).Position.x, (*itr).Position.y, (*itr).Position.z, E_BLOCK_REDSTONE_REPEATER_ON, m_World->GetBlockMeta( (*itr).Position ) ); + m_Blocks.push_back( (*itr).Position ); + } + else if( (*itr).bPowerOn == false && Block == E_BLOCK_REDSTONE_REPEATER_ON ) + { + m_World->FastSetBlock( (*itr).Position.x, (*itr).Position.y, (*itr).Position.z, E_BLOCK_REDSTONE_REPEATER_OFF, m_World->GetBlockMeta( (*itr).Position ) ); + m_Blocks.push_back( (*itr).Position ); + } + + if( (*itr).bPowerOffNextTime ) + { + (*itr).bPowerOn = false; + (*itr).bPowerOffNextTime = false; + (*itr).Ticks = 10; // TODO: Look up actual ticks from block metadata + ++itr; + } + else + { + itr = m_SetRepeaters.erase( itr ); + } + } + else + { + ++itr; + } + } + + // Handle changed blocks + { + cCSLock Lock( m_CS ); + std::swap( m_Blocks, m_BlocksBuffer ); + } + for( BlockList::iterator itr = m_BlocksBuffer.begin(); itr != m_BlocksBuffer.end(); ++itr ) + { + HandleChange( *itr ); + } + m_BlocksBuffer.clear(); +} + + + + + +void cRedstoneSimulator::RefreshTorchesAround( const Vector3i & a_BlockPos ) +{ + static Vector3i Surroundings [] = { + Vector3i(-1, 0, 0), + Vector3i( 1, 0, 0), + Vector3i( 0, 0,-1), + Vector3i( 0, 0, 1), + Vector3i( 0, 1, 0), // Also toggle torch on top + }; + char TargetBlockID = E_BLOCK_REDSTONE_TORCH_ON; + char TargetRepeaterID = E_BLOCK_REDSTONE_REPEATER_OFF; + if( IsPowered( a_BlockPos, true ) ) + { + TargetBlockID = E_BLOCK_REDSTONE_TORCH_OFF; + TargetRepeaterID = E_BLOCK_REDSTONE_REPEATER_ON; + //if( m_World->GetBlock( a_BlockPos ) == E_BLOCK_DIRT ) + //{ + // m_World->FastSetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, E_BLOCK_STONE, 0 ); + //} + } + else + { + //if( m_World->GetBlock( a_BlockPos ) == E_BLOCK_STONE ) + //{ + // m_World->FastSetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, E_BLOCK_DIRT, 0 ); + //} + } + + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i TorchPos = a_BlockPos + Surroundings[i]; + const char Block = m_World->GetBlock( TorchPos ); + switch( Block ) + { + case E_BLOCK_REDSTONE_TORCH_ON: + case E_BLOCK_REDSTONE_TORCH_OFF: + if( Block != TargetBlockID ) + { + char TorchMeta = m_World->GetBlockMeta( TorchPos ); + if( cTorch::IsAttachedTo( TorchPos, TorchMeta, a_BlockPos ) ) + { + m_World->FastSetBlock( TorchPos.x, TorchPos.y, TorchPos.z, TargetBlockID, m_World->GetBlockMeta( TorchPos ) ); + m_Blocks.push_back( TorchPos ); + } + } + break; + case E_BLOCK_REDSTONE_REPEATER_ON: + case E_BLOCK_REDSTONE_REPEATER_OFF: + if ((Block != TargetRepeaterID) && IsRepeaterPointingAway( TorchPos, m_World->GetBlockMeta( TorchPos ), a_BlockPos ) ) + { + SetRepeater( TorchPos, 10, TargetRepeaterID == E_BLOCK_REDSTONE_REPEATER_ON ); + } + break; + default: + break; + }; + } +} + + + + + +void cRedstoneSimulator::HandleChange( const Vector3i & a_BlockPos ) +{ + std::deque< Vector3i > SpreadStack; + + Vector3i Surroundings[] = { + Vector3i( 1, 0, 0 ), + Vector3i( 1, 1, 0 ), + Vector3i( 1,-1, 0 ), + Vector3i(-1, 0, 0 ), + Vector3i(-1, 1, 0 ), + Vector3i(-1,-1, 0 ), + Vector3i( 0, 0, 1 ), + Vector3i( 0, 1, 1 ), + Vector3i( 0,-1, 1 ), + Vector3i( 0, 0,-1 ), + Vector3i( 0, 1,-1 ), + Vector3i( 0,-1,-1 ), + Vector3i( 0,-1, 0 ), + }; + + char Block = m_World->GetBlock( a_BlockPos ); + + // First check whether torch should be on or off + if( Block == E_BLOCK_REDSTONE_TORCH_ON || Block == E_BLOCK_REDSTONE_TORCH_OFF ) + { + static Vector3i Surroundings [] = { + Vector3i(-1, 0, 0), + Vector3i( 1, 0, 0), + Vector3i( 0, 0,-1), + Vector3i( 0, 0, 1), + Vector3i( 0,-1, 0), + }; + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i pos = a_BlockPos + Surroundings[i]; + char OtherBlock = m_World->GetBlock( pos ); + if( (OtherBlock != E_BLOCK_AIR) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_ON) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_OFF) ) + { + RefreshTorchesAround( pos ); + } + } + Block = m_World->GetBlock( a_BlockPos ); // Make sure we got the updated block + } + else if( Block == E_BLOCK_REDSTONE_REPEATER_ON || Block == E_BLOCK_REDSTONE_REPEATER_OFF ) // Check if repeater is powered by a 'powered block' (not wires/torch) + { + Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) ); + Vector3i pos = a_BlockPos - Direction; // NOTE: It's minus Direction + char OtherBlock = m_World->GetBlock( pos ); + if( (OtherBlock != E_BLOCK_AIR) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_ON) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_OFF) && (OtherBlock != E_BLOCK_REDSTONE_WIRE) ) + { + RefreshTorchesAround( pos ); + } + else + { + SetRepeater( a_BlockPos, 10, IsPowered( a_BlockPos, false ) ); + } + Block = m_World->GetBlock( a_BlockPos ); + } + + BlockList Sources; + // If torch is still on, use it as a source + if( Block == E_BLOCK_REDSTONE_TORCH_ON ) + { + Sources.push_back( a_BlockPos ); + } + else if( Block == E_BLOCK_REDSTONE_REPEATER_ON ) + { + static Vector3i Surroundings [] = { // It only spreads right in front, and one block up + Vector3i( 0, 0, 0), + Vector3i( 0, 1, 0), + }; + Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) ); + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i pos = a_BlockPos + Direction + Surroundings[i]; + if( PowerBlock( pos, a_BlockPos, 0xf ) ) + { + SpreadStack.push_back( pos ); + } + } + } + + // Power all blocks legally connected to the sources + if( Block != E_BLOCK_REDSTONE_REPEATER_ON ) + { + BlockList NewSources = RemoveCurrent( a_BlockPos ); + Sources.insert( Sources.end(), NewSources.begin(), NewSources.end() ); + while( !Sources.empty() ) + { + Vector3i SourcePos = Sources.back(); + Sources.pop_back(); + + char Block = m_World->GetBlock( SourcePos ); + switch( Block ) + { + case E_BLOCK_REDSTONE_TORCH_OFF: + case E_BLOCK_REDSTONE_TORCH_ON: + { + static Vector3i Surroundings [] = { + Vector3i(-1, 0, 0), + Vector3i( 1, 0, 0), + Vector3i( 0, 0,-1), + Vector3i( 0, 0, 1), + }; + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i OtherPos = SourcePos + Surroundings[i]; + if( PowerBlock( OtherPos, a_BlockPos, 0xf ) ) + { + SpreadStack.push_back( OtherPos ); // Changed, so add to stack + } + } + } + break; + case E_BLOCK_REDSTONE_REPEATER_OFF: + case E_BLOCK_REDSTONE_REPEATER_ON: + { + static Vector3i Surroundings [] = { + Vector3i( 0, 0, 0), + Vector3i( 0, 1, 0), + }; + Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( SourcePos ) ); + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i pos = SourcePos + Direction + Surroundings[i]; + if( PowerBlock( pos, a_BlockPos, 0xf ) ) + { + SpreadStack.push_back( pos ); + } + } + } + break; + }; + + + } + } + + + // Do a floodfill + while( !SpreadStack.empty() ) + { + Vector3i pos = SpreadStack.back(); + SpreadStack.pop_back(); + + char Meta = m_World->GetBlockMeta( pos ); + + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i OtherPos = pos + Surroundings[i]; + if( PowerBlock( OtherPos, pos, Meta-1 ) ) + { + SpreadStack.push_back( OtherPos ); // Changed, so add to stack + } + } + } + + // Only after a redstone area has been completely simulated the redstone entities can react + while( !m_RefreshPistons.empty() ) + { + Vector3i pos = m_RefreshPistons.back(); + m_RefreshPistons.pop_back(); + + char Block = m_World->GetBlock( pos ); + switch( Block ) + { + case E_BLOCK_PISTON: + case E_BLOCK_STICKY_PISTON: + if( IsPowered( pos ) ) + { + cPiston Piston( m_World ); + Piston.ExtendPiston( pos.x, pos.y, pos.z ); + } + else + { + cPiston Piston( m_World ); + Piston.RetractPiston( pos.x, pos.y, pos.z ); + } + break; + default: + break; + }; + } +} + + + + + +bool cRedstoneSimulator::PowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock, char a_Power ) +{ + char Block = m_World->GetBlock( a_BlockPos ); + switch( Block ) + { + case E_BLOCK_REDSTONE_WIRE: + { + if( m_World->GetBlockMeta( a_BlockPos ) < a_Power ) + { + m_World->SetBlockMeta( a_BlockPos, a_Power ); + return true; + } + } + break; + case E_BLOCK_PISTON: + case E_BLOCK_STICKY_PISTON: + { + m_RefreshPistons.push_back( a_BlockPos ); + } + break; + case E_BLOCK_REDSTONE_REPEATER_OFF: + case E_BLOCK_REDSTONE_REPEATER_ON: + { + if (IsRepeaterPointingAway( a_BlockPos, m_World->GetBlockMeta( a_BlockPos ), a_FromBlock )) + { + SetRepeater( a_BlockPos, 10, true ); + } + } + break; + default: + { + if( Block != E_BLOCK_AIR && Block != E_BLOCK_REDSTONE_TORCH_ON && Block != E_BLOCK_REDSTONE_TORCH_OFF ) + { + if( IsPowered( a_BlockPos, true ) ) + { + m_RefreshTorchesAround.push_back( a_BlockPos ); + } + } + } + break; + }; + + return false; +} + + + + + +int cRedstoneSimulator::UnPowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock) +{ + BLOCKTYPE BlockType = m_World->GetBlock(a_BlockPos); + switch (BlockType) + { + case E_BLOCK_REDSTONE_WIRE: + { + if( m_World->GetBlockMeta( a_BlockPos ) > 0 ) + { + m_World->SetBlockMeta( a_BlockPos, 0 ); + return 1; + } + break; + } + + case E_BLOCK_PISTON: + case E_BLOCK_STICKY_PISTON: + { + m_RefreshPistons.push_back( a_BlockPos ); + break; + } + + case E_BLOCK_REDSTONE_TORCH_ON: + { + return 2; + break; + } + + case E_BLOCK_REDSTONE_REPEATER_ON: + { + if ( + IsRepeaterPointingTo(a_BlockPos, m_World->GetBlockMeta(a_BlockPos), a_FromBlock ) || // Repeater is next to wire + IsRepeaterPointingTo(a_BlockPos, m_World->GetBlockMeta(a_BlockPos), a_FromBlock - Vector3i(0, 1, 0)) // Repeater is below wire + ) + { + return 2; + } + else if (IsRepeaterPointingAway( a_BlockPos, m_World->GetBlockMeta( a_BlockPos ), a_FromBlock ) ) + { + SetRepeater( a_BlockPos, 10, false ); + } + // fall-through: + } + + case E_BLOCK_REDSTONE_REPEATER_OFF: + { + if (IsRepeaterPointingAway( a_BlockPos, m_World->GetBlockMeta( a_BlockPos ), a_FromBlock )) + { + SetRepeater( a_BlockPos, 10, false ); + } + break; + } + + default: + { + if ((BlockType != E_BLOCK_AIR) && (BlockType != E_BLOCK_REDSTONE_TORCH_ON) && (BlockType != E_BLOCK_REDSTONE_TORCH_OFF)) + { + if (!IsPowered(a_BlockPos, true)) + { + m_RefreshTorchesAround.push_back( a_BlockPos ); + } + } + break; + } + } // switch (BlockType) + + return 0; +} + + + + + +// Removes current from all powered redstone wires until it reaches an energy source. +// Also returns all energy sources it encountered +cRedstoneSimulator::BlockList cRedstoneSimulator::RemoveCurrent( const Vector3i & a_BlockPos ) +{ + + + std::deque< Vector3i > SpreadStack; + std::deque< Vector3i > FoundSources; + + Vector3i Surroundings[] = { + Vector3i( 1, 0, 0 ), + Vector3i( 1, 1, 0 ), + Vector3i( 1,-1, 0 ), + Vector3i(-1, 0, 0 ), + Vector3i(-1, 1, 0 ), + Vector3i(-1,-1, 0 ), + Vector3i( 0, 0, 1 ), + Vector3i( 0, 1, 1 ), + Vector3i( 0,-1, 1 ), + Vector3i( 0, 0,-1 ), + Vector3i( 0, 1,-1 ), + Vector3i( 0,-1,-1 ), + Vector3i( 0,-1, 0 ), + }; + + char Block = m_World->GetBlock( a_BlockPos ); + if( Block == E_BLOCK_REDSTONE_REPEATER_ON || Block == E_BLOCK_REDSTONE_REPEATER_OFF ) + { + static Vector3i Surroundings [] = { // Repeaters only spread right in front and 1 block up + Vector3i( 0, 0, 0), + Vector3i( 0, 1, 0), + }; + Vector3i Direction = GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) ); + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i pos = a_BlockPos + Direction + Surroundings[i]; + int RetVal = UnPowerBlock( pos, a_BlockPos ); + if( RetVal == 1 ) + { + SpreadStack.push_back( pos ); // Changed, so add to stack + } + else if( RetVal == 2 ) + { + FoundSources.push_back( pos ); + } + } + } + else if( Block == E_BLOCK_REDSTONE_TORCH_OFF || Block == E_BLOCK_REDSTONE_TORCH_ON ) + { + static Vector3i Surroundings [] = { // Torches only spread on the same level + Vector3i(-1, 0, 0), + Vector3i( 1, 0, 0), + Vector3i( 0, 0,-1), + Vector3i( 0, 0, 1), + }; + + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i pos = Vector3i( a_BlockPos ) + Surroundings[i]; + int RetVal = UnPowerBlock( pos, a_BlockPos ); + if( RetVal == 1 ) + { + SpreadStack.push_back( pos ); // Changed, so add to stack + } + else if( RetVal == 2 ) + { + FoundSources.push_back( pos ); + } + } + } + else + { + SpreadStack.push_back( a_BlockPos ); + } + + + while( !SpreadStack.empty() ) + { + Vector3i pos = SpreadStack.back(); + SpreadStack.pop_back(); + + for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i ) + { + Vector3i OtherPos = pos + Surroundings[i]; + int RetVal = UnPowerBlock( OtherPos, pos ); + if( RetVal == 1 ) + { + SpreadStack.push_back( OtherPos ); // Changed, so add to stack + } + else if( RetVal == 2 ) + { + FoundSources.push_back( OtherPos ); + } + } + } + + return FoundSources; +} + + + + + +bool cRedstoneSimulator::IsPowering( const Vector3i & a_PowerPos, const Vector3i & a_BlockPos, eRedstoneDirection a_WireDirection, bool a_bOnlyByWire ) +{ + BLOCKTYPE PowerBlock = m_World->GetBlock( a_PowerPos ); + if (!a_bOnlyByWire && (PowerBlock == E_BLOCK_REDSTONE_TORCH_ON)) return true; + if (PowerBlock == E_BLOCK_REDSTONE_REPEATER_ON ) // A repeater pointing towards block is regarded as wire + { + if (IsRepeaterPointingTo( a_PowerPos, m_World->GetBlockMeta( a_PowerPos ), a_BlockPos ) ) + { + return true; + } + } + if (PowerBlock == E_BLOCK_REDSTONE_WIRE) + { + if (m_World->GetBlockMeta(a_PowerPos) > 0) + { + if (GetDirection(a_PowerPos) == a_WireDirection) + { + return true; + } + } + } + + return false; +} + + + + + +bool cRedstoneSimulator::IsPowered( const Vector3i & a_BlockPos, bool a_bOnlyByWire /* = false */ ) +{ + BLOCKTYPE Block = m_World->GetBlock( a_BlockPos ); + if ((Block == E_BLOCK_REDSTONE_REPEATER_OFF) || (Block == E_BLOCK_REDSTONE_REPEATER_ON)) + { + Vector3i Behind = a_BlockPos - GetRepeaterDirection( m_World->GetBlockMeta( a_BlockPos ) ); + BLOCKTYPE BehindBlock = m_World->GetBlock( Behind ); + if (BehindBlock == E_BLOCK_REDSTONE_TORCH_ON) + { + return true; + } + if (BehindBlock == E_BLOCK_REDSTONE_WIRE) + { + if( m_World->GetBlockMeta( Behind ) > 0 ) + { + return true; + } + } + if (BehindBlock == E_BLOCK_REDSTONE_REPEATER_ON) + { + if (IsRepeaterPointingTo( Behind, m_World->GetBlockMeta( Behind ), a_BlockPos)) + { + return true; + } + } + return false; + } + + if( IsPowering( Vector3i( a_BlockPos.x-1, a_BlockPos.y, a_BlockPos.z ), a_BlockPos, REDSTONE_X_POS, a_bOnlyByWire ) ) + return true; + if( IsPowering( Vector3i( a_BlockPos.x+1, a_BlockPos.y, a_BlockPos.z ), a_BlockPos, REDSTONE_X_NEG, a_bOnlyByWire ) ) + return true; + if( IsPowering( Vector3i( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z-1 ), a_BlockPos, REDSTONE_Z_POS, a_bOnlyByWire ) ) + return true; + if( IsPowering( Vector3i( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z+1 ), a_BlockPos, REDSTONE_Z_NEG, a_bOnlyByWire ) ) + return true; + + // Only wires can power the bottom block + char PosY = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y+1, a_BlockPos.z ); + if( PosY == E_BLOCK_REDSTONE_WIRE ) + { + if( m_World->GetBlockMeta( a_BlockPos.x, a_BlockPos.y+1, a_BlockPos.z ) > 0 ) + { + return true; + } + } + + return false; +} + + + + +// Believe me, it works!! TODO: Add repeaters and low/high wires +cRedstoneSimulator::eRedstoneDirection cRedstoneSimulator::GetDirection( int a_X, int a_Y, int a_Z ) +{ + int Dir = REDSTONE_NONE; + + char NegX = m_World->GetBlock( a_X-1, a_Y, a_Z ); + if( NegX == E_BLOCK_REDSTONE_WIRE || NegX == E_BLOCK_REDSTONE_TORCH_ON ) + { + Dir |= (REDSTONE_X_POS); + } + char PosX = m_World->GetBlock( a_X+1, a_Y, a_Z ); + if( PosX == E_BLOCK_REDSTONE_WIRE || PosX == E_BLOCK_REDSTONE_TORCH_ON ) + { + Dir |= (REDSTONE_X_NEG); + } + char NegZ = m_World->GetBlock( a_X, a_Y, a_Z-1 ); + if( NegZ == E_BLOCK_REDSTONE_WIRE || NegZ == E_BLOCK_REDSTONE_TORCH_ON ) + { + if( (Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG ) ) //corner + { + Dir ^= REDSTONE_X_POS; + Dir |= REDSTONE_X_NEG; + } + if( (Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS ) ) //corner + { + Dir ^= REDSTONE_X_NEG; + Dir |= REDSTONE_X_POS; + } + Dir |= REDSTONE_Z_POS; + } + char PosZ = m_World->GetBlock( a_X, a_Y, a_Z+1 ); + if( PosZ == E_BLOCK_REDSTONE_WIRE || PosZ == E_BLOCK_REDSTONE_TORCH_ON ) + { + if( (Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG ) ) //corner + { + Dir ^= REDSTONE_X_POS; + Dir |= REDSTONE_X_NEG; + } + if( (Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS ) ) //corner + { + Dir ^= REDSTONE_X_NEG; + Dir |= REDSTONE_X_POS; + } + Dir |= REDSTONE_Z_NEG; + } + + return (eRedstoneDirection)Dir; +} + + + + + +bool cRedstoneSimulator::IsRepeaterPointingTo(const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos) +{ + switch (a_MetaData & 0x3) + { + case 0x0: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0, 1 ) ) ) + { + return true; + } + break; + } + + case 0x1: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i(-1, 0, 0 ) ) ) + { + return true; + } + break; + } + + case 0x2: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0,-1 ) ) ) + { + return true; + } + break; + } + + case 0x3: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 1, 0, 0 ) ) ) + { + return true; + } + break; + } + } + return false; +} + + + + + +bool cRedstoneSimulator::IsRepeaterPointingAway( const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos ) +{ + switch (a_MetaData & 0x3) + { + case 0x0: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0,-1 ) ) ) + { + return true; + } + break; + } + + case 0x1: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 1, 0, 0 ) ) ) + { + return true; + } + break; + } + + case 0x2: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i( 0, 0, 1 ) ) ) + { + return true; + } + break; + } + + case 0x3: + { + if( (a_RepeaterPos - a_BlockPos).Equals( Vector3i(-1, 0, 0 ) ) ) + { + return true; + } + break; + } + } + return false; +} + + + + + +NIBBLETYPE cRedstoneSimulator::RepeaterRotationToMetaData(float a_Rotation) +{ + a_Rotation += 90 + 45; // So its not aligned with axis + if (a_Rotation > 360.f) + { + a_Rotation -= 360.f; + } + + if ((a_Rotation >= 0.f) && (a_Rotation < 90.f)) + { + return 0x1; + } + else if ((a_Rotation >= 180) && (a_Rotation < 270)) + { + return 0x3; + } + else if ((a_Rotation >= 90) && (a_Rotation < 180)) + { + return 0x2; + } + else + { + return 0x0; + } +} + + + + + +Vector3i cRedstoneSimulator::GetRepeaterDirection(NIBBLETYPE a_MetaData) +{ + switch (a_MetaData & 0x3) + { + case 0x0: return Vector3i( 0, 0,-1); + case 0x1: return Vector3i( 1, 0, 0); + case 0x2: return Vector3i( 0, 0, 1); + case 0x3: return Vector3i(-1, 0, 0); + } + return Vector3i(); +} + + + + + +void cRedstoneSimulator::SetRepeater( const Vector3i & a_Position, int a_Ticks, bool a_bPowerOn ) +{ + for( RepeaterList::iterator itr = m_SetRepeaters.begin(); itr != m_SetRepeaters.end(); ++itr ) + { + sRepeaterChange & Change = *itr; + if( Change.Position.Equals( a_Position ) ) + { + if( Change.bPowerOn && a_bPowerOn == false ) + { + Change.bPowerOffNextTime = true; + } + if( a_bPowerOn == true ) + { + Change.bPowerOffNextTime = false; + } + Change.bPowerOn |= a_bPowerOn; + return; + } + } + + sRepeaterChange RC; + RC.Position = a_Position; + RC.Ticks = a_Ticks; + RC.bPowerOn = a_bPowerOn; + RC.bPowerOffNextTime = false; + m_SetRepeaters.push_back( RC ); +} + + + + diff --git a/source/Simulator/RedstoneSimulator.h b/source/Simulator/RedstoneSimulator.h new file mode 100644 index 000000000..f26b6b46b --- /dev/null +++ b/source/Simulator/RedstoneSimulator.h @@ -0,0 +1,81 @@ + +#pragma once + +#include "Simulator.h" + + + + + +class cRedstoneSimulator : + public cSimulator +{ + typedef cSimulator super; +public: + cRedstoneSimulator( cWorld* a_World ); + ~cRedstoneSimulator(); + + virtual void Simulate( float a_Dt ) override; + virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override { return true; } + + virtual void WakeUp( int a_X, int a_Y, int a_Z ) override; + + enum eRedstoneDirection + { + REDSTONE_NONE = 0, + REDSTONE_X_POS = 0x1, + REDSTONE_X_NEG = 0x2, + REDSTONE_Z_POS = 0x4, + REDSTONE_Z_NEG = 0x8, + }; + eRedstoneDirection GetDirection( int a_X, int a_Y, int a_Z ); + eRedstoneDirection GetDirection( const Vector3i & a_Pos ) { return GetDirection( a_Pos.x, a_Pos.y, a_Pos.z ); } + + static bool IsRepeaterPointingTo (const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos); + static bool IsRepeaterPointingAway(const Vector3i & a_RepeaterPos, char a_MetaData, const Vector3i & a_BlockPos); + static NIBBLETYPE RepeaterRotationToMetaData(float a_Rotation); + static Vector3i GetRepeaterDirection(NIBBLETYPE a_MetaData); + + +private: + struct sRepeaterChange + { + Vector3i Position; + int Ticks; + bool bPowerOn; + bool bPowerOffNextTime; + }; + + typedef std::deque BlockList; + + typedef std::deque< sRepeaterChange > RepeaterList; + RepeaterList m_SetRepeaters; + + void SetRepeater(const Vector3i & a_Position, int a_Ticks, bool a_bPowerOn); + + virtual void AddBlock(int a_X, int a_Y, int a_Z) {} + + void HandleChange( const Vector3i & a_BlockPos ); + BlockList RemoveCurrent( const Vector3i & a_BlockPos ); + + bool PowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock, char a_Power ); + int UnPowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock ); + + bool IsPowered( const Vector3i & a_BlockPos, bool a_bOnlyByWire = false ); + bool IsPowering( const Vector3i & a_PowerPos, const Vector3i & a_BlockPos, eRedstoneDirection a_WireDirection, bool a_bOnlyByWire ); + + BlockList m_Blocks; + BlockList m_BlocksBuffer; + + BlockList m_RefreshPistons; + + BlockList m_RefreshTorchesAround; + + void RefreshTorchesAround( const Vector3i & a_BlockPos ); + + cCriticalSection m_CS; +}; + + + + diff --git a/source/Simulator/SandSimulator.cpp b/source/Simulator/SandSimulator.cpp new file mode 100644 index 000000000..69513afef --- /dev/null +++ b/source/Simulator/SandSimulator.cpp @@ -0,0 +1,101 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "SandSimulator.h" +#include "../World.h" +#include "../BlockID.h" +#include "../Defines.h" +#include "../FallingBlock.h" + + + + +cSandSimulator::cSandSimulator( cWorld* a_World ) + : cSimulator(a_World) + , m_Blocks(new BlockList) + , m_Buffer(new BlockList) +{ + +} + + + + + +cSandSimulator::~cSandSimulator() +{ + delete m_Buffer; + delete m_Blocks; +} + + + + + +void cSandSimulator::Simulate( float a_Dt ) +{ + m_Buffer->clear(); + std::swap( m_Blocks, m_Buffer ); + + for( BlockList::iterator itr = m_Buffer->begin(); itr != m_Buffer->end(); ++itr ) + { + Vector3i Pos = *itr; + BLOCKTYPE BlockID = m_World->GetBlock(Pos.x, Pos.y, Pos.z); + if(!IsAllowedBlock(BlockID)) + continue; + + BLOCKTYPE BottomBlock = m_World->GetBlock( Pos.x, Pos.y - 1, Pos.z ); + + if( IsPassable(BottomBlock) ) + { + cFallingBlock * FallingBlock = new cFallingBlock( Pos, BlockID ); + FallingBlock->Initialize( m_World ); + m_World->SetBlock( Pos.x, Pos.y, Pos.z, E_BLOCK_AIR, 0 ); + } + } + +} + + + + + +bool cSandSimulator::IsAllowedBlock( BLOCKTYPE a_BlockType ) +{ + return a_BlockType == E_BLOCK_SAND + || a_BlockType == E_BLOCK_GRAVEL; +} + + + + + +void cSandSimulator::AddBlock(int a_X, int a_Y, int a_Z) +{ + if(!IsAllowedBlock(m_World->GetBlock(a_X, a_Y, a_Z))) + return; + + Vector3i Block(a_X, a_Y, a_Z); + + //check for duplicates + for( BlockList::iterator itr = m_Blocks->begin(); itr != m_Blocks->end(); ++itr ) + { + Vector3i Pos = *itr; + if( Pos.x == a_X && Pos.y == a_Y && Pos.z == a_Z ) + return; + } + + m_Blocks->push_back(Block); +} + + + + + +bool cSandSimulator::IsPassable( BLOCKTYPE a_BlockType ) +{ + return a_BlockType == E_BLOCK_AIR + || IsBlockWater(a_BlockType) + || IsBlockLava(a_BlockType) + || a_BlockType == E_BLOCK_FIRE; +} diff --git a/source/Simulator/SandSimulator.h b/source/Simulator/SandSimulator.h new file mode 100644 index 000000000..928ea63fc --- /dev/null +++ b/source/Simulator/SandSimulator.h @@ -0,0 +1,33 @@ + +#pragma once + +#include "Simulator.h" +#include "../BlockEntity.h" +#include "../Vector3i.h" + + + + + +class cSandSimulator : public cSimulator +{ +public: + cSandSimulator( cWorld* a_World ); + ~cSandSimulator(); + + virtual void Simulate( float a_Dt ) override; + + virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override; + virtual bool IsPassable( BLOCKTYPE a_BlockType ); + +protected: + virtual void AddBlock(int a_X, int a_Y, int a_Z) override; + + typedef std::list BlockList; + BlockList * m_Blocks; + BlockList * m_Buffer; +}; + + + + 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/Simulator/SimulatorManager.cpp b/source/Simulator/SimulatorManager.cpp new file mode 100644 index 000000000..1ab7a51b5 --- /dev/null +++ b/source/Simulator/SimulatorManager.cpp @@ -0,0 +1,67 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "SimulatorManager.h" + + + + + +cSimulatorManager::cSimulatorManager() +{ + +} + + + + + +cSimulatorManager::~cSimulatorManager() +{ + for (cSimulators::iterator itr = m_Simulators.begin(); itr != m_Simulators.end(); ++itr ) + { + delete *itr; + } // for itr - m_Simulators[] +} + + + + + +void cSimulatorManager::Simulate( float a_Dt ) +{ + m_Ticks++; + for (cSimulators::iterator itr = m_Simulators.begin(); itr != m_Simulators.end(); ++itr ) + { + if(m_Ticks % (*itr)->second == 0) + (*itr)->first->Simulate(a_Dt); + } +} + + + + + +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_BlockX, a_BlockY, a_BlockZ); + } +} + + + + + +void cSimulatorManager::RegisterSimulator(cSimulator *a_Simulator, short a_Rate) +{ + //TODO needs some checking + std::pair *Pair = new std::pair(a_Simulator, a_Rate); + + m_Simulators.push_back(Pair); +} + + + + diff --git a/source/Simulator/SimulatorManager.h b/source/Simulator/SimulatorManager.h new file mode 100644 index 000000000..e90acffab --- /dev/null +++ b/source/Simulator/SimulatorManager.h @@ -0,0 +1,39 @@ + +// cSimulatorManager.h + + + + +#pragma once + + + + +#include "Simulator.h" + + + + + +class cSimulatorManager +{ +public: + cSimulatorManager(); + ~cSimulatorManager(); + + void Simulate( float a_Dt ); + void WakeUp(int a_X, int a_Y, int a_Z); + + void RegisterSimulator(cSimulator * a_Simulator, short a_Rate); // Takes ownership of the simulator object! + +protected: + + typedef std::vector *> cSimulators; + + cSimulators m_Simulators; + long long m_Ticks; +}; + + + + diff --git a/source/Simulator/WaterSimulator.cpp b/source/Simulator/WaterSimulator.cpp new file mode 100644 index 000000000..c63135419 --- /dev/null +++ b/source/Simulator/WaterSimulator.cpp @@ -0,0 +1,22 @@ +#include "Globals.h" +#include "WaterSimulator.h" +#include "Defines.h" +#include "World.h" + + + +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; +} + + +bool cWaterSimulator::IsAllowedBlock(BLOCKTYPE a_BlockType) +{ + return IsBlockWater(a_BlockType); +} + diff --git a/source/Simulator/WaterSimulator.h b/source/Simulator/WaterSimulator.h new file mode 100644 index 000000000..4bc35b8f7 --- /dev/null +++ b/source/Simulator/WaterSimulator.h @@ -0,0 +1,11 @@ +#pragma once +#include "FluidSimulator.h" + +class cWaterSimulator : public cFluidSimulator +{ +public: + cWaterSimulator( cWorld* a_World ); + + virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override; + +}; \ No newline at end of file -- cgit v1.2.3