From c52f299e724bf893944553ac3aeedf7bf0a58241 Mon Sep 17 00:00:00 2001 From: Tiger Wang Date: Sun, 2 Jan 2022 11:56:36 +0000 Subject: Handlers: update item and block handlers (#5371) + Resend blocks when server rejects placement because in a block * Fix chest handler not invoked, fixes #5367 * Fix comparator handler not invoked * Update some naming --- src/Blocks/BlockEnderChest.h | 40 ++++++ src/Blocks/BlockEnderchest.h | 44 ------- src/Blocks/BlockHandler.cpp | 42 +++---- src/Blocks/BlockRedstone.h | 70 ----------- src/Blocks/BlockRedstoneWire.h | 70 +++++++++++ src/Blocks/BlockSugarCane.h | 140 +++++++++++++++++++++ src/Blocks/BlockSugarcane.h | 140 --------------------- src/Blocks/BlockVine.h | 271 ----------------------------------------- src/Blocks/BlockVines.h | 271 +++++++++++++++++++++++++++++++++++++++++ src/Blocks/CMakeLists.txt | 8 +- src/Items/CMakeLists.txt | 4 +- src/Items/ItemComparator.h | 15 +-- src/Items/ItemDefaultItem.h | 7 ++ src/Items/ItemEnderChest.h | 26 ++++ src/Items/ItemEnderchest.h | 26 ---- src/Items/ItemHandler.cpp | 74 +++++------ src/Items/ItemVine.h | 44 ------- src/Items/ItemVines.h | 44 +++++++ 18 files changed, 664 insertions(+), 672 deletions(-) create mode 100644 src/Blocks/BlockEnderChest.h delete mode 100644 src/Blocks/BlockEnderchest.h delete mode 100644 src/Blocks/BlockRedstone.h create mode 100644 src/Blocks/BlockRedstoneWire.h create mode 100644 src/Blocks/BlockSugarCane.h delete mode 100644 src/Blocks/BlockSugarcane.h delete mode 100644 src/Blocks/BlockVine.h create mode 100644 src/Blocks/BlockVines.h create mode 100644 src/Items/ItemEnderChest.h delete mode 100644 src/Items/ItemEnderchest.h delete mode 100644 src/Items/ItemVine.h create mode 100644 src/Items/ItemVines.h diff --git a/src/Blocks/BlockEnderChest.h b/src/Blocks/BlockEnderChest.h new file mode 100644 index 000000000..2e0da0f17 --- /dev/null +++ b/src/Blocks/BlockEnderChest.h @@ -0,0 +1,40 @@ + +#pragma once + +#include "Mixins.h" + + + + +class cBlockEnderChestHandler final : + public cYawRotator +{ + using Super = cYawRotator; + +public: + + using Super::Super; + +private: + + virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override + { + // Only drop something when mined with a pickaxe: + if ( + (a_Tool != nullptr) && + ItemCategory::IsPickaxe(a_Tool->m_ItemType) + ) + { + // Only drop self when mined with a silk-touch pickaxe: + if (a_Tool->m_Enchantments.GetLevel(cEnchantments::enchSilkTouch) > 0) + { + return cItem(E_BLOCK_ENDER_CHEST); + } + + return cItem(E_BLOCK_OBSIDIAN, 8); + } + + return {}; + } + +}; diff --git a/src/Blocks/BlockEnderchest.h b/src/Blocks/BlockEnderchest.h deleted file mode 100644 index aae16ccec..000000000 --- a/src/Blocks/BlockEnderchest.h +++ /dev/null @@ -1,44 +0,0 @@ - -#pragma once - -#include "Mixins.h" - - - - -class cBlockEnderchestHandler final : - public cYawRotator -{ - using Super = cYawRotator; - -public: - - using Super::Super; - -private: - - virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override - { - // Only drop something when mined with a pickaxe: - if ( - (a_Tool != nullptr) && - ItemCategory::IsPickaxe(a_Tool->m_ItemType) - ) - { - // Only drop self when mined with a silk-touch pickaxe: - if (a_Tool->m_Enchantments.GetLevel(cEnchantments::enchSilkTouch) > 0) - { - return cItem(E_BLOCK_ENDER_CHEST); - } - - return cItem(E_BLOCK_OBSIDIAN, 8); - } - - return {}; - } - -}; - - - - diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp index 2ce7904ab..937f800fd 100644 --- a/src/Blocks/BlockHandler.cpp +++ b/src/Blocks/BlockHandler.cpp @@ -33,7 +33,7 @@ #include "BlockDropSpenser.h" #include "BlockEnchantingTable.h" #include "BlockEndPortalFrame.h" -#include "BlockEnderchest.h" +#include "BlockEnderChest.h" #include "BlockEntity.h" #include "BlockFarmland.h" #include "BlockFence.h" @@ -75,7 +75,7 @@ #include "BlockPumpkin.h" #include "BlockQuartz.h" #include "BlockRail.h" -#include "BlockRedstone.h" +#include "BlockRedstoneWire.h" #include "BlockRedstoneLamp.h" #include "BlockRedstoneOre.h" #include "BlockRedstoneRepeater.h" @@ -91,14 +91,14 @@ #include "BlockStairs.h" #include "BlockStems.h" #include "BlockStone.h" -#include "BlockSugarcane.h" +#include "BlockSugarCane.h" #include "BlockTNT.h" #include "BlockTallGrass.h" #include "BlockTorch.h" #include "BlockTrapdoor.h" #include "BlockTripwire.h" #include "BlockTripwireHook.h" -#include "BlockVine.h" +#include "BlockVines.h" #include "BlockWallSign.h" #include "BlockWorkbench.h" @@ -215,14 +215,14 @@ namespace constexpr cBlockStairsHandler BlockBirchWoodStairsHandler (E_BLOCK_BIRCH_WOOD_STAIRS); constexpr cBlockGlazedTerracottaHandler BlockBlackGlazedTerracottaHandler (E_BLOCK_BLACK_GLAZED_TERRACOTTA); constexpr cDefaultBlockHandler BlockBlackShulkerBoxHandler (E_BLOCK_BLACK_SHULKER_BOX); - constexpr cDefaultBlockHandler BlockBlockOfCoalHandler (E_BLOCK_BLOCK_OF_COAL); - constexpr cDefaultBlockHandler BlockBlockOfRedstoneHandler (E_BLOCK_BLOCK_OF_REDSTONE); + constexpr cDefaultBlockHandler BlockCoalBlockHandler (E_BLOCK_BLOCK_OF_COAL); + constexpr cDefaultBlockHandler BlockRedstoneBlockHandler (E_BLOCK_BLOCK_OF_REDSTONE); constexpr cBlockGlazedTerracottaHandler BlockBlueGlazedTerracottaHandler (E_BLOCK_BLUE_GLAZED_TERRACOTTA); constexpr cDefaultBlockHandler BlockBlueShulkerBoxHandler (E_BLOCK_BLUE_SHULKER_BOX); constexpr cDefaultBlockHandler BlockBoneBlockHandler (E_BLOCK_BONE_BLOCK); constexpr cBlockBookShelfHandler BlockBookcaseHandler (E_BLOCK_BOOKCASE); constexpr cBlockBrewingStandHandler BlockBrewingStandHandler (E_BLOCK_BREWING_STAND); - constexpr cDefaultBlockHandler BlockBrickHandler (E_BLOCK_BRICK); + constexpr cDefaultBlockHandler BlockBricksHandler (E_BLOCK_BRICK); constexpr cBlockStairsHandler BlockBrickStairsHandler (E_BLOCK_BRICK_STAIRS); constexpr cBlockGlazedTerracottaHandler BlockBrownGlazedTerracottaHandler (E_BLOCK_BROWN_GLAZED_TERRACOTTA); constexpr cBlockMushroomHandler BlockBrownMushroomHandler (E_BLOCK_BROWN_MUSHROOM); @@ -274,7 +274,7 @@ namespace constexpr cDefaultBlockHandler BlockEndPortalHandler (E_BLOCK_END_PORTAL); constexpr cDefaultBlockHandler BlockEndRodHandler (E_BLOCK_END_ROD); constexpr cDefaultBlockHandler BlockEndStoneHandler (E_BLOCK_END_STONE); - constexpr cBlockEnderchestHandler BlockEnderChestHandler (E_BLOCK_ENDER_CHEST); + constexpr cBlockEnderChestHandler BlockEnderChestHandler (E_BLOCK_ENDER_CHEST); constexpr cBlockFarmlandHandler BlockFarmlandHandler (E_BLOCK_FARMLAND); constexpr cBlockFenceHandler BlockFenceHandler (E_BLOCK_FENCE); constexpr cBlockFireHandler BlockFireHandler (E_BLOCK_FIRE); @@ -339,7 +339,7 @@ namespace constexpr cDefaultBlockHandler BlockMossyCobblestoneHandler (E_BLOCK_MOSSY_COBBLESTONE); constexpr cBlockMyceliumHandler BlockMyceliumHandler (E_BLOCK_MYCELIUM); constexpr cBlockFenceHandler BlockNetherBrickFenceHandler (E_BLOCK_NETHER_BRICK_FENCE); - constexpr cDefaultBlockHandler BlockNetherBrickHandler (E_BLOCK_NETHER_BRICK); + constexpr cDefaultBlockHandler BlockNetherBricksHandler (E_BLOCK_NETHER_BRICK); constexpr cBlockStairsHandler BlockNetherBrickStairsHandler (E_BLOCK_NETHER_BRICK_STAIRS); constexpr cBlockPortalHandler BlockNetherPortalHandler (E_BLOCK_NETHER_PORTAL); constexpr cDefaultOreHandler BlockNetherQuartzOreHandler (E_BLOCK_NETHER_QUARTZ_ORE); @@ -380,7 +380,7 @@ namespace constexpr cBlockRailHandler BlockRailHandler (E_BLOCK_RAIL); constexpr cBlockGlazedTerracottaHandler BlockRedGlazedTerracottaHandler (E_BLOCK_RED_GLAZED_TERRACOTTA); constexpr cBlockMushroomHandler BlockRedMushroomHandler (E_BLOCK_RED_MUSHROOM); - constexpr cDefaultBlockHandler BlockRedNetherBrickHandler (E_BLOCK_RED_NETHER_BRICK); + constexpr cDefaultBlockHandler BlockRedNetherBricksHandler (E_BLOCK_RED_NETHER_BRICK); constexpr cBlockFlowerHandler BlockRedRoseHandler (E_BLOCK_RED_ROSE); constexpr cDefaultBlockHandler BlockRedSandstoneHandler (E_BLOCK_RED_SANDSTONE); constexpr cBlockSlabHandler BlockRedSandstoneSlabHandler (E_BLOCK_RED_SANDSTONE_SLAB); @@ -393,7 +393,7 @@ namespace constexpr cBlockRedstoneRepeaterHandler BlockRedstoneRepeaterOnHandler (E_BLOCK_REDSTONE_REPEATER_ON); constexpr cBlockRedstoneTorchHandler BlockRedstoneTorchOffHandler (E_BLOCK_REDSTONE_TORCH_OFF); constexpr cBlockRedstoneTorchHandler BlockRedstoneTorchOnHandler (E_BLOCK_REDSTONE_TORCH_ON); - constexpr cBlockRedstoneHandler BlockRedstoneWireHandler (E_BLOCK_REDSTONE_WIRE); + constexpr cBlockRedstoneWireHandler BlockRedstoneWireHandler (E_BLOCK_REDSTONE_WIRE); constexpr cBlockCommandBlockHandler BlockRepeatingCommandBlockHandler (E_BLOCK_REPEATING_COMMAND_BLOCK); constexpr cBlockSandHandler BlockSandHandler (E_BLOCK_SAND); constexpr cDefaultBlockHandler BlockSandstoneHandler (E_BLOCK_SANDSTONE); @@ -425,15 +425,15 @@ namespace constexpr cBlockSlabHandler BlockStoneSlabHandler (E_BLOCK_STONE_SLAB); constexpr cDefaultBlockHandler BlockStructureBlockHandler (E_BLOCK_STRUCTURE_BLOCK); constexpr cDefaultBlockHandler BlockStructureVoidHandler (E_BLOCK_STRUCTURE_VOID); - constexpr cBlockSugarcaneHandler BlockSugarcaneHandler (E_BLOCK_SUGARCANE); + constexpr cBlockSugarCaneHandler BlockSugarCaneHandler (E_BLOCK_SUGARCANE); constexpr cBlockTallGrassHandler BlockTallGrassHandler (E_BLOCK_TALL_GRASS); - constexpr cBlockTNTHandler BlockTntHandler (E_BLOCK_TNT); + constexpr cBlockTNTHandler BlockTNTHandler (E_BLOCK_TNT); constexpr cBlockTorchHandler BlockTorchHandler (E_BLOCK_TORCH); constexpr cBlockTrapdoorHandler BlockTrapdoorHandler (E_BLOCK_TRAPDOOR); constexpr cBlockChestHandler BlockTrappedChestHandler (E_BLOCK_TRAPPED_CHEST); constexpr cBlockTripwireHandler BlockTripwireHandler (E_BLOCK_TRIPWIRE); constexpr cBlockTripwireHookHandler BlockTripwireHookHandler (E_BLOCK_TRIPWIRE_HOOK); - constexpr cBlockVineHandler BlockVinesHandler (E_BLOCK_VINES); + constexpr cBlockVinesHandler BlockVinesHandler (E_BLOCK_VINES); constexpr cBlockBannerHandler BlockWallBannerHandler (E_BLOCK_WALL_BANNER); constexpr cBlockWallSignHandler BlockWallsignHandler (E_BLOCK_WALLSIGN); constexpr cBlockWaterHandler BlockWaterHandler (E_BLOCK_WATER); @@ -655,14 +655,14 @@ const cBlockHandler & cBlockHandler::For(BLOCKTYPE a_BlockType) case E_BLOCK_BIRCH_WOOD_STAIRS: return BlockBirchWoodStairsHandler; case E_BLOCK_BLACK_GLAZED_TERRACOTTA: return BlockBlackGlazedTerracottaHandler; case E_BLOCK_BLACK_SHULKER_BOX: return BlockBlackShulkerBoxHandler; - case E_BLOCK_BLOCK_OF_COAL: return BlockBlockOfCoalHandler; - case E_BLOCK_BLOCK_OF_REDSTONE: return BlockBlockOfRedstoneHandler; + case E_BLOCK_BLOCK_OF_COAL: return BlockCoalBlockHandler; + case E_BLOCK_BLOCK_OF_REDSTONE: return BlockRedstoneBlockHandler; case E_BLOCK_BLUE_GLAZED_TERRACOTTA: return BlockBlueGlazedTerracottaHandler; case E_BLOCK_BLUE_SHULKER_BOX: return BlockBlueShulkerBoxHandler; case E_BLOCK_BONE_BLOCK: return BlockBoneBlockHandler; case E_BLOCK_BOOKCASE: return BlockBookcaseHandler; case E_BLOCK_BREWING_STAND: return BlockBrewingStandHandler; - case E_BLOCK_BRICK: return BlockBrickHandler; + case E_BLOCK_BRICK: return BlockBricksHandler; case E_BLOCK_BRICK_STAIRS: return BlockBrickStairsHandler; case E_BLOCK_BROWN_GLAZED_TERRACOTTA: return BlockBrownGlazedTerracottaHandler; case E_BLOCK_BROWN_MUSHROOM: return BlockBrownMushroomHandler; @@ -779,7 +779,7 @@ const cBlockHandler & cBlockHandler::For(BLOCKTYPE a_BlockType) case E_BLOCK_MOSSY_COBBLESTONE: return BlockMossyCobblestoneHandler; case E_BLOCK_MYCELIUM: return BlockMyceliumHandler; case E_BLOCK_NETHERRACK: return BlockNetherrackHandler; - case E_BLOCK_NETHER_BRICK: return BlockNetherBrickHandler; + case E_BLOCK_NETHER_BRICK: return BlockNetherBricksHandler; case E_BLOCK_NETHER_BRICK_FENCE: return BlockNetherBrickFenceHandler; case E_BLOCK_NETHER_BRICK_STAIRS: return BlockNetherBrickStairsHandler; case E_BLOCK_NETHER_PORTAL: return BlockNetherPortalHandler; @@ -829,7 +829,7 @@ const cBlockHandler & cBlockHandler::For(BLOCKTYPE a_BlockType) case E_BLOCK_REDSTONE_WIRE: return BlockRedstoneWireHandler; case E_BLOCK_RED_GLAZED_TERRACOTTA: return BlockRedGlazedTerracottaHandler; case E_BLOCK_RED_MUSHROOM: return BlockRedMushroomHandler; - case E_BLOCK_RED_NETHER_BRICK: return BlockRedNetherBrickHandler; + case E_BLOCK_RED_NETHER_BRICK: return BlockRedNetherBricksHandler; case E_BLOCK_RED_ROSE: return BlockRedRoseHandler; case E_BLOCK_RED_SANDSTONE: return BlockRedSandstoneHandler; case E_BLOCK_RED_SANDSTONE_SLAB: return BlockRedSandstoneSlabHandler; @@ -867,9 +867,9 @@ const cBlockHandler & cBlockHandler::For(BLOCKTYPE a_BlockType) case E_BLOCK_STONE_SLAB: return BlockStoneSlabHandler; case E_BLOCK_STRUCTURE_BLOCK: return BlockStructureBlockHandler; case E_BLOCK_STRUCTURE_VOID: return BlockStructureVoidHandler; - case E_BLOCK_SUGARCANE: return BlockSugarcaneHandler; + case E_BLOCK_SUGARCANE: return BlockSugarCaneHandler; case E_BLOCK_TALL_GRASS: return BlockTallGrassHandler; - case E_BLOCK_TNT: return BlockTntHandler; + case E_BLOCK_TNT: return BlockTNTHandler; case E_BLOCK_TORCH: return BlockTorchHandler; case E_BLOCK_TRAPDOOR: return BlockTrapdoorHandler; case E_BLOCK_TRAPPED_CHEST: return BlockTrappedChestHandler; diff --git a/src/Blocks/BlockRedstone.h b/src/Blocks/BlockRedstone.h deleted file mode 100644 index d77ff151a..000000000 --- a/src/Blocks/BlockRedstone.h +++ /dev/null @@ -1,70 +0,0 @@ - -#pragma once - -#include "BlockHandler.h" -#include "BlockSlab.h" - - - - - -class cBlockRedstoneHandler final : - public cBlockHandler -{ - using Super = cBlockHandler; - -public: - - using Super::Super; - -private: - - virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override - { - if (a_Position.y <= 0) - { - return false; - } - - BLOCKTYPE BelowBlock; - NIBBLETYPE BelowBlockMeta; - a_Chunk.GetBlockTypeMeta(a_Position.addedY(-1), BelowBlock, BelowBlockMeta); - - if (cBlockInfo::FullyOccupiesVoxel(BelowBlock)) - { - return true; - } - else if (cBlockSlabHandler::IsAnySlabType(BelowBlock)) - { - // Check if the slab is turned up side down - if ((BelowBlockMeta & 0x08) == 0x08) - { - return true; - } - } - return false; - } - - - - - - virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override - { - return cItem(E_ITEM_REDSTONE_DUST, 1, 0); - } - - - - - - virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override - { - UNUSED(a_Meta); - return 0; - } -} ; - - - - diff --git a/src/Blocks/BlockRedstoneWire.h b/src/Blocks/BlockRedstoneWire.h new file mode 100644 index 000000000..3976afa90 --- /dev/null +++ b/src/Blocks/BlockRedstoneWire.h @@ -0,0 +1,70 @@ + +#pragma once + +#include "BlockHandler.h" +#include "BlockSlab.h" + + + + + +class cBlockRedstoneWireHandler final : + public cBlockHandler +{ + using Super = cBlockHandler; + +public: + + using Super::Super; + +private: + + virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override + { + if (a_Position.y <= 0) + { + return false; + } + + BLOCKTYPE BelowBlock; + NIBBLETYPE BelowBlockMeta; + a_Chunk.GetBlockTypeMeta(a_Position.addedY(-1), BelowBlock, BelowBlockMeta); + + if (cBlockInfo::FullyOccupiesVoxel(BelowBlock)) + { + return true; + } + else if (cBlockSlabHandler::IsAnySlabType(BelowBlock)) + { + // Check if the slab is turned up side down + if ((BelowBlockMeta & 0x08) == 0x08) + { + return true; + } + } + return false; + } + + + + + + virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override + { + return cItem(E_ITEM_REDSTONE_DUST, 1, 0); + } + + + + + + virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override + { + UNUSED(a_Meta); + return 0; + } +} ; + + + + diff --git a/src/Blocks/BlockSugarCane.h b/src/Blocks/BlockSugarCane.h new file mode 100644 index 000000000..cffe667e5 --- /dev/null +++ b/src/Blocks/BlockSugarCane.h @@ -0,0 +1,140 @@ + +#pragma once + +#include "BlockPlant.h" + + + + + +class cBlockSugarCaneHandler final : + public cBlockPlant +{ + using Super = cBlockPlant; + +public: + + using Super::Super; + +private: + + virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override + { + return cItem(E_ITEM_SUGARCANE, 1, 0); + } + + + + + + virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override + { + if (a_Position.y <= 0) + { + return false; + } + + switch (a_Chunk.GetBlock(a_Position.addedY(-1))) + { + case E_BLOCK_DIRT: + case E_BLOCK_GRASS: + case E_BLOCK_FARMLAND: + case E_BLOCK_SAND: + { + static const Vector3i Coords[] = + { + {-1, -1, 0}, + { 1, -1, 0}, + { 0, -1, -1}, + { 0, -1, 1}, + } ; + for (size_t i = 0; i < ARRAYCOUNT(Coords); i++) + { + BLOCKTYPE BlockType; + NIBBLETYPE BlockMeta; + if (!a_Chunk.UnboundedRelGetBlock(a_Position + Coords[i], BlockType, BlockMeta)) + { + // Too close to the edge, cannot simulate + return true; + } + if (IsBlockWater(BlockType) || (BlockType == E_BLOCK_FROSTED_ICE)) + { + return true; + } + } // for i - Coords[] + // Not directly neighboring a water block + return false; + } + case E_BLOCK_SUGARCANE: + { + return true; + } + } + return false; + } + + + + + + virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override + { + UNUSED(a_Meta); + return 7; + } + + + + + + virtual int Grow(cChunk & a_Chunk, Vector3i a_RelPos, int a_NumStages = 1) const override + { + // Check the total height of the sugarcane blocks here: + int top = a_RelPos.y + 1; + while ( + (top < cChunkDef::Height) && + (a_Chunk.GetBlock({a_RelPos.x, top, a_RelPos.z}) == E_BLOCK_SUGARCANE) + ) + { + ++top; + } + int bottom = a_RelPos.y - 1; + while ( + (bottom > 0) && + (a_Chunk.GetBlock({a_RelPos.x, bottom, a_RelPos.z}) == E_BLOCK_SUGARCANE) + ) + { + --bottom; + } + + // Grow by at most a_NumStages, but no more than max height: + auto toGrow = std::min(a_NumStages, a_Chunk.GetWorld()->GetMaxSugarcaneHeight() + 1 - (top - bottom)); + Vector3i topPos(a_RelPos.x, top, a_RelPos.z); + for (int i = 0; i < toGrow; i++) + { + if (a_Chunk.GetBlock(topPos.addedY(i)) == E_BLOCK_AIR) + { + a_Chunk.SetBlock(topPos.addedY(i), E_BLOCK_SUGARCANE, 0); + } + else + { + return i; + } + } // for i + return toGrow; + } + + virtual PlantAction CanGrow(cChunk & a_Chunk, Vector3i a_RelPos) const override + { + // Only allow growing if there's an air block above: + if (((a_RelPos.y + 1) < cChunkDef::Height) && (a_Chunk.GetBlock(a_RelPos.addedY(1)) == E_BLOCK_AIR)) + { + return Super::CanGrow(a_Chunk, a_RelPos); + } + return paStay; + } +} ; + + + + diff --git a/src/Blocks/BlockSugarcane.h b/src/Blocks/BlockSugarcane.h deleted file mode 100644 index bf5ae5e73..000000000 --- a/src/Blocks/BlockSugarcane.h +++ /dev/null @@ -1,140 +0,0 @@ - -#pragma once - -#include "BlockPlant.h" - - - - - -class cBlockSugarcaneHandler final : - public cBlockPlant -{ - using Super = cBlockPlant; - -public: - - using Super::Super; - -private: - - virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override - { - return cItem(E_ITEM_SUGARCANE, 1, 0); - } - - - - - - virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override - { - if (a_Position.y <= 0) - { - return false; - } - - switch (a_Chunk.GetBlock(a_Position.addedY(-1))) - { - case E_BLOCK_DIRT: - case E_BLOCK_GRASS: - case E_BLOCK_FARMLAND: - case E_BLOCK_SAND: - { - static const Vector3i Coords[] = - { - {-1, -1, 0}, - { 1, -1, 0}, - { 0, -1, -1}, - { 0, -1, 1}, - } ; - for (size_t i = 0; i < ARRAYCOUNT(Coords); i++) - { - BLOCKTYPE BlockType; - NIBBLETYPE BlockMeta; - if (!a_Chunk.UnboundedRelGetBlock(a_Position + Coords[i], BlockType, BlockMeta)) - { - // Too close to the edge, cannot simulate - return true; - } - if (IsBlockWater(BlockType) || (BlockType == E_BLOCK_FROSTED_ICE)) - { - return true; - } - } // for i - Coords[] - // Not directly neighboring a water block - return false; - } - case E_BLOCK_SUGARCANE: - { - return true; - } - } - return false; - } - - - - - - virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override - { - UNUSED(a_Meta); - return 7; - } - - - - - - virtual int Grow(cChunk & a_Chunk, Vector3i a_RelPos, int a_NumStages = 1) const override - { - // Check the total height of the sugarcane blocks here: - int top = a_RelPos.y + 1; - while ( - (top < cChunkDef::Height) && - (a_Chunk.GetBlock({a_RelPos.x, top, a_RelPos.z}) == E_BLOCK_SUGARCANE) - ) - { - ++top; - } - int bottom = a_RelPos.y - 1; - while ( - (bottom > 0) && - (a_Chunk.GetBlock({a_RelPos.x, bottom, a_RelPos.z}) == E_BLOCK_SUGARCANE) - ) - { - --bottom; - } - - // Grow by at most a_NumStages, but no more than max height: - auto toGrow = std::min(a_NumStages, a_Chunk.GetWorld()->GetMaxSugarcaneHeight() + 1 - (top - bottom)); - Vector3i topPos(a_RelPos.x, top, a_RelPos.z); - for (int i = 0; i < toGrow; i++) - { - if (a_Chunk.GetBlock(topPos.addedY(i)) == E_BLOCK_AIR) - { - a_Chunk.SetBlock(topPos.addedY(i), E_BLOCK_SUGARCANE, 0); - } - else - { - return i; - } - } // for i - return toGrow; - } - - virtual PlantAction CanGrow(cChunk & a_Chunk, Vector3i a_RelPos) const override - { - // Only allow growing if there's an air block above: - if (((a_RelPos.y + 1) < cChunkDef::Height) && (a_Chunk.GetBlock(a_RelPos.addedY(1)) == E_BLOCK_AIR)) - { - return Super::CanGrow(a_Chunk, a_RelPos); - } - return paStay; - } -} ; - - - - diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h deleted file mode 100644 index da4d6dfc3..000000000 --- a/src/Blocks/BlockVine.h +++ /dev/null @@ -1,271 +0,0 @@ -#pragma once - -#include "BlockHandler.h" - - - - - -class cBlockVineHandler final : - public cBlockHandler -{ - using Super = cBlockHandler; - -public: - - using Super::Super; - -private: - - static const NIBBLETYPE VINE_LOST_SUPPORT = 16; - static const NIBBLETYPE VINE_UNCHANGED = 17; - - - virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override - { - return GetMaxMeta(a_Chunk, a_Position, a_Meta) != VINE_LOST_SUPPORT; - } - - - virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override - { - // Only drops self when using shears, otherwise drops nothing: - if ((a_Tool == nullptr) || (a_Tool->m_ItemType != E_ITEM_SHEARS)) - { - return {}; - } - return cItem(E_BLOCK_VINES, 1, 0); - } - - - - - - static char MetaDataToDirection(NIBBLETYPE a_MetaData) - { - switch (a_MetaData) - { - case 0x1: return BLOCK_FACE_NORTH; - case 0x4: return BLOCK_FACE_SOUTH; - case 0x8: return BLOCK_FACE_WEST; - case 0x2: return BLOCK_FACE_EAST; - default: return BLOCK_FACE_TOP; - } - } - - - - - - /** Returns true if the specified block type is good for vines to attach to */ - static bool IsBlockAttachable(BLOCKTYPE a_BlockType) - { - switch (a_BlockType) - { - case E_BLOCK_CHEST: - case E_BLOCK_ENDER_CHEST: - case E_BLOCK_GLASS: - case E_BLOCK_PISTON: - case E_BLOCK_PISTON_EXTENSION: - case E_BLOCK_REDSTONE_REPEATER_OFF: - case E_BLOCK_REDSTONE_REPEATER_ON: - case E_BLOCK_STAINED_GLASS: - case E_BLOCK_STICKY_PISTON: - case E_BLOCK_TRAPPED_CHEST: - { - // You can't attach a vine to this solid blocks. - return false; - } - default: - { - return cBlockInfo::IsSolid(a_BlockType); - } - } - } - - - - - - /** Returns the meta that has the maximum allowable sides of the vine, given the surroundings and current vine meta. - Returns special values for a vine that can continue to exist unchanged, or must die completely. */ - static NIBBLETYPE GetMaxMeta(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_CurrentMeta) - { - static const struct - { - int x, z; - NIBBLETYPE Bit; - } Coords[] = - { - { 0, 1, 1}, // south, ZP - {-1, 0, 2}, // west, XM - { 0, -1, 4}, // north, ZM - { 1, 0, 8}, // east, XP - } ; - - NIBBLETYPE MaxMeta = 0; - for (auto & Coord : Coords) - { - BLOCKTYPE BlockType; - NIBBLETYPE BlockMeta; - auto checkPos = a_Position.addedXZ(Coord.x, Coord.z); - if ( - a_Chunk.UnboundedRelGetBlock(checkPos.x, checkPos.y, checkPos.z, BlockType, BlockMeta) && - IsBlockAttachable(BlockType) - ) - { - MaxMeta |= Coord.Bit; - } - } - - // Check if vine above us, add its meta to MaxMeta: - if ((a_Position.y < cChunkDef::Height - 1) && (a_Chunk.GetBlock(a_Position.addedY(1)) == E_BLOCK_VINES)) - { - MaxMeta |= a_Chunk.GetMeta(a_Position.addedY(1)); - } - - NIBBLETYPE Common = a_CurrentMeta & MaxMeta; // Neighbors that we have and are legal. - if (Common != a_CurrentMeta) - { - bool HasTop = (a_Position.y < (cChunkDef::Height - 1)) && IsBlockAttachable(a_Chunk.GetBlock(a_Position.addedY(1))); - if ((Common == 0) && !HasTop) // Meta equals 0 also means top. Make a last-ditch attempt to save the vine. - { - return VINE_LOST_SUPPORT; - } - - return Common; - } - - return VINE_UNCHANGED; - } - - - - - - virtual void OnNeighborChanged(cChunkInterface & a_ChunkInterface, Vector3i a_BlockPos, eBlockFace a_WhichNeighbor) const override - { - a_ChunkInterface.DoWithChunkAt(a_BlockPos, [&](cChunk & a_Chunk) - { - - const auto Position = cChunkDef::AbsoluteToRelative(a_BlockPos); - const auto MaxMeta = GetMaxMeta(a_Chunk, Position, a_Chunk.GetMeta(Position)); - - if (MaxMeta == VINE_UNCHANGED) - { - return false; - } - - // There is a neighbor missing, need to update the meta or even destroy the block. - - if (MaxMeta == VINE_LOST_SUPPORT) - { - // The vine just lost all its support, destroy the block: - a_Chunk.SetBlock(Position, E_BLOCK_AIR, 0); - } - else - { - // It lost some of its support, set it to what remains (SetBlock to notify neighbors): - a_Chunk.SetBlock(Position, E_BLOCK_VINES, MaxMeta); - } - - return false; - }); - } - - - - - - virtual bool DoesIgnoreBuildCollision(const cWorld & a_World, const cItem & a_HeldItem, const Vector3i a_Position, const NIBBLETYPE a_Meta, const eBlockFace a_ClickedBlockFace, const bool a_ClickedDirectly) const override - { - return !a_ClickedDirectly || (a_HeldItem.m_ItemType != m_BlockType); - } - - - - - - virtual void OnUpdate( - cChunkInterface & a_ChunkInterface, - cWorldInterface & a_WorldInterface, - cBlockPluginInterface & a_PluginInterface, - cChunk & a_Chunk, - const Vector3i a_RelPos - ) const override - { - UNUSED(a_ChunkInterface); - UNUSED(a_WorldInterface); - - // Vine cannot grow down if at the bottom: - auto GrowPos = a_RelPos.addedY(-1); - if (!cChunkDef::IsValidHeight(GrowPos.y)) - { - return; - } - - // Grow one block down, if possible: - BLOCKTYPE Block; - a_Chunk.UnboundedRelGetBlockType(GrowPos, Block); - if (Block == E_BLOCK_AIR) - { - auto WorldPos = a_Chunk.RelativeToAbsolute(GrowPos); - if (!a_PluginInterface.CallHookBlockSpread(WorldPos.x, WorldPos.y, WorldPos.z, ssVineSpread)) - { - a_Chunk.UnboundedRelSetBlock(GrowPos, E_BLOCK_VINES, a_Chunk.GetMeta(a_RelPos)); - } - } - } - - - - - - virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) const override - { - return ((a_Meta >> 1) | (a_Meta << 3)) & 0x0f; // Rotate bits to the right - } - - - - - - virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) const override - { - return ((a_Meta << 1) | (a_Meta >> 3)) & 0x0f; // Rotate bits to the left - } - - - - - - virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) const override - { - // Bits 2 and 4 stay, bits 1 and 3 swap - return static_cast((a_Meta & 0x0a) | ((a_Meta & 0x01) << 2) | ((a_Meta & 0x04) >> 2)); - } - - - - - - virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) const override - { - // Bits 1 and 3 stay, bits 2 and 4 swap - return static_cast((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2)); - } - - - - - - virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override - { - UNUSED(a_Meta); - return 7; - } -} ; - - - - diff --git a/src/Blocks/BlockVines.h b/src/Blocks/BlockVines.h new file mode 100644 index 000000000..d6eccd552 --- /dev/null +++ b/src/Blocks/BlockVines.h @@ -0,0 +1,271 @@ +#pragma once + +#include "BlockHandler.h" + + + + + +class cBlockVinesHandler final : + public cBlockHandler +{ + using Super = cBlockHandler; + +public: + + using Super::Super; + +private: + + static const NIBBLETYPE VINE_LOST_SUPPORT = 16; + static const NIBBLETYPE VINE_UNCHANGED = 17; + + + virtual bool CanBeAt(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_Meta) const override + { + return GetMaxMeta(a_Chunk, a_Position, a_Meta) != VINE_LOST_SUPPORT; + } + + + virtual cItems ConvertToPickups(const NIBBLETYPE a_BlockMeta, const cItem * const a_Tool) const override + { + // Only drops self when using shears, otherwise drops nothing: + if ((a_Tool == nullptr) || (a_Tool->m_ItemType != E_ITEM_SHEARS)) + { + return {}; + } + return cItem(E_BLOCK_VINES, 1, 0); + } + + + + + + static char MetaDataToDirection(NIBBLETYPE a_MetaData) + { + switch (a_MetaData) + { + case 0x1: return BLOCK_FACE_NORTH; + case 0x4: return BLOCK_FACE_SOUTH; + case 0x8: return BLOCK_FACE_WEST; + case 0x2: return BLOCK_FACE_EAST; + default: return BLOCK_FACE_TOP; + } + } + + + + + + /** Returns true if the specified block type is good for vines to attach to */ + static bool IsBlockAttachable(BLOCKTYPE a_BlockType) + { + switch (a_BlockType) + { + case E_BLOCK_CHEST: + case E_BLOCK_ENDER_CHEST: + case E_BLOCK_GLASS: + case E_BLOCK_PISTON: + case E_BLOCK_PISTON_EXTENSION: + case E_BLOCK_REDSTONE_REPEATER_OFF: + case E_BLOCK_REDSTONE_REPEATER_ON: + case E_BLOCK_STAINED_GLASS: + case E_BLOCK_STICKY_PISTON: + case E_BLOCK_TRAPPED_CHEST: + { + // You can't attach a vine to this solid blocks. + return false; + } + default: + { + return cBlockInfo::IsSolid(a_BlockType); + } + } + } + + + + + + /** Returns the meta that has the maximum allowable sides of the vine, given the surroundings and current vine meta. + Returns special values for a vine that can continue to exist unchanged, or must die completely. */ + static NIBBLETYPE GetMaxMeta(const cChunk & a_Chunk, const Vector3i a_Position, const NIBBLETYPE a_CurrentMeta) + { + static const struct + { + int x, z; + NIBBLETYPE Bit; + } Coords[] = + { + { 0, 1, 1}, // south, ZP + {-1, 0, 2}, // west, XM + { 0, -1, 4}, // north, ZM + { 1, 0, 8}, // east, XP + } ; + + NIBBLETYPE MaxMeta = 0; + for (auto & Coord : Coords) + { + BLOCKTYPE BlockType; + NIBBLETYPE BlockMeta; + auto checkPos = a_Position.addedXZ(Coord.x, Coord.z); + if ( + a_Chunk.UnboundedRelGetBlock(checkPos.x, checkPos.y, checkPos.z, BlockType, BlockMeta) && + IsBlockAttachable(BlockType) + ) + { + MaxMeta |= Coord.Bit; + } + } + + // Check if vine above us, add its meta to MaxMeta: + if ((a_Position.y < cChunkDef::Height - 1) && (a_Chunk.GetBlock(a_Position.addedY(1)) == E_BLOCK_VINES)) + { + MaxMeta |= a_Chunk.GetMeta(a_Position.addedY(1)); + } + + NIBBLETYPE Common = a_CurrentMeta & MaxMeta; // Neighbors that we have and are legal. + if (Common != a_CurrentMeta) + { + bool HasTop = (a_Position.y < (cChunkDef::Height - 1)) && IsBlockAttachable(a_Chunk.GetBlock(a_Position.addedY(1))); + if ((Common == 0) && !HasTop) // Meta equals 0 also means top. Make a last-ditch attempt to save the vine. + { + return VINE_LOST_SUPPORT; + } + + return Common; + } + + return VINE_UNCHANGED; + } + + + + + + virtual void OnNeighborChanged(cChunkInterface & a_ChunkInterface, Vector3i a_BlockPos, eBlockFace a_WhichNeighbor) const override + { + a_ChunkInterface.DoWithChunkAt(a_BlockPos, [&](cChunk & a_Chunk) + { + + const auto Position = cChunkDef::AbsoluteToRelative(a_BlockPos); + const auto MaxMeta = GetMaxMeta(a_Chunk, Position, a_Chunk.GetMeta(Position)); + + if (MaxMeta == VINE_UNCHANGED) + { + return false; + } + + // There is a neighbor missing, need to update the meta or even destroy the block. + + if (MaxMeta == VINE_LOST_SUPPORT) + { + // The vine just lost all its support, destroy the block: + a_Chunk.SetBlock(Position, E_BLOCK_AIR, 0); + } + else + { + // It lost some of its support, set it to what remains (SetBlock to notify neighbors): + a_Chunk.SetBlock(Position, E_BLOCK_VINES, MaxMeta); + } + + return false; + }); + } + + + + + + virtual bool DoesIgnoreBuildCollision(const cWorld & a_World, const cItem & a_HeldItem, const Vector3i a_Position, const NIBBLETYPE a_Meta, const eBlockFace a_ClickedBlockFace, const bool a_ClickedDirectly) const override + { + return !a_ClickedDirectly || (a_HeldItem.m_ItemType != m_BlockType); + } + + + + + + virtual void OnUpdate( + cChunkInterface & a_ChunkInterface, + cWorldInterface & a_WorldInterface, + cBlockPluginInterface & a_PluginInterface, + cChunk & a_Chunk, + const Vector3i a_RelPos + ) const override + { + UNUSED(a_ChunkInterface); + UNUSED(a_WorldInterface); + + // Vine cannot grow down if at the bottom: + auto GrowPos = a_RelPos.addedY(-1); + if (!cChunkDef::IsValidHeight(GrowPos.y)) + { + return; + } + + // Grow one block down, if possible: + BLOCKTYPE Block; + a_Chunk.UnboundedRelGetBlockType(GrowPos, Block); + if (Block == E_BLOCK_AIR) + { + auto WorldPos = a_Chunk.RelativeToAbsolute(GrowPos); + if (!a_PluginInterface.CallHookBlockSpread(WorldPos.x, WorldPos.y, WorldPos.z, ssVineSpread)) + { + a_Chunk.UnboundedRelSetBlock(GrowPos, E_BLOCK_VINES, a_Chunk.GetMeta(a_RelPos)); + } + } + } + + + + + + virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) const override + { + return ((a_Meta >> 1) | (a_Meta << 3)) & 0x0f; // Rotate bits to the right + } + + + + + + virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) const override + { + return ((a_Meta << 1) | (a_Meta >> 3)) & 0x0f; // Rotate bits to the left + } + + + + + + virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) const override + { + // Bits 2 and 4 stay, bits 1 and 3 swap + return static_cast((a_Meta & 0x0a) | ((a_Meta & 0x01) << 2) | ((a_Meta & 0x04) >> 2)); + } + + + + + + virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) const override + { + // Bits 1 and 3 stay, bits 2 and 4 swap + return static_cast((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2)); + } + + + + + + virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) const override + { + UNUSED(a_Meta); + return 7; + } +} ; + + + + diff --git a/src/Blocks/CMakeLists.txt b/src/Blocks/CMakeLists.txt index f69350c30..a7dd7b675 100644 --- a/src/Blocks/CMakeLists.txt +++ b/src/Blocks/CMakeLists.txt @@ -34,7 +34,7 @@ target_sources( BlockDoor.h BlockDropSpenser.h BlockEnchantingTable.h - BlockEnderchest.h + BlockEnderChest.h BlockEndPortalFrame.h BlockEntity.h BlockFarmland.h @@ -80,7 +80,7 @@ target_sources( BlockPumpkin.h BlockQuartz.h BlockRail.h - BlockRedstone.h + BlockRedstoneWire.h BlockRedstoneLamp.h BlockRedstoneOre.h BlockRedstoneRepeater.h @@ -96,14 +96,14 @@ target_sources( BlockStairs.h BlockStems.h BlockStone.h - BlockSugarcane.h + BlockSugarCane.h BlockTNT.h BlockTallGrass.h BlockTorch.h BlockTrapdoor.h BlockTripwire.h BlockTripwireHook.h - BlockVine.h + BlockVines.h BlockWallSign.h BlockWorkbench.h BroadcastInterface.h diff --git a/src/Items/CMakeLists.txt b/src/Items/CMakeLists.txt index 1e3a05bd0..7b327e486 100644 --- a/src/Items/CMakeLists.txt +++ b/src/Items/CMakeLists.txt @@ -27,7 +27,7 @@ target_sources( ItemEnchantingTable.h ItemEndCrystal.h ItemEndPortalFrame.h - ItemEnderchest.h + ItemEnderChest.h ItemEyeOfEnder.h ItemFenceGate.h ItemFishingRod.h @@ -83,6 +83,6 @@ target_sources( ItemTorch.h ItemTrapdoor.h ItemTripwireHook.h - ItemVine.h + ItemVines.h SimplePlaceableItemHandler.h ) diff --git a/src/Items/ItemComparator.h b/src/Items/ItemComparator.h index a8caa2431..48db85959 100644 --- a/src/Items/ItemComparator.h +++ b/src/Items/ItemComparator.h @@ -15,13 +15,7 @@ class cItemComparatorHandler final: public: - cItemComparatorHandler(int a_ItemType): - cItemHandler(a_ItemType) - { - } - - - + using Super::Super; virtual bool CommitPlacement(cPlayer & a_Player, const cItem & a_HeldItem, const Vector3i a_PlacePosition, const eBlockFace a_ClickedBlockFace, const Vector3i a_CursorPosition) const override @@ -30,15 +24,8 @@ public: } - - - virtual bool IsPlaceable(void) const override { return true; } } ; - - - - diff --git a/src/Items/ItemDefaultItem.h b/src/Items/ItemDefaultItem.h index f455257aa..afd5ab126 100644 --- a/src/Items/ItemDefaultItem.h +++ b/src/Items/ItemDefaultItem.h @@ -1,9 +1,16 @@ +#pragma once + #include "ItemHandler.h" + + + + class cDefaultItemHandler final : public cItemHandler { public: + using cItemHandler::cItemHandler; }; diff --git a/src/Items/ItemEnderChest.h b/src/Items/ItemEnderChest.h new file mode 100644 index 000000000..120abb8e6 --- /dev/null +++ b/src/Items/ItemEnderChest.h @@ -0,0 +1,26 @@ + +#pragma once + +#include "ItemHandler.h" +#include "Blocks/BlockEnderChest.h" + + + + + +class cItemEnderChestHandler final : + public cItemHandler +{ + using Super = cItemHandler; + +public: + + using Super::Super; + +private: + + virtual bool CommitPlacement(cPlayer & a_Player, const cItem & a_HeldItem, const Vector3i a_PlacePosition, const eBlockFace a_ClickedBlockFace, const Vector3i a_CursorPosition) const override + { + return a_Player.PlaceBlock(a_PlacePosition, E_BLOCK_ENDER_CHEST, cBlockEnderChestHandler::YawToMetaData(a_Player.GetYaw())); + } +}; diff --git a/src/Items/ItemEnderchest.h b/src/Items/ItemEnderchest.h deleted file mode 100644 index bd8487b11..000000000 --- a/src/Items/ItemEnderchest.h +++ /dev/null @@ -1,26 +0,0 @@ - -#pragma once - -#include "ItemHandler.h" -#include "Blocks/BlockEnderchest.h" - - - - - -class cItemEnderchestHandler final : - public cItemHandler -{ - using Super = cItemHandler; - -public: - - using Super::Super; - -private: - - virtual bool CommitPlacement(cPlayer & a_Player, const cItem & a_HeldItem, const Vector3i a_PlacePosition, const eBlockFace a_ClickedBlockFace, const Vector3i a_CursorPosition) const override - { - return a_Player.PlaceBlock(a_PlacePosition, E_BLOCK_ENDER_CHEST, cBlockEnderchestHandler::YawToMetaData(a_Player.GetYaw())); - } -}; diff --git a/src/Items/ItemHandler.cpp b/src/Items/ItemHandler.cpp index c8994fada..fa518da20 100644 --- a/src/Items/ItemHandler.cpp +++ b/src/Items/ItemHandler.cpp @@ -31,7 +31,7 @@ #include "ItemEmptyMap.h" #include "ItemEnchantingTable.h" #include "ItemEndCrystal.h" -#include "ItemEnderchest.h" +#include "ItemEnderChest.h" #include "ItemEndPortalFrame.h" #include "ItemEyeOfEnder.h" #include "ItemFenceGate.h" @@ -87,7 +87,7 @@ #include "ItemTorch.h" #include "ItemTrapdoor.h" #include "ItemTripwireHook.h" -#include "ItemVine.h" +#include "ItemVines.h" #include "../Blocks/BlockHandler.h" #include "SimplePlaceableItemHandler.h" @@ -117,7 +117,7 @@ namespace constexpr cItemBannerHandler ItemBannerHandler (E_ITEM_BANNER); constexpr cDefaultItemHandler ItemBarrierHandler (E_BLOCK_BARRIER); constexpr cDefaultItemHandler ItemBeaconHandler (E_BLOCK_BEACON); - constexpr cItemBedHandler ItemBedBlockHandler (E_BLOCK_BED); + constexpr cDefaultItemHandler ItemBedBlockHandler (E_BLOCK_BED); constexpr cItemBedHandler ItemBedHandler (E_ITEM_BED); constexpr cDefaultItemHandler ItemBedrockHandler (E_BLOCK_BEDROCK); constexpr cItemSimpleFoodHandler ItemBeetrootHandler (E_ITEM_BEETROOT, cItemHandler::FoodInfo(1, 1.2)); @@ -170,7 +170,7 @@ namespace constexpr cDefaultItemHandler ItemChainCommandBlockHandler (E_BLOCK_CHAIN_COMMAND_BLOCK); constexpr cItemArmorHandler ItemChainHelmetHandler (E_ITEM_CHAIN_HELMET); constexpr cItemArmorHandler ItemChainLeggingsHandler (E_ITEM_CHAIN_LEGGINGS); - constexpr cDefaultItemHandler ItemChestBlockHandler (E_BLOCK_CHEST); + constexpr cItemChestHandler ItemChestHandler (E_BLOCK_CHEST); constexpr cItemMinecartHandler ItemChestMinecartHandler (E_ITEM_CHEST_MINECART); constexpr cDefaultItemHandler ItemChirpDiscHandler (E_ITEM_CHIRP_DISC); constexpr cDefaultItemHandler ItemChorusFlowerHandler (E_BLOCK_CHORUS_FLOWER); @@ -188,7 +188,7 @@ namespace constexpr cDefaultItemHandler ItemCobwebHandler (E_BLOCK_COBWEB); constexpr cDefaultItemHandler ItemCocoaPodHandler (E_BLOCK_COCOA_POD); constexpr cDefaultItemHandler ItemCommandBlockHandler (E_BLOCK_COMMAND_BLOCK); - constexpr cDefaultItemHandler ItemComparatorHandler (E_ITEM_COMPARATOR); + constexpr cItemComparatorHandler ItemComparatorHandler (E_ITEM_COMPARATOR); constexpr cDefaultItemHandler ItemCompassHandler (E_ITEM_COMPASS); constexpr cDefaultItemHandler ItemConcreteBlockHandler (E_BLOCK_CONCRETE); constexpr cDefaultItemHandler ItemConcretePowderHandler (E_BLOCK_CONCRETE_POWDER); @@ -250,7 +250,7 @@ namespace constexpr cDefaultItemHandler ItemEndRodHandler (E_BLOCK_END_ROD); constexpr cDefaultItemHandler ItemEndStoneBlockHandler (E_BLOCK_END_STONE); constexpr cItemEnderPearlHandler ItemEnderPearlHandler (E_ITEM_ENDER_PEARL); - constexpr cItemEnderchestHandler ItemEnderchestHandler (E_BLOCK_ENDER_CHEST); + constexpr cItemEnderChestHandler ItemEnderChestHandler (E_BLOCK_ENDER_CHEST); constexpr cItemEyeOfEnderHandler ItemEyeOfEnderHandler (E_ITEM_EYE_OF_ENDER); constexpr cDefaultItemHandler ItemFarDiscHandler (E_ITEM_FAR_DISC); constexpr cDefaultItemHandler ItemFarmlandHandler (E_BLOCK_FARMLAND); @@ -272,7 +272,7 @@ namespace constexpr cDefaultItemHandler ItemGhastTearHandler (E_ITEM_GHAST_TEAR); constexpr cItemBottleHandler ItemGlassBottleHandler (E_ITEM_GLASS_BOTTLE); constexpr cDefaultItemHandler ItemGlassHandler (E_BLOCK_GLASS); - constexpr cDefaultItemHandler ItemGlassPaneBlockHandler (E_BLOCK_GLASS_PANE); + constexpr cDefaultItemHandler ItemGlassPaneHandler (E_BLOCK_GLASS_PANE); constexpr cDefaultItemHandler ItemGlisteringMelonHandler (E_ITEM_GLISTERING_MELON); constexpr cDefaultItemHandler ItemGlowstoneBlockHandler (E_BLOCK_GLOWSTONE); constexpr cDefaultItemHandler ItemGlowstoneDustHandler (E_ITEM_GLOWSTONE_DUST); @@ -302,9 +302,9 @@ namespace constexpr cDefaultItemHandler ItemGunpowderHandler (E_ITEM_GUNPOWDER); constexpr cDefaultItemHandler ItemHardenedClayHandler (E_BLOCK_HARDENED_CLAY); constexpr cItemSidewaysHandler ItemHayBaleHandler (E_BLOCK_HAY_BALE); - constexpr cItemMobHeadHandler ItemHeadBlockHandler (E_BLOCK_HEAD); + constexpr cDefaultItemHandler ItemHeadBlockHandler (E_BLOCK_HEAD); constexpr cItemMobHeadHandler ItemHeadHandler (E_ITEM_HEAD); - constexpr cDefaultItemHandler ItemHeavyWeightedPressurePlateBlockHandler (E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE); + constexpr cDefaultItemHandler ItemHeavyWeightedPressurePlateHandler (E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE); constexpr cItemHopperHandler ItemHopperHandler (E_BLOCK_HOPPER); constexpr cDefaultItemHandler ItemHugeBrownMushroomBlockHandler (E_BLOCK_HUGE_BROWN_MUSHROOM); constexpr cDefaultItemHandler ItemHugeRedMushroomBlockHandler (E_BLOCK_HUGE_RED_MUSHROOM); @@ -355,7 +355,7 @@ namespace constexpr cDefaultItemHandler ItemLightBlueShulkerBoxHandler (E_BLOCK_LIGHT_BLUE_SHULKER_BOX); constexpr cItemGlazedTerracottaHandler ItemLightGrayGlazedTerracottaHandler (E_BLOCK_LIGHT_GRAY_GLAZED_TERRACOTTA); constexpr cDefaultItemHandler ItemLightGrayShulkerBoxHandler (E_BLOCK_LIGHT_GRAY_SHULKER_BOX); - constexpr cDefaultItemHandler ItemLightWeightedPressurePlateBlockHandler (E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE); + constexpr cDefaultItemHandler ItemLightWeightedPressurePlateHandler (E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE); constexpr cItemLilypadHandler ItemLilypadHandler (E_BLOCK_LILY_PAD); constexpr cItemGlazedTerracottaHandler ItemLimeGlazedTerracottaHandler (E_BLOCK_LIME_GLAZED_TERRACOTTA); constexpr cDefaultItemHandler ItemLimeShulkerBoxHandler (E_BLOCK_LIME_SHULKER_BOX); @@ -383,16 +383,16 @@ namespace constexpr cItemSoupHandler ItemMushroomSoupHandler (E_ITEM_MUSHROOM_SOUP, cItemHandler::FoodInfo(6, 7.2)); constexpr cDefaultItemHandler ItemMyceliumHandler (E_BLOCK_MYCELIUM); constexpr cDefaultItemHandler ItemNameTagHandler (E_ITEM_NAME_TAG); - constexpr cDefaultItemHandler ItemNetherBrickBlockHandler (E_BLOCK_NETHER_BRICK); - constexpr cDefaultItemHandler ItemNetherBrickFenceBlockHandler (E_BLOCK_NETHER_BRICK_FENCE); + constexpr cDefaultItemHandler ItemNetherBricksHandler (E_BLOCK_NETHER_BRICK); + constexpr cDefaultItemHandler ItemNetherBrickFenceHandler (E_BLOCK_NETHER_BRICK_FENCE); constexpr cDefaultItemHandler ItemNetherBrickHandler (E_ITEM_NETHER_BRICK); constexpr cItemStairsHandler ItemNetherBrickStairsHandler (E_BLOCK_NETHER_BRICK_STAIRS); constexpr cDefaultItemHandler ItemNetherPortalBlockHandler (E_BLOCK_NETHER_PORTAL); constexpr cDefaultItemHandler ItemNetherQuartzHandler (E_ITEM_NETHER_QUARTZ); constexpr cDefaultItemHandler ItemNetherQuartzOreHandler (E_BLOCK_NETHER_QUARTZ_ORE); constexpr cDefaultItemHandler ItemNetherStarHandler (E_ITEM_NETHER_STAR); - constexpr cDefaultItemHandler ItemNetherWartBlockBlockHandler (E_BLOCK_NETHER_WART_BLOCK); - constexpr cDefaultItemHandler ItemNetherWartBlockHandler (E_BLOCK_NETHER_WART); + constexpr cDefaultItemHandler ItemNetherWartBlockHandler (E_BLOCK_NETHER_WART_BLOCK); + constexpr cDefaultItemHandler ItemNetherWartTechnicalBlockHandler (E_BLOCK_NETHER_WART); constexpr cItemNetherWartHandler ItemNetherWartHandler (E_ITEM_NETHER_WART); constexpr cDefaultItemHandler ItemNetherrackHandler (E_BLOCK_NETHERRACK); constexpr cItemLeavesHandler ItemNewLeavesHandler (E_BLOCK_NEW_LEAVES); @@ -519,26 +519,26 @@ namespace constexpr cDefaultItemHandler ItemStoneHandler (E_BLOCK_STONE); constexpr cItemHoeHandler ItemStoneHoeHandler (E_ITEM_STONE_HOE); constexpr cItemPickaxeHandler ItemStonePickaxeHandler (E_ITEM_STONE_PICKAXE); - constexpr cDefaultItemHandler ItemStonePressurePlateBlockHandler (E_BLOCK_STONE_PRESSURE_PLATE); + constexpr cDefaultItemHandler ItemStonePressurePlateHandler (E_BLOCK_STONE_PRESSURE_PLATE); constexpr cItemShovelHandler ItemStoneShovelHandler (E_ITEM_STONE_SHOVEL); constexpr cItemSlabHandler ItemStoneSlabHandler (E_BLOCK_STONE_SLAB); constexpr cItemSwordHandler ItemStoneSwordHandler (E_ITEM_STONE_SWORD); constexpr cDefaultItemHandler ItemStradDiscHandler (E_ITEM_STRAD_DISC); constexpr cDefaultItemHandler ItemStructureBlockHandler (E_BLOCK_STRUCTURE_BLOCK); constexpr cDefaultItemHandler ItemStructureVoidHandler (E_BLOCK_STRUCTURE_VOID); - constexpr cSimplePlaceableItemHandler ItemSugarCaneHandler (E_BLOCK_SUGARCANE, E_BLOCK_SUGARCANE); + constexpr cDefaultItemHandler ItemSugarCaneBlockHandler (E_BLOCK_SUGARCANE); + constexpr cSimplePlaceableItemHandler ItemSugarCaneHandler (E_ITEM_SUGARCANE, E_BLOCK_SUGARCANE); constexpr cDefaultItemHandler ItemSugarHandler (E_ITEM_SUGAR); - constexpr cSimplePlaceableItemHandler ItemSugarcaneHandler (E_ITEM_SUGARCANE, E_BLOCK_SUGARCANE); - constexpr cDefaultItemHandler ItemTNTBlockHandler (E_BLOCK_TNT); + constexpr cDefaultItemHandler ItemTNTHandler (E_BLOCK_TNT); constexpr cDefaultItemHandler ItemTallGrassHandler (E_BLOCK_TALL_GRASS); constexpr cDefaultItemHandler ItemTerracottaHandler (E_BLOCK_TERRACOTTA); constexpr cDefaultItemHandler ItemTippedArrowHandler (E_ITEM_TIPPED_ARROW); - constexpr cItemTorchHandler ItemTorchBlockHandler (E_BLOCK_TORCH); + constexpr cDefaultItemHandler ItemTorchBlockHandler (E_BLOCK_TORCH); constexpr cDefaultItemHandler ItemTotemOfUndyingHandler (E_ITEM_TOTEM_OF_UNDYING); constexpr cItemChestHandler ItemTrappedChestHandler (E_BLOCK_TRAPPED_CHEST); constexpr cDefaultItemHandler ItemTripwireHandler (E_BLOCK_TRIPWIRE); constexpr cItemTripwireHookHandler ItemTripwireHookHandler (E_BLOCK_TRIPWIRE_HOOK); - constexpr cItemVineHandler ItemVineHandler (E_BLOCK_VINES); + constexpr cItemVinesHandler ItemVinesHandler (E_BLOCK_VINES); constexpr cDefaultItemHandler ItemWaitDiscHandler (E_ITEM_WAIT_DISC); constexpr cDefaultItemHandler ItemWallBannerHandler (E_BLOCK_WALL_BANNER); constexpr cDefaultItemHandler ItemWallsignHandler (E_BLOCK_WALLSIGN); @@ -552,7 +552,7 @@ namespace constexpr cItemAxeHandler ItemWoodenAxeHandler (E_ITEM_WOODEN_AXE); constexpr cItemHoeHandler ItemWoodenHoeHandler (E_ITEM_WOODEN_HOE); constexpr cItemPickaxeHandler ItemWoodenPickaxeHandler (E_ITEM_WOODEN_PICKAXE); - constexpr cDefaultItemHandler ItemWoodenPressurePlateBlockHandler (E_BLOCK_WOODEN_PRESSURE_PLATE); + constexpr cDefaultItemHandler ItemWoodenPressurePlateHandler (E_BLOCK_WOODEN_PRESSURE_PLATE); constexpr cItemShovelHandler ItemWoodenShovelHandler (E_ITEM_WOODEN_SHOVEL); constexpr cItemSwordHandler ItemWoodenSwordHandler (E_ITEM_WOODEN_SWORD); constexpr cItemClothHandler ItemWoolHandler (E_BLOCK_WOOL); @@ -608,7 +608,7 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_CARROTS: return ItemCarrotsBlockHandler; case E_BLOCK_CAULDRON: return ItemCauldronBlockHandler; case E_BLOCK_CHAIN_COMMAND_BLOCK: return ItemChainCommandBlockHandler; - case E_BLOCK_CHEST: return ItemChestBlockHandler; + case E_BLOCK_CHEST: return ItemChestHandler; case E_BLOCK_CHORUS_FLOWER: return ItemChorusFlowerHandler; case E_BLOCK_CHORUS_PLANT: return ItemChorusPlantHandler; case E_BLOCK_CLAY: return ItemClayBlockHandler; @@ -644,7 +644,7 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_EMERALD_BLOCK: return ItemEmeraldBlockHandler; case E_BLOCK_EMERALD_ORE: return ItemEmeraldOreHandler; case E_BLOCK_ENCHANTMENT_TABLE: return ItemEnchantingTableHandler; - case E_BLOCK_ENDER_CHEST: return ItemEnderchestHandler; + case E_BLOCK_ENDER_CHEST: return ItemEnderChestHandler; case E_BLOCK_END_BRICKS: return ItemEndBricksHandler; case E_BLOCK_END_GATEWAY: return ItemEndGatewayHandler; case E_BLOCK_END_PORTAL: return ItemEndPortalBlockHandler; @@ -659,7 +659,7 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_FROSTED_ICE: return ItemFrostedIceHandler; case E_BLOCK_FURNACE: return ItemFurnaceHandler; case E_BLOCK_GLASS: return ItemGlassHandler; - case E_BLOCK_GLASS_PANE: return ItemGlassPaneBlockHandler; + case E_BLOCK_GLASS_PANE: return ItemGlassPaneHandler; case E_BLOCK_GLOWSTONE: return ItemGlowstoneBlockHandler; case E_BLOCK_GOLD_BLOCK: return ItemGoldBlockHandler; case E_BLOCK_GOLD_ORE: return ItemGoldOreHandler; @@ -673,7 +673,7 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_HARDENED_CLAY: return ItemHardenedClayHandler; case E_BLOCK_HAY_BALE: return ItemHayBaleHandler; case E_BLOCK_HEAD: return ItemHeadBlockHandler; - case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE: return ItemHeavyWeightedPressurePlateBlockHandler; + case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE: return ItemHeavyWeightedPressurePlateHandler; case E_BLOCK_HOPPER: return ItemHopperHandler; case E_BLOCK_HUGE_BROWN_MUSHROOM: return ItemHugeBrownMushroomBlockHandler; case E_BLOCK_HUGE_RED_MUSHROOM: return ItemHugeRedMushroomBlockHandler; @@ -701,7 +701,7 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_LIGHT_BLUE_SHULKER_BOX: return ItemLightBlueShulkerBoxHandler; case E_BLOCK_LIGHT_GRAY_GLAZED_TERRACOTTA: return ItemLightGrayGlazedTerracottaHandler; case E_BLOCK_LIGHT_GRAY_SHULKER_BOX: return ItemLightGrayShulkerBoxHandler; - case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE: return ItemLightWeightedPressurePlateBlockHandler; + case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE: return ItemLightWeightedPressurePlateHandler; case E_BLOCK_LILY_PAD: return ItemLilypadHandler; case E_BLOCK_LIME_GLAZED_TERRACOTTA: return ItemLimeGlazedTerracottaHandler; case E_BLOCK_LIME_SHULKER_BOX: return ItemLimeShulkerBoxHandler; @@ -716,13 +716,13 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_MOSSY_COBBLESTONE: return ItemMossyCobblestoneHandler; case E_BLOCK_MYCELIUM: return ItemMyceliumHandler; case E_BLOCK_NETHERRACK: return ItemNetherrackHandler; - case E_BLOCK_NETHER_BRICK: return ItemNetherBrickBlockHandler; - case E_BLOCK_NETHER_BRICK_FENCE: return ItemNetherBrickFenceBlockHandler; + case E_BLOCK_NETHER_BRICK: return ItemNetherBricksHandler; + case E_BLOCK_NETHER_BRICK_FENCE: return ItemNetherBrickFenceHandler; case E_BLOCK_NETHER_BRICK_STAIRS: return ItemNetherBrickStairsHandler; case E_BLOCK_NETHER_PORTAL: return ItemNetherPortalBlockHandler; case E_BLOCK_NETHER_QUARTZ_ORE: return ItemNetherQuartzOreHandler; - case E_BLOCK_NETHER_WART: return ItemNetherWartBlockHandler; - case E_BLOCK_NETHER_WART_BLOCK: return ItemNetherWartBlockBlockHandler; + case E_BLOCK_NETHER_WART: return ItemNetherWartTechnicalBlockHandler; + case E_BLOCK_NETHER_WART_BLOCK: return ItemNetherWartBlockHandler; case E_BLOCK_NEW_LEAVES: return ItemNewLeavesHandler; case E_BLOCK_NEW_LOG: return ItemNewLogHandler; case E_BLOCK_NOTE_BLOCK: return ItemNoteBlockHandler; @@ -798,20 +798,20 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_STONE_BRICKS: return ItemStoneBricksHandler; case E_BLOCK_STONE_BRICK_STAIRS: return ItemStoneBrickStairsHandler; case E_BLOCK_STONE_BUTTON: return ItemStoneButtonHandler; - case E_BLOCK_STONE_PRESSURE_PLATE: return ItemStonePressurePlateBlockHandler; + case E_BLOCK_STONE_PRESSURE_PLATE: return ItemStonePressurePlateHandler; case E_BLOCK_STONE_SLAB: return ItemStoneSlabHandler; case E_BLOCK_STRUCTURE_BLOCK: return ItemStructureBlockHandler; case E_BLOCK_STRUCTURE_VOID: return ItemStructureVoidHandler; - case E_BLOCK_SUGARCANE: return ItemSugarcaneHandler; + case E_BLOCK_SUGARCANE: return ItemSugarCaneBlockHandler; case E_BLOCK_TALL_GRASS: return ItemTallGrassHandler; case E_BLOCK_TERRACOTTA: return ItemTerracottaHandler; - case E_BLOCK_TNT: return ItemTNTBlockHandler; + case E_BLOCK_TNT: return ItemTNTHandler; case E_BLOCK_TORCH: return ItemTorchBlockHandler; case E_BLOCK_TRAPDOOR: return ItemOakTrapdoorHandler; case E_BLOCK_TRAPPED_CHEST: return ItemTrappedChestHandler; case E_BLOCK_TRIPWIRE: return ItemTripwireHandler; case E_BLOCK_TRIPWIRE_HOOK: return ItemTripwireHookHandler; - case E_BLOCK_VINES: return ItemVineHandler; + case E_BLOCK_VINES: return ItemVinesHandler; case E_BLOCK_WALLSIGN: return ItemWallsignHandler; case E_BLOCK_WALL_BANNER: return ItemWallBannerHandler; case E_BLOCK_WATER: return ItemWaterHandler; @@ -819,7 +819,7 @@ const cItemHandler & cItemHandler::For(int a_ItemType) case E_BLOCK_WHITE_GLAZED_TERRACOTTA: return ItemWhiteGlazedTerracottaHandler; case E_BLOCK_WHITE_SHULKER_BOX: return ItemWhiteShulkerBoxHandler; case E_BLOCK_WOODEN_BUTTON: return ItemOakButtonHandler; - case E_BLOCK_WOODEN_PRESSURE_PLATE: return ItemWoodenPressurePlateBlockHandler; + case E_BLOCK_WOODEN_PRESSURE_PLATE: return ItemWoodenPressurePlateHandler; case E_BLOCK_WOODEN_SLAB: return ItemOakSlabHandler; case E_BLOCK_WOOL: return ItemWoolHandler; case E_BLOCK_YELLOW_GLAZED_TERRACOTTA: return ItemYellowGlazedTerracottaHandler; @@ -1091,7 +1091,9 @@ void cItemHandler::OnPlayerPlace(cPlayer & a_Player, const cItem & a_HeldItem, c if (!cBlockHandler::For(PlaceBlock).DoesIgnoreBuildCollision(World, a_HeldItem, PlacedPosition, PlaceMeta, a_ClickedBlockFace, false)) { // Tried to place a block into another? - // Happens when you place a block aiming at side of block with a torch on it or stem beside it + // Happens when you place a block aiming at side of block with a torch on it or stem beside it. + a_Player.SendBlocksAround(PlacedPosition.x, PlacedPosition.y, PlacedPosition.z, 2); + a_Player.GetInventory().SendEquippedSlot(); return; } diff --git a/src/Items/ItemVine.h b/src/Items/ItemVine.h deleted file mode 100644 index be5cf4588..000000000 --- a/src/Items/ItemVine.h +++ /dev/null @@ -1,44 +0,0 @@ - -#pragma once - -#include "ItemHandler.h" - - - - - -class cItemVineHandler final : - public cItemHandler -{ - using Super = cItemHandler; - -public: - - using Super::Super; - -private: - - virtual bool CommitPlacement(cPlayer & a_Player, const cItem & a_HeldItem, const Vector3i a_PlacePosition, const eBlockFace a_ClickedBlockFace, const Vector3i a_CursorPosition) const override - { - BLOCKTYPE Block; - NIBBLETYPE Meta; - a_Player.GetWorld()->GetBlockTypeMeta(a_PlacePosition, Block, Meta); - - NIBBLETYPE PlaceMeta; - switch (a_ClickedBlockFace) - { - case BLOCK_FACE_NORTH: PlaceMeta = 0x1; break; - case BLOCK_FACE_SOUTH: PlaceMeta = 0x4; break; - case BLOCK_FACE_WEST: PlaceMeta = 0x8; break; - case BLOCK_FACE_EAST: PlaceMeta = 0x2; break; - default: return false; - } - - if (Block == E_BLOCK_VINES) - { - PlaceMeta |= Meta; - } - - return a_Player.PlaceBlock(a_PlacePosition, E_BLOCK_VINES, PlaceMeta); - } -}; diff --git a/src/Items/ItemVines.h b/src/Items/ItemVines.h new file mode 100644 index 000000000..07b6ec23e --- /dev/null +++ b/src/Items/ItemVines.h @@ -0,0 +1,44 @@ + +#pragma once + +#include "ItemHandler.h" + + + + + +class cItemVinesHandler final : + public cItemHandler +{ + using Super = cItemHandler; + +public: + + using Super::Super; + +private: + + virtual bool CommitPlacement(cPlayer & a_Player, const cItem & a_HeldItem, const Vector3i a_PlacePosition, const eBlockFace a_ClickedBlockFace, const Vector3i a_CursorPosition) const override + { + BLOCKTYPE Block; + NIBBLETYPE Meta; + a_Player.GetWorld()->GetBlockTypeMeta(a_PlacePosition, Block, Meta); + + NIBBLETYPE PlaceMeta; + switch (a_ClickedBlockFace) + { + case BLOCK_FACE_NORTH: PlaceMeta = 0x1; break; + case BLOCK_FACE_SOUTH: PlaceMeta = 0x4; break; + case BLOCK_FACE_WEST: PlaceMeta = 0x8; break; + case BLOCK_FACE_EAST: PlaceMeta = 0x2; break; + default: return false; + } + + if (Block == E_BLOCK_VINES) + { + PlaceMeta |= Meta; + } + + return a_Player.PlaceBlock(a_PlacePosition, E_BLOCK_VINES, PlaceMeta); + } +}; -- cgit v1.2.3