From 60dfaa09679219868e58a44d6d86f5d8d524ce24 Mon Sep 17 00:00:00 2001 From: peterbell10 Date: Sat, 15 Jul 2017 03:09:55 +0100 Subject: Allocate redstone component handlers upfront --- src/Blocks/BlockPiston.cpp | 44 ++++++------- src/Blocks/BlockPiston.h | 8 +-- src/Globals.h | 7 +- .../CommandBlockHandler.h | 20 +++--- .../IncrementalRedstoneSimulator/DoorHandler.h | 22 +++---- .../DropSpenserHandler.h | 20 +++--- .../IncrementalRedstoneSimulator.cpp | 75 ++++++++++++++-------- .../IncrementalRedstoneSimulator.h | 5 +- .../NoteBlockHandler.h | 21 +++--- .../IncrementalRedstoneSimulator/PistonHandler.h | 22 +++---- .../PoweredRailHandler.h | 24 +++---- .../PressurePlateHandler.h | 24 +++---- .../RedstoneBlockHandler.h | 16 ++--- .../RedstoneComparatorHandler.h | 45 ++++++------- .../IncrementalRedstoneSimulator/RedstoneHandler.h | 42 +++++------- .../RedstoneLampHandler.h | 18 ++---- .../RedstoneRepeaterHandler.h | 23 ++++--- .../RedstoneToggleHandler.h | 19 +++--- .../RedstoneTorchHandler.h | 20 +++--- .../RedstoneWireHandler.h | 35 +++++----- .../SmallGateHandler.h | 22 +++---- .../SolidBlockHandler.h | 22 +++---- .../IncrementalRedstoneSimulator/TNTHandler.h | 22 +++---- .../TrappedChestHandler.h | 22 +++---- .../TripwireHookHandler.h | 24 +++---- 25 files changed, 293 insertions(+), 329 deletions(-) diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp index 7e5efe4ae..e3c45cfdb 100644 --- a/src/Blocks/BlockPiston.cpp +++ b/src/Blocks/BlockPiston.cpp @@ -101,7 +101,7 @@ Vector3i cBlockPistonHandler::MetadataToOffset(NIBBLETYPE a_PistonMeta) void cBlockPistonHandler::PushBlocks( const Vector3iSet & a_BlocksToPush, - cWorld * a_World, const Vector3i & a_PushDir + cWorld & a_World, const Vector3i & a_PushDir ) { // Sort blocks to move the blocks first, which are farest away from the piston @@ -117,8 +117,8 @@ void cBlockPistonHandler::PushBlocks( NIBBLETYPE moveMeta; for (auto & moveBlockPos : sortedBlocks) { - a_World->GetBlockTypeMeta(moveBlockPos.x, moveBlockPos.y, moveBlockPos.z, moveBlock, moveMeta); - a_World->SetBlock(moveBlockPos.x, moveBlockPos.y, moveBlockPos.z, E_BLOCK_AIR, 0); + a_World.GetBlockTypeMeta(moveBlockPos.x, moveBlockPos.y, moveBlockPos.z, moveBlock, moveMeta); + a_World.SetBlock(moveBlockPos.x, moveBlockPos.y, moveBlockPos.z, E_BLOCK_AIR, 0); moveBlockPos += a_PushDir; if (cBlockInfo::IsPistonBreakable(moveBlock)) @@ -127,9 +127,9 @@ void cBlockPistonHandler::PushBlocks( cBlockHandler * Handler = BlockHandler(moveBlock); if (Handler->DoesDropOnUnsuitable()) { - cChunkInterface ChunkInterface(a_World->GetChunkMap()); - cBlockInServerPluginInterface PluginInterface(*a_World); - Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, nullptr, + cChunkInterface ChunkInterface(a_World.GetChunkMap()); + cBlockInServerPluginInterface PluginInterface(a_World); + Handler->DropBlock(ChunkInterface, a_World, PluginInterface, nullptr, moveBlockPos.x, moveBlockPos.y, moveBlockPos.z ); } @@ -137,7 +137,7 @@ void cBlockPistonHandler::PushBlocks( else { // Not breakable, just move it - a_World->SetBlock(moveBlockPos.x, moveBlockPos.y, moveBlockPos.z, moveBlock, moveMeta); + a_World.SetBlock(moveBlockPos.x, moveBlockPos.y, moveBlockPos.z, moveBlock, moveMeta); } } } @@ -147,7 +147,7 @@ void cBlockPistonHandler::PushBlocks( bool cBlockPistonHandler::CanPushBlock( - const Vector3i & a_BlockPos, cWorld * a_World, bool a_RequirePushable, + const Vector3i & a_BlockPos, cWorld & a_World, bool a_RequirePushable, Vector3iSet & a_BlocksPushed, const Vector3i & a_PushDir ) { @@ -162,7 +162,7 @@ bool cBlockPistonHandler::CanPushBlock( BLOCKTYPE currBlock; NIBBLETYPE currMeta; - a_World->GetBlockTypeMeta(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, currBlock, currMeta); + a_World.GetBlockTypeMeta(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, currBlock, currMeta); if (currBlock == E_BLOCK_AIR) { @@ -214,11 +214,11 @@ bool cBlockPistonHandler::CanPushBlock( -void cBlockPistonHandler::ExtendPiston(Vector3i a_BlockPos, cWorld * a_World) +void cBlockPistonHandler::ExtendPiston(Vector3i a_BlockPos, cWorld & a_World) { BLOCKTYPE pistonBlock; NIBBLETYPE pistonMeta; - a_World->GetBlockTypeMeta(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta); + a_World.GetBlockTypeMeta(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta); if (IsExtended(pistonMeta)) { @@ -235,15 +235,15 @@ void cBlockPistonHandler::ExtendPiston(Vector3i a_BlockPos, cWorld * a_World) return; } - a_World->BroadcastBlockAction(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 0, pistonMeta, pistonBlock); - a_World->BroadcastSoundEffect("block.piston.extend", a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 0.5f, 0.7f); + a_World.BroadcastBlockAction(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 0, pistonMeta, pistonBlock); + a_World.BroadcastSoundEffect("block.piston.extend", a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 0.5f, 0.7f); PushBlocks(blocksPushed, a_World, pushDir); // Set the extension and the piston base correctly Vector3i extensionPos = a_BlockPos + pushDir; - a_World->SetBlock(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta | 0x8); - a_World->SetBlock( + a_World.SetBlock(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta | 0x8); + a_World.SetBlock( extensionPos.x, extensionPos.y, extensionPos.z, E_BLOCK_PISTON_EXTENSION, pistonMeta | (IsSticky(pistonBlock) ? 8 : 0) ); @@ -253,11 +253,11 @@ void cBlockPistonHandler::ExtendPiston(Vector3i a_BlockPos, cWorld * a_World) -void cBlockPistonHandler::RetractPiston(Vector3i a_BlockPos, cWorld * a_World) +void cBlockPistonHandler::RetractPiston(Vector3i a_BlockPos, cWorld & a_World) { BLOCKTYPE pistonBlock; NIBBLETYPE pistonMeta; - a_World->GetBlockTypeMeta(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta); + a_World.GetBlockTypeMeta(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta); if (!IsExtended(pistonMeta)) { @@ -269,18 +269,18 @@ void cBlockPistonHandler::RetractPiston(Vector3i a_BlockPos, cWorld * a_World) // Check the extension: Vector3i extensionPos = a_BlockPos + pushDir; - if (a_World->GetBlock(extensionPos) != E_BLOCK_PISTON_EXTENSION) + if (a_World.GetBlock(extensionPos) != E_BLOCK_PISTON_EXTENSION) { LOGD("%s: Piston without an extension - still extending, or just in an invalid state?", __FUNCTION__); return; } // Remove Extension - a_World->SetBlock(extensionPos.x, extensionPos.y, extensionPos.z, E_BLOCK_AIR, 0); + a_World.SetBlock(extensionPos.x, extensionPos.y, extensionPos.z, E_BLOCK_AIR, 0); - a_World->SetBlock(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta & ~(8)); - a_World->BroadcastBlockAction(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 1, pistonMeta & ~(8), pistonBlock); - a_World->BroadcastSoundEffect("block.piston.contract", a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 0.5f, 0.7f); + a_World.SetBlock(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, pistonBlock, pistonMeta & ~(8)); + a_World.BroadcastBlockAction(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 1, pistonMeta & ~(8), pistonBlock); + a_World.BroadcastSoundEffect("block.piston.contract", a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, 0.5f, 0.7f); if (!IsSticky(pistonBlock)) { diff --git a/src/Blocks/BlockPiston.h b/src/Blocks/BlockPiston.h index e1445c21c..c9320a50f 100644 --- a/src/Blocks/BlockPiston.h +++ b/src/Blocks/BlockPiston.h @@ -84,8 +84,8 @@ public: /** Converts piston block's metadata into a unit vector representing the direction in which the piston will extend. */ static Vector3i MetadataToOffset(NIBBLETYPE a_PistonMeta); - static void ExtendPiston(Vector3i a_BlockPos, cWorld * a_World); - static void RetractPiston(Vector3i a_BlockPos, cWorld * a_World); + static void ExtendPiston(Vector3i a_BlockPos, cWorld & a_World); + static void RetractPiston(Vector3i a_BlockPos, cWorld & a_World); virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) override { @@ -154,13 +154,13 @@ private: /** Tries to push a block and increases the pushed blocks variable. Returns true if the block is pushable */ static bool CanPushBlock( - const Vector3i & a_BlockPos, cWorld * a_World, bool a_RequirePushable, + const Vector3i & a_BlockPos, cWorld & a_World, bool a_RequirePushable, Vector3iSet & a_BlocksPushed, const Vector3i & a_PushDir ); /** Moves a list of blocks in a specific direction */ static void PushBlocks(const Vector3iSet & a_BlocksToPush, - cWorld * a_World, const Vector3i & a_PushDir + cWorld & a_World, const Vector3i & a_PushDir ); } ; diff --git a/src/Globals.h b/src/Globals.h index 777f8ca3d..dcac8dd94 100644 --- a/src/Globals.h +++ b/src/Globals.h @@ -175,10 +175,10 @@ template class SizeChecker; template class SizeChecker; // A macro to disallow the copy constructor and operator = functions -// This should be used in the private: declarations for any class that shouldn't allow copying itself +// This should be used in the declarations for any class that shouldn't allow copying itself #define DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName &); \ - void operator =(const TypeName &) + TypeName(const TypeName &) = delete; \ + TypeName & operator =(const TypeName &) = delete // A macro that is used to mark unused local variables, to avoid pedantic warnings in gcc / clang / MSVC // Note that in MSVC it requires the full type of X to be known @@ -227,7 +227,6 @@ template class SizeChecker; #include #include #include - #include #include #include #endif diff --git a/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h b/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h index 3114e92c4..91fbe05ff 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/CommandBlockHandler.h @@ -13,13 +13,9 @@ class cCommandBlockHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cCommandBlockHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -28,19 +24,20 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating commander the cmdblck (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Previous = static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData); + auto Previous = static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData); if ((Previous.PowerLevel != 0) || (a_PoweringData.PowerLevel == 0)) { // If we're already powered or received an update of no power, don't activate @@ -57,12 +54,13 @@ public: } } CmdBlockSP; - m_World.DoWithCommandBlockAt(a_Position.x, a_Position.y, a_Position.z, CmdBlockSP); + a_World.DoWithCommandBlockAt(a_Position.x, a_Position.y, a_Position.z, CmdBlockSP); return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents());; diff --git a/src/Simulator/IncrementalRedstoneSimulator/DoorHandler.h b/src/Simulator/IncrementalRedstoneSimulator/DoorHandler.h index 702c79fee..999454b56 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/DoorHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/DoorHandler.h @@ -13,13 +13,9 @@ class cDoorHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cDoorHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -28,30 +24,32 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating dori the door (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - if (a_PoweringData != static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData)) + if (a_PoweringData != static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData)) { - cChunkInterface ChunkInterface(m_World.GetChunkMap()); + cChunkInterface ChunkInterface(a_World.GetChunkMap()); cBlockDoorHandler::SetOpen(ChunkInterface, a_Position.x, a_Position.y, a_Position.z, (a_PoweringData.PowerLevel != 0)); - m_World.BroadcastSoundParticleEffect(EffectID::SFX_RANDOM_WOODEN_DOOR_OPEN, a_Position.x, a_Position.y, a_Position.z, 0); + a_World.BroadcastSoundParticleEffect(EffectID::SFX_RANDOM_WOODEN_DOOR_OPEN, a_Position.x, a_Position.y, a_Position.z, 0); } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents());; diff --git a/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h b/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h index 3c9952582..62b37eb1d 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/DropSpenserHandler.h @@ -13,11 +13,6 @@ class cDropSpenserHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cDropSpenserHandler(cWorld & a_World) : - super(a_World) - { - } - inline static bool IsActivated(NIBBLETYPE a_Meta) { return (a_Meta & E_META_DROPSPENSER_ACTIVATED) != 0; @@ -34,8 +29,9 @@ public: } } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -44,15 +40,16 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating spencer the dropspenser (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); bool IsPoweredNow = (a_PoweringData.PowerLevel > 0); @@ -70,20 +67,21 @@ public: } } DrSpSP; - m_World.DoWithDropSpenserAt(a_Position.x, a_Position.y, a_Position.z, DrSpSP); + a_World.DoWithDropSpenserAt(a_Position.x, a_Position.y, a_Position.z, DrSpSP); } // Update the internal dropspenser state if necessary if (IsPoweredNow != WasPoweredPreviously) { - m_World.SetBlockMeta(a_Position, SetActivationState(a_Meta, IsPoweredNow)); + a_World.SetBlockMeta(a_Position, SetActivationState(a_Meta, IsPoweredNow)); } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); diff --git a/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.cpp b/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.cpp index 0ca7afbf3..966ee28ca 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.cpp +++ b/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.cpp @@ -29,25 +29,48 @@ +const cRedstoneHandler * cIncrementalRedstoneSimulator::GetComponentHandler(BLOCKTYPE a_BlockType) +{ + struct sComponents: + public std::array, 256> + { + sComponents() + { + for (size_t i = 0; i != 256; ++i) + { + (*this)[i] = cIncrementalRedstoneSimulator::CreateComponent(static_cast(i)); + } + } + }; + + + static sComponents Components; + return Components[a_BlockType].get(); +} + + + + + -std::unique_ptr cIncrementalRedstoneSimulator::CreateComponent(cWorld & a_World, BLOCKTYPE a_BlockType, cIncrementalRedstoneSimulatorChunkData * a_Data) +std::unique_ptr cIncrementalRedstoneSimulator::CreateComponent(BLOCKTYPE a_BlockType) { switch (a_BlockType) { case E_BLOCK_ACTIVATOR_RAIL: case E_BLOCK_DETECTOR_RAIL: - case E_BLOCK_POWERED_RAIL: return cpp14::make_unique(a_World); + case E_BLOCK_POWERED_RAIL: return cpp14::make_unique(); case E_BLOCK_ACTIVE_COMPARATOR: - case E_BLOCK_INACTIVE_COMPARATOR: return cpp14::make_unique(a_World); + case E_BLOCK_INACTIVE_COMPARATOR: return cpp14::make_unique(); case E_BLOCK_DISPENSER: - case E_BLOCK_DROPPER: return cpp14::make_unique(a_World); + case E_BLOCK_DROPPER: return cpp14::make_unique(); case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE: case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE: case E_BLOCK_STONE_PRESSURE_PLATE: - case E_BLOCK_WOODEN_PRESSURE_PLATE: return cpp14::make_unique(a_World); + case E_BLOCK_WOODEN_PRESSURE_PLATE: return cpp14::make_unique(); case E_BLOCK_ACACIA_FENCE_GATE: case E_BLOCK_BIRCH_FENCE_GATE: @@ -56,41 +79,41 @@ std::unique_ptr cIncrementalRedstoneSimulator::CreateComponent case E_BLOCK_IRON_TRAPDOOR: case E_BLOCK_JUNGLE_FENCE_GATE: case E_BLOCK_SPRUCE_FENCE_GATE: - case E_BLOCK_TRAPDOOR: return cpp14::make_unique(a_World); + case E_BLOCK_TRAPDOOR: return cpp14::make_unique(); case E_BLOCK_REDSTONE_LAMP_OFF: - case E_BLOCK_REDSTONE_LAMP_ON: return cpp14::make_unique(a_World); + case E_BLOCK_REDSTONE_LAMP_ON: return cpp14::make_unique(); case E_BLOCK_REDSTONE_REPEATER_OFF: - case E_BLOCK_REDSTONE_REPEATER_ON: return cpp14::make_unique(a_World); + case E_BLOCK_REDSTONE_REPEATER_ON: return cpp14::make_unique(); case E_BLOCK_REDSTONE_TORCH_OFF: - case E_BLOCK_REDSTONE_TORCH_ON: return cpp14::make_unique(a_World); + case E_BLOCK_REDSTONE_TORCH_ON: return cpp14::make_unique(); case E_BLOCK_PISTON: - case E_BLOCK_STICKY_PISTON: return cpp14::make_unique(a_World); + case E_BLOCK_STICKY_PISTON: return cpp14::make_unique(); case E_BLOCK_LEVER: case E_BLOCK_STONE_BUTTON: - case E_BLOCK_WOODEN_BUTTON: return cpp14::make_unique(a_World); - - case E_BLOCK_BLOCK_OF_REDSTONE: return cpp14::make_unique(a_World); - case E_BLOCK_COMMAND_BLOCK: return cpp14::make_unique(a_World); - case E_BLOCK_NOTE_BLOCK: return cpp14::make_unique(a_World); - case E_BLOCK_REDSTONE_WIRE: return cpp14::make_unique(a_World); - case E_BLOCK_TNT: return cpp14::make_unique(a_World); - case E_BLOCK_TRAPPED_CHEST: return cpp14::make_unique(a_World); - case E_BLOCK_TRIPWIRE_HOOK: return cpp14::make_unique(a_World); + case E_BLOCK_WOODEN_BUTTON: return cpp14::make_unique(); + + case E_BLOCK_BLOCK_OF_REDSTONE: return cpp14::make_unique(); + case E_BLOCK_COMMAND_BLOCK: return cpp14::make_unique(); + case E_BLOCK_NOTE_BLOCK: return cpp14::make_unique(); + case E_BLOCK_REDSTONE_WIRE: return cpp14::make_unique(); + case E_BLOCK_TNT: return cpp14::make_unique(); + case E_BLOCK_TRAPPED_CHEST: return cpp14::make_unique(); + case E_BLOCK_TRIPWIRE_HOOK: return cpp14::make_unique(); default: { if (cBlockDoorHandler::IsDoorBlockType(a_BlockType)) { - return cpp14::make_unique(a_World); + return cpp14::make_unique(); } if (cBlockInfo::FullyOccupiesVoxel(a_BlockType)) { - return cpp14::make_unique(a_World); + return cpp14::make_unique(); } return nullptr; } @@ -129,7 +152,7 @@ void cIncrementalRedstoneSimulator::Simulate(float a_dt) continue; } - auto CurrentHandler = cIncrementalRedstoneSimulator::CreateComponent(m_World, CurrentBlock, &m_Data); + auto CurrentHandler = GetComponentHandler(CurrentBlock); if (CurrentHandler == nullptr) // Block at CurrentPosition doesn't have a corresponding redstone handler { // Clean up cached PowerData for CurrentPosition @@ -139,7 +162,7 @@ void cIncrementalRedstoneSimulator::Simulate(float a_dt) } cRedstoneHandler::PoweringData Power; - for (const auto & Location : CurrentHandler->GetValidSourcePositions(CurrentLocation, CurrentBlock, CurrentMeta)) + for (const auto & Location : CurrentHandler->GetValidSourcePositions(m_World, CurrentLocation, CurrentBlock, CurrentMeta)) { if (!cChunk::IsValidHeight(Location.y)) { @@ -149,18 +172,18 @@ void cIncrementalRedstoneSimulator::Simulate(float a_dt) NIBBLETYPE PotentialMeta; m_World.GetBlockTypeMeta(Location.x, Location.y, Location.z, PotentialBlock, PotentialMeta); - auto PotentialSourceHandler = cIncrementalRedstoneSimulator::CreateComponent(m_World, PotentialBlock, &m_Data); + auto PotentialSourceHandler = GetComponentHandler(PotentialBlock); if (PotentialSourceHandler == nullptr) { continue; } - decltype(Power) PotentialPower(PotentialBlock, PotentialSourceHandler->GetPowerDeliveredToPosition(Location, PotentialBlock, PotentialMeta, CurrentLocation, CurrentBlock)); + decltype(Power) PotentialPower(PotentialBlock, PotentialSourceHandler->GetPowerDeliveredToPosition(m_World, Location, PotentialBlock, PotentialMeta, CurrentLocation, CurrentBlock)); Power = std::max(Power, PotentialPower); } // Inform the handler to update - cVector3iArray Updates = CurrentHandler->Update(CurrentLocation, CurrentBlock, CurrentMeta, Power); + cVector3iArray Updates = CurrentHandler->Update(m_World, CurrentLocation, CurrentBlock, CurrentMeta, Power); WorkQueue.insert(WorkQueue.end(), Updates.begin(), Updates.end()); if (IsAlwaysTicked(CurrentBlock)) diff --git a/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h b/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h index 673d50e49..a869b3489 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h +++ b/src/Simulator/IncrementalRedstoneSimulator/IncrementalRedstoneSimulator.h @@ -158,10 +158,13 @@ public: } cIncrementalRedstoneSimulatorChunkData * GetChunkData() { return &m_Data; } - static std::unique_ptr CreateComponent(cWorld & a_World, BLOCKTYPE a_BlockType, cIncrementalRedstoneSimulatorChunkData * a_Data); + + static const cRedstoneHandler * GetComponentHandler(BLOCKTYPE a_BlockType); private: + static std::unique_ptr CreateComponent(BLOCKTYPE a_BlockType); + // oh yea its crazy time cIncrementalRedstoneSimulatorChunkData m_Data; } ; diff --git a/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h b/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h index f2cbf7c81..add608654 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/NoteBlockHandler.h @@ -13,13 +13,10 @@ class cNoteBlockHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cNoteBlockHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -28,19 +25,20 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating sparky the magical note block (%d %d %d) %i", a_Position.x, a_Position.y, a_Position.z, a_PoweringData.PowerLevel); - auto Previous = static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData); + auto Previous = static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData); if ((Previous.PowerLevel != 0) || (a_PoweringData.PowerLevel == 0)) { // If we're already powered or received an update of no power, don't make a sound @@ -57,13 +55,14 @@ public: } } NoteBlockSP; - m_World.DoWithNoteBlockAt(a_Position.x, a_Position.y, a_Position.z, NoteBlockSP); + a_World.DoWithNoteBlockAt(a_Position.x, a_Position.y, a_Position.z, NoteBlockSP); return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents());; diff --git a/src/Simulator/IncrementalRedstoneSimulator/PistonHandler.h b/src/Simulator/IncrementalRedstoneSimulator/PistonHandler.h index f82ebdf94..f41fad89d 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/PistonHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/PistonHandler.h @@ -13,13 +13,9 @@ class cPistonHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cPistonHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -28,18 +24,19 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating pisty the piston (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Data = static_cast(m_World.GetRedstoneSimulator())->GetChunkData(); + auto Data = static_cast(a_World.GetRedstoneSimulator())->GetChunkData(); auto DelayInfo = Data->GetMechanismDelayInfo(a_Position); // Delay is used here to prevent an infinite loop (#3168) @@ -61,11 +58,11 @@ public: { if (ShouldBeExtended) { - cBlockPistonHandler::ExtendPiston(a_Position, &m_World); + cBlockPistonHandler::ExtendPiston(a_Position, a_World); } else { - cBlockPistonHandler::RetractPiston(a_Position, &m_World); + cBlockPistonHandler::RetractPiston(a_Position, a_World); } Data->m_MechanismDelays.erase(a_Position); @@ -75,8 +72,9 @@ public: return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); auto PositionsOffset = GetRelativeAdjacents(); diff --git a/src/Simulator/IncrementalRedstoneSimulator/PoweredRailHandler.h b/src/Simulator/IncrementalRedstoneSimulator/PoweredRailHandler.h index e7d30bec3..0b18ae511 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/PoweredRailHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/PoweredRailHandler.h @@ -12,12 +12,7 @@ class cPoweredRailHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cPoweredRailHandler(cWorld & a_World) : - super(a_World) - { - } - - static const Vector3i GetPoweredRailAdjacentXZCoordinateOffset(NIBBLETYPE a_Meta) // Not in cBlockRailHandler since specific to powered rails + static Vector3i GetPoweredRailAdjacentXZCoordinateOffset(NIBBLETYPE a_Meta) // Not in cBlockRailHandler since specific to powered rails { switch (a_Meta & 0x7) { @@ -35,27 +30,27 @@ public: } } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { UNUSED(a_QueryBlockType); auto Offset = GetPoweredRailAdjacentXZCoordinateOffset(a_Meta); if (((Offset + a_Position) == a_QueryPosition) || ((-Offset + a_Position) == a_QueryPosition)) { - auto Power = GetPowerLevel(a_Position, a_BlockType, a_Meta); + auto Power = GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); return (Power <= 7) ? 0 : --Power; } return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { UNUSED(a_BlockType); UNUSED(a_Meta); - return static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; + return static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating tracky the rail (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); @@ -75,9 +70,9 @@ public: case E_BLOCK_POWERED_RAIL: { auto Offset = GetPoweredRailAdjacentXZCoordinateOffset(a_Meta); - if (a_PoweringData != static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData)) + if (a_PoweringData != static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData)) { - m_World.SetBlockMeta(a_Position, (a_PoweringData.PowerLevel == 0) ? (a_Meta & 0x07) : (a_Meta | 0x08)); + a_World.SetBlockMeta(a_Position, (a_PoweringData.PowerLevel == 0) ? (a_Meta & 0x07) : (a_Meta | 0x08)); return cVector3iArray{ { Offset + a_Position }, { -Offset + a_Position } }; } @@ -91,8 +86,9 @@ public: } } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents()); diff --git a/src/Simulator/IncrementalRedstoneSimulator/PressurePlateHandler.h b/src/Simulator/IncrementalRedstoneSimulator/PressurePlateHandler.h index 07bb1fdc1..14d7baf85 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/PressurePlateHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/PressurePlateHandler.h @@ -13,22 +13,17 @@ class cPressurePlateHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cPressurePlateHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { UNUSED(a_BlockType); UNUSED(a_Meta); UNUSED(a_QueryPosition); UNUSED(a_QueryBlockType); - return static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; + return static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { UNUSED(a_Meta); @@ -56,7 +51,7 @@ public: unsigned int m_NumberOfEntities; bool m_FoundPlayer; } PressurePlateCallback; - m_World.ForEachEntityInBox(cBoundingBox(Vector3d(0.5, 0, 0.5) + a_Position, 0.5, 0.5), PressurePlateCallback); + a_World.ForEachEntityInBox(cBoundingBox(Vector3d(0.5, 0, 0.5) + a_Position, 0.5, 0.5), PressurePlateCallback); switch (a_BlockType) { @@ -84,25 +79,26 @@ public: } } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { UNUSED(a_PoweringData.PowerLevel); // LOGD("Evaluating clicky the pressure plate (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Power = GetPowerLevel(a_Position, a_BlockType, a_Meta); - auto PreviousPower = static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, PoweringData(a_BlockType, Power)); + auto Power = GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); + auto PreviousPower = static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, PoweringData(a_BlockType, Power)); if (Power != PreviousPower.PowerLevel) { - m_World.SetBlockMeta(a_Position, (Power == 0) ? E_META_PRESSURE_PLATE_RAISED : E_META_PRESSURE_PLATE_DEPRESSED); + a_World.SetBlockMeta(a_Position, (Power == 0) ? E_META_PRESSURE_PLATE_RAISED : E_META_PRESSURE_PLATE_DEPRESSED); return GetAdjustedRelatives(a_Position, StaticAppend(GetRelativeLaterals(), cVector3iArray{ OffsetYM() })); } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneBlockHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneBlockHandler.h index 18a775b7d..4151fc9ad 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneBlockHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneBlockHandler.h @@ -12,13 +12,9 @@ class cRedstoneBlockHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cRedstoneBlockHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -26,22 +22,24 @@ public: return cIncrementalRedstoneSimulator::IsMechanism(a_QueryBlockType) ? 15 : 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 15; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating crimson the redstone block (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneComparatorHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneComparatorHandler.h index 34af3ccbc..55efee6b5 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneComparatorHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneComparatorHandler.h @@ -13,12 +13,7 @@ class cRedstoneComparatorHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cRedstoneComparatorHandler(cWorld & a_World) : - super(a_World) - { - } - - unsigned char GetFrontPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, unsigned char a_HighestSidePowerLevel, unsigned char a_HighestRearPowerLevel) + unsigned char GetFrontPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, unsigned char a_HighestSidePowerLevel, unsigned char a_HighestRearPowerLevel) const { if (cBlockComparatorHandler::IsInSubtractionMode(a_Meta)) { @@ -32,15 +27,19 @@ public: } } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { UNUSED(a_QueryPosition); UNUSED(a_QueryBlockType); + auto ChunkData = static_cast(a_World.GetRedstoneSimulator())->GetChunkData(); - return (cBlockComparatorHandler::GetFrontCoordinate(a_Position, a_Meta & 0x3) == a_QueryPosition) ? static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel : 0; + return ( + (cBlockComparatorHandler::GetFrontCoordinate(a_Position, a_Meta & 0x3) == a_QueryPosition) ? + ChunkData->GetCachedPowerData(a_Position).PowerLevel : 0 + ); } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { UNUSED(a_Position); UNUSED(a_BlockType); @@ -77,36 +76,33 @@ public: } CCB; auto RearCoordinate = cBlockComparatorHandler::GetRearCoordinate(a_Position, a_Meta & 0x3); - m_World.DoWithBlockEntityAt(RearCoordinate.x, RearCoordinate.y, RearCoordinate.z, CCB); + a_World.DoWithBlockEntityAt(RearCoordinate.x, RearCoordinate.y, RearCoordinate.z, CCB); auto RearPower = CCB.m_SignalStrength; + auto RearType = a_World.GetBlock(RearCoordinate); - auto PotentialSourceHandler = cIncrementalRedstoneSimulator::CreateComponent(m_World, m_World.GetBlock(RearCoordinate), static_cast(m_World.GetRedstoneSimulator())->GetChunkData()); + auto PotentialSourceHandler = cIncrementalRedstoneSimulator::GetComponentHandler(RearType); if (PotentialSourceHandler != nullptr) { - BLOCKTYPE Type; - NIBBLETYPE Meta; - if (m_World.GetBlockTypeMeta(RearCoordinate.x, RearCoordinate.y, RearCoordinate.z, Type, Meta)) - { - RearPower = std::max(CCB.m_SignalStrength, PotentialSourceHandler->GetPowerDeliveredToPosition(RearCoordinate, Type, Meta, a_Position, a_BlockType)); - } + NIBBLETYPE RearMeta = a_World.GetBlockMeta(RearCoordinate); + RearPower = std::max(CCB.m_SignalStrength, PotentialSourceHandler->GetPowerDeliveredToPosition(a_World, RearCoordinate, RearType, RearMeta, a_Position, a_BlockType)); } return RearPower; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // Note that a_PoweringData here contains the maximum * side * power level, as specified by GetValidSourcePositions // LOGD("Evaluating ALU the comparator (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Data = static_cast(m_World.GetRedstoneSimulator())->GetChunkData(); + auto Data = static_cast(a_World.GetRedstoneSimulator())->GetChunkData(); auto DelayInfo = Data->GetMechanismDelayInfo(a_Position); // Delay is used here to prevent an infinite loop (#3168) if (DelayInfo == nullptr) { - auto RearPower = GetPowerLevel(a_Position, a_BlockType, a_Meta); - auto FrontPower = GetFrontPowerLevel(a_Position, a_BlockType, a_Meta, a_PoweringData.PowerLevel, RearPower); - auto PreviousFrontPower = static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, PoweringData(a_PoweringData.PoweringBlock, FrontPower)); + auto RearPower = GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); + auto FrontPower = GetFrontPowerLevel(a_World, a_Position, a_BlockType, a_Meta, a_PoweringData.PowerLevel, RearPower); + auto PreviousFrontPower = Data->ExchangeUpdateOncePowerData(a_Position, PoweringData(a_PoweringData.PoweringBlock, FrontPower)); bool ShouldBeOn = (RearPower > 0); // Provide visual indication by examining * rear * power level bool ShouldUpdate = (FrontPower != PreviousFrontPower.PowerLevel); // "Business logic" (:P) - determine by examining *side* power levels @@ -124,7 +120,7 @@ public: if (DelayTicks == 0) { - m_World.SetBlockMeta(a_Position, ShouldPowerOn ? (a_Meta | 0x8) : (a_Meta & 0x7)); + a_World.SetBlockMeta(a_Position, ShouldPowerOn ? (a_Meta | 0x8) : (a_Meta & 0x7)); Data->m_MechanismDelays.erase(a_Position); // Assume that an update (to front power) is needed. @@ -138,8 +134,9 @@ public: return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); return cVector3iArray {cBlockComparatorHandler::GetSideCoordinate(a_Position, a_Meta & 0x3, false), cBlockComparatorHandler::GetSideCoordinate(a_Position, a_Meta & 0x3, true)}; } diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.h index 36fe640f1..48356ee9c 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneHandler.h @@ -12,16 +12,8 @@ class cRedstoneHandler { public: - cRedstoneHandler(cWorld & a_World) : - m_World(a_World) - { - } - -public: - - // Disable the copy constructor and assignment operator - cRedstoneHandler(const cRedstoneHandler &) = delete; - cRedstoneHandler & operator=(const cRedstoneHandler &) = delete; + cRedstoneHandler() = default; + DISALLOW_COPY_AND_ASSIGN(cRedstoneHandler); struct PoweringData { @@ -63,44 +55,44 @@ public: } }; - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) = 0; - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) = 0; - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) = 0; - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) = 0; + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const = 0; + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const = 0; + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const = 0; + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const = 0; // Force a virtual destructor virtual ~cRedstoneHandler() {} protected: - cWorld & m_World; - template - static const Container StaticAppend(const Container && a_Lhs, const Container && a_Rhs) + static Container StaticAppend(const Container & a_Lhs, const Container & a_Rhs) { Container ToReturn = a_Lhs; std::copy(a_Rhs.begin(), a_Rhs.end(), std::back_inserter(ToReturn)); return ToReturn; } - inline static const Vector3i OffsetYP() + inline static Vector3i OffsetYP() { return Vector3i(0, 1, 0); } - inline static const Vector3i OffsetYM() + inline static Vector3i OffsetYM() { return Vector3i(0, -1, 0); } - static const cVector3iArray GetAdjustedRelatives(const Vector3i & a_Position, const cVector3iArray & a_Relatives) + static cVector3iArray GetAdjustedRelatives(Vector3i a_Position, cVector3iArray a_Relatives) { - cVector3iArray Adjusted = a_Relatives; - std::for_each(Adjusted.begin(), Adjusted.end(), [a_Position](cVector3iArray::value_type & a_Entry) { a_Entry += a_Position; }); - return Adjusted; + for (auto & Entry : a_Relatives) + { + Entry += a_Position; + } + return a_Relatives; } - inline static const cVector3iArray GetRelativeAdjacents() + inline static cVector3iArray GetRelativeAdjacents() { return { @@ -115,7 +107,7 @@ protected: }; } - inline static const cVector3iArray GetRelativeLaterals() + inline static cVector3iArray GetRelativeLaterals() { return { diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneLampHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneLampHandler.h index 4d6902feb..5d9cd241b 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneLampHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneLampHandler.h @@ -11,27 +11,22 @@ class cRedstoneLampHandler : public cRedstoneHandler { public: - cRedstoneLampHandler(cWorld & a_World) : - cRedstoneHandler(a_World) - { - } - inline static bool IsOn(BLOCKTYPE a_BlockType) { return (a_BlockType == E_BLOCK_REDSTONE_LAMP_ON); } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating lamp (%i %i %i)", a_Position.x, a_Position.y, a_Position.z); @@ -39,22 +34,23 @@ public: { if (!IsOn(a_BlockType)) { - m_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, E_BLOCK_REDSTONE_LAMP_ON, 0); + a_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, E_BLOCK_REDSTONE_LAMP_ON, 0); } } else { if (IsOn(a_BlockType)) { - m_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, E_BLOCK_REDSTONE_LAMP_OFF, 0); + a_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, E_BLOCK_REDSTONE_LAMP_OFF, 0); } } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Meta); UNUSED(a_BlockType); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents()); diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneRepeaterHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneRepeaterHandler.h index bf95b66e7..9d8dda1bb 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneRepeaterHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneRepeaterHandler.h @@ -13,32 +13,31 @@ class cRedstoneRepeaterHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cRedstoneRepeaterHandler(cWorld & a_World) : - super(a_World) - { - } - inline static bool IsOn(BLOCKTYPE a_Block) { return (a_Block == E_BLOCK_REDSTONE_REPEATER_ON); } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { - return (a_QueryPosition == (a_Position + cBlockRedstoneRepeaterHandler::GetFrontCoordinateOffset(a_Meta))) ? GetPowerLevel(a_Position, a_BlockType, a_Meta) : 0; + return ( + (a_QueryPosition == (a_Position + cBlockRedstoneRepeaterHandler::GetFrontCoordinateOffset(a_Meta))) ? + GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta) : 0 + ); } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_Meta); return IsOn(a_BlockType) ? 15 : 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating loopy the repeater (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Data = static_cast(m_World.GetRedstoneSimulator())->GetChunkData(); + auto Data = static_cast(a_World.GetRedstoneSimulator())->GetChunkData(); auto DelayInfo = Data->GetMechanismDelayInfo(a_Position); if (DelayInfo == nullptr) @@ -57,7 +56,7 @@ public: if (DelayTicks == 0) { - m_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, ShouldPowerOn ? E_BLOCK_REDSTONE_REPEATER_ON : E_BLOCK_REDSTONE_REPEATER_OFF, a_Meta); + a_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, ShouldPowerOn ? E_BLOCK_REDSTONE_REPEATER_ON : E_BLOCK_REDSTONE_REPEATER_OFF, a_Meta); Data->m_MechanismDelays.erase(a_Position); return cVector3iArray{ cBlockRedstoneRepeaterHandler::GetFrontCoordinateOffset(a_Meta) + a_Position }; } @@ -66,7 +65,7 @@ public: return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { return { cBlockRedstoneRepeaterHandler::GetRearCoordinateOffset(a_Meta) + a_Position }; } diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneToggleHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneToggleHandler.h index 160614bc3..9d950a8b9 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneToggleHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneToggleHandler.h @@ -14,12 +14,7 @@ class cRedstoneToggleHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cRedstoneToggleHandler(cWorld & a_World) : - super(a_World) - { - } - - inline static const Vector3i GetPositionAttachedTo(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) + inline static Vector3i GetPositionAttachedTo(Vector3i a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) { switch (a_BlockType) { @@ -68,18 +63,19 @@ public: } } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { UNUSED(a_QueryBlockType); if ((GetPositionAttachedTo(a_Position, a_BlockType, a_Meta) == a_QueryPosition) || cIncrementalRedstoneSimulator::IsMechanism(a_QueryBlockType)) { - return GetPowerLevel(a_Position, a_BlockType, a_Meta); + return GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); } return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); switch (a_BlockType) @@ -95,14 +91,15 @@ public: } } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating templatio<> the lever/button (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneTorchHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneTorchHandler.h index a95cf2e24..b892dedb5 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneTorchHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneTorchHandler.h @@ -11,17 +11,12 @@ class cRedstoneTorchHandler : public cRedstoneHandler { public: - cRedstoneTorchHandler(cWorld & a_World) : - cRedstoneHandler(a_World) - { - } - inline static bool IsOn(BLOCKTYPE a_Block) { return (a_Block == E_BLOCK_REDSTONE_TORCH_ON); } - inline static const Vector3i GetOffsetAttachedTo(const Vector3i & a_Position, NIBBLETYPE a_Meta) + inline static Vector3i GetOffsetAttachedTo(const Vector3i & a_Position, NIBBLETYPE a_Meta) { switch (a_Meta) { @@ -38,7 +33,7 @@ public: } } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { if ( IsOn(a_BlockType) && @@ -51,16 +46,16 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { return IsOn(a_BlockType) ? 15 : 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating torchy the redstone torch (%i %i %i)", a_Position.x, a_Position.y, a_Position.z); - auto Data = static_cast(m_World.GetRedstoneSimulator())->GetChunkData(); + auto Data = static_cast(a_World.GetRedstoneSimulator())->GetChunkData(); auto DelayInfo = Data->GetMechanismDelayInfo(a_Position); if (DelayInfo == nullptr) @@ -79,7 +74,7 @@ public: if (DelayTicks == 0) { - m_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, ShouldPowerOn ? E_BLOCK_REDSTONE_TORCH_ON : E_BLOCK_REDSTONE_TORCH_OFF, a_Meta); + a_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, ShouldPowerOn ? E_BLOCK_REDSTONE_TORCH_ON : E_BLOCK_REDSTONE_TORCH_OFF, a_Meta); Data->m_MechanismDelays.erase(a_Position); cVector3iArray RelativePositions = GetRelativeAdjacents(); @@ -91,8 +86,9 @@ public: return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); return { (a_Position + GetOffsetAttachedTo(a_Position, a_Meta)) }; } diff --git a/src/Simulator/IncrementalRedstoneSimulator/RedstoneWireHandler.h b/src/Simulator/IncrementalRedstoneSimulator/RedstoneWireHandler.h index e9543bb02..7b2a60323 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/RedstoneWireHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/RedstoneWireHandler.h @@ -12,11 +12,6 @@ class cRedstoneWireHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cRedstoneWireHandler(cWorld & a_World) : - super(a_World) - { - } - inline static bool IsDirectlyConnectingMechanism(BLOCKTYPE a_Block) { switch (a_Block) @@ -32,26 +27,26 @@ public: } } - const cVector3iArray GetTerracingConnectionOffsets(const Vector3i & a_Position) + cVector3iArray GetTerracingConnectionOffsets(cWorld & a_World, const Vector3i & a_Position) const { cVector3iArray RelativePositions; - auto YPTerraceBlock = m_World.GetBlock(a_Position + OffsetYP()); + auto YPTerraceBlock = a_World.GetBlock(a_Position + OffsetYP()); bool IsYPTerracingBlocked = cBlockInfo::IsSolid(YPTerraceBlock) && !cBlockInfo::IsTransparent(YPTerraceBlock); for (const auto & Adjacent : GetRelativeLaterals()) { if ( !IsYPTerracingBlocked && - (m_World.GetBlock(a_Position + Adjacent + OffsetYP()) == E_BLOCK_REDSTONE_WIRE) + (a_World.GetBlock(a_Position + Adjacent + OffsetYP()) == E_BLOCK_REDSTONE_WIRE) ) { RelativePositions.emplace_back(Adjacent + OffsetYP()); } - auto YMTerraceBlock = m_World.GetBlock(a_Position + Adjacent); + auto YMTerraceBlock = a_World.GetBlock(a_Position + Adjacent); if ( // IsYMTerracingBlocked (i.e. check block above lower terracing position, a.k.a. just the plain adjacent) (!cBlockInfo::IsSolid(YMTerraceBlock) || cBlockInfo::IsTransparent(YMTerraceBlock)) && - (m_World.GetBlock(a_Position + Adjacent + OffsetYM()) == E_BLOCK_REDSTONE_WIRE) + (a_World.GetBlock(a_Position + Adjacent + OffsetYM()) == E_BLOCK_REDSTONE_WIRE) ) { RelativePositions.emplace_back(Adjacent + OffsetYM()); @@ -61,7 +56,7 @@ public: return RelativePositions; } - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { if (a_QueryPosition == (a_Position + OffsetYP())) { @@ -80,9 +75,9 @@ public: Vector3i PotentialOffset; bool FoundOneBorderingMechanism = false; - for (const auto & Offset : StaticAppend(GetRelativeLaterals(), GetTerracingConnectionOffsets(a_Position))) + for (const auto & Offset : StaticAppend(GetRelativeLaterals(), GetTerracingConnectionOffsets(a_World, a_Position))) { - if (IsDirectlyConnectingMechanism(m_World.GetBlock(Offset + a_Position))) + if (IsDirectlyConnectingMechanism(a_World.GetBlock(Offset + a_Position))) { if (FoundOneBorderingMechanism) { @@ -105,32 +100,34 @@ public: return (a_Meta != 0) ? --a_Meta : a_Meta; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); return a_Meta; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { UNUSED(a_BlockType); // LOGD("Evaluating dusty the wire (%d %d %d) %i", a_Position.x, a_Position.y, a_Position.z, a_PoweringData.PowerLevel); if (a_Meta != a_PoweringData.PowerLevel) { - m_World.SetBlockMeta(a_Position, a_PoweringData.PowerLevel); - return GetAdjustedRelatives(a_Position, StaticAppend(StaticAppend(GetRelativeLaterals(), GetTerracingConnectionOffsets(a_Position)), cVector3iArray{ OffsetYM() })); + a_World.SetBlockMeta(a_Position, a_PoweringData.PowerLevel); + return GetAdjustedRelatives(a_Position, StaticAppend(StaticAppend(GetRelativeLaterals(), GetTerracingConnectionOffsets(a_World, a_Position)), cVector3iArray{ OffsetYM() })); } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); - return GetAdjustedRelatives(a_Position, StaticAppend(GetRelativeAdjacents(), GetTerracingConnectionOffsets(a_Position))); + return GetAdjustedRelatives(a_Position, StaticAppend(GetRelativeAdjacents(), GetTerracingConnectionOffsets(a_World, a_Position))); } }; diff --git a/src/Simulator/IncrementalRedstoneSimulator/SmallGateHandler.h b/src/Simulator/IncrementalRedstoneSimulator/SmallGateHandler.h index 1844f417d..6c201f354 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/SmallGateHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/SmallGateHandler.h @@ -12,13 +12,9 @@ class cSmallGateHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cSmallGateHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -27,28 +23,30 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating gateydory the fence gate/trapdoor (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - - if (a_PoweringData != static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData)) + auto Data = static_cast(a_World.GetRedstoneSimulator())->GetChunkData(); + if (a_PoweringData != Data->ExchangeUpdateOncePowerData(a_Position, a_PoweringData)) { - m_World.SetBlockMeta(a_Position, (a_PoweringData.PowerLevel > 0) ? (a_Meta | 0x4) : (a_Meta & ~0x04)); + a_World.SetBlockMeta(a_Position, (a_PoweringData.PowerLevel > 0) ? (a_Meta | 0x4) : (a_Meta & ~0x04)); } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents());; diff --git a/src/Simulator/IncrementalRedstoneSimulator/SolidBlockHandler.h b/src/Simulator/IncrementalRedstoneSimulator/SolidBlockHandler.h index 341b5ae36..215ccd990 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/SolidBlockHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/SolidBlockHandler.h @@ -12,35 +12,30 @@ class cSolidBlockHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cSolidBlockHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { // TODO: wire isn't linked powered only if the source was a wire, not just because it is a wire return ( !cIncrementalRedstoneSimulator::IsRedstone(a_QueryBlockType) || ( (a_QueryBlockType == E_BLOCK_REDSTONE_WIRE) && - (static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PoweringBlock == E_BLOCK_REDSTONE_WIRE) + (static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PoweringBlock == E_BLOCK_REDSTONE_WIRE) ) - ) ? 0 : GetPowerLevel(a_Position, a_BlockType, a_Meta); + ) ? 0 : GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { - return static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; + return static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { UNUSED(a_BlockType); UNUSED(a_Meta); // LOGD("Evaluating blocky the generic block (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto PreviousPower = static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData); + auto PreviousPower = static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, a_PoweringData); if ((a_PoweringData != PreviousPower) || (a_PoweringData.PoweringBlock != PreviousPower.PoweringBlock)) { return GetAdjustedRelatives(a_Position, GetRelativeAdjacents()); @@ -49,8 +44,9 @@ public: return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); diff --git a/src/Simulator/IncrementalRedstoneSimulator/TNTHandler.h b/src/Simulator/IncrementalRedstoneSimulator/TNTHandler.h index c313bd07d..253b502fe 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/TNTHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/TNTHandler.h @@ -14,13 +14,9 @@ class cTNTHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cTNTHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); @@ -29,28 +25,30 @@ public: return 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating explodinator the trinitrotoluene (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); if (a_PoweringData.PowerLevel != 0) { - m_World.BroadcastSoundEffect("entity.tnt.primed", static_cast(a_Position.x), static_cast(a_Position.y), static_cast(a_Position.z), 0.5f, 0.6f); - m_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, E_BLOCK_AIR, 0); - m_World.SpawnPrimedTNT(a_Position.x + 0.5, a_Position.y + 0.5, a_Position.z + 0.5); // 80 ticks to boom + a_World.BroadcastSoundEffect("entity.tnt.primed", static_cast(a_Position.x), static_cast(a_Position.y), static_cast(a_Position.z), 0.5f, 0.6f); + a_World.SetBlock(a_Position.x, a_Position.y, a_Position.z, E_BLOCK_AIR, 0); + a_World.SpawnPrimedTNT(a_Position.x + 0.5, a_Position.y + 0.5, a_Position.z + 0.5); // 80 ticks to boom } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents());; diff --git a/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h b/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h index 561c32d19..8b7b82d49 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/TrappedChestHandler.h @@ -13,22 +13,17 @@ class cTrappedChestHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cTrappedChestHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { UNUSED(a_BlockType); UNUSED(a_Meta); UNUSED(a_QueryPosition); UNUSED(a_QueryBlockType); - return static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; + return static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->GetCachedPowerData(a_Position).PowerLevel; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { UNUSED(a_BlockType); UNUSED(a_Meta); @@ -63,16 +58,16 @@ public: } GTCP; - VERIFY(!m_World.DoWithChestAt(a_Position.x, a_Position.y, a_Position.z, GTCP)); + VERIFY(!a_World.DoWithChestAt(a_Position.x, a_Position.y, a_Position.z, GTCP)); return GTCP.GetPowerLevel(); } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating tricky the trapped chest (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Power = GetPowerLevel(a_Position, a_BlockType, a_Meta); - auto PreviousPower = static_cast(m_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, PoweringData(a_BlockType, Power)); + auto Power = GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); + auto PreviousPower = static_cast(a_World.GetRedstoneSimulator())->GetChunkData()->ExchangeUpdateOncePowerData(a_Position, PoweringData(a_BlockType, Power)); if (Power != PreviousPower.PowerLevel) { @@ -82,8 +77,9 @@ public: return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_Position); UNUSED(a_BlockType); UNUSED(a_Meta); diff --git a/src/Simulator/IncrementalRedstoneSimulator/TripwireHookHandler.h b/src/Simulator/IncrementalRedstoneSimulator/TripwireHookHandler.h index 382a1c311..85c05430c 100644 --- a/src/Simulator/IncrementalRedstoneSimulator/TripwireHookHandler.h +++ b/src/Simulator/IncrementalRedstoneSimulator/TripwireHookHandler.h @@ -13,20 +13,15 @@ class cTripwireHookHandler : public cRedstoneHandler typedef cRedstoneHandler super; public: - cTripwireHookHandler(cWorld & a_World) : - super(a_World) - { - } - - virtual unsigned char GetPowerDeliveredToPosition(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) override + virtual unsigned char GetPowerDeliveredToPosition(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, const Vector3i & a_QueryPosition, BLOCKTYPE a_QueryBlockType) const override { UNUSED(a_QueryBlockType); UNUSED(a_QueryPosition); - return (GetPowerLevel(a_Position, a_BlockType, a_Meta) == 15) ? 15 : 0; + return (GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta) == 15) ? 15 : 0; } - virtual unsigned char GetPowerLevel(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual unsigned char GetPowerLevel(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { UNUSED(a_BlockType); @@ -40,7 +35,7 @@ public: NIBBLETYPE Meta; AddFaceDirection(Position.x, Position.y, Position.z, FaceToGoTowards); - m_World.GetBlockTypeMeta(Position.x, Position.y, Position.z, Type, Meta); + a_World.GetBlockTypeMeta(Position.x, Position.y, Position.z, Type, Meta); if (Type == E_BLOCK_TRIPWIRE) { @@ -63,7 +58,7 @@ public: bool m_FoundPlayer; } TripwireCallback; - if (!m_World.ForEachEntityInBox(cBoundingBox(Vector3d(0.5, 0, 0.5) + Position, 0.5, 0.5), TripwireCallback)) + if (!a_World.ForEachEntityInBox(cBoundingBox(Vector3d(0.5, 0, 0.5) + Position, 0.5, 0.5), TripwireCallback)) { FoundActivated = true; } @@ -91,11 +86,11 @@ public: return 0; } - virtual cVector3iArray Update(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) override + virtual cVector3iArray Update(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta, PoweringData a_PoweringData) const override { // LOGD("Evaluating hooky the tripwire hook (%d %d %d)", a_Position.x, a_Position.y, a_Position.z); - auto Power = GetPowerLevel(a_Position, a_BlockType, a_Meta); + auto Power = GetPowerLevel(a_World, a_Position, a_BlockType, a_Meta); NIBBLETYPE Meta; if (Power == 0) { @@ -119,15 +114,16 @@ public: if (Meta != a_Meta) { - m_World.SetBlockMeta(a_Position, Meta); + a_World.SetBlockMeta(a_Position, Meta); return GetAdjustedRelatives(a_Position, GetRelativeAdjacents()); } return {}; } - virtual cVector3iArray GetValidSourcePositions(const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) override + virtual cVector3iArray GetValidSourcePositions(cWorld & a_World, const Vector3i & a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_Meta) const override { + UNUSED(a_World); UNUSED(a_BlockType); UNUSED(a_Meta); UNUSED(a_Position); -- cgit v1.2.3