From 58695b1ab4c8e8819d1ed0b5a8f29eaf162a4d5e Mon Sep 17 00:00:00 2001 From: raoulvdberge Date: Wed, 21 Dec 2016 20:49:22 +0100 Subject: [PATCH] Refactor of network nodes. TODO: generics and proper node saving / loading --- .../raoulvdberge/refinedstorage/RSUtils.java | 7 + .../api/network/INetworkNode.java | 12 + .../api/network/INetworkNodeProxy.java | 7 + .../refinedstorage/apiimpl/API.java | 8 +- .../apiimpl/network/NetworkListener.java | 14 +- .../apiimpl/network/NetworkNodeGraph.java | 14 +- .../apiimpl/network/node/NetworkNode.java | 151 +++++ .../network/node/NetworkNodeBasic.java | 25 + .../network/node/NetworkNodeConstructor.java | 320 ++++++++++ .../network/node/NetworkNodeCrafter.java | 206 +++++++ .../node/NetworkNodeCraftingMonitor.java | 62 ++ .../network/node/NetworkNodeDestructor.java | 279 +++++++++ .../network/node/NetworkNodeDetector.java | 239 ++++++++ .../network/node/NetworkNodeDiskDrive.java | 492 +++++++++++++++ .../node/NetworkNodeDiskManipulator.java | 580 ++++++++++++++++++ .../network/node/NetworkNodeExporter.java | 253 ++++++++ .../node/NetworkNodeFluidInterface.java | 219 +++++++ .../network/node/NetworkNodeFluidStorage.java | 331 ++++++++++ .../apiimpl/network/node/NetworkNodeGrid.java | 552 +++++++++++++++++ .../network/node/NetworkNodeImporter.java | 202 ++++++ .../network/node/NetworkNodeInterface.java | 190 ++++++ .../node/NetworkNodeNetworkTransmitter.java | 152 +++++ .../network/node/NetworkNodeReader.java | 79 +++ .../network/node/NetworkNodeRelay.java | 33 + .../node/NetworkNodeSecurityManager.java | 174 ++++++ .../network/node/NetworkNodeSolderer.java | 188 ++++++ .../network/node/NetworkNodeStorage.java | 333 ++++++++++ .../node/NetworkNodeWirelessTransmitter.java | 84 +++ .../network/node/NetworkNodeWriter.java | 127 ++++ .../NetworkNodeExternalStorage.java} | 113 ++-- .../externalstorage/StorageFluidExternal.java | 6 +- .../node}/externalstorage/StorageItemDSU.java | 6 +- .../externalstorage/StorageItemDrawer.java | 8 +- .../StorageItemDrawerGroup.java | 6 +- .../externalstorage/StorageItemExternal.java | 2 +- .../StorageItemItemHandler.java | 10 +- .../apiimpl/storage/StorageFluidNBT.java | 14 +- .../apiimpl/storage/StorageItemNBT.java | 15 +- .../refinedstorage/block/BlockBase.java | 15 +- .../refinedstorage/block/BlockCable.java | 4 +- .../block/BlockCraftingMonitor.java | 3 +- .../refinedstorage/block/BlockDiskDrive.java | 3 +- .../block/BlockDiskManipulator.java | 3 +- .../block/BlockExternalStorage.java | 7 +- .../block/BlockFluidStorage.java | 9 +- .../refinedstorage/block/BlockGrid.java | 3 +- .../refinedstorage/block/BlockReader.java | 3 +- .../block/BlockSecurityManager.java | 5 +- .../refinedstorage/block/BlockStorage.java | 9 +- .../refinedstorage/block/BlockWriter.java | 6 +- .../container/ContainerConstructor.java | 5 +- .../container/ContainerCrafter.java | 5 +- .../container/ContainerDestructor.java | 5 +- .../container/ContainerDetector.java | 3 +- .../container/ContainerDiskDrive.java | 5 +- .../container/ContainerDiskManipulator.java | 9 +- .../container/ContainerExporter.java | 5 +- .../container/ContainerExternalStorage.java | 5 +- .../container/ContainerFluidInterface.java | 7 +- .../container/ContainerFluidStorage.java | 3 +- .../container/ContainerGrid.java | 14 +- .../container/ContainerImporter.java | 5 +- .../container/ContainerInterface.java | 9 +- .../ContainerNetworkTransmitter.java | 5 +- .../container/ContainerSecurityManager.java | 5 +- .../container/ContainerSolderer.java | 7 +- .../container/ContainerStorage.java | 3 +- .../ContainerWirelessTransmitter.java | 3 +- .../slot/SlotGridCraftingResult.java | 7 +- .../refinedstorage/gui/GuiFluidInterface.java | 3 +- .../refinedstorage/gui/GuiHandler.java | 23 +- .../gui/GuiNetworkTransmitter.java | 3 +- .../refinedstorage/gui/GuiReaderWriter.java | 2 +- .../gui/GuiSecurityManager.java | 3 +- .../refinedstorage/gui/grid/GuiGrid.java | 13 +- .../gui/grid/filtering/GridFilterParser.java | 6 +- .../gui/grid/sorting/GridSortingName.java | 6 +- .../gui/grid/sorting/GridSortingQuantity.java | 6 +- .../sidebutton/SideButtonDetectorMode.java | 17 +- .../SideButtonGridSearchBoxMode.java | 22 +- .../SideButtonGridSortingDirection.java | 10 +- .../sidebutton/SideButtonGridSortingType.java | 10 +- .../sidebutton/SideButtonGridViewType.java | 14 +- .../gui/sidebutton/SideButtonIOMode.java | 7 +- .../inventory/IItemHandlerChangeListener.java | 5 + .../inventory/ItemHandlerBasic.java | 11 +- .../ItemHandlerChangeListenerNode.java | 16 + .../ItemHandlerChangeListenerTile.java | 16 + .../inventory/ItemHandlerFluid.java | 5 +- .../inventory/ItemHandlerUpgrade.java | 5 +- .../item/ItemBlockFluidStorage.java | 12 +- .../refinedstorage/item/ItemBlockStorage.java | 12 +- .../item/ItemWirelessFluidGrid.java | 20 +- .../refinedstorage/item/ItemWirelessGrid.java | 30 +- .../network/MessageGridCraftingClear.java | 5 +- .../network/MessageGridCraftingTransfer.java | 3 +- .../network/MessageGridPatternCreate.java | 5 +- .../network/MessageSecurityManagerUpdate.java | 3 +- ...essageWirelessFluidGridSettingsUpdate.java | 14 +- .../MessageWirelessGridSettingsUpdate.java | 20 +- .../proxy/CapabilityNetworkNode.java | 65 -- .../proxy/CapabilityNetworkNodeProxy.java | 40 ++ .../refinedstorage/proxy/ProxyCommon.java | 3 +- .../tile/INetworkNodeHolder.java | 15 + .../refinedstorage/tile/IReaderWriter.java | 2 - .../refinedstorage/tile/TileBase.java | 15 +- .../refinedstorage/tile/TileCable.java | 11 +- .../refinedstorage/tile/TileConstructor.java | 306 +-------- .../refinedstorage/tile/TileController.java | 70 ++- .../refinedstorage/tile/TileCrafter.java | 210 +------ .../refinedstorage/tile/TileDestructor.java | 266 +------- .../refinedstorage/tile/TileDetector.java | 235 +------ .../refinedstorage/tile/TileDiskDrive.java | 483 +-------------- .../tile/TileDiskManipulator.java | 567 +---------------- .../refinedstorage/tile/TileExporter.java | 259 +------- .../tile/TileExternalStorage.java | 68 ++ .../tile/TileFluidInterface.java | 213 +------ .../refinedstorage/tile/TileFluidStorage.java | 324 +--------- .../refinedstorage/tile/TileImporter.java | 188 +----- .../refinedstorage/tile/TileInterface.java | 182 +----- .../tile/TileNetworkReceiver.java | 21 +- .../tile/TileNetworkTransmitter.java | 151 +---- .../refinedstorage/tile/TileNode.java | 256 +++----- .../tile/TileProcessingPatternEncoder.java | 5 +- .../refinedstorage/tile/TileReader.java | 91 +-- .../refinedstorage/tile/TileRelay.java | 31 +- .../tile/TileSecurityManager.java | 170 +---- .../refinedstorage/tile/TileSolderer.java | 177 +----- .../refinedstorage/tile/TileStorage.java | 326 +--------- .../tile/TileWirelessTransmitter.java | 83 +-- .../refinedstorage/tile/TileWriter.java | 130 +--- .../tile/config/IAccessType.java | 7 +- .../tile/config/IComparable.java | 7 +- .../tile/config/IExcessVoidable.java | 7 +- .../tile/config/IFilterable.java | 7 +- .../tile/config/IPrioritizable.java | 7 +- .../refinedstorage/tile/config/IType.java | 11 +- .../craftingmonitor/TileCraftingMonitor.java | 53 +- .../refinedstorage/tile/grid/TileGrid.java | 563 +---------------- .../assets/refinedstorage/lang/en_US.lang | 1 - 140 files changed, 6199 insertions(+), 5447 deletions(-) create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNodeProxy.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNode.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeBasic.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeConstructor.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCrafter.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCraftingMonitor.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDestructor.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDetector.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskDrive.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskManipulator.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidStorage.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeGrid.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeInterface.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeNetworkTransmitter.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeReader.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeRelay.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSecurityManager.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSolderer.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeStorage.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWirelessTransmitter.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWriter.java rename src/main/java/com/raoulvdberge/refinedstorage/{tile/externalstorage/TileExternalStorage.java => apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java} (73%) rename src/main/java/com/raoulvdberge/refinedstorage/{tile => apiimpl/network/node}/externalstorage/StorageFluidExternal.java (92%) rename src/main/java/com/raoulvdberge/refinedstorage/{tile => apiimpl/network/node}/externalstorage/StorageItemDSU.java (94%) rename src/main/java/com/raoulvdberge/refinedstorage/{tile => apiimpl/network/node}/externalstorage/StorageItemDrawer.java (90%) rename src/main/java/com/raoulvdberge/refinedstorage/{tile => apiimpl/network/node}/externalstorage/StorageItemDrawerGroup.java (93%) rename src/main/java/com/raoulvdberge/refinedstorage/{tile => apiimpl/network/node}/externalstorage/StorageItemExternal.java (97%) rename src/main/java/com/raoulvdberge/refinedstorage/{tile => apiimpl/network/node}/externalstorage/StorageItemItemHandler.java (91%) create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/inventory/IItemHandlerChangeListener.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerNode.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerTile.java delete mode 100755 src/main/java/com/raoulvdberge/refinedstorage/proxy/CapabilityNetworkNode.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/proxy/CapabilityNetworkNodeProxy.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/tile/INetworkNodeHolder.java create mode 100755 src/main/java/com/raoulvdberge/refinedstorage/tile/TileExternalStorage.java diff --git a/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java b/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java index a5b59e527..9d3d7ae94 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java @@ -34,6 +34,7 @@ import net.minecraft.util.math.Vec3d; import net.minecraft.util.text.Style; import net.minecraft.util.text.TextComponentTranslation; import net.minecraft.util.text.TextFormatting; +import net.minecraft.world.World; import net.minecraftforge.common.util.Constants; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidRegistry; @@ -254,6 +255,12 @@ public final class RSUtils { return AccessType.INSERT_EXTRACT; } + public static void updateBlock(World world, BlockPos pos) { + if (world != null) { + world.notifyBlockUpdate(pos, world.getBlockState(pos), world.getBlockState(pos), 1 | 2); + } + } + public static IItemHandler getItemHandler(TileEntity tile, EnumFacing side) { if (tile == null) { return null; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNode.java b/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNode.java index 2880c0926..90fe5245c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNode.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNode.java @@ -1,6 +1,8 @@ package com.raoulvdberge.refinedstorage.api.network; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.math.BlockPos; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -44,4 +46,14 @@ public interface INetworkNode { */ @Nullable INetworkMaster getNetwork(); + + void update(); + + NBTTagCompound write(NBTTagCompound tag); + + void read(NBTTagCompound tag); + + BlockPos getPos(); + + void markDirty(); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNodeProxy.java b/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNodeProxy.java new file mode 100755 index 000000000..8b3235e93 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/api/network/INetworkNodeProxy.java @@ -0,0 +1,7 @@ +package com.raoulvdberge.refinedstorage.api.network; + +public interface INetworkNodeProxy { + INetworkNode getNode(); + + INetworkNode createNode(); +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/API.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/API.java index c684cc726..9aeb43f73 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/API.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/API.java @@ -8,6 +8,7 @@ import com.raoulvdberge.refinedstorage.api.autocrafting.preview.ICraftingPreview import com.raoulvdberge.refinedstorage.api.autocrafting.registry.ICraftingTaskRegistry; import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterChannel; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterHandlerRegistry; import com.raoulvdberge.refinedstorage.api.solderer.ISoldererRegistry; @@ -23,7 +24,7 @@ import com.raoulvdberge.refinedstorage.apiimpl.solderer.SoldererRegistry; import com.raoulvdberge.refinedstorage.apiimpl.util.Comparer; import com.raoulvdberge.refinedstorage.apiimpl.util.StackListFluid; import com.raoulvdberge.refinedstorage.apiimpl.util.StackListItem; -import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode; +import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy; import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; @@ -137,8 +138,9 @@ public class API implements IRSAPI { for (EnumFacing facing : EnumFacing.VALUES) { TileEntity tile = world.getTileEntity(pos.offset(facing)); - if (tile != null && tile.hasCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, facing.getOpposite())) { - INetworkNode node = tile.getCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, facing.getOpposite()); + if (tile != null && tile.hasCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, facing.getOpposite())) { + INetworkNodeProxy nodeProxy = tile.getCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, facing.getOpposite()); + INetworkNode node = nodeProxy.getNode(); if (node.getNetwork() != null) { node.getNetwork().getNodeGraph().rebuild(); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkListener.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkListener.java index 8df6e1642..980e6200e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkListener.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkListener.java @@ -2,8 +2,9 @@ package com.raoulvdberge.refinedstorage.apiimpl.network; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.api.network.security.Permission; -import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode; +import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; import net.minecraftforge.event.world.BlockEvent; @@ -16,8 +17,9 @@ public class NetworkListener { for (EnumFacing facing : EnumFacing.VALUES) { TileEntity tile = e.getWorld().getTileEntity(e.getBlockSnapshot().getPos().offset(facing)); - if (tile != null && tile.hasCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, facing.getOpposite())) { - INetworkNode node = tile.getCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, facing.getOpposite()); + if (tile != null && tile.hasCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, facing.getOpposite())) { + INetworkNodeProxy nodeProxy = tile.getCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, facing.getOpposite()); + INetworkNode node = nodeProxy.getNode(); if (node.getNetwork() != null && !node.getNetwork().getSecurityManager().hasPermission(Permission.BUILD, e.getPlayer())) { RSUtils.sendNoPermissionMessage(e.getPlayer()); @@ -36,9 +38,9 @@ public class NetworkListener { if (!e.getWorld().isRemote) { TileEntity tile = e.getWorld().getTileEntity(e.getPos()); - if (tile != null && tile.hasCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, null)) { - - INetworkNode node = tile.getCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, null); + if (tile != null && tile.hasCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, null)) { + INetworkNodeProxy nodeProxy = tile.getCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, null); + INetworkNode node = nodeProxy.getNode(); if (node.getNetwork() != null && !node.getNetwork().getSecurityManager().hasPermission(Permission.BUILD, e.getPlayer())) { RSUtils.sendNoPermissionMessage(e.getPlayer()); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkNodeGraph.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkNodeGraph.java index f31f625a2..7b159c93e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkNodeGraph.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/NetworkNodeGraph.java @@ -4,6 +4,7 @@ import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.api.network.INetworkNeighborhoodAware; import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.network.INetworkNodeGraph; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.item.ItemBlockController; import com.raoulvdberge.refinedstorage.tile.TileController; import net.minecraft.block.state.IBlockState; @@ -16,7 +17,7 @@ import net.minecraft.world.World; import java.util.*; -import static com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode.NETWORK_NODE_CAPABILITY; +import static com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY; public class NetworkNodeGraph implements INetworkNodeGraph { private TileController controller; @@ -42,11 +43,14 @@ public class NetworkNodeGraph implements INetworkNodeGraph { INetworkNeighborhoodAware.Operator operator = (world, pos, side) -> { TileEntity tile = world.getTileEntity(pos); + if (tile != null && !tile.isInvalid()) { if (tile instanceof TileController) { - removeOtherControler(world, pos); + removeOtherController(world, pos); } else { - INetworkNode otherNode = NETWORK_NODE_CAPABILITY.cast(tile.getCapability(NETWORK_NODE_CAPABILITY, side)); + INetworkNodeProxy otherNodeProxy = NETWORK_NODE_PROXY_CAPABILITY.cast(tile.getCapability(NETWORK_NODE_PROXY_CAPABILITY, side)); + INetworkNode otherNode = otherNodeProxy.getNode(); + if (otherNode != null && newNodes.add(otherNode)) { toCheck.add(new NodeToCheck(otherNode, world, pos, side, tile)); } @@ -117,7 +121,7 @@ public class NetworkNodeGraph implements INetworkNodeGraph { return controller.getWorld(); } - private void removeOtherControler(World world, BlockPos otherControllerPos) { + private void removeOtherController(World world, BlockPos otherControllerPos) { if (!controller.getPos().equals(otherControllerPos)) { IBlockState state = world.getBlockState(otherControllerPos); @@ -157,7 +161,7 @@ public class NetworkNodeGraph implements INetworkNodeGraph { } else { for (EnumFacing checkSide : EnumFacing.VALUES) { if (checkSide != side) { // Avoid going backward - INetworkNode nodeOnSide = NETWORK_NODE_CAPABILITY.cast(tile.getCapability(NETWORK_NODE_CAPABILITY, checkSide)); + INetworkNode nodeOnSide = NETWORK_NODE_PROXY_CAPABILITY.cast(tile.getCapability(NETWORK_NODE_PROXY_CAPABILITY, checkSide)); if (nodeOnSide == node) { operator.apply(world, pos.offset(checkSide), checkSide.getOpposite()); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNode.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNode.java new file mode 100755 index 000000000..4f2deed8e --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNode.java @@ -0,0 +1,151 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.network.INetworkNeighborhoodAware; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.api.util.IWrenchable; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraftforge.items.IItemHandler; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +public abstract class NetworkNode implements INetworkNode, INetworkNeighborhoodAware, IWrenchable { + protected boolean rebuildOnUpdateChange; + private RedstoneMode redstoneMode = RedstoneMode.IGNORE; + @Nullable + protected INetworkMaster network; + private boolean couldUpdate; + protected int ticks; + protected INetworkNodeHolder holder; + + public NetworkNode(INetworkNodeHolder holder) { + this.holder = holder; + } + + public RedstoneMode getRedstoneMode() { + return redstoneMode; + } + + public void setRedstoneMode(RedstoneMode redstoneMode) { + this.redstoneMode = redstoneMode; + } + + @Nonnull + @Override + public ItemStack getItemStack() { + IBlockState state = holder.world().getBlockState(holder.pos()); + + Item item = Item.getItemFromBlock(state.getBlock()); + + return new ItemStack(item, 1, state.getBlock().getMetaFromState(state)); + } + + @Override + public void onConnected(INetworkMaster network) { + onConnectedStateChange(network, true); + + this.network = network; + } + + @Override + public void onDisconnected(INetworkMaster network) { + this.network = null; + + onConnectedStateChange(network, false); + } + + protected void onConnectedStateChange(INetworkMaster network, boolean state) { + if (hasConnectivityState()) { + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + + @Override + public void markDirty() { + // @todo + } + + @Override + public boolean canUpdate() { + return redstoneMode.isEnabled(holder.world(), holder.pos()); + } + + @Override + public void update() { + ++ticks; + + if (couldUpdate != canUpdate()) { + couldUpdate = canUpdate(); + + if (network != null) { + onConnectedStateChange(network, couldUpdate); + + if (rebuildOnUpdateChange) { + network.getNodeGraph().rebuild(); + } + } + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + writeConfiguration(tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + return tag; + } + + @Override + public void read(NBTTagCompound tag) { + readConfiguration(tag); + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + } + + @Nullable + @Override + public INetworkMaster getNetwork() { + return network; + } + + @Override + public BlockPos getPos() { + return holder.pos(); + } + + public boolean canConduct(@Nullable EnumFacing direction) { + return true; + } + + @Override + public void walkNeighborhood(Operator operator) { + for (EnumFacing facing : EnumFacing.VALUES) { + if (canConduct(facing)) { + operator.apply(holder.world(), holder.pos().offset(facing), facing.getOpposite()); + } + } + } + + public IItemHandler getDrops() { + return null; + } + + public boolean hasConnectivityState() { + return false; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeBasic.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeBasic.java new file mode 100755 index 000000000..14d49ebf9 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeBasic.java @@ -0,0 +1,25 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; + +public class NetworkNodeBasic extends NetworkNode { + private int energyUsage; + private boolean connectivityState; + + public NetworkNodeBasic(INetworkNodeHolder holder, int energyUsage, boolean connectivityState) { + super(holder); + + this.energyUsage = energyUsage; + this.connectivityState = connectivityState; + } + + @Override + public int getEnergyUsage() { + return energyUsage; + } + + @Override + public boolean hasConnectivityState() { + return connectivityState; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeConstructor.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeConstructor.java new file mode 100755 index 000000000..53575695a --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeConstructor.java @@ -0,0 +1,320 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.mojang.authlib.GameProfile; +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.container.slot.SlotFilter; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileConstructor; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import com.raoulvdberge.refinedstorage.tile.config.IType; +import net.minecraft.block.Block; +import net.minecraft.block.BlockSkull; +import net.minecraft.block.SoundType; +import net.minecraft.block.state.IBlockState; +import net.minecraft.dispenser.BehaviorDefaultDispenseItem; +import net.minecraft.dispenser.PositionImpl; +import net.minecraft.entity.item.EntityFireworkRocket; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTUtil; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.tileentity.TileEntitySkull; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.SoundCategory; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.WorldServer; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.BlockSnapshot; +import net.minecraftforge.common.util.FakePlayerFactory; +import net.minecraftforge.event.world.BlockEvent; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.items.IItemHandler; + +public class NetworkNodeConstructor extends NetworkNode implements IComparable, IType { + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_TYPE = "Type"; + private static final String NBT_DROP = "Drop"; + + private static final int BASE_SPEED = 20; + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(1, new ItemHandlerChangeListenerNode(this)) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + item = getStackInSlot(slot).isEmpty() ? null : getStackInSlot(slot).copy(); + block = SlotFilter.getBlockState(holder.world(), holder.pos().offset(holder.getDirection()), getStackInSlot(slot)); + } + }; + + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING); + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int type = IType.ITEMS; + private boolean drop = false; + + private IBlockState block; + private ItemStack item; + + public NetworkNodeConstructor(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.constructorUsage + upgrades.getEnergyUsage(); + } + + @Override + public void update() { + super.update(); + + if (network != null && ticks % upgrades.getSpeed(BASE_SPEED, 4) == 0) { + if (type == IType.ITEMS) { + if (block != null) { + if (drop && item != null) { + dropItem(); + } else { + placeBlock(); + } + } else if (item != null) { + if (item.getItem() == Items.FIREWORKS && !drop) { + ItemStack took = network.extractItem(item, 1, false); + + if (took != null) { + holder.world().spawnEntity(new EntityFireworkRocket(holder.world(), getDispensePositionX(), getDispensePositionY(), getDispensePositionZ(), took)); + } + } else { + dropItem(); + } + } + } else if (type == IType.FLUIDS) { + FluidStack stack = fluidFilters.getFluidStackInSlot(0); + + if (stack != null && stack.getFluid().canBePlacedInWorld() && stack.amount >= Fluid.BUCKET_VOLUME) { + BlockPos front = holder.pos().offset(holder.getDirection()); + + Block block = stack.getFluid().getBlock(); + + if (holder.world().isAirBlock(front) && block.canPlaceBlockAt(holder.world(), front)) { + FluidStack took = network.extractFluid(stack, Fluid.BUCKET_VOLUME, compare, false); + + if (took != null) { + IBlockState state = block.getDefaultState(); + + if (state.getBlock() == Blocks.WATER) { + state = Blocks.FLOWING_WATER.getDefaultState(); + } else if (state.getBlock() == Blocks.LAVA) { + state = Blocks.FLOWING_LAVA.getDefaultState(); + } + + holder.world().setBlockState(front, state, 1 | 2); + } + } + } + } + } + } + + private void placeBlock() { + BlockPos front = holder.pos().offset(holder.getDirection()); + + if (holder.world().isAirBlock(front) && block.getBlock().canPlaceBlockAt(holder.world(), front)) { + ItemStack took = network.extractItem(itemFilters.getStackInSlot(0), 1, compare, true); + + if (took != null) { + @SuppressWarnings("deprecation") + IBlockState state = block.getBlock().getStateFromMeta(took.getMetadata()); + + BlockEvent.PlaceEvent e = new BlockEvent.PlaceEvent(new BlockSnapshot(holder.world(), front, state), holder.world().getBlockState(holder.pos()), FakePlayerFactory.getMinecraft((WorldServer) holder.world()), null); + + if (MinecraftForge.EVENT_BUS.post(e)) { + return; + } + + network.extractItem(itemFilters.getStackInSlot(0), 1, compare, false); + + holder.world().setBlockState(front, state, 1 | 2); + + // From ItemBlock#onItemUse + SoundType blockSound = block.getBlock().getSoundType(state, holder.world(), holder.pos(), null); + holder.world().playSound(null, front, blockSound.getPlaceSound(), SoundCategory.BLOCKS, (blockSound.getVolume() + 1.0F) / 2.0F, blockSound.getPitch() * 0.8F); + + if (block.getBlock() == Blocks.SKULL) { + holder.world().setBlockState(front, holder.world().getBlockState(front).withProperty(BlockSkull.FACING, holder.getDirection())); + + TileEntity tile = holder.world().getTileEntity(front); + + if (tile instanceof TileEntitySkull) { + TileEntitySkull skullTile = (TileEntitySkull) tile; + + if (item.getItemDamage() == 3) { + GameProfile playerInfo = null; + + if (item.hasTagCompound()) { + NBTTagCompound tag = item.getTagCompound(); + + if (tag.hasKey("SkullOwner", 10)) { + playerInfo = NBTUtil.readGameProfileFromNBT(tag.getCompoundTag("SkullOwner")); + } else if (tag.hasKey("SkullOwner", 8) && !tag.getString("SkullOwner").isEmpty()) { + playerInfo = new GameProfile(null, tag.getString("SkullOwner")); + } + } + + skullTile.setPlayerProfile(playerInfo); + } else { + skullTile.setType(item.getMetadata()); + } + + Blocks.SKULL.checkWitherSpawn(holder.world(), front, skullTile); + } + + } + } else if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { + ItemStack craft = itemFilters.getStackInSlot(0); + + network.scheduleCraftingTask(craft, 1, compare); + } + } + } + + private void dropItem() { + ItemStack took = network.extractItem(item, 1, false); + + if (took != null) { + BehaviorDefaultDispenseItem.doDispense(holder.world(), took, 6, holder.getDirection(), new PositionImpl(getDispensePositionX(), getDispensePositionY(), getDispensePositionZ())); + } else if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { + ItemStack craft = itemFilters.getStackInSlot(0); + + network.scheduleCraftingTask(craft, 1, compare); + } + } + + // From BlockDispenser#getDispensePosition + private double getDispensePositionX() { + return (double) holder.pos().getX() + 0.5D + 0.8D * (double) holder.getDirection().getFrontOffsetX(); + } + + // From BlockDispenser#getDispensePosition + private double getDispensePositionY() { + return (double) holder.pos().getY() + (holder.getDirection() == EnumFacing.DOWN ? 0.45D : 0.5D) + 0.8D * (double) holder.getDirection().getFrontOffsetY(); + } + + // From BlockDispenser#getDispensePosition + private double getDispensePositionZ() { + return (double) holder.pos().getZ() + 0.5D + 0.8D * (double) holder.getDirection().getFrontOffsetZ(); + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(upgrades, 1, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_TYPE, type); + tag.setBoolean(NBT_DROP, drop); + + RSUtils.writeItems(itemFilters, 0, tag); + RSUtils.writeItems(fluidFilters, 2, tag); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + if (tag.hasKey(NBT_DROP)) { + drop = tag.getBoolean(NBT_DROP); + } + + RSUtils.readItems(itemFilters, 0, tag); + RSUtils.readItems(fluidFilters, 2, tag); + } + + public boolean isDrop() { + return drop; + } + + public void setDrop(boolean drop) { + this.drop = drop; + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + @Override + public IItemHandler getDrops() { + return upgrades; + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public int getType() { + return holder.world().isRemote ? TileConstructor.TYPE.getValue() : type; + } + + @Override + public void setType(int type) { + this.type = type; + + markDirty(); + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCrafter.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCrafter.java new file mode 100755 index 000000000..2b5744dae --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCrafter.java @@ -0,0 +1,206 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPattern; +import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPatternContainer; +import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPatternProvider; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; + +import java.util.ArrayList; +import java.util.List; + +public class NetworkNodeCrafter extends NetworkNode implements ICraftingPatternContainer { + private static final String NBT_TRIGGERED_AUTOCRAFTING = "TriggeredAutocrafting"; + + private ItemHandlerBasic patterns = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this), s -> { + // We can only validate the crafting pattern if the world exists. + // If the world doesn't exist, this is probably called while reading and in that case it doesn't matter. + if (holder.world() != null) { + return s.getItem() instanceof ICraftingPatternProvider && ((ICraftingPatternProvider) s.getItem()).create(holder.world(), s, this).isValid(); + } + + return true; + }) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + if (network != null && !holder.world().isRemote) { + rebuildPatterns(); + } + + if (network != null) { + network.rebuildPatterns(); + } + } + }; + + private List actualPatterns = new ArrayList<>(); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED); + + private boolean triggeredAutocrafting = false; + + public NetworkNodeCrafter(INetworkNodeHolder holder) { + super(holder); + } + + private void rebuildPatterns() { + actualPatterns.clear(); + + for (int i = 0; i < patterns.getSlots(); ++i) { + ItemStack patternStack = patterns.getStackInSlot(i); + + if (!patternStack.isEmpty()) { + ICraftingPattern pattern = ((ICraftingPatternProvider) patternStack.getItem()).create(holder.world(), patternStack, this); + + if (pattern.isValid()) { + actualPatterns.add(pattern); + } + } + } + } + + @Override + public int getEnergyUsage() { + int usage = RS.INSTANCE.config.crafterUsage + upgrades.getEnergyUsage(); + + for (int i = 0; i < patterns.getSlots(); ++i) { + if (!patterns.getStackInSlot(i).isEmpty()) { + usage += RS.INSTANCE.config.crafterPerPatternUsage; + } + } + + return usage; + } + + @Override + public void update() { + super.update(); + + if (ticks == 1) { + rebuildPatterns(); + } + + if (network != null && triggeredAutocrafting && holder.world().isBlockPowered(holder.pos())) { + for (ICraftingPattern pattern : actualPatterns) { + for (ItemStack output : pattern.getOutputs()) { + network.scheduleCraftingTask(output, 1, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT); + } + } + } + } + + @Override + protected void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + if (!state) { + network.getCraftingTasks().stream() + .filter(task -> task.getPattern().getContainer().getPosition().equals(holder.pos())) + .forEach(network::cancelCraftingTask); + } + + network.rebuildPatterns(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(patterns, 0, tag); + RSUtils.readItems(upgrades, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(patterns, 0, tag); + RSUtils.writeItems(upgrades, 1, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setBoolean(NBT_TRIGGERED_AUTOCRAFTING, triggeredAutocrafting); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_TRIGGERED_AUTOCRAFTING)) { + triggeredAutocrafting = tag.getBoolean(NBT_TRIGGERED_AUTOCRAFTING); + } + } + + @Override + public int getSpeedUpdateCount() { + return upgrades.getUpgradeCount(ItemUpgrade.TYPE_SPEED); + } + + @Override + public IItemHandler getFacingInventory() { + return RSUtils.getItemHandler(getFacingTile(), holder.getDirection().getOpposite()); + } + + @Override + public TileEntity getFacingTile() { + return holder.world().getTileEntity(holder.pos().offset(holder.getDirection())); + } + + @Override + public List getPatterns() { + return actualPatterns; + } + + @Override + public BlockPos getPosition() { + return holder.pos(); + } + + public IItemHandler getPatternItems() { + return patterns; + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + public boolean isTriggeredAutocrafting() { + return triggeredAutocrafting; + } + + public void setTriggeredAutocrafting(boolean triggeredAutocrafting) { + this.triggeredAutocrafting = triggeredAutocrafting; + } + + @Override + public IItemHandler getDrops() { + return new CombinedInvWrapper(patterns, upgrades); + } + + @Override + public boolean hasConnectivityState() { + return true; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCraftingMonitor.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCraftingMonitor.java new file mode 100755 index 000000000..bd11cc2b3 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCraftingMonitor.java @@ -0,0 +1,62 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.craftingmonitor.ICraftingMonitor; +import com.raoulvdberge.refinedstorage.tile.craftingmonitor.TileCraftingMonitor; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.util.math.BlockPos; + +import javax.annotation.Nullable; + +public class NetworkNodeCraftingMonitor extends NetworkNode implements ICraftingMonitor { + public NetworkNodeCraftingMonitor(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.craftingMonitorUsage; + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public String getGuiTitle() { + return "gui.refinedstorage:crafting_monitor"; + } + + @Override + public void onCancelled(EntityPlayerMP player, int id) { + if (network != null) { + network.getItemGridHandler().onCraftingCancelRequested(player, id); + } + } + + @Override + public TileDataParameter getRedstoneModeParameter() { + return TileCraftingMonitor.REDSTONE_MODE; + } + + @Nullable + @Override + public BlockPos getNetworkPosition() { + return network != null ? network.getPosition() : null; + } + + @Override + public boolean isActive() { + return ((TileCraftingMonitor) holder.world().getTileEntity(holder.pos())).isActive(); + } + + public void onOpened(EntityPlayer player) { + if (network != null) { + network.sendCraftingMonitorUpdate((EntityPlayerMP) player); + } + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDestructor.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDestructor.java new file mode 100755 index 000000000..372277214 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDestructor.java @@ -0,0 +1,279 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileDestructor; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import com.raoulvdberge.refinedstorage.tile.config.IFilterable; +import com.raoulvdberge.refinedstorage.tile.config.IType; +import net.minecraft.block.Block; +import net.minecraft.block.BlockLiquid; +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.Entity; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.inventory.InventoryHelper; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.WorldServer; +import net.minecraft.world.chunk.Chunk; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.FakePlayerFactory; +import net.minecraftforge.event.world.BlockEvent; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidBlock; +import net.minecraftforge.fluids.capability.IFluidHandler; +import net.minecraftforge.fluids.capability.wrappers.BlockLiquidWrapper; +import net.minecraftforge.fluids.capability.wrappers.FluidBlockWrapper; +import net.minecraftforge.items.IItemHandler; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class NetworkNodeDestructor extends NetworkNode implements IComparable, IFilterable, IType { + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_TYPE = "Type"; + private static final String NBT_PICKUP = "Pickup"; + + private static final int BASE_SPEED = 20; + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_SILK_TOUCH, ItemUpgrade.TYPE_FORTUNE); + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int mode = IFilterable.WHITELIST; + private int type = IType.ITEMS; + private boolean pickupItem = false; + + public NetworkNodeDestructor(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.destructorUsage + upgrades.getEnergyUsage(); + } + + @Override + public void update() { + if (network != null && ticks % upgrades.getSpeed(BASE_SPEED, 4) == 0) { + BlockPos front = holder.pos().offset(holder.getDirection()); + + if (pickupItem && type == IType.ITEMS) { + List droppedItems = new ArrayList<>(); + + Chunk chunk = holder.world().getChunkFromBlockCoords(front); + chunk.getEntitiesWithinAABBForEntity(null, new AxisAlignedBB(front), droppedItems, null); + + for (Entity entity : droppedItems) { + if (entity instanceof EntityItem) { + ItemStack droppedItem = ((EntityItem) entity).getEntityItem(); + + if (IFilterable.canTake(itemFilters, mode, compare, droppedItem) && network.insertItem(droppedItem, droppedItem.getCount(), true) == null) { + network.insertItem(droppedItem.copy(), droppedItem.getCount(), false); + + holder.world().removeEntity(entity); + + break; + } + } + } + } else if (type == IType.ITEMS) { + IBlockState frontBlockState = holder.world().getBlockState(front); + Block frontBlock = frontBlockState.getBlock(); + + @SuppressWarnings("deprecation") + ItemStack frontStack = frontBlock.getItem(holder.world(), front, frontBlockState); + + if (!frontStack.isEmpty()) { + if (IFilterable.canTake(itemFilters, mode, compare, frontStack) && frontBlockState.getBlockHardness(holder.world(), front) != -1.0) { + List drops; + if (upgrades.hasUpgrade(ItemUpgrade.TYPE_SILK_TOUCH) && frontBlock.canSilkHarvest(holder.world(), front, frontBlockState, null)) { + drops = Collections.singletonList(frontStack); + } else { + drops = frontBlock.getDrops(holder.world(), front, frontBlockState, upgrades.getFortuneLevel()); + } + + for (ItemStack drop : drops) { + if (network.insertItem(drop, drop.getCount(), true) != null) { + return; + } + } + + BlockEvent.BreakEvent e = new BlockEvent.BreakEvent(holder.world(), front, frontBlockState, FakePlayerFactory.getMinecraft((WorldServer) holder.world())); + + if (!MinecraftForge.EVENT_BUS.post(e)) { + holder.world().playEvent(null, 2001, front, Block.getStateId(frontBlockState)); + holder.world().setBlockToAir(front); + + for (ItemStack drop : drops) { + // We check if the controller isn't null here because when a destructor faces a node and removes it + // it will essentially remove this block itself from the network without knowing + if (network == null) { + InventoryHelper.spawnItemStack(holder.world(), front.getX(), front.getY(), front.getZ(), drop); + } else { + network.insertItem(drop, drop.getCount(), false); + } + } + } + } + } + } else if (type == IType.FLUIDS) { + Block frontBlock = holder.world().getBlockState(front).getBlock(); + + IFluidHandler handler = null; + + if (frontBlock instanceof BlockLiquid) { + handler = new BlockLiquidWrapper((BlockLiquid) frontBlock, holder.world(), front); + } else if (frontBlock instanceof IFluidBlock) { + handler = new FluidBlockWrapper((IFluidBlock) frontBlock, holder.world(), front); + } + + if (handler != null) { + FluidStack stack = handler.drain(Fluid.BUCKET_VOLUME, false); + + if (stack != null && IFilterable.canTakeFluids(fluidFilters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { + FluidStack drained = handler.drain(Fluid.BUCKET_VOLUME, true); + + network.insertFluid(drained, drained.amount, false); + } + } + } + } + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public int getMode() { + return mode; + } + + @Override + public void setMode(int mode) { + this.mode = mode; + + markDirty(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(upgrades, 1, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setInteger(NBT_TYPE, type); + tag.setBoolean(NBT_PICKUP, pickupItem); + + RSUtils.writeItems(itemFilters, 0, tag); + RSUtils.writeItems(fluidFilters, 2, tag); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + if (tag.hasKey(NBT_PICKUP)) { + pickupItem = tag.getBoolean(NBT_PICKUP); + } + + RSUtils.readItems(itemFilters, 0, tag); + RSUtils.readItems(fluidFilters, 2, tag); + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + public IItemHandler getInventory() { + return itemFilters; + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public IItemHandler getDrops() { + return upgrades; + } + + @Override + public int getType() { + return holder.world().isRemote ? TileDestructor.TYPE.getValue() : type; + } + + @Override + public void setType(int type) { + this.type = type; + + markDirty(); + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } + + public boolean isPickupItem() { + return pickupItem; + } + + public void setPickupItem(boolean pickupItem) { + this.pickupItem = pickupItem; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDetector.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDetector.java new file mode 100755 index 000000000..4037009da --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDetector.java @@ -0,0 +1,239 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSBlocks; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileDetector; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import com.raoulvdberge.refinedstorage.tile.config.IType; +import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.items.IItemHandler; + +public class NetworkNodeDetector extends NetworkNode implements IComparable, IType { + private static final int SPEED = 5; + + public static final int MODE_UNDER = 0; + public static final int MODE_EQUAL = 1; + public static final int MODE_ABOVE = 2; + public static final int MODE_AUTOCRAFTING = 3; + + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_AMOUNT = "Amount"; + private static final String NBT_TYPE = "Type"; + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(1, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, new ItemHandlerChangeListenerNode(this)); + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int type = IType.ITEMS; + private int mode = MODE_EQUAL; + private int amount = 0; + + private boolean powered = false; + private boolean wasPowered; + + public NetworkNodeDetector(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.detectorUsage; + } + + @Override + public void update() { + if (powered != wasPowered) { + wasPowered = powered; + + holder.world().notifyNeighborsOfStateChange(holder.pos(), RSBlocks.DETECTOR, true); + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + + if (network != null && ticks % SPEED == 0) { + if (type == IType.ITEMS) { + ItemStack slot = itemFilters.getStackInSlot(0); + + if (!slot.isEmpty()) { + if (mode == MODE_AUTOCRAFTING) { + boolean found = false; + + for (ICraftingTask task : network.getCraftingTasks()) { + for (ItemStack output : task.getPattern().getOutputs()) { + if (API.instance().getComparer().isEqualNoQuantity(slot, output)) { + found = true; + + break; + } + } + + if (found) { + break; + } + } + + powered = found; + } else { + ItemStack stack = network.getItemStorageCache().getList().get(slot, compare); + + powered = isPowered(stack == null ? null : stack.getCount()); + } + } else { + powered = mode == MODE_AUTOCRAFTING ? !network.getCraftingTasks().isEmpty() : isPowered(network.getItemStorageCache().getList().getStacks().stream().map(s -> s.getCount()).mapToInt(Number::intValue).sum()); + } + } else if (type == IType.FLUIDS) { + FluidStack slot = fluidFilters.getFluidStackInSlot(0); + + if (slot != null) { + FluidStack stack = network.getFluidStorageCache().getList().get(slot, compare); + + powered = isPowered(stack == null ? null : stack.amount); + } else { + powered = isPowered(network.getFluidStorageCache().getList().getStacks().stream().map(s -> s.amount).mapToInt(Number::intValue).sum()); + } + } + } + } + + @Override + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + if (!state) { + powered = false; + } + } + + public boolean isPowered() { + return powered; + } + + private boolean isPowered(Integer size) { + if (size != null) { + switch (mode) { + case MODE_UNDER: + return size < amount; + case MODE_EQUAL: + return size == amount; + case MODE_ABOVE: + return size > amount; + } + } else { + if (mode == MODE_UNDER && amount != 0) { + return true; + } else if (mode == MODE_EQUAL && amount == 0) { + return true; + } else { + return false; + } + } + + return false; + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + public int getMode() { + return mode; + } + + public void setMode(int mode) { + this.mode = mode; + } + + public int getAmount() { + return amount; + } + + public void setAmount(int amount) { + this.amount = amount; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setInteger(NBT_AMOUNT, amount); + tag.setInteger(NBT_TYPE, type); + + RSUtils.writeItems(itemFilters, 0, tag); + RSUtils.writeItems(fluidFilters, 1, tag); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_AMOUNT)) { + amount = tag.getInteger(NBT_AMOUNT); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + RSUtils.readItems(itemFilters, 0, tag); + RSUtils.readItems(fluidFilters, 1, tag); + } + + public IItemHandler getInventory() { + return itemFilters; + } + + @Override + public void setRedstoneMode(RedstoneMode mode) { + // NO OP + } + + @Override + public int getType() { + return holder.world().isRemote ? TileDetector.TYPE.getValue() : type; + } + + @Override + public void setType(int type) { + this.type = type; + + markDirty(); + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskDrive.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskDrive.java new file mode 100755 index 000000000..0c4e52920 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskDrive.java @@ -0,0 +1,492 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.storage.AccessType; +import com.raoulvdberge.refinedstorage.api.storage.IStorage; +import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; +import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; +import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; +import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; +import com.raoulvdberge.refinedstorage.inventory.IItemValidator; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.IStorageGui; +import com.raoulvdberge.refinedstorage.tile.TileDiskDrive; +import com.raoulvdberge.refinedstorage.tile.config.*; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.ItemHandlerHelper; + +import javax.annotation.Nonnull; +import java.util.List; + +public class NetworkNodeDiskDrive extends NetworkNode implements IStorageGui, IStorageProvider, IComparable, IFilterable, IPrioritizable, IType, IExcessVoidable, IAccessType { + public class StorageItem extends StorageItemNBT { + private int lastState; + + public StorageItem(ItemStack disk) { + super(disk.getTagCompound(), EnumItemStorageType.getById(disk.getItemDamage()).getCapacity(), NetworkNodeDiskDrive.this); + + lastState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { + if (!IFilterable.canTake(itemFilters, mode, getCompare(), stack)) { + return ItemHandlerHelper.copyStackWithSize(stack, size); + } + + return super.insert(stack, size, simulate); + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public boolean isVoiding() { + return voidExcess; + } + + @Override + public void onStorageChanged() { + super.onStorageChanged(); + + int currentState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + + if (lastState != currentState) { + lastState = currentState; + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + } + + public class StorageFluid extends StorageFluidNBT { + private int lastState; + + public StorageFluid(ItemStack disk) { + super(disk.getTagCompound(), EnumFluidStorageType.getById(disk.getItemDamage()).getCapacity(), NetworkNodeDiskDrive.this); + + lastState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public FluidStack insert(FluidStack stack, int size, boolean simulate) { + if (!IFilterable.canTakeFluids(fluidFilters, mode, getCompare(), stack)) { + return RSUtils.copyStackWithSize(stack, size); + } + + return super.insert(stack, size, simulate); + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public boolean isVoiding() { + return voidExcess; + } + + @Override + public void onStorageChanged() { + super.onStorageChanged(); + + int currentState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + + if (lastState != currentState) { + lastState = currentState; + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + } + + private static final String NBT_PRIORITY = "Priority"; + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_TYPE = "Type"; + private static final String NBT_VOID_EXCESS = "VoidExcess"; + + private ItemHandlerBasic disks = new ItemHandlerBasic(8, new ItemHandlerChangeListenerNode(this), IItemValidator.STORAGE_DISK) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { + RSUtils.createStorages(getStackInSlot(slot), slot, itemStorages, fluidStorages, s -> new StorageItem(s), s -> new StorageFluid(s)); + + if (network != null) { + network.getItemStorageCache().invalidate(); + network.getFluidStorageCache().invalidate(); + } + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + + @Override + public ItemStack extractItem(int slot, int amount, boolean simulate) { + if (itemStorages[slot] != null) { + itemStorages[slot].writeToNBT(); + } + + if (fluidStorages[slot] != null) { + fluidStorages[slot].writeToNBT(); + } + + return super.extractItem(slot, amount, simulate); + } + }; + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); + + private StorageItem itemStorages[] = new StorageItem[8]; + private StorageFluid fluidStorages[] = new StorageFluid[8]; + + private AccessType accessType = AccessType.INSERT_EXTRACT; + private int priority = 0; + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int mode = IFilterable.WHITELIST; + private int type = IType.ITEMS; + private boolean voidExcess = false; + + public NetworkNodeDiskDrive(INetworkNodeHolder holder) { + super(holder); + } + + public StorageItem[] getItemStorages() { + return itemStorages; + } + + public StorageFluid[] getFluidStorages() { + return fluidStorages; + } + + @Override + public int getEnergyUsage() { + int usage = RS.INSTANCE.config.diskDriveUsage; + + for (int i = 0; i < disks.getSlots(); ++i) { + if (!disks.getStackInSlot(i).isEmpty()) { + usage += RS.INSTANCE.config.diskDrivePerDiskUsage; + } + } + + return usage; + } + + public void onBreak() { + for (StorageItem storage : this.itemStorages) { + if (storage != null) { + storage.writeToNBT(); + } + } + + for (StorageFluid storage : this.fluidStorages) { + if (storage != null) { + storage.writeToNBT(); + } + } + } + + @Override + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + network.getItemStorageCache().invalidate(); + network.getFluidStorageCache().invalidate(); + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + + @Override + public void addItemStorages(List> storages) { + for (IStorage storage : this.itemStorages) { + if (storage != null) { + storages.add(storage); + } + } + } + + @Override + public void addFluidStorages(List> storages) { + for (IStorage storage : this.fluidStorages) { + if (storage != null) { + storages.add(storage); + } + } + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(disks, 0, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + for (int i = 0; i < disks.getSlots(); ++i) { + if (itemStorages[i] != null) { + itemStorages[i].writeToNBT(); + } + + if (fluidStorages[i] != null) { + fluidStorages[i].writeToNBT(); + } + } + + RSUtils.writeItems(disks, 0, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + RSUtils.writeItems(itemFilters, 1, tag); + RSUtils.writeItems(fluidFilters, 2, tag); + + tag.setInteger(NBT_PRIORITY, priority); + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setInteger(NBT_TYPE, type); + tag.setBoolean(NBT_VOID_EXCESS, voidExcess); + + RSUtils.writeAccessType(tag, accessType); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + RSUtils.readItems(itemFilters, 1, tag); + RSUtils.readItems(fluidFilters, 2, tag); + + if (tag.hasKey(NBT_PRIORITY)) { + priority = tag.getInteger(NBT_PRIORITY); + } + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + if (tag.hasKey(NBT_VOID_EXCESS)) { + voidExcess = tag.getBoolean(NBT_VOID_EXCESS); + } + + accessType = RSUtils.readAccessType(tag); + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public int getMode() { + return mode; + } + + @Override + public void setMode(int mode) { + this.mode = mode; + + markDirty(); + } + + @Override + public String getGuiTitle() { + return "block.refinedstorage:disk_drive.name"; + } + + @Override + public TileDataParameter getTypeParameter() { + return TileDiskDrive.TYPE; + } + + @Override + public TileDataParameter getRedstoneModeParameter() { + return TileDiskDrive.REDSTONE_MODE; + } + + @Override + public TileDataParameter getCompareParameter() { + return TileDiskDrive.COMPARE; + } + + @Override + public TileDataParameter getFilterParameter() { + return TileDiskDrive.MODE; + } + + @Override + public TileDataParameter getPriorityParameter() { + return TileDiskDrive.PRIORITY; + } + + @Override + public TileDataParameter getVoidExcessParameter() { + return TileDiskDrive.VOID_EXCESS; + } + + @Override + public TileDataParameter getAccessTypeParameter() { + return TileDiskDrive.ACCESS_TYPE; + } + + @Override + public String getVoidExcessType() { + return "items_fluids"; + } + + @Override + public int getStored() { + int stored = 0; + + for (int i = 0; i < disks.getSlots(); ++i) { + ItemStack disk = disks.getStackInSlot(i); + + if (!disk.isEmpty()) { + stored += disk.getItem() == RSItems.STORAGE_DISK ? StorageItemNBT.getStoredFromNBT(disk.getTagCompound()) : StorageFluidNBT.getStoredFromNBT(disk.getTagCompound()); + } + } + + return stored; + } + + @Override + public int getCapacity() { + int capacity = 0; + + for (int i = 0; i < disks.getSlots(); ++i) { + ItemStack disk = disks.getStackInSlot(i); + + if (!disk.isEmpty()) { + int diskCapacity = disk.getItem() == RSItems.STORAGE_DISK ? EnumItemStorageType.getById(disk.getItemDamage()).getCapacity() : EnumFluidStorageType.getById(disk.getItemDamage()).getCapacity(); + + if (diskCapacity == -1) { + return -1; + } + + capacity += diskCapacity; + } + } + + return capacity; + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public void setAccessType(AccessType value) { + this.accessType = value; + + if (network != null) { + network.getFluidStorageCache().invalidate(); + network.getItemStorageCache().invalidate(); + } + + markDirty(); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public void setPriority(int priority) { + this.priority = priority; + + markDirty(); + } + + public IItemHandler getDisks() { + return disks; + } + + @Override + public boolean getVoidExcess() { + return voidExcess; + } + + @Override + public void setVoidExcess(boolean voidExcess) { + this.voidExcess = voidExcess; + + markDirty(); + } + + @Override + public int getType() { + return holder.world().isRemote ? TileDiskDrive.TYPE.getValue() : type; + } + + @Override + public void setType(int type) { + this.type = type; + + markDirty(); + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } + + @Override + public IItemHandler getDrops() { + return disks; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskManipulator.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskManipulator.java new file mode 100755 index 000000000..f0698ac4c --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDiskManipulator.java @@ -0,0 +1,580 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; +import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; +import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; +import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; +import com.raoulvdberge.refinedstorage.inventory.*; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileDiskDrive; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import com.raoulvdberge.refinedstorage.tile.config.IFilterable; +import com.raoulvdberge.refinedstorage.tile.config.IType; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.ItemHandlerHelper; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; + +import javax.annotation.Nonnull; +import java.util.ArrayList; + +public class NetworkNodeDiskManipulator extends NetworkNode implements IComparable, IFilterable, IType { + public static final int IO_MODE_INSERT = 0; + public static final int IO_MODE_EXTRACT = 1; + + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_TYPE = "Type"; + private static final String NBT_IO_MODE = "IOMode"; + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int mode = IFilterable.WHITELIST; + private int type = IType.ITEMS; + private int ioMode = IO_MODE_INSERT; + + private StorageItem[] itemStorages = new StorageItem[6]; + private StorageFluid[] fluidStorages = new StorageFluid[6]; + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK); + + private ItemHandlerBasic inputDisks = new ItemHandlerBasic(3, new ItemHandlerChangeListenerNode(this), IItemValidator.STORAGE_DISK) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { + RSUtils.createStorages(getStackInSlot(slot), slot, itemStorages, fluidStorages, s -> new StorageItem(s), s -> new StorageFluid(s)); + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + + @Override + @Nonnull + public ItemStack extractItem(int slot, int amount, boolean simulate) { + if (itemStorages[slot] != null) { + itemStorages[slot].writeToNBT(); + } + + if (fluidStorages[slot] != null) { + fluidStorages[slot].writeToNBT(); + } + + return super.extractItem(slot, amount, simulate); + } + }; + + private ItemHandlerBasic outputDisks = new ItemHandlerBasic(3, new ItemHandlerChangeListenerNode(this), IItemValidator.STORAGE_DISK) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { + RSUtils.createStorages(getStackInSlot(slot), 3 + slot, itemStorages, fluidStorages, s -> new StorageItem(s), s -> new StorageFluid(s)); + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + }; + + public NetworkNodeDiskManipulator(INetworkNodeHolder holder) { + super(holder); + } + + public class StorageItem extends StorageItemNBT { + private int lastState; + + public StorageItem(ItemStack disk) { + super(disk.getTagCompound(), EnumItemStorageType.getById(disk.getItemDamage()).getCapacity(), NetworkNodeDiskManipulator.this); + + lastState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + } + + @Override + public int getPriority() { + return 0; + } + + @Override + public boolean isVoiding() { + return false; + } + + @Override + public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { + if (!IFilterable.canTake(itemFilters, mode, getCompare(), stack)) { + return ItemHandlerHelper.copyStackWithSize(stack, size); + } + + return super.insert(stack, size, simulate); + } + + @Override + public ItemStack extract(@Nonnull ItemStack stack, int size, int flags, boolean simulate) { + if (!IFilterable.canTake(itemFilters, mode, getCompare(), stack)) { + return null; + } + + return super.extract(stack, size, flags, simulate); + } + + @Override + public void onStorageChanged() { + super.onStorageChanged(); + + int currentState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + + if (lastState != currentState) { + lastState = currentState; + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + } + + public class StorageFluid extends StorageFluidNBT { + private int lastState; + + public StorageFluid(ItemStack disk) { + super(disk.getTagCompound(), EnumFluidStorageType.getById(disk.getItemDamage()).getCapacity(), NetworkNodeDiskManipulator.this); + + lastState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + } + + @Override + public int getPriority() { + return 0; + } + + @Override + public boolean isVoiding() { + return false; + } + + @Override + public FluidStack insert(FluidStack stack, int size, boolean simulate) { + if (!IFilterable.canTakeFluids(fluidFilters, mode, getCompare(), stack)) { + return RSUtils.copyStackWithSize(stack, size); + } + + return super.insert(stack, size, simulate); + } + + @Override + public FluidStack extract(FluidStack stack, int size, int flags, boolean simulate) { + if (!IFilterable.canTakeFluids(fluidFilters, mode, getCompare(), stack)) { + return null; + } + + return super.extract(stack, size, flags, simulate); + } + + @Override + public void onStorageChanged() { + super.onStorageChanged(); + + int currentState = TileDiskDrive.getDiskState(getStored(), getCapacity()); + + if (lastState != currentState) { + lastState = currentState; + + RSUtils.updateBlock(holder.world(), holder.pos()); + } + } + } + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.diskManipulatorUsage + upgrades.getEnergyUsage(); + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public void update() { + if (network == null || ticks % upgrades.getSpeed() != 0) { + return; + } + + int slot = 0; + if (type == IType.ITEMS) { + while (slot < 3 && itemStorages[slot] == null) { + slot++; + } + + if (slot == 3) { + return; + } + + StorageItem storage = itemStorages[slot]; + + if (ioMode == IO_MODE_INSERT) { + insertIntoNetwork(storage, slot); + } else if (ioMode == IO_MODE_EXTRACT) { + extractFromNetwork(storage, slot); + } + } else if (type == IType.FLUIDS) { + while (slot < 3 && fluidStorages[slot] == null) { + slot++; + } + + if (slot == 3) { + return; + } + + StorageFluid storage = fluidStorages[slot]; + + if (ioMode == IO_MODE_INSERT) { + insertIntoNetwork(storage, slot); + } else if (ioMode == IO_MODE_EXTRACT) { + extractFromNetwork(storage, slot); + } + } + } + + private void insertIntoNetwork(StorageItem storage, int slot) { + if (storage.getStored() == 0) { + moveDriveToOutput(slot); + return; + } + + for (int i = 0; i < storage.getStacks().size(); i++) { + ItemStack stack = storage.getStacks().get(i); + if (stack == null) { + continue; + } + + ItemStack extracted = storage.extract(stack, upgrades.getItemInteractCount(), compare, false); + if (extracted == null) { + continue; + } + + ItemStack remainder = network.insertItem(extracted, extracted.getCount(), false); + if (remainder == null) { + break; + } + + // We need to check if the stack was inserted + storage.insert(((extracted == remainder) ? remainder.copy() : remainder), remainder.getCount(), false); + } + + if (storage.getStacks().size() == 0) { + moveDriveToOutput(slot); + } + } + + private void extractFromNetwork(StorageItem storage, int slot) { + if (storage.getStored() == storage.getCapacity()) { + moveDriveToOutput(slot); + return; + } + + ItemStack extracted = null; + int i = 0; + + if (IFilterable.isEmpty(itemFilters)) { + ItemStack toExtract = null; + ArrayList networkItems = new ArrayList<>(network.getItemStorageCache().getList().getStacks()); + + int j = 0; + + while ((toExtract == null || toExtract.getCount() == 0) && j < networkItems.size()) { + toExtract = networkItems.get(j++); + } + + if (toExtract != null) { + extracted = network.extractItem(toExtract, upgrades.getItemInteractCount(), compare, false); + } + } else { + while (itemFilters.getSlots() > i && extracted == null) { + ItemStack stack = null; + + while (itemFilters.getSlots() > i && stack == null) { + stack = itemFilters.getStackInSlot(i++); + } + + if (stack != null) { + extracted = network.extractItem(stack, upgrades.getItemInteractCount(), compare, false); + } + } + } + + if (extracted == null) { + moveDriveToOutput(slot); + return; + } + + ItemStack remainder = storage.insert(extracted, extracted.getCount(), false); + + if (remainder != null) { + network.insertItem(remainder, remainder.getCount(), false); + } + } + + private void insertIntoNetwork(StorageFluid storage, int slot) { + if (storage.getStored() == 0) { + moveDriveToOutput(slot); + return; + } + + FluidStack extracted = null; + int i = 0; + + while (extracted == null && storage.getStacks().size() > i) { + FluidStack stack = storage.getStacks().get(i); + + while (stack == null && storage.getStacks().size() > i) { + i++; + } + + if (stack != null) { + extracted = storage.extract(stack, upgrades.getItemInteractCount(), compare, false); + } + } + + if (extracted == null) { + moveDriveToOutput(slot); + return; + } + + FluidStack remainder = network.insertFluid(extracted, extracted.amount, false); + + if (remainder != null) { + storage.insert(remainder, remainder.amount, false); + } + } + + private void extractFromNetwork(StorageFluid storage, int slot) { + if (storage.getStored() == storage.getCapacity()) { + moveDriveToOutput(slot); + return; + } + + FluidStack extracted = null; + int i = 0; + + if (IFilterable.isEmpty(itemFilters)) { + FluidStack toExtract = null; + ArrayList networkFluids = new ArrayList<>(network.getFluidStorageCache().getList().getStacks()); + + int j = 0; + + while ((toExtract == null || toExtract.amount == 0) && j < networkFluids.size()) { + toExtract = networkFluids.get(j++); + } + + if (toExtract != null) { + extracted = network.extractFluid(toExtract, upgrades.getItemInteractCount(), compare, false); + } + } else { + while (fluidFilters.getSlots() > i && extracted == null) { + FluidStack stack = null; + + while (fluidFilters.getSlots() > i && stack == null) { + stack = fluidFilters.getFluidStackInSlot(i++); + } + + if (stack != null) { + extracted = network.extractFluid(stack, upgrades.getItemInteractCount(), compare, false); + } + } + } + + if (extracted == null) { + moveDriveToOutput(slot); + return; + } + + FluidStack remainder = storage.insert(extracted, extracted.amount, false); + + if (remainder != null) { + network.insertFluid(remainder, remainder.amount, false); + } + } + + private void moveDriveToOutput(int slot) { + ItemStack disk = inputDisks.getStackInSlot(slot); + if (!disk.isEmpty()) { + int i = 0; + while (i < 3 && !outputDisks.getStackInSlot(i).isEmpty()) { + i++; + } + + if (i == 3) { + return; + } + + if (slot < 3) { + if (itemStorages[slot] != null) { + itemStorages[slot].writeToNBT(); + itemStorages[slot] = null; + } + + if (fluidStorages[slot] != null) { + fluidStorages[slot].writeToNBT(); + fluidStorages[slot] = null; + } + } + inputDisks.extractItem(slot, 1, false); + outputDisks.insertItem(i, disk, false); + } + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + } + + @Override + public int getType() { + return this.type; + } + + @Override + public void setType(int type) { + this.type = type; + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } + + @Override + public void setMode(int mode) { + this.mode = mode; + } + + @Override + public int getMode() { + return this.mode; + } + + public int getIoMode() { + return ioMode; + } + + public void setIoMode(int ioMode) { + this.ioMode = ioMode; + } + + public IItemHandler getInputDisks() { + return inputDisks; + } + + public IItemHandler getOutputDisks() { + return outputDisks; + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + public StorageItem[] getItemStorages() { + return itemStorages; + } + + public StorageFluid[] getFluidStorages() { + return fluidStorages; + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 3, tag); + RSUtils.readItems(inputDisks, 4, tag); + RSUtils.readItems(outputDisks, 5, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + onBreak(); + + RSUtils.writeItems(upgrades, 3, tag); + RSUtils.writeItems(inputDisks, 4, tag); + RSUtils.writeItems(outputDisks, 5, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + RSUtils.writeItems(itemFilters, 1, tag); + RSUtils.writeItems(fluidFilters, 2, tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setInteger(NBT_TYPE, type); + tag.setInteger(NBT_IO_MODE, ioMode); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + RSUtils.readItems(itemFilters, 1, tag); + RSUtils.readItems(fluidFilters, 2, tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + if (tag.hasKey(NBT_IO_MODE)) { + ioMode = tag.getInteger(NBT_IO_MODE); + } + } + + public void onBreak() { + for (StorageItem storage : itemStorages) { + if (storage != null) { + storage.writeToNBT(); + } + } + + for (StorageFluid storage : fluidStorages) { + if (storage != null) { + storage.writeToNBT(); + } + } + } + + + @Override + public IItemHandler getDrops() { + return new CombinedInvWrapper(inputDisks, outputDisks, upgrades); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java new file mode 100755 index 000000000..70c20b203 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java @@ -0,0 +1,253 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileExporter; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import com.raoulvdberge.refinedstorage.tile.config.IType; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.capability.IFluidHandler; +import net.minecraftforge.fluids.capability.IFluidTankProperties; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.ItemHandlerHelper; + +public class NetworkNodeExporter extends NetworkNode implements IComparable, IType { + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_TYPE = "Type"; + private static final String NBT_REGULATOR = "Regulator"; + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK); + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int type = IType.ITEMS; + private boolean regulator = false; + + public NetworkNodeExporter(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.exporterUsage + upgrades.getEnergyUsage(); + } + + @Override + public void update() { + if (network != null && ticks % upgrades.getSpeed() == 0) { + if (type == IType.ITEMS) { + IItemHandler handler = RSUtils.getItemHandler(holder.world().getTileEntity(holder.pos().offset(holder.getDirection())), holder.getDirection().getOpposite()); + + if (handler != null) { + for (int i = 0; i < itemFilters.getSlots(); ++i) { + ItemStack slot = itemFilters.getStackInSlot(i); + + if (!slot.isEmpty()) { + int stackSize = upgrades.getItemInteractCount(); + + boolean skipSlot = false; + + if (regulator) { + for (int index = 0; i < handler.getSlots() && !skipSlot; i++) { + ItemStack exporterStack = handler.getStackInSlot(index); + + if (API.instance().getComparer().isEqual(slot, exporterStack, compare)) { + if (exporterStack.getCount() >= slot.getCount()) { + skipSlot = true; + } else { + stackSize = upgrades.hasUpgrade(ItemUpgrade.TYPE_STACK) ? slot.getCount() - exporterStack.getCount() : 1; + } + } + } + } + + if (skipSlot) { + continue; + } + + ItemStack took = network.extractItem(slot, stackSize, compare, true); + + if (took == null) { + if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { + network.scheduleCraftingTask(slot, 1, compare); + } + } else if (ItemHandlerHelper.insertItem(handler, took, true).isEmpty()) { + took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false); + + ItemHandlerHelper.insertItem(handler, took, false); + } + } + } + } + } else if (type == IType.FLUIDS) { + IFluidHandler handler = RSUtils.getFluidHandler(holder.world().getTileEntity(holder.pos().offset(holder.getDirection())), holder.getDirection().getOpposite()); + + if (handler != null) { + for (FluidStack stack : fluidFilters.getFluids()) { + if (stack != null) { + FluidStack stackInStorage = network.getFluidStorageCache().getList().get(stack, compare); + + if (stackInStorage != null) { + int toExtract = Math.min(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), stackInStorage.amount); + + boolean skipSlot = false; + + if (regulator) { + for (IFluidTankProperties tankProperty : handler.getTankProperties()) { + FluidStack exporterStack = tankProperty.getContents(); + + if (API.instance().getComparer().isEqual(stackInStorage, exporterStack, compare)) { + if (exporterStack.amount >= stack.amount * Fluid.BUCKET_VOLUME) { + skipSlot = true; + + break; + } else { + toExtract = upgrades.hasUpgrade(ItemUpgrade.TYPE_STACK) ? stack.amount * Fluid.BUCKET_VOLUME - exporterStack.amount : Fluid.BUCKET_VOLUME; + toExtract = Math.min(toExtract, stackInStorage.amount); + } + } + } + } + + if (skipSlot) { + continue; + } + + FluidStack took = network.extractFluid(stack, toExtract, compare, true); + + if (took != null) { + int filled = handler.fill(took, false); + + if (filled > 0) { + took = network.extractFluid(stack, filled, compare, false); + + handler.fill(took, true); + + break; + } + } + } + } + } + } + } + } + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(upgrades, 1, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_TYPE, type); + tag.setBoolean(NBT_REGULATOR, regulator); + + RSUtils.writeItems(itemFilters, 0, tag); + RSUtils.writeItems(fluidFilters, 2, tag); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + if (tag.hasKey(NBT_REGULATOR)) { + regulator = tag.getBoolean(NBT_REGULATOR); + } + + RSUtils.readItems(itemFilters, 0, tag); + RSUtils.readItems(fluidFilters, 2, tag); + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + @Override + public IItemHandler getDrops() { + return upgrades; + } + + @Override + public int getType() { + return holder.world().isRemote ? TileExporter.TYPE.getValue() : type; + } + + @Override + public void setType(int type) { + this.type = type; + + markDirty(); + } + + public void setRegulator(boolean regulator) { + this.regulator = regulator; + } + + public boolean isRegulator() { + return holder.world().isRemote ? TileExporter.REGULATOR.getValue() : regulator; + } + + public ItemHandlerBasic getItemFilters() { + return itemFilters; + } + + public ItemHandlerFluid getFluidFilters() { + return fluidFilters; + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java new file mode 100755 index 000000000..b4e1944f9 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java @@ -0,0 +1,219 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileFluidInterface; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import org.apache.commons.lang3.tuple.Pair; + +public class NetworkNodeFluidInterface extends NetworkNode implements IComparable { + public static final int TANK_CAPACITY = 16000; + + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_TANK_IN = "TankIn"; + private static final String NBT_TANK_OUT = "TankOut"; + + private int compare = IComparer.COMPARE_NBT; + + private FluidTank tankIn = new FluidTank(TANK_CAPACITY) { + @Override + protected void onContentsChanged() { + super.onContentsChanged(); + + if (!holder.world().isRemote) { + ((TileFluidInterface) holder.world().getTileEntity(holder.pos())).getDataManager().sendParameterToWatchers(TileFluidInterface.TANK_IN); + } + + markDirty(); + } + }; + + private FluidTank tankOut = new FluidTank(TANK_CAPACITY) { + @Override + protected void onContentsChanged() { + super.onContentsChanged(); + + if (!holder.world().isRemote) { + ((TileFluidInterface) holder.world().getTileEntity(holder.pos())).getDataManager().sendParameterToWatchers(TileFluidInterface.TANK_OUT); + } + + markDirty(); + } + }; + + private ItemHandlerBasic in = new ItemHandlerBasic(1, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid out = new ItemHandlerFluid(1, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK); + + public NetworkNodeFluidInterface(INetworkNodeHolder holder) { + super(holder); + + tankIn.setCanDrain(false); + tankIn.setCanFill(true); + + tankOut.setCanDrain(true); + tankOut.setCanFill(false); + } + + @Override + public void update() { + ItemStack container = in.getStackInSlot(0); + + if (!container.isEmpty()) { + Pair result = RSUtils.getFluidFromStack(container, true); + + if (result.getValue() != null && tankIn.fillInternal(result.getValue(), false) == result.getValue().amount) { + result = RSUtils.getFluidFromStack(container, false); + + tankIn.fillInternal(result.getValue(), true); + + in.setStackInSlot(0, result.getLeft()); + } + } + + if (network != null && ticks % upgrades.getSpeed() == 0) { + FluidStack drained = tankIn.drainInternal(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), true); + + // Drain in tank + if (drained != null) { + FluidStack remainder = network.insertFluid(drained, drained.amount, false); + + if (remainder != null) { + tankIn.fillInternal(remainder, true); + } + } + + FluidStack stack = out.getFluidStackInSlot(0); + + // Fill out tank + + // If our out fluid doesn't match the new fluid, empty it first + if (tankOut.getFluid() != null && (stack == null || (tankOut.getFluid().getFluid() != stack.getFluid()))) { + FluidStack remainder = tankOut.drainInternal(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), true); + + if (remainder != null) { + network.insertFluid(remainder, remainder.amount, false); + } + } else if (stack != null) { + // Fill the out fluid + FluidStack stackInStorage = network.getFluidStorageCache().getList().get(stack, compare); + + if (stackInStorage != null) { + int toExtract = Math.min(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), stackInStorage.amount); + + FluidStack took = network.extractFluid(stack, toExtract, compare, true); + + if (took != null && (toExtract - tankOut.fillInternal(took, false)) == 0) { + took = network.extractFluid(stack, toExtract, compare, false); + + tankOut.fillInternal(took, true); + } + } + } + } + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.fluidInterfaceUsage; + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(upgrades, 0, tag); + RSUtils.writeItems(in, 1, tag); + + tag.setTag(NBT_TANK_IN, tankIn.writeToNBT(new NBTTagCompound())); + tag.setTag(NBT_TANK_OUT, tankOut.writeToNBT(new NBTTagCompound())); + + return tag; + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 0, tag); + RSUtils.readItems(in, 1, tag); + + if (tag.hasKey(NBT_TANK_IN)) { + tankIn.readFromNBT(tag.getCompoundTag(NBT_TANK_IN)); + } + + if (tag.hasKey(NBT_TANK_OUT)) { + tankOut.readFromNBT(tag.getCompoundTag(NBT_TANK_OUT)); + } + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + RSUtils.writeItems(out, 2, tag); + + tag.setInteger(NBT_COMPARE, compare); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + RSUtils.readItems(out, 2, tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + } + + public ItemHandlerUpgrade getUpgrades() { + return upgrades; + } + + public ItemHandlerBasic getIn() { + return in; + } + + public ItemHandlerFluid getOut() { + return out; + } + + public FluidTank getTankIn() { + return tankIn; + } + + public FluidTank getTankOut() { + return tankOut; + } + + @Override + public boolean hasConnectivityState() { + return true; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidStorage.java new file mode 100755 index 000000000..6a89fad87 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidStorage.java @@ -0,0 +1,331 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSBlocks; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.storage.AccessType; +import com.raoulvdberge.refinedstorage.api.storage.IStorage; +import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; +import com.raoulvdberge.refinedstorage.block.BlockFluidStorage; +import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.IStorageGui; +import com.raoulvdberge.refinedstorage.tile.TileFluidStorage; +import com.raoulvdberge.refinedstorage.tile.config.*; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; + +import java.util.List; + +public class NetworkNodeFluidStorage extends NetworkNode implements IStorageGui, IStorageProvider, IComparable, IFilterable, IPrioritizable, IExcessVoidable, IAccessType { + class StorageFluid extends StorageFluidNBT { + public StorageFluid() { + super(NetworkNodeFluidStorage.this.getStorageTag(), NetworkNodeFluidStorage.this.getCapacity(), NetworkNodeFluidStorage.this); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public FluidStack insert(FluidStack stack, int size, boolean simulate) { + if (!IFilterable.canTakeFluids(filters, mode, compare, stack)) { + return RSUtils.copyStackWithSize(stack, size); + } + + return super.insert(stack, size, simulate); + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public boolean isVoiding() { + return voidExcess; + } + } + + public static final String NBT_STORAGE = "Storage"; + + private static final String NBT_PRIORITY = "Priority"; + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_VOID_EXCESS = "VoidExcess"; + + private ItemHandlerFluid filters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); + + private NBTTagCompound storageTag = StorageFluidNBT.createNBT(); + + private StorageFluid storage; + + private EnumFluidStorageType type; + + private AccessType accessType = AccessType.INSERT_EXTRACT; + private int priority = 0; + private int compare = IComparer.COMPARE_NBT; + private int mode = IFilterable.WHITELIST; + private boolean voidExcess = false; + + public NetworkNodeFluidStorage(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.fluidStorageUsage; + } + + @Override + public void update() { + super.update(); + + if (storage == null && storageTag != null) { + storage = new StorageFluid(); + + if (network != null) { + network.getFluidStorageCache().invalidate(); + } + } + } + + public void onBreak() { + if (storage != null) { + storage.writeToNBT(); + } + } + + @Override + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + network.getFluidStorageCache().invalidate(); + } + + @Override + public void addItemStorages(List> storages) { + // NO OP + } + + @Override + public void addFluidStorages(List> storages) { + if (storage != null) { + storages.add(storage); + } + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + if (tag.hasKey(NBT_STORAGE)) { + storageTag = tag.getCompoundTag(NBT_STORAGE); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + if (storage != null) { + storage.writeToNBT(); + } + + tag.setTag(NBT_STORAGE, storageTag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + RSUtils.writeItems(filters, 0, tag); + + tag.setInteger(NBT_PRIORITY, priority); + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setBoolean(NBT_VOID_EXCESS, voidExcess); + + RSUtils.writeAccessType(tag, accessType); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + RSUtils.readItems(filters, 0, tag); + + if (tag.hasKey(NBT_PRIORITY)) { + priority = tag.getInteger(NBT_PRIORITY); + } + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_VOID_EXCESS)) { + voidExcess = tag.getBoolean(NBT_VOID_EXCESS); + } + + accessType = RSUtils.readAccessType(tag); + } + + public EnumFluidStorageType getType() { + if (type == null && holder.world().getBlockState(holder.pos()).getBlock() == RSBlocks.FLUID_STORAGE) { + type = ((EnumFluidStorageType) holder.world().getBlockState(holder.pos()).getValue(BlockFluidStorage.TYPE)); + } + + return type == null ? EnumFluidStorageType.TYPE_64K : type; + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public int getMode() { + return mode; + } + + @Override + public void setMode(int mode) { + this.mode = mode; + + markDirty(); + } + + public NBTTagCompound getStorageTag() { + return storageTag; + } + + public void setStorageTag(NBTTagCompound storageTag) { + this.storageTag = storageTag; + } + + public StorageFluidNBT getStorage() { + return storage; + } + + public ItemHandlerFluid getFilters() { + return filters; + } + + @Override + public String getGuiTitle() { + return "block.refinedstorage:fluid_storage." + getType().getId() + ".name"; + } + + @Override + public TileDataParameter getTypeParameter() { + return null; + } + + @Override + public TileDataParameter getRedstoneModeParameter() { + return TileFluidStorage.REDSTONE_MODE; + } + + @Override + public TileDataParameter getCompareParameter() { + return TileFluidStorage.COMPARE; + } + + @Override + public TileDataParameter getFilterParameter() { + return TileFluidStorage.MODE; + } + + @Override + public TileDataParameter getPriorityParameter() { + return TileFluidStorage.PRIORITY; + } + + @Override + public TileDataParameter getVoidExcessParameter() { + return TileFluidStorage.VOID_EXCESS; + } + + @Override + public TileDataParameter getAccessTypeParameter() { + return TileFluidStorage.ACCESS_TYPE; + } + + @Override + public String getVoidExcessType() { + return "fluids"; + } + + @Override + public int getStored() { + return TileFluidStorage.STORED.getValue(); + } + + @Override + public int getCapacity() { + return getType().getCapacity(); + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public void setAccessType(AccessType value) { + this.accessType = value; + + if (network != null) { + network.getFluidStorageCache().invalidate(); + } + + markDirty(); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public void setPriority(int priority) { + this.priority = priority; + + markDirty(); + } + + @Override + public boolean getVoidExcess() { + return voidExcess; + } + + @Override + public void setVoidExcess(boolean value) { + this.voidExcess = value; + + markDirty(); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeGrid.java new file mode 100755 index 000000000..c7c979f3e --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeGrid.java @@ -0,0 +1,552 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSBlocks; +import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.grid.IFluidGridHandler; +import com.raoulvdberge.refinedstorage.api.network.grid.IItemGridHandler; +import com.raoulvdberge.refinedstorage.api.network.security.Permission; +import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.block.BlockGrid; +import com.raoulvdberge.refinedstorage.block.EnumGridType; +import com.raoulvdberge.refinedstorage.container.ContainerGrid; +import com.raoulvdberge.refinedstorage.gui.grid.GridFilter; +import com.raoulvdberge.refinedstorage.gui.grid.GridTab; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerGridFilterInGrid; +import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; +import com.raoulvdberge.refinedstorage.item.ItemPattern; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.data.TileDataManager; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import com.raoulvdberge.refinedstorage.tile.grid.IGrid; +import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.*; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.ItemHandlerHelper; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; +import net.minecraftforge.items.wrapper.InvWrapper; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.List; + +public class NetworkNodeGrid extends NetworkNode implements IGrid { + public static final String NBT_VIEW_TYPE = "ViewType"; + public static final String NBT_SORTING_DIRECTION = "SortingDirection"; + public static final String NBT_SORTING_TYPE = "SortingType"; + public static final String NBT_SEARCH_BOX_MODE = "SearchBoxMode"; + public static final String NBT_OREDICT_PATTERN = "OredictPattern"; + public static final String NBT_TAB_SELECTED = "TabSelected"; + + public static final int SORTING_DIRECTION_ASCENDING = 0; + public static final int SORTING_DIRECTION_DESCENDING = 1; + + public static final int SORTING_TYPE_QUANTITY = 0; + public static final int SORTING_TYPE_NAME = 1; + + public static final int SEARCH_BOX_MODE_NORMAL = 0; + public static final int SEARCH_BOX_MODE_NORMAL_AUTOSELECTED = 1; + public static final int SEARCH_BOX_MODE_JEI_SYNCHRONIZED = 2; + public static final int SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED = 3; + + public static final int VIEW_TYPE_NORMAL = 0; + public static final int VIEW_TYPE_NON_CRAFTABLES = 1; + public static final int VIEW_TYPE_CRAFTABLES = 2; + + private Container craftingContainer = new Container() { + @Override + public boolean canInteractWith(EntityPlayer player) { + return false; + } + + @Override + public void onCraftMatrixChanged(IInventory inventory) { + onCraftingMatrixChanged(); + } + }; + private InventoryCrafting matrix = new InventoryCrafting(craftingContainer, 3, 3); + private InventoryCraftResult result = new InventoryCraftResult(); + + private ItemHandlerBasic patterns = new ItemHandlerBasic(2, new ItemHandlerChangeListenerNode(this), new ItemValidatorBasic(RSItems.PATTERN)); + private List filteredItems = new ArrayList<>(); + private List tabs = new ArrayList<>(); + private ItemHandlerGridFilterInGrid filter = new ItemHandlerGridFilterInGrid(filteredItems, tabs); + + private EnumGridType type; + + private int viewType = VIEW_TYPE_NORMAL; + private int sortingDirection = SORTING_DIRECTION_DESCENDING; + private int sortingType = SORTING_TYPE_QUANTITY; + private int searchBoxMode = SEARCH_BOX_MODE_NORMAL; + + private int tabSelected = -1; + + private boolean oredictPattern = false; + + public NetworkNodeGrid(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + switch (getType()) { + case NORMAL: + return RS.INSTANCE.config.gridUsage; + case CRAFTING: + return RS.INSTANCE.config.craftingGridUsage; + case PATTERN: + return RS.INSTANCE.config.patternGridUsage; + case FLUID: + return RS.INSTANCE.config.fluidGridUsage; + default: + return 0; + } + } + + public void setViewType(int viewType) { + this.viewType = viewType; + } + + public void setSortingDirection(int sortingDirection) { + this.sortingDirection = sortingDirection; + } + + public void setSortingType(int sortingType) { + this.sortingType = sortingType; + } + + public void setSearchBoxMode(int searchBoxMode) { + this.searchBoxMode = searchBoxMode; + } + + public void setTabSelected(int tabSelected) { + this.tabSelected = tabSelected; + } + + public boolean isOredictPattern() { + return oredictPattern; + } + + public void setOredictPattern(boolean oredictPattern) { + this.oredictPattern = oredictPattern; + } + + public EnumGridType getType() { + if (type == null && holder.world().getBlockState(holder.pos()).getBlock() == RSBlocks.GRID) { + type = (EnumGridType) holder.world().getBlockState(holder.pos()).getValue(BlockGrid.TYPE); + } + + return type == null ? EnumGridType.NORMAL : type; + } + + @Nullable + @Override + public BlockPos getNetworkPosition() { + return network != null ? network.getPosition() : null; + } + + public void onOpened(EntityPlayer player) { + if (network != null) { + if (getType() == EnumGridType.FLUID) { + network.sendFluidStorageToClient((EntityPlayerMP) player); + } else { + network.sendItemStorageToClient((EntityPlayerMP) player); + } + } + } + + @Override + public IItemGridHandler getItemHandler() { + return network != null ? network.getItemGridHandler() : null; + } + + @Override + public IFluidGridHandler getFluidHandler() { + return network != null ? network.getFluidGridHandler() : null; + } + + @Override + public String getGuiTitle() { + return getType() == EnumGridType.FLUID ? "gui.refinedstorage:fluid_grid" : "gui.refinedstorage:grid"; + } + + public InventoryCrafting getMatrix() { + return matrix; + } + + public InventoryCraftResult getResult() { + return result; + } + + public IItemHandler getPatterns() { + return patterns; + } + + @Override + public ItemHandlerBasic getFilter() { + return filter; + } + + @Override + public List getFilteredItems() { + return filteredItems; + } + + @Override + public List getTabs() { + return tabs; + } + + public void onCraftingMatrixChanged() { + markDirty(); + + result.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(matrix, holder.world())); + } + + public void onCrafted(EntityPlayer player) { + NonNullList remainder = CraftingManager.getInstance().getRemainingItems(matrix, holder.world()); + + for (int i = 0; i < matrix.getSizeInventory(); ++i) { + ItemStack slot = matrix.getStackInSlot(i); + + if (i < remainder.size() && !remainder.get(i).isEmpty()) { + // If there is no space for the remainder, dump it in the player inventory + if (!slot.isEmpty() && slot.getCount() > 1) { + if (!player.inventory.addItemStackToInventory(remainder.get(i).copy())) { + ItemStack remainderStack = network.insertItem(remainder.get(i).copy(), remainder.get(i).getCount(), false); + + if (remainderStack != null) { + InventoryHelper.spawnItemStack(player.getEntityWorld(), player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), remainderStack); + } + } + + matrix.decrStackSize(i, 1); + } else { + matrix.setInventorySlotContents(i, remainder.get(i).copy()); + } + } else if (!slot.isEmpty()) { + if (slot.getCount() == 1 && network != null) { + matrix.setInventorySlotContents(i, RSUtils.getStack(network.extractItem(slot, 1, false))); + } else { + matrix.decrStackSize(i, 1); + } + } + } + + onCraftingMatrixChanged(); + } + + public void onCraftedShift(ContainerGrid container, EntityPlayer player) { + List craftedItemsList = new ArrayList<>(); + int craftedItems = 0; + ItemStack crafted = result.getStackInSlot(0); + + while (true) { + onCrafted(player); + + craftedItemsList.add(crafted.copy()); + + craftedItems += crafted.getCount(); + + if (!API.instance().getComparer().isEqual(crafted, result.getStackInSlot(0)) || craftedItems + crafted.getCount() > crafted.getMaxStackSize()) { + break; + } + } + + for (ItemStack craftedItem : craftedItemsList) { + if (!player.inventory.addItemStackToInventory(craftedItem.copy())) { + ItemStack remainder = network.insertItem(craftedItem, craftedItem.getCount(), false); + if (remainder != null) { + InventoryHelper.spawnItemStack(player.getEntityWorld(), player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), remainder); + } + } + } + + container.sendCraftingSlots(); + container.detectAndSendChanges(); + } + + public void onCreatePattern() { + if (canCreatePattern()) { + patterns.extractItem(0, 1, false); + + ItemStack pattern = new ItemStack(RSItems.PATTERN); + + ItemPattern.setOredict(pattern, oredictPattern); + + for (int i = 0; i < 9; ++i) { + ItemStack ingredient = matrix.getStackInSlot(i); + + if (!ingredient.isEmpty()) { + ItemPattern.setSlot(pattern, i, ingredient); + } + } + + patterns.setStackInSlot(1, pattern); + } + } + + public boolean canCreatePattern() { + return !result.getStackInSlot(0).isEmpty() && patterns.getStackInSlot(1).isEmpty() && !patterns.getStackInSlot(0).isEmpty(); + } + + public void onRecipeTransfer(EntityPlayer player, ItemStack[][] recipe) { + if (network != null && getType() == EnumGridType.CRAFTING && !network.getSecurityManager().hasPermission(Permission.EXTRACT, player)) { + return; + } + + // First try to empty the crafting matrix + for (int i = 0; i < matrix.getSizeInventory(); ++i) { + ItemStack slot = matrix.getStackInSlot(i); + + if (!slot.isEmpty()) { + // Only if we are a crafting grid. Pattern grids can just be emptied. + if (getType() == EnumGridType.CRAFTING) { + // If we are connected, try to insert into network. If it fails, stop. + if (network != null) { + if (network.insertItem(slot, slot.getCount(), true) != null) { + return; + } else { + network.insertItem(slot, slot.getCount(), false); + } + } else { + // If we aren't connected, try to insert into player inventory. If it fails, stop. + if (!player.inventory.addItemStackToInventory(slot.copy())) { + return; + } + } + } + + matrix.setInventorySlotContents(i, ItemStack.EMPTY); + } + } + + // Now let's fill the matrix + for (int i = 0; i < matrix.getSizeInventory(); ++i) { + if (recipe[i] != null) { + ItemStack[] possibilities = recipe[i]; + + // If we are a crafting grid + if (getType() == EnumGridType.CRAFTING) { + boolean found = false; + + // If we are connected, first try to get the possibilities from the network + if (network != null) { + for (ItemStack possibility : possibilities) { + ItemStack took = network.extractItem(possibility, 1, false); + + if (took != null) { + matrix.setInventorySlotContents(i, RSUtils.getStack(took)); + + found = true; + + break; + } + } + } + + // If we haven't found anything in the network (or we are disconnected), go look in the player inventory + if (!found) { + for (ItemStack possibility : possibilities) { + for (int j = 0; j < player.inventory.getSizeInventory(); ++j) { + if (API.instance().getComparer().isEqualNoQuantity(possibility, player.inventory.getStackInSlot(j))) { + matrix.setInventorySlotContents(i, ItemHandlerHelper.copyStackWithSize(player.inventory.getStackInSlot(j), 1)); + + player.inventory.decrStackSize(j, 1); + + found = true; + + break; + } + } + + if (found) { + break; + } + } + } + } else if (getType() == EnumGridType.PATTERN) { + // If we are a pattern grid we can just set the slot + matrix.setInventorySlotContents(i, possibilities[0]); + } + } + } + } + + @Override + public int getViewType() { + return holder.world().isRemote ? TileGrid.VIEW_TYPE.getValue() : viewType; + } + + @Override + public int getSortingDirection() { + return holder.world().isRemote ? TileGrid.SORTING_DIRECTION.getValue() : sortingDirection; + } + + @Override + public int getSortingType() { + return holder.world().isRemote ? TileGrid.SORTING_TYPE.getValue() : sortingType; + } + + @Override + public int getSearchBoxMode() { + return holder.world().isRemote ? TileGrid.SEARCH_BOX_MODE.getValue() : searchBoxMode; + } + + @Override + public int getTabSelected() { + return holder.world().isRemote ? TileGrid.TAB_SELECTED.getValue() : tabSelected; + } + + @Override + public void onViewTypeChanged(int type) { + TileDataManager.setParameter(TileGrid.VIEW_TYPE, type); + } + + @Override + public void onSortingTypeChanged(int type) { + TileDataManager.setParameter(TileGrid.SORTING_TYPE, type); + } + + @Override + public void onSortingDirectionChanged(int direction) { + TileDataManager.setParameter(TileGrid.SORTING_DIRECTION, direction); + } + + @Override + public void onSearchBoxModeChanged(int searchBoxMode) { + TileDataManager.setParameter(TileGrid.SEARCH_BOX_MODE, searchBoxMode); + } + + @Override + public void onTabSelectionChanged(int tab) { + TileDataManager.setParameter(TileGrid.TAB_SELECTED, tab); + } + + @Override + public TileDataParameter getRedstoneModeConfig() { + return TileGrid.REDSTONE_MODE; + } + + @Override + public boolean isActive() { + return ((TileGrid) holder.world().getTileEntity(holder.pos())).isActive(); + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItemsLegacy(matrix, 0, tag); + RSUtils.readItems(patterns, 1, tag); + RSUtils.readItems(filter, 2, tag); + + if (tag.hasKey(NBT_TAB_SELECTED)) { + tabSelected = tag.getInteger(NBT_TAB_SELECTED); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItemsLegacy(matrix, 0, tag); + RSUtils.writeItems(patterns, 1, tag); + RSUtils.writeItems(filter, 2, tag); + + tag.setInteger(NBT_TAB_SELECTED, tabSelected); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setInteger(NBT_VIEW_TYPE, viewType); + tag.setInteger(NBT_SORTING_DIRECTION, sortingDirection); + tag.setInteger(NBT_SORTING_TYPE, sortingType); + tag.setInteger(NBT_SEARCH_BOX_MODE, searchBoxMode); + + tag.setBoolean(NBT_OREDICT_PATTERN, oredictPattern); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_VIEW_TYPE)) { + viewType = tag.getInteger(NBT_VIEW_TYPE); + } + + if (tag.hasKey(NBT_SORTING_DIRECTION)) { + sortingDirection = tag.getInteger(NBT_SORTING_DIRECTION); + } + + if (tag.hasKey(NBT_SORTING_TYPE)) { + sortingType = tag.getInteger(NBT_SORTING_TYPE); + } + + if (tag.hasKey(NBT_SEARCH_BOX_MODE)) { + searchBoxMode = tag.getInteger(NBT_SEARCH_BOX_MODE); + } + + if (tag.hasKey(NBT_OREDICT_PATTERN)) { + oredictPattern = tag.getBoolean(NBT_OREDICT_PATTERN); + } + } + + @Override + public IItemHandler getDrops() { + switch (getType()) { + case CRAFTING: + return new CombinedInvWrapper(filter, new InvWrapper(matrix)); + case PATTERN: + return new CombinedInvWrapper(filter, patterns); + default: + return new CombinedInvWrapper(filter); + } + } + + public static boolean isValidViewType(int type) { + return type == VIEW_TYPE_NORMAL || + type == VIEW_TYPE_CRAFTABLES || + type == VIEW_TYPE_NON_CRAFTABLES; + } + + public static boolean isValidSearchBoxMode(int mode) { + return mode == SEARCH_BOX_MODE_NORMAL || + mode == SEARCH_BOX_MODE_NORMAL_AUTOSELECTED || + mode == SEARCH_BOX_MODE_JEI_SYNCHRONIZED || + mode == SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED; + } + + public static boolean isSearchBoxModeWithAutoselection(int mode) { + return mode == SEARCH_BOX_MODE_NORMAL_AUTOSELECTED || mode == SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED; + } + + public static boolean isValidSortingType(int type) { + return type == SORTING_TYPE_QUANTITY || type == SORTING_TYPE_NAME; + } + + public static boolean isValidSortingDirection(int direction) { + return direction == SORTING_DIRECTION_ASCENDING || direction == SORTING_DIRECTION_DESCENDING; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java new file mode 100755 index 000000000..1da4773ac --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java @@ -0,0 +1,202 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileDiskDrive; +import com.raoulvdberge.refinedstorage.tile.TileImporter; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import com.raoulvdberge.refinedstorage.tile.config.IFilterable; +import com.raoulvdberge.refinedstorage.tile.config.IType; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.capability.IFluidHandler; +import net.minecraftforge.items.IItemHandler; + +public class NetworkNodeImporter extends NetworkNode implements IComparable, IFilterable, IType { + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_TYPE = "Type"; + + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK); + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int mode = IFilterable.WHITELIST; + private int type = IType.ITEMS; + + private int currentSlot; + + public NetworkNodeImporter(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.importerUsage + upgrades.getEnergyUsage(); + } + + @Override + public void update() { + if (type == IType.ITEMS) { + TileEntity tile = holder.world().getTileEntity(holder.pos().offset(holder.getDirection())); + IItemHandler handler = RSUtils.getItemHandler(tile, holder.getDirection().getOpposite()); + + if (handler == null || tile instanceof TileDiskDrive) { + return; + } + + if (currentSlot >= handler.getSlots()) { + currentSlot = 0; + } + + if (handler.getSlots() > 0) { + ItemStack stack = handler.getStackInSlot(currentSlot); + + if (stack.isEmpty() || !IFilterable.canTake(itemFilters, mode, compare, stack)) { + currentSlot++; + } else if (ticks % upgrades.getSpeed() == 0) { + ItemStack result = handler.extractItem(currentSlot, upgrades.getItemInteractCount(), true); + + if (!result.isEmpty() && network.insertItem(result, result.getCount(), true) == null) { + network.insertItem(result, result.getCount(), false); + + handler.extractItem(currentSlot, upgrades.getItemInteractCount(), false); + } else { + currentSlot++; + } + } + } + } else if (type == IType.FLUIDS && ticks % upgrades.getSpeed() == 0) { + IFluidHandler handler = RSUtils.getFluidHandler(holder.world().getTileEntity(holder.pos().offset(holder.getDirection())), holder.getDirection().getOpposite()); + + if (handler != null) { + FluidStack stack = handler.drain(Fluid.BUCKET_VOLUME, false); + + if (stack != null && IFilterable.canTakeFluids(fluidFilters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { + FluidStack toDrain = handler.drain(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), false); + + if (toDrain != null) { + FluidStack remainder = network.insertFluid(toDrain, toDrain.amount, false); + if (remainder != null) { + toDrain.amount -= remainder.amount; + } + handler.drain(toDrain, true); + } + } + } + } + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public int getMode() { + return mode; + } + + @Override + public void setMode(int mode) { + this.mode = mode; + + markDirty(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(upgrades, 1, tag); + + return tag; + } + + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setInteger(NBT_TYPE, type); + + RSUtils.writeItems(itemFilters, 0, tag); + RSUtils.writeItems(fluidFilters, 2, tag); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_TYPE)) { + type = tag.getInteger(NBT_TYPE); + } + + RSUtils.readItems(itemFilters, 0, tag); + RSUtils.readItems(fluidFilters, 2, tag); + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + @Override + public IItemHandler getDrops() { + return upgrades; + } + + @Override + public int getType() { + return holder.world().isRemote ? TileImporter.TYPE.getValue() : type; + } + + @Override + public void setType(int type) { + this.type = type; + + markDirty(); + } + + @Override + public IItemHandler getFilterInventory() { + return getType() == IType.ITEMS ? itemFilters : fluidFilters; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeInterface.java new file mode 100755 index 000000000..53e3d2a6f --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeInterface.java @@ -0,0 +1,190 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerInterface; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.config.IComparable; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; + +public class NetworkNodeInterface extends NetworkNode implements IComparable { + private static final String NBT_COMPARE = "Compare"; + + private ItemHandlerBasic importItems = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerBasic exportSpecimenItems = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerBasic exportItems = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + + private ItemHandlerInterface items = new ItemHandlerInterface(importItems, exportItems); + + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING); + + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + + private int currentSlot = 0; + + public NetworkNodeInterface(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.interfaceUsage + upgrades.getEnergyUsage(); + } + + @Override + public void update() { + if (network == null) { + return; + } + + if (currentSlot >= importItems.getSlots()) { + currentSlot = 0; + } + + ItemStack slot = importItems.getStackInSlot(currentSlot); + + if (slot.isEmpty()) { + currentSlot++; + } else if (ticks % upgrades.getSpeed() == 0) { + int size = Math.min(slot.getCount(), upgrades.getItemInteractCount()); + + ItemStack remainder = network.insertItem(slot, size, false); + + if (remainder == null) { + importItems.extractItemInternal(currentSlot, size, false); + } else { + importItems.extractItemInternal(currentSlot, size - remainder.getCount(), false); + + currentSlot++; + } + } + + for (int i = 0; i < 9; ++i) { + ItemStack wanted = exportSpecimenItems.getStackInSlot(i); + ItemStack got = exportItems.getStackInSlot(i); + + if (wanted.isEmpty()) { + if (!got.isEmpty()) { + exportItems.setStackInSlot(i, RSUtils.getStack(network.insertItem(got, got.getCount(), false))); + } + } else { + int delta = got.isEmpty() ? wanted.getCount() : (wanted.getCount() - got.getCount()); + + if (delta > 0) { + ItemStack result = network.extractItem(wanted, delta, compare, false); + + if (result != null) { + if (exportItems.getStackInSlot(i).isEmpty()) { + exportItems.setStackInSlot(i, result); + } else { + exportItems.getStackInSlot(i).grow(result.getCount()); + } + } else if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { + network.scheduleCraftingTask(wanted, delta, compare); + } + } else if (delta < 0) { + ItemStack remainder = network.insertItem(got, Math.abs(delta), false); + + if (remainder == null) { + exportItems.extractItem(i, Math.abs(delta), false); + } else { + exportItems.extractItem(i, Math.abs(delta) - remainder.getCount(), false); + } + } + } + } + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(importItems, 0, tag); + RSUtils.readItems(exportItems, 2, tag); + RSUtils.readItems(upgrades, 3, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(importItems, 0, tag); + RSUtils.writeItems(exportItems, 2, tag); + RSUtils.writeItems(upgrades, 3, tag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + RSUtils.writeItems(exportSpecimenItems, 1, tag); + + tag.setInteger(NBT_COMPARE, compare); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + RSUtils.readItems(exportSpecimenItems, 1, tag); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + } + + public IItemHandler getImportItems() { + return importItems; + } + + public IItemHandler getExportSpecimenItems() { + return exportSpecimenItems; + } + + public IItemHandler getExportItems() { + return exportItems; + } + + public ItemHandlerInterface getItems() { + return items; + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + @Override + public IItemHandler getDrops() { + return new CombinedInvWrapper(importItems, exportItems, upgrades); + } + + @Override + public boolean hasConnectivityState() { + return true; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeNetworkTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeNetworkTransmitter.java new file mode 100755 index 000000000..9c1e0b510 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeNetworkTransmitter.java @@ -0,0 +1,152 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; +import com.raoulvdberge.refinedstorage.item.ItemNetworkCard; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; + +import javax.annotation.Nullable; + +public class NetworkNodeNetworkTransmitter extends NetworkNode { + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(1, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_INTERDIMENSIONAL) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + if (network != null) { + network.getNodeGraph().rebuild(); + } + } + }; + + private ItemHandlerBasic networkCard = new ItemHandlerBasic(1, new ItemHandlerChangeListenerNode(this), new ItemValidatorBasic(RSItems.NETWORK_CARD)) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + ItemStack card = getStackInSlot(slot); + + if (card.isEmpty()) { + receiver = null; + } else { + receiver = ItemNetworkCard.getReceiver(card); + receiverDimension = ItemNetworkCard.getDimension(card); + } + + if (network != null) { + network.getNodeGraph().rebuild(); + } + } + }; + + private BlockPos receiver; + private int receiverDimension; + + public NetworkNodeNetworkTransmitter(INetworkNodeHolder holder) { + super(holder); + + rebuildOnUpdateChange = true; + } + + public boolean canTransmit() { + return canUpdate() && receiver != null && isDimensionSupported(); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(networkCard, 0, tag); + RSUtils.writeItems(upgrades, 1, tag); + + return tag; + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(networkCard, 0, tag); + RSUtils.readItems(upgrades, 1, tag); + } + + @Override + public int getEnergyUsage() { + return Math.min( + RS.INSTANCE.config.interdimensionalUpgradeUsage, + RS.INSTANCE.config.networkTransmitterUsage + (isSameDimension() ? (int) Math.ceil(RS.INSTANCE.config.networkTransmitterPerBlockUsage * getDistance()) : 0) + upgrades.getEnergyUsage() + ); + } + + public ItemHandlerBasic getNetworkCard() { + return networkCard; + } + + public ItemHandlerUpgrade getUpgrades() { + return upgrades; + } + + @Override + public IItemHandler getDrops() { + return new CombinedInvWrapper(networkCard, upgrades); + } + + @Nullable + public BlockPos getReceiver() { + return receiver; + } + + public int getReceiverDimension() { + return receiverDimension; + } + + public int getDistance() { + if (receiver == null) { + return 0; + } + + return (int) Math.sqrt(Math.pow(holder.pos().getX() - receiver.getX(), 2) + Math.pow(holder.pos().getY() - receiver.getY(), 2) + Math.pow(holder.pos().getZ() - receiver.getZ(), 2)); + } + + public boolean isSameDimension() { + return holder.world().provider.getDimension() == receiverDimension; + } + + public boolean isDimensionSupported() { + return isSameDimension() || upgrades.hasUpgrade(ItemUpgrade.TYPE_INTERDIMENSIONAL); + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public void walkNeighborhood(Operator operator) { + super.walkNeighborhood(operator); + + if (canTransmit()) { + if (!isSameDimension()) { + final World dimensionWorld = DimensionManager.getWorld(receiverDimension); + if (dimensionWorld != null) { + operator.apply(dimensionWorld, receiver, null); + } + } else { + operator.apply(holder.world(), receiver, null); + } + } + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeReader.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeReader.java new file mode 100755 index 000000000..d9850b598 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeReader.java @@ -0,0 +1,79 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReader; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileReader; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTTagCompound; + +public class NetworkNodeReader extends NetworkNode implements IReader { + private static final String NBT_CHANNEL = "Channel"; + + private String channel = ""; + + public NetworkNodeReader(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.readerUsage; + } + + @Override + public int getRedstoneStrength() { + return holder.world().getRedstonePower(holder.pos().offset(holder.getDirection()), holder.getDirection()); + } + + @Override + public String getTitle() { + return "gui.refinedstorage:reader"; + } + + @Override + public String getChannel() { + return channel; + } + + @Override + public void setChannel(String channel) { + this.channel = channel; + } + + @Override + public TileDataParameter getChannelParameter() { + return TileReader.CHANNEL; + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + if (tag.hasKey(NBT_CHANNEL)) { + channel = tag.getString(NBT_CHANNEL); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + tag.setString(NBT_CHANNEL, channel); + + return tag; + } + + public void onOpened(EntityPlayer entity) { + if (network != null) { + network.sendReaderWriterChannelUpdate((EntityPlayerMP) entity); + } + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeRelay.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeRelay.java new file mode 100755 index 000000000..b6f9740ab --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeRelay.java @@ -0,0 +1,33 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; +import net.minecraft.util.EnumFacing; + +import javax.annotation.Nullable; + +public class NetworkNodeRelay extends NetworkNode { + public NetworkNodeRelay(INetworkNodeHolder holder) { + super(holder); + + setRedstoneMode(RedstoneMode.LOW); + + rebuildOnUpdateChange = true; + } + + @Override + public int getEnergyUsage() { + return getRedstoneMode() == RedstoneMode.IGNORE ? 0 : RS.INSTANCE.config.relayUsage; + } + + @Override + public boolean canConduct(@Nullable EnumFacing direction) { + return canUpdate(); + } + + @Override + public boolean hasConnectivityState() { + return true; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSecurityManager.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSecurityManager.java new file mode 100755 index 000000000..d282b9641 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSecurityManager.java @@ -0,0 +1,174 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCard; +import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCardContainer; +import com.raoulvdberge.refinedstorage.api.network.security.Permission; +import com.raoulvdberge.refinedstorage.apiimpl.network.security.SecurityCard; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; +import com.raoulvdberge.refinedstorage.item.ItemSecurityCard; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +public class NetworkNodeSecurityManager extends NetworkNode implements ISecurityCardContainer { + private static final String NBT_OWNER = "Owner"; + + private List actualCards = new ArrayList<>(); + + private ItemHandlerBasic cards = new ItemHandlerBasic(9 * 2, new ItemHandlerChangeListenerNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD)) { + @Override + protected void onContentsChanged(int slot) { + super.onContentsChanged(slot); + + if (!holder.world().isRemote) { + rebuildCards(); + } + + if (network != null) { + network.getSecurityManager().rebuild(); + } + } + }; + private ItemHandlerBasic editCard = new ItemHandlerBasic(1, new ItemHandlerChangeListenerNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD)); + + @Nullable + private UUID owner; + + public NetworkNodeSecurityManager(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + int usage = RS.INSTANCE.config.securityManagerUsage; + + for (int i = 0; i < cards.getSlots(); ++i) { + if (!cards.getStackInSlot(i).isEmpty()) { + usage += RS.INSTANCE.config.securityManagerPerSecurityCardUsage; + } + } + + return usage; + } + + @Override + public void update() { + super.update(); + + if (ticks == 1) { + rebuildCards(); + } + } + + public void setOwner(@Nullable UUID owner) { + this.owner = owner; + + markDirty(); + } + + @Nullable + public UUID getOwner() { + return owner; + } + + private void rebuildCards() { + actualCards.clear(); + + for (int i = 0; i < cards.getSlots(); ++i) { + ItemStack stack = cards.getStackInSlot(i); + + if (!stack.isEmpty()) { + UUID uuid = ItemSecurityCard.getOwner(stack); + + if (uuid == null) { + continue; + } + + SecurityCard card = new SecurityCard(uuid); + + for (Permission permission : Permission.values()) { + card.getPermissions().put(permission, ItemSecurityCard.hasPermission(stack, permission)); + } + + actualCards.add(card); + } + } + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + if (tag.hasKey(NBT_OWNER)) { + owner = UUID.fromString(tag.getString(NBT_OWNER)); + } + + RSUtils.readItems(cards, 0, tag); + RSUtils.readItems(editCard, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + if (owner != null) { + tag.setString(NBT_OWNER, owner.toString()); + } + + RSUtils.writeItems(cards, 0, tag); + RSUtils.writeItems(editCard, 1, tag); + + return tag; + } + + @Override + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + network.getSecurityManager().rebuild(); + } + + public ItemHandlerBasic getCardsItems() { + return cards; + } + + public ItemHandlerBasic getEditCard() { + return editCard; + } + + public void updatePermission(Permission permission, boolean state) { + ItemStack card = getEditCard().getStackInSlot(0); + + if (!card.isEmpty()) { + ItemSecurityCard.setPermission(card, permission, state); + } + } + + @Override + public List getCards() { + return actualCards; + } + + @Override + public IItemHandler getDrops() { + return new CombinedInvWrapper(cards, editCard); + } + + @Override + public boolean hasConnectivityState() { + return true; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSolderer.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSolderer.java new file mode 100755 index 000000000..8b568e62e --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSolderer.java @@ -0,0 +1,188 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.solderer.ISoldererRecipe; +import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.wrapper.CombinedInvWrapper; + +import javax.annotation.Nonnull; + +public class NetworkNodeSolderer extends NetworkNode { + private static final String NBT_WORKING = "Working"; + private static final String NBT_PROGRESS = "Progress"; + + private ItemHandlerBasic items = new ItemHandlerBasic(3, new ItemHandlerChangeListenerNode(this)) { + @Override + @Nonnull + public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) { + for (ISoldererRecipe recipe : API.instance().getSoldererRegistry().getRecipes()) { + if (API.instance().getComparer().isEqualNoQuantity(recipe.getRow(slot), stack) || API.instance().getComparer().isEqualOredict(recipe.getRow(slot), stack)) { + return super.insertItem(slot, stack, simulate); + } + } + + return stack; + } + }; + private ItemHandlerBasic result = new ItemHandlerBasic(1, new ItemHandlerChangeListenerNode(this)) { + @Override + @Nonnull + public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) { + return stack; + } + }; + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_SPEED); + + private ISoldererRecipe recipe; + + private boolean working = false; + private int progress = 0; + + public NetworkNodeSolderer(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.soldererUsage + upgrades.getEnergyUsage(); + } + + @Override + public void update() { + if (network == null) { + return; + } + + if (items.getStackInSlot(1).isEmpty() && items.getStackInSlot(2).isEmpty() && result.getStackInSlot(0).isEmpty()) { + stop(); + } else { + ISoldererRecipe newRecipe = API.instance().getSoldererRegistry().getRecipe(items); + + if (newRecipe == null) { + stop(); + } else if (newRecipe != recipe) { + boolean sameItem = !result.getStackInSlot(0).isEmpty() && API.instance().getComparer().isEqualNoQuantity(result.getStackInSlot(0), newRecipe.getResult()); + + if (result.getStackInSlot(0).isEmpty() || (sameItem && ((result.getStackInSlot(0).getCount() + newRecipe.getResult().getCount()) <= result.getStackInSlot(0).getMaxStackSize()))) { + recipe = newRecipe; + progress = 0; + working = true; + + markDirty(); + } + } else if (working) { + progress += 1 + upgrades.getUpgradeCount(ItemUpgrade.TYPE_SPEED); + + if (progress >= recipe.getDuration()) { + if (!result.getStackInSlot(0).isEmpty()) { + result.getStackInSlot(0).grow(recipe.getResult().getCount()); + } else { + result.setStackInSlot(0, recipe.getResult().copy()); + } + + for (int i = 0; i < 3; ++i) { + if (recipe.getRow(i) != null) { + items.extractItem(i, recipe.getRow(i).getCount(), false); + } + } + + recipe = null; + progress = 0; + // Don't set working to false yet, wait till the next update because we may have another stack waiting. + + markDirty(); + } + } + } + } + + @Override + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + if (!state) { + stop(); + } + } + + private void stop() { + progress = 0; + working = false; + recipe = null; + + markDirty(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(items, 0, tag); + RSUtils.readItems(upgrades, 1, tag); + RSUtils.readItems(result, 2, tag); + + recipe = API.instance().getSoldererRegistry().getRecipe(items); + + if (tag.hasKey(NBT_WORKING)) { + working = tag.getBoolean(NBT_WORKING); + } + + if (tag.hasKey(NBT_PROGRESS)) { + progress = tag.getInteger(NBT_PROGRESS); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(items, 0, tag); + RSUtils.writeItems(upgrades, 1, tag); + RSUtils.writeItems(result, 2, tag); + + tag.setBoolean(NBT_WORKING, working); + tag.setInteger(NBT_PROGRESS, progress); + + return tag; + } + + public ItemHandlerBasic getItems() { + return items; + } + + public ItemHandlerBasic getResult() { + return result; + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + public ISoldererRecipe getRecipe() { + return recipe; + } + + public boolean isWorking() { + return working; + } + + public int getProgress() { + return progress; + } + + @Override + public IItemHandler getDrops() { + return new CombinedInvWrapper(items, result, upgrades); + } + +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeStorage.java new file mode 100755 index 000000000..d4c5ca668 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeStorage.java @@ -0,0 +1,333 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSBlocks; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.storage.AccessType; +import com.raoulvdberge.refinedstorage.api.storage.IStorage; +import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; +import com.raoulvdberge.refinedstorage.block.BlockStorage; +import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.IStorageGui; +import com.raoulvdberge.refinedstorage.tile.TileStorage; +import com.raoulvdberge.refinedstorage.tile.config.*; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.items.ItemHandlerHelper; + +import javax.annotation.Nonnull; +import java.util.List; + +public class NetworkNodeStorage extends NetworkNode implements IStorageGui, IStorageProvider, IComparable, IFilterable, IPrioritizable, IExcessVoidable, IAccessType { + class StorageItem extends StorageItemNBT { + public StorageItem() { + super(NetworkNodeStorage.this.getStorageTag(), NetworkNodeStorage.this.getCapacity(), NetworkNodeStorage.this); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { + if (!IFilterable.canTake(filters, mode, compare, stack)) { + return ItemHandlerHelper.copyStackWithSize(stack, size); + } + + return super.insert(stack, size, simulate); + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public boolean isVoiding() { + return voidExcess; + } + } + + public static final String NBT_STORAGE = "Storage"; + + private static final String NBT_PRIORITY = "Priority"; + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + private static final String NBT_VOID_EXCESS = "VoidExcess"; + + private ItemHandlerBasic filters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + + private NBTTagCompound storageTag = StorageItemNBT.createNBT(); + + private StorageItem storage; + + private EnumItemStorageType type; + + private AccessType accessType = AccessType.INSERT_EXTRACT; + private int priority = 0; + private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; + private int mode = IFilterable.WHITELIST; + private boolean voidExcess = false; + + public NetworkNodeStorage(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.storageUsage; + } + + @Override + public void update() { + super.update(); + + if (storage == null && storageTag != null) { + storage = new StorageItem(); + + if (network != null) { + network.getItemStorageCache().invalidate(); + } + } + } + + public void onBreak() { + if (storage != null) { + storage.writeToNBT(); + } + } + + @Override + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); + + network.getItemStorageCache().invalidate(); + } + + @Override + public void addItemStorages(List> storages) { + if (storage != null) { + storages.add(storage); + } + } + + @Override + public void addFluidStorages(List> storages) { + // NO OP + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + if (tag.hasKey(NBT_STORAGE)) { + storageTag = tag.getCompoundTag(NBT_STORAGE); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + if (storage != null) { + storage.writeToNBT(); + } + + tag.setTag(NBT_STORAGE, storageTag); + + return tag; + } + + @Override + public NBTTagCompound writeConfiguration(NBTTagCompound tag) { + super.writeConfiguration(tag); + + RSUtils.writeItems(filters, 0, tag); + + tag.setInteger(NBT_PRIORITY, priority); + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + tag.setBoolean(NBT_VOID_EXCESS, voidExcess); + + RSUtils.writeAccessType(tag, accessType); + + return tag; + } + + @Override + public void readConfiguration(NBTTagCompound tag) { + super.readConfiguration(tag); + + RSUtils.readItems(filters, 0, tag); + + if (tag.hasKey(NBT_PRIORITY)) { + priority = tag.getInteger(NBT_PRIORITY); + } + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + if (tag.hasKey(NBT_VOID_EXCESS)) { + voidExcess = tag.getBoolean(NBT_VOID_EXCESS); + } + + accessType = RSUtils.readAccessType(tag); + } + + public EnumItemStorageType getType() { + if (type == null && holder.world().getBlockState(holder.pos()).getBlock() == RSBlocks.STORAGE) { + type = ((EnumItemStorageType) holder.world().getBlockState(holder.pos()).getValue(BlockStorage.TYPE)); + } + + return type == null ? EnumItemStorageType.TYPE_1K : type; + } + + @Override + public int getCompare() { + return compare; + } + + @Override + public void setCompare(int compare) { + this.compare = compare; + + markDirty(); + } + + @Override + public int getMode() { + return mode; + } + + @Override + public void setMode(int mode) { + this.mode = mode; + + markDirty(); + } + + @Override + public boolean getVoidExcess() { + return voidExcess; + } + + @Override + public void setVoidExcess(boolean voidExcess) { + this.voidExcess = voidExcess; + + markDirty(); + } + + public NBTTagCompound getStorageTag() { + return storageTag; + } + + public void setStorageTag(NBTTagCompound storageTag) { + this.storageTag = storageTag; + } + + public StorageItemNBT getStorage() { + return storage; + } + + public ItemHandlerBasic getFilters() { + return filters; + } + + @Override + public String getGuiTitle() { + return "block.refinedstorage:storage." + getType().getId() + ".name"; + } + + @Override + public TileDataParameter getTypeParameter() { + return null; + } + + @Override + public TileDataParameter getRedstoneModeParameter() { + return TileStorage.REDSTONE_MODE; + } + + @Override + public TileDataParameter getCompareParameter() { + return TileStorage.COMPARE; + } + + @Override + public TileDataParameter getFilterParameter() { + return TileStorage.MODE; + } + + @Override + public TileDataParameter getPriorityParameter() { + return TileStorage.PRIORITY; + } + + @Override + public TileDataParameter getVoidExcessParameter() { + return TileStorage.VOID_EXCESS; + } + + @Override + public TileDataParameter getAccessTypeParameter() { + return TileStorage.ACCESS_TYPE; + } + + @Override + public String getVoidExcessType() { + return "items"; + } + + @Override + public int getStored() { + return TileStorage.STORED.getValue(); + } + + @Override + public int getCapacity() { + return getType().getCapacity(); + } + + @Override + public AccessType getAccessType() { + return accessType; + } + + @Override + public void setAccessType(AccessType value) { + this.accessType = value; + + if (network != null) { + network.getItemStorageCache().invalidate(); + } + + markDirty(); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public void setPriority(int priority) { + this.priority = priority; + + markDirty(); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWirelessTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWirelessTransmitter.java new file mode 100755 index 000000000..b3cc77e65 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWirelessTransmitter.java @@ -0,0 +1,84 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.IWirelessTransmitter; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraftforge.items.IItemHandler; + +import javax.annotation.Nullable; + +public class NetworkNodeWirelessTransmitter extends NetworkNode implements IWirelessTransmitter { + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerChangeListenerNode(this), ItemUpgrade.TYPE_RANGE); + + public NetworkNodeWirelessTransmitter(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.wirelessTransmitterUsage + upgrades.getEnergyUsage(); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + RSUtils.readItems(upgrades, 0, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + RSUtils.writeItems(upgrades, 0, tag); + + return tag; + } + + @Override + public int getRange() { + return RS.INSTANCE.config.wirelessTransmitterBaseRange + (upgrades.getUpgradeCount(ItemUpgrade.TYPE_RANGE) * RS.INSTANCE.config.wirelessTransmitterRangePerUpgrade); + } + + @Override + public BlockPos getOrigin() { + return holder.pos(); + } + + @Override + public int getDimension() { + return holder.world().provider.getDimension(); + } + + public ItemHandlerBasic getUpgrades() { + return upgrades; + } + + @Override + public IItemHandler getDrops() { + return upgrades; + } + + @Override + public boolean canConduct(@Nullable EnumFacing direction) { + return direction != null && EnumFacing.DOWN.equals(direction); + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public void walkNeighborhood(Operator operator) { + operator.apply(holder.world(), holder.pos().offset(EnumFacing.DOWN), EnumFacing.UP); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWriter.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWriter.java new file mode 100755 index 000000000..2c6ec5690 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWriter.java @@ -0,0 +1,127 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node; + +import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.RSBlocks; +import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterChannel; +import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterHandler; +import com.raoulvdberge.refinedstorage.api.network.readerwriter.IWriter; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; +import com.raoulvdberge.refinedstorage.tile.TileWriter; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; + +public class NetworkNodeWriter extends NetworkNode implements IWriter { + private static final String NBT_CHANNEL = "Channel"; + + private String channel = ""; + + private int redstoneStrength; + private int lastRedstoneStrength; + + public NetworkNodeWriter(INetworkNodeHolder holder) { + super(holder); + } + + @Override + public int getEnergyUsage() { + return RS.INSTANCE.config.writerUsage; + } + + @Override + public void update() { + super.update(); + + if (getRedstoneStrength() != lastRedstoneStrength) { + lastRedstoneStrength = getRedstoneStrength(); + + holder.world().notifyNeighborsOfStateChange(holder.pos(), RSBlocks.WRITER, true); + } + } + + @Override + public int getRedstoneStrength() { + return network != null ? redstoneStrength : 0; + } + + @Override + public void setRedstoneStrength(int strength) { + redstoneStrength = strength; + } + + // @todo + @Override + public EnumFacing getDirection() { + return null; + } + + @Override + public String getTitle() { + return "gui.refinedstorage:writer"; + } + + @Override + public String getChannel() { + return channel; + } + + @Override + public void setChannel(String channel) { + if (network != null && channel.equals("")) { + IReaderWriterChannel networkChannel = network.getReaderWriterChannel(this.channel); + + if (networkChannel != null) { + for (IReaderWriterHandler handler : networkChannel.getHandlers()) { + handler.onWriterDisabled(this); + } + } + } + + this.channel = channel; + } + + @Override + public TileDataParameter getChannelParameter() { + return TileWriter.CHANNEL; + } + + @Override + public boolean hasConnectivityState() { + return true; + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + if (tag.hasKey(NBT_CHANNEL)) { + channel = tag.getString(NBT_CHANNEL); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + tag.setString(NBT_CHANNEL, channel); + + return tag; + } + + // @todo + /* + @Override + public void setDirection(EnumFacing direction) { + super.setDirection(direction); + + world.notifyNeighborsOfStateChange(pos, RSBlocks.WRITER, true); + }*/ + + public void onOpened(EntityPlayer entity) { + if (network != null) { + network.sendReaderWriterChannelUpdate((EntityPlayerMP) entity); + } + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/TileExternalStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java similarity index 73% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/TileExternalStorage.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java index d8fda7fa5..2d3c5f55d 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/TileExternalStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer; import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawerGroup; @@ -9,16 +9,18 @@ import com.raoulvdberge.refinedstorage.api.storage.AccessType; import com.raoulvdberge.refinedstorage.api.storage.IStorage; import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerNode; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; +import com.raoulvdberge.refinedstorage.tile.INetworkNodeHolder; import com.raoulvdberge.refinedstorage.tile.IStorageGui; +import com.raoulvdberge.refinedstorage.tile.TileExternalStorage; import com.raoulvdberge.refinedstorage.tile.TileNode; import com.raoulvdberge.refinedstorage.tile.config.*; -import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.network.datasync.DataSerializers; import net.minecraft.tileentity.TileEntity; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.capability.IFluidHandler; @@ -29,72 +31,27 @@ import powercrystals.minefactoryreloaded.api.IDeepStorageUnit; import java.util.ArrayList; import java.util.List; -public class TileExternalStorage extends TileNode implements IStorageProvider, IStorageGui, IComparable, IFilterable, IPrioritizable, IType, IAccessType { - public static final TileDataParameter PRIORITY = IPrioritizable.createParameter(); - public static final TileDataParameter COMPARE = IComparable.createParameter(); - public static final TileDataParameter MODE = IFilterable.createParameter(); - public static final TileDataParameter TYPE = IType.createParameter(); - public static final TileDataParameter ACCESS_TYPE = IAccessType.createParameter(); - - public static final TileDataParameter STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { - @Override - public Integer getValue(TileExternalStorage tile) { - int stored = 0; - - for (StorageItemExternal storage : tile.itemStorages) { - stored += storage.getStored(); - } - - for (StorageFluidExternal storage : tile.fluidStorages) { - stored += storage.getStored(); - } - - return stored; - } - }); - - public static final TileDataParameter CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { - @Override - public Integer getValue(TileExternalStorage tile) { - int capacity = 0; - - for (StorageItemExternal storage : tile.itemStorages) { - capacity += storage.getCapacity(); - } - - for (StorageFluidExternal storage : tile.fluidStorages) { - capacity += storage.getCapacity(); - } - - return capacity; - } - }); - +public class NetworkNodeExternalStorage extends NetworkNode implements IStorageProvider, IStorageGui, IComparable, IFilterable, IPrioritizable, IType, IAccessType { private static final String NBT_PRIORITY = "Priority"; private static final String NBT_COMPARE = "Compare"; private static final String NBT_MODE = "Mode"; private static final String NBT_TYPE = "Type"; - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this); + private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, new ItemHandlerChangeListenerNode(this)); + private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerChangeListenerNode(this)); private int priority = 0; private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; private int mode = IFilterable.WHITELIST; private int type = IType.ITEMS; private AccessType accessType = AccessType.INSERT_EXTRACT; + private int networkTicks; private List itemStorages = new ArrayList<>(); private List fluidStorages = new ArrayList<>(); - public TileExternalStorage() { - dataManager.addWatchedParameter(PRIORITY); - dataManager.addWatchedParameter(COMPARE); - dataManager.addWatchedParameter(MODE); - dataManager.addWatchedParameter(STORED); - dataManager.addWatchedParameter(CAPACITY); - dataManager.addWatchedParameter(TYPE); - dataManager.addWatchedParameter(ACCESS_TYPE); + public NetworkNodeExternalStorage(INetworkNodeHolder holder) { + super(holder); } @Override @@ -103,12 +60,8 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I } @Override - public void updateNode() { - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - super.onConnectionChange(network, state); + public void onConnectedStateChange(INetworkMaster network, boolean state) { + super.onConnectedStateChange(network, state); updateStorage(network); @@ -116,11 +69,11 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I network.getFluidStorageCache().invalidate(); } - private int networkTicks; - @Override public void update() { - if (!getWorld().isRemote && network != null) { + super.update(); + + if (network != null) { if (networkTicks++ == 0) { updateStorage(network); @@ -143,8 +96,6 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I network.getFluidStorageCache().invalidate(); } } - - super.update(); } @Override @@ -230,7 +181,7 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I itemStorages.clear(); fluidStorages.clear(); - TileEntity facing = getFacingTile(); + TileEntity facing = holder.world().getTileEntity(holder.pos().offset(holder.getDirection())); if (type == IType.ITEMS) { if (facing instanceof IDrawerGroup) { @@ -240,14 +191,14 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I } else if (facing instanceof IDeepStorageUnit) { itemStorages.add(new StorageItemDSU(this, (IDeepStorageUnit) facing)); } else if (!(facing instanceof TileNode)) { - IItemHandler itemHandler = RSUtils.getItemHandler(facing, getDirection().getOpposite()); + IItemHandler itemHandler = RSUtils.getItemHandler(facing, holder.getDirection().getOpposite()); if (itemHandler != null) { itemStorages.add(new StorageItemItemHandler(this, itemHandler)); } } } else if (type == IType.FLUIDS) { - IFluidHandler fluidHandler = RSUtils.getFluidHandler(facing, getDirection().getOpposite()); + IFluidHandler fluidHandler = RSUtils.getFluidHandler(facing, holder.getDirection().getOpposite()); if (fluidHandler != null) { for (IFluidTankProperties property : fluidHandler.getTankProperties()) { @@ -277,22 +228,22 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I @Override public TileDataParameter getRedstoneModeParameter() { - return REDSTONE_MODE; + return TileExternalStorage.REDSTONE_MODE; } @Override public TileDataParameter getCompareParameter() { - return COMPARE; + return TileExternalStorage.COMPARE; } @Override public TileDataParameter getFilterParameter() { - return MODE; + return TileExternalStorage.MODE; } @Override public TileDataParameter getPriorityParameter() { - return PRIORITY; + return TileExternalStorage.PRIORITY; } @Override @@ -302,7 +253,7 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I @Override public TileDataParameter getAccessTypeParameter() { - return ACCESS_TYPE; + return TileExternalStorage.ACCESS_TYPE; } @Override @@ -312,12 +263,12 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I @Override public int getStored() { - return STORED.getValue(); + return TileExternalStorage.STORED.getValue(); } @Override public int getCapacity() { - return CAPACITY.getValue(); + return TileExternalStorage.CAPACITY.getValue(); } @Override @@ -339,12 +290,12 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I @Override public TileDataParameter getTypeParameter() { - return TYPE; + return TileExternalStorage.TYPE; } @Override public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; + return holder.world().isRemote ? TileExternalStorage.TYPE.getValue() : type; } @Override @@ -370,4 +321,12 @@ public class TileExternalStorage extends TileNode implements IStorageProvider, I public ItemHandlerFluid getFluidFilters() { return fluidFilters; } + + public List getItemStorages() { + return itemStorages; + } + + public List getFluidStorages() { + return fluidStorages; + } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageFluidExternal.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageFluidExternal.java similarity index 92% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageFluidExternal.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageFluidExternal.java index d041da561..3faa41f86 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageFluidExternal.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageFluidExternal.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.storage.AccessType; @@ -17,10 +17,10 @@ import javax.annotation.Nullable; public class StorageFluidExternal implements IStorage { private FluidStack cache; - private TileExternalStorage externalStorage; + private NetworkNodeExternalStorage externalStorage; private IFluidHandler handler; - public StorageFluidExternal(TileExternalStorage externalStorage, IFluidHandler handler, IFluidTankProperties properties) { + public StorageFluidExternal(NetworkNodeExternalStorage externalStorage, IFluidHandler handler, IFluidTankProperties properties) { this.externalStorage = externalStorage; this.handler = handler; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDSU.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDSU.java similarity index 94% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDSU.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDSU.java index f33319b8a..627c4aa6d 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDSU.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDSU.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.storage.AccessType; @@ -12,10 +12,10 @@ import powercrystals.minefactoryreloaded.api.IDeepStorageUnit; import javax.annotation.Nonnull; public class StorageItemDSU extends StorageItemExternal { - private TileExternalStorage externalStorage; + private NetworkNodeExternalStorage externalStorage; private IDeepStorageUnit unit; - public StorageItemDSU(TileExternalStorage externalStorage, IDeepStorageUnit unit) { + public StorageItemDSU(NetworkNodeExternalStorage externalStorage, IDeepStorageUnit unit) { this.externalStorage = externalStorage; this.unit = unit; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDrawer.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDrawer.java similarity index 90% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDrawer.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDrawer.java index e0573983a..64afe9def 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDrawer.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDrawer.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer; import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.IVoidable; @@ -13,10 +13,10 @@ import net.minecraftforge.items.ItemHandlerHelper; import javax.annotation.Nonnull; public class StorageItemDrawer extends StorageItemExternal { - private TileExternalStorage externalStorage; + private NetworkNodeExternalStorage externalStorage; private IDrawer drawer; - public StorageItemDrawer(TileExternalStorage externalStorage, IDrawer drawer) { + public StorageItemDrawer(NetworkNodeExternalStorage externalStorage, IDrawer drawer) { this.externalStorage = externalStorage; this.drawer = drawer; } @@ -64,7 +64,7 @@ public class StorageItemDrawer extends StorageItemExternal { return RSUtils.emptyNonNullList(); } - public static ItemStack insert(TileExternalStorage externalStorage, IDrawer drawer, @Nonnull ItemStack stack, int size, boolean simulate) { + public static ItemStack insert(NetworkNodeExternalStorage externalStorage, IDrawer drawer, @Nonnull ItemStack stack, int size, boolean simulate) { if (IFilterable.canTake(externalStorage.getItemFilters(), externalStorage.getMode(), externalStorage.getCompare(), stack) && drawer.canItemBeStored(stack)) { int stored = drawer.getStoredItemCount(); int remainingSpace = drawer.getMaxCapacity(stack) - stored; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDrawerGroup.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDrawerGroup.java similarity index 93% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDrawerGroup.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDrawerGroup.java index 576fe6dba..db06bf71b 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemDrawerGroup.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemDrawerGroup.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawerGroup; import com.raoulvdberge.refinedstorage.api.storage.AccessType; @@ -9,10 +9,10 @@ import javax.annotation.Nonnull; import javax.annotation.Nullable; public class StorageItemDrawerGroup extends StorageItemExternal { - private TileExternalStorage externalStorage; + private NetworkNodeExternalStorage externalStorage; private IDrawerGroup drawers; - public StorageItemDrawerGroup(TileExternalStorage externalStorage, IDrawerGroup drawers) { + public StorageItemDrawerGroup(NetworkNodeExternalStorage externalStorage, IDrawerGroup drawers) { this.externalStorage = externalStorage; this.drawers = drawers; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemExternal.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemExternal.java similarity index 97% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemExternal.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemExternal.java index 2dc609634..3f2868ffe 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemExternal.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemExternal.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; import com.raoulvdberge.refinedstorage.api.storage.AccessType; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemItemHandler.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemItemHandler.java similarity index 91% rename from src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemItemHandler.java rename to src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemItemHandler.java index 8c9a75c98..7cd3a4f28 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/externalstorage/StorageItemItemHandler.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemItemHandler.java @@ -1,4 +1,4 @@ -package com.raoulvdberge.refinedstorage.tile.externalstorage; +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; import com.raoulvdberge.refinedstorage.api.storage.AccessType; import com.raoulvdberge.refinedstorage.apiimpl.API; @@ -11,17 +11,19 @@ import net.minecraftforge.items.ItemHandlerHelper; import javax.annotation.Nonnull; public class StorageItemItemHandler extends StorageItemExternal { - private TileExternalStorage externalStorage; + private NetworkNodeExternalStorage externalStorage; private IItemHandler handler; private AccessType lockedAccessType = AccessType.INSERT_EXTRACT; - public StorageItemItemHandler(TileExternalStorage externalStorage, IItemHandler handler) { + public StorageItemItemHandler(NetworkNodeExternalStorage externalStorage, IItemHandler handler) { this.externalStorage = externalStorage; this.handler = handler; + // @todo + /* if (externalStorage.getFacingTile().getBlockType().getUnlocalizedName().equals("tile.ExtraUtils2:TrashCan")) { lockedAccessType = AccessType.INSERT; - } + }*/ } @Override diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageFluidNBT.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageFluidNBT.java index 408eb1722..d0f0fb2ea 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageFluidNBT.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageFluidNBT.java @@ -1,13 +1,13 @@ package com.raoulvdberge.refinedstorage.apiimpl.storage; import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.storage.AccessType; import com.raoulvdberge.refinedstorage.api.storage.IStorage; import com.raoulvdberge.refinedstorage.apiimpl.API; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; -import net.minecraft.tileentity.TileEntity; import net.minecraft.util.NonNullList; import net.minecraftforge.fluids.FluidStack; @@ -31,19 +31,19 @@ public abstract class StorageFluidNBT implements IStorage { private NBTTagCompound tag; private int capacity; - private TileEntity tile; + private INetworkNode node; private NonNullList stacks = NonNullList.create(); /** * @param tag The NBT tag we are reading from and writing the amount stored to, has to be initialized with {@link StorageFluidNBT#createNBT()} if it doesn't exist yet * @param capacity The capacity of this storage, -1 for infinite capacity - * @param tile A {@link TileEntity} that the NBT storage is in, will be marked dirty when the storage changes + * @param node A {@link INetworkNode} that the NBT storage is in, will be marked dirty when the storage changes */ - public StorageFluidNBT(NBTTagCompound tag, int capacity, @Nullable TileEntity tile) { + public StorageFluidNBT(NBTTagCompound tag, int capacity, @Nullable INetworkNode node) { this.tag = tag; this.capacity = capacity; - this.tile = tile; + this.node = node; readFromNBT(); } @@ -178,8 +178,8 @@ public abstract class StorageFluidNBT implements IStorage { } public void onStorageChanged() { - if (tile != null) { - tile.markDirty(); + if (node != null) { + node.markDirty(); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageItemNBT.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageItemNBT.java index 177069427..601def56c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageItemNBT.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageItemNBT.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.apiimpl.storage; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.storage.AccessType; import com.raoulvdberge.refinedstorage.api.storage.IStorage; import com.raoulvdberge.refinedstorage.apiimpl.API; @@ -7,7 +8,6 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; -import net.minecraft.tileentity.TileEntity; import net.minecraft.util.NonNullList; import net.minecraftforge.items.ItemHandlerHelper; @@ -37,19 +37,20 @@ public abstract class StorageItemNBT implements IStorage { private NBTTagCompound tag; private int capacity; - private TileEntity tile; + @Nullable + private INetworkNode node; private NonNullList stacks = NonNullList.create(); /** * @param tag The NBT tag we are reading from and writing the amount stored to, has to be initialized with {@link StorageItemNBT#createNBT()} if it doesn't exist yet * @param capacity The capacity of this storage, -1 for infinite capacity - * @param tile A {@link TileEntity} that the NBT storage is in, will be marked dirty when the storage changes + * @param node A {@link INetworkNode} that the NBT storage is in, will be marked dirty when the storage changes */ - public StorageItemNBT(NBTTagCompound tag, int capacity, @Nullable TileEntity tile) { + public StorageItemNBT(NBTTagCompound tag, int capacity, @Nullable INetworkNode node) { this.tag = tag; this.capacity = capacity; - this.tile = tile; + this.node = node; readFromNBT(); } @@ -214,8 +215,8 @@ public abstract class StorageItemNBT implements IStorage { } public void onStorageChanged() { - if (tile != null) { - tile.markDirty(); + if (node != null) { + node.markDirty(); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockBase.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockBase.java index dcddaf52d..b6e512f4e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockBase.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockBase.java @@ -3,9 +3,10 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RS; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.api.network.security.Permission; import com.raoulvdberge.refinedstorage.item.ItemBlockBase; -import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode; +import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.TileBase; import net.minecraft.block.Block; import net.minecraft.block.material.Material; @@ -96,7 +97,7 @@ public abstract class BlockBase extends Block { tile.setDirection(getPlacementType().cycle(tile.getDirection())); - tile.updateBlock(); + RSUtils.updateBlock(world, pos); return true; } @@ -140,8 +141,9 @@ public abstract class BlockBase extends Block { protected boolean tryOpenNetworkGui(int guiId, EntityPlayer player, World world, BlockPos pos, EnumFacing facing, Permission... permissions) { TileEntity tile = world.getTileEntity(pos); - if (tile != null && tile.hasCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, facing)) { - INetworkNode node = CapabilityNetworkNode.NETWORK_NODE_CAPABILITY.cast(tile.getCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, facing)); + if (tile != null && tile.hasCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, facing)) { + INetworkNodeProxy nodeProxy = CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY.cast(tile.getCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, facing)); + INetworkNode node = nodeProxy.getNode(); if (node.getNetwork() != null) { for (Permission permission : permissions) { @@ -163,8 +165,9 @@ public abstract class BlockBase extends Block { public boolean canEntityDestroy(IBlockState state, IBlockAccess world, BlockPos pos, Entity entity) { TileEntity tile = world.getTileEntity(pos); - if (tile != null && tile.hasCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, null)) { - INetworkNode node = tile.getCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, null); + if (tile != null && tile.hasCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, null)) { + INetworkNodeProxy nodeProxy = tile.getCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, null); + INetworkNode node = nodeProxy.getNode(); if (node.getNetwork() != null) { if (!(entity instanceof EntityPlayer)) { diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java index 1850f48c8..9a0685d09 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java @@ -1,7 +1,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode; +import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.TileCable; import net.minecraft.block.properties.PropertyBool; import net.minecraft.block.state.BlockStateContainer; @@ -93,7 +93,7 @@ public class BlockCable extends BlockNode { TileEntity otherTile = world.getTileEntity(pos.offset(direction)); EnumFacing otherTileSide = direction.getOpposite(); - return otherTile != null && otherTile.hasCapability(CapabilityNetworkNode.NETWORK_NODE_CAPABILITY, otherTileSide); + return otherTile != null && otherTile.hasCapability(CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY, otherTileSide); } private boolean isInAABB(AxisAlignedBB aabb, float hitX, float hitY, float hitZ) { diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCraftingMonitor.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCraftingMonitor.java index 11f26b9b1..0541aa20b 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCraftingMonitor.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCraftingMonitor.java @@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSGui; import com.raoulvdberge.refinedstorage.api.network.security.Permission; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCraftingMonitor; import com.raoulvdberge.refinedstorage.tile.craftingmonitor.TileCraftingMonitor; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; @@ -24,7 +25,7 @@ public class BlockCraftingMonitor extends BlockNode { @Override public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) { if (!world.isRemote && tryOpenNetworkGui(RSGui.CRAFTING_MONITOR, player, world, pos, side, Permission.MODIFY, Permission.AUTOCRAFTING)) { - ((TileCraftingMonitor) world.getTileEntity(pos)).onOpened(player); + ((NetworkNodeCraftingMonitor) ((TileCraftingMonitor) world.getTileEntity(pos)).getNode()).onOpened(player); } return true; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskDrive.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskDrive.java index b33216c5d..822f17905 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskDrive.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskDrive.java @@ -1,6 +1,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskDrive; import com.raoulvdberge.refinedstorage.render.PropertyObject; import com.raoulvdberge.refinedstorage.tile.TileDiskDrive; import net.minecraft.block.state.BlockStateContainer; @@ -47,7 +48,7 @@ public class BlockDiskDrive extends BlockNode { @Override public void breakBlock(World world, BlockPos pos, IBlockState state) { - ((TileDiskDrive) world.getTileEntity(pos)).onBreak(); + ((NetworkNodeDiskDrive) ((TileDiskDrive) world.getTileEntity(pos)).getNode()).onBreak(); super.breakBlock(world, pos, state); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskManipulator.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskManipulator.java index d763475d5..206a66c6d 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskManipulator.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockDiskManipulator.java @@ -1,6 +1,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskManipulator; import com.raoulvdberge.refinedstorage.render.PropertyObject; import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator; import net.minecraft.block.state.BlockStateContainer; @@ -47,7 +48,7 @@ public class BlockDiskManipulator extends BlockNode { @Override public void breakBlock(World world, BlockPos pos, IBlockState state) { - ((TileDiskManipulator) world.getTileEntity(pos)).onBreak(); + ((NetworkNodeDiskManipulator) ((TileDiskManipulator) world.getTileEntity(pos)).getNode()).onBreak(); super.breakBlock(world, pos, state); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockExternalStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockExternalStorage.java index b7ff7b8c0..5b2b6de5b 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockExternalStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockExternalStorage.java @@ -1,7 +1,8 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSGui; -import com.raoulvdberge.refinedstorage.tile.externalstorage.TileExternalStorage; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.NetworkNodeExternalStorage; +import com.raoulvdberge.refinedstorage.tile.TileExternalStorage; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; @@ -85,9 +86,9 @@ public class BlockExternalStorage extends BlockCable { super.neighborChanged(state, world, pos, block, fromPos); if (!world.isRemote) { - TileExternalStorage externalStorage = (TileExternalStorage) world.getTileEntity(pos); + NetworkNodeExternalStorage externalStorage = (NetworkNodeExternalStorage) ((TileExternalStorage) world.getTileEntity(pos)).getNode(); - if (externalStorage.hasNetwork()) { + if (externalStorage.getNetwork() != null) { externalStorage.updateStorage(externalStorage.getNetwork()); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockFluidStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockFluidStorage.java index 62bd9d178..47ea014d0 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockFluidStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockFluidStorage.java @@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidStorage; import com.raoulvdberge.refinedstorage.item.ItemBlockFluidStorage; import com.raoulvdberge.refinedstorage.tile.TileFluidStorage; import net.minecraft.block.properties.PropertyEnum; @@ -75,14 +76,14 @@ public class BlockFluidStorage extends BlockNode { public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack stack) { super.onBlockPlacedBy(world, pos, state, player, stack); - if (!world.isRemote && stack.hasTagCompound() && stack.getTagCompound().hasKey(TileFluidStorage.NBT_STORAGE)) { - ((TileFluidStorage) world.getTileEntity(pos)).setStorageTag(stack.getTagCompound().getCompoundTag(TileFluidStorage.NBT_STORAGE)); + if (!world.isRemote && stack.hasTagCompound() && stack.getTagCompound().hasKey(NetworkNodeFluidStorage.NBT_STORAGE)) { + ((NetworkNodeFluidStorage) ((TileFluidStorage) world.getTileEntity(pos)).getNode()).setStorageTag(stack.getTagCompound().getCompoundTag(NetworkNodeFluidStorage.NBT_STORAGE)); } } @Override public void breakBlock(World world, BlockPos pos, IBlockState state) { - ((TileFluidStorage) world.getTileEntity(pos)).onBreak(); + ((NetworkNodeFluidStorage) ((TileFluidStorage) world.getTileEntity(pos)).getNode()).onBreak(); super.breakBlock(world, pos, state); } @@ -95,7 +96,7 @@ public class BlockFluidStorage extends BlockNode { ItemStack stack = new ItemStack(RSBlocks.FLUID_STORAGE, 1, getMetaFromState(state)); stack.setTagCompound(new NBTTagCompound()); - stack.getTagCompound().setTag(TileFluidStorage.NBT_STORAGE, storage.getStorageTag()); + stack.getTagCompound().setTag(NetworkNodeFluidStorage.NBT_STORAGE, ((NetworkNodeFluidStorage) ((TileFluidStorage) world.getTileEntity(pos)).getNode()).getStorageTag()); drops.add(stack); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockGrid.java index e1f1171c6..7eb85441e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockGrid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockGrid.java @@ -1,6 +1,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.item.ItemBlockBase; import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.block.properties.PropertyEnum; @@ -56,7 +57,7 @@ public class BlockGrid extends BlockNode { @Override public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) { if (!world.isRemote && tryOpenNetworkGui(RSGui.GRID, player, world, pos, side)) { - ((TileGrid) world.getTileEntity(pos)).onOpened(player); + ((NetworkNodeGrid) ((TileGrid) world.getTileEntity(pos)).getNode()).onOpened(player); } return true; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockReader.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockReader.java index 4e3c24bb5..57af222fc 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockReader.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockReader.java @@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeReader; import com.raoulvdberge.refinedstorage.tile.TileReader; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; @@ -32,7 +33,7 @@ public class BlockReader extends BlockCable { } if (!world.isRemote && tryOpenNetworkGui(RSGui.READER_WRITER, player, world, pos, side)) { - ((TileReader) world.getTileEntity(pos)).onOpened(player); + ((NetworkNodeReader) ((TileReader) world.getTileEntity(pos)).getNode()).onOpened(player); } return true; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockSecurityManager.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockSecurityManager.java index 1cfc498b1..bb63ed0ac 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockSecurityManager.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockSecurityManager.java @@ -3,6 +3,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RS; import com.raoulvdberge.refinedstorage.RSGui; import com.raoulvdberge.refinedstorage.api.network.security.Permission; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSecurityManager; import com.raoulvdberge.refinedstorage.tile.TileSecurityManager; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.EntityLivingBase; @@ -29,14 +30,14 @@ public class BlockSecurityManager extends BlockNode { super.onBlockPlacedBy(world, pos, state, placer, stack); if (!world.isRemote && placer instanceof EntityPlayer) { - ((TileSecurityManager) world.getTileEntity(pos)).setOwner(((EntityPlayer) placer).getGameProfile().getId()); + ((NetworkNodeSecurityManager) ((TileSecurityManager) world.getTileEntity(pos)).getNode()).setOwner(((EntityPlayer) placer).getGameProfile().getId()); } } @Override public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ) { if (!world.isRemote) { - if (player.getGameProfile().getId().equals(((TileSecurityManager) world.getTileEntity(pos)).getOwner())) { + if (player.getGameProfile().getId().equals(((NetworkNodeSecurityManager) ((TileSecurityManager) world.getTileEntity(pos)).getNode()).getOwner())) { player.openGui(RS.INSTANCE, RSGui.SECURITY_MANAGER, world, pos.getX(), pos.getY(), pos.getZ()); } else { tryOpenNetworkGui(RSGui.SECURITY_MANAGER, player, world, pos, side, Permission.MODIFY, Permission.SECURITY); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockStorage.java index a64ea7b83..70902fb19 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockStorage.java @@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorage; import com.raoulvdberge.refinedstorage.item.ItemBlockStorage; import com.raoulvdberge.refinedstorage.tile.TileStorage; import net.minecraft.block.properties.PropertyEnum; @@ -75,14 +76,14 @@ public class BlockStorage extends BlockNode { public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack stack) { super.onBlockPlacedBy(world, pos, state, player, stack); - if (!world.isRemote && stack.hasTagCompound() && stack.getTagCompound().hasKey(TileStorage.NBT_STORAGE)) { - ((TileStorage) world.getTileEntity(pos)).setStorageTag(stack.getTagCompound().getCompoundTag(TileStorage.NBT_STORAGE)); + if (!world.isRemote && stack.hasTagCompound() && stack.getTagCompound().hasKey(NetworkNodeStorage.NBT_STORAGE)) { + ((NetworkNodeStorage) ((TileStorage) world.getTileEntity(pos)).getNode()).setStorageTag(stack.getTagCompound().getCompoundTag(NetworkNodeStorage.NBT_STORAGE)); } } @Override public void breakBlock(World world, BlockPos pos, IBlockState state) { - ((TileStorage) world.getTileEntity(pos)).onBreak(); + ((NetworkNodeStorage) ((TileStorage) world.getTileEntity(pos)).getNode()).onBreak(); super.breakBlock(world, pos, state); } @@ -95,7 +96,7 @@ public class BlockStorage extends BlockNode { ItemStack stack = new ItemStack(RSBlocks.STORAGE, 1, getMetaFromState(state)); stack.setTagCompound(new NBTTagCompound()); - stack.getTagCompound().setTag(TileStorage.NBT_STORAGE, storage.getStorageTag()); + stack.getTagCompound().setTag(NetworkNodeStorage.NBT_STORAGE, ((NetworkNodeStorage) ((TileStorage) world.getTileEntity(pos)).getNode()).getStorageTag()); drops.add(stack); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockWriter.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockWriter.java index 9a70d7b5f..fb7a6ab6c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockWriter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockWriter.java @@ -2,6 +2,8 @@ package com.raoulvdberge.refinedstorage.block; import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.RSGui; +import com.raoulvdberge.refinedstorage.api.network.readerwriter.IWriter; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeWriter; import com.raoulvdberge.refinedstorage.tile.TileWriter; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; @@ -32,7 +34,7 @@ public class BlockWriter extends BlockCable { } if (!world.isRemote && tryOpenNetworkGui(RSGui.READER_WRITER, player, world, pos, side)) { - ((TileWriter) world.getTileEntity(pos)).onOpened(player); + ((NetworkNodeWriter) ((TileWriter) world.getTileEntity(pos)).getNode()).onOpened(player); } return true; @@ -46,7 +48,7 @@ public class BlockWriter extends BlockCable { @Override @SuppressWarnings("deprecation") public int getWeakPower(IBlockState state, IBlockAccess world, BlockPos pos, EnumFacing side) { - TileWriter writer = (TileWriter) world.getTileEntity(pos); + IWriter writer = (IWriter) ((TileWriter) world.getTileEntity(pos)).getNode(); return side == writer.getDirection().getOpposite() ? writer.getRedstoneStrength() : 0; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerConstructor.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerConstructor.java index d29a2372c..c4f04625b 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerConstructor.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerConstructor.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeConstructor; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileConstructor; import net.minecraft.entity.player.EntityPlayer; @@ -12,10 +13,10 @@ public class ContainerConstructor extends ContainerBase { super(constructor, player); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(constructor.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeConstructor) constructor.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } - addSlotToContainer(new SlotFilterType(constructor, 0, 80, 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeConstructor) constructor.getNode(), 0, 80, 20)); addPlayerInventory(8, 55); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCrafter.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCrafter.java index 32bf796f0..f72569b5a 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCrafter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCrafter.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCrafter; import com.raoulvdberge.refinedstorage.tile.TileCrafter; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Slot; @@ -11,11 +12,11 @@ public class ContainerCrafter extends ContainerBase { super(crafter, player); for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotItemHandler(crafter.getPatternItems(), i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeCrafter) crafter.getNode()).getPatternItems(), i, 8 + (18 * i), 20)); } for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(crafter.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeCrafter) crafter.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } addPlayerInventory(8, 55); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDestructor.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDestructor.java index a3216351a..06fd47fa5 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDestructor.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDestructor.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDestructor; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileDestructor; import net.minecraft.entity.player.EntityPlayer; @@ -12,11 +13,11 @@ public class ContainerDestructor extends ContainerBase { super(destructor, player); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(destructor.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeDestructor) destructor.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterType(destructor, i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeDestructor) destructor.getNode(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 55); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDetector.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDetector.java index efd16ddf6..0bd6c1bea 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDetector.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDetector.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDetector; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileDetector; import net.minecraft.entity.player.EntityPlayer; @@ -10,7 +11,7 @@ public class ContainerDetector extends ContainerBase { public ContainerDetector(TileDetector detector, EntityPlayer player) { super(detector, player); - addSlotToContainer(new SlotFilterType(detector, 0, 107, 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeDetector) detector.getNode(), 0, 107, 20)); addPlayerInventory(8, 55); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskDrive.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskDrive.java index a9bffda27..21d3e1143 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskDrive.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskDrive.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskDrive; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileDiskDrive; import net.minecraft.entity.player.EntityPlayer; @@ -15,11 +16,11 @@ public class ContainerDiskDrive extends ContainerBase { int y = 54; for (int i = 0; i < 8; ++i) { - addSlotToContainer(new SlotItemHandler(drive.getDisks(), i, x + ((i % 2) * 18), y + Math.floorDiv(i, 2) * 18)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeDiskDrive) drive.getNode()).getDisks(), i, x + ((i % 2) * 18), y + Math.floorDiv(i, 2) * 18)); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterType(drive, i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeDiskDrive) drive.getNode(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 141); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskManipulator.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskManipulator.java index 7c28f470b..8084b0d0f 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskManipulator.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskManipulator.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskManipulator; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator; import net.minecraft.entity.player.EntityPlayer; @@ -12,19 +13,19 @@ public class ContainerDiskManipulator extends ContainerBase { super(manipulator, player); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(manipulator.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeDiskManipulator) manipulator.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } for (int i = 0; i < 3; ++i) { - addSlotToContainer(new SlotItemHandler(manipulator.getInputDisks(), i, 44, 57 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeDiskManipulator) manipulator.getNode()).getInputDisks(), i, 44, 57 + (i * 18))); } for (int i = 0; i < 3; ++i) { - addSlotToContainer(new SlotItemHandler(manipulator.getOutputDisks(), i, 116, 57 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeDiskManipulator) manipulator.getNode()).getOutputDisks(), i, 116, 57 + (i * 18))); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterType(manipulator, i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeDiskManipulator) manipulator.getNode(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 129); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExporter.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExporter.java index 5ee9468c0..2553b16ff 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExporter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExporter.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeExporter; import com.raoulvdberge.refinedstorage.container.slot.SlotFilter; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileExporter; @@ -24,11 +25,11 @@ public class ContainerExporter extends ContainerBase { this.inventoryItemStacks.clear(); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(exporter.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeExporter) exporter.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterType(exporter, i, 8 + (18 * i), 20, exporter.isRegulator() ? SlotFilter.FILTER_ALLOW_SIZE : 0)); + addSlotToContainer(new SlotFilterType((NetworkNodeExporter) exporter.getNode(), i, 8 + (18 * i), 20, ((NetworkNodeExporter) exporter.getNode()).isRegulator() ? SlotFilter.FILTER_ALLOW_SIZE : 0)); } addPlayerInventory(8, 55); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExternalStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExternalStorage.java index ff5beaa1b..388e7f447 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExternalStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExternalStorage.java @@ -1,7 +1,8 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.NetworkNodeExternalStorage; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; -import com.raoulvdberge.refinedstorage.tile.externalstorage.TileExternalStorage; +import com.raoulvdberge.refinedstorage.tile.TileExternalStorage; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Slot; import net.minecraft.item.ItemStack; @@ -11,7 +12,7 @@ public class ContainerExternalStorage extends ContainerBase { super(tile, player); for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterType(tile, i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeExternalStorage) tile.getNode(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 141); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidInterface.java index a2a8d45a5..7f099abd4 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidInterface.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidInterface.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidInterface; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterFluid; import com.raoulvdberge.refinedstorage.tile.TileFluidInterface; import net.minecraft.entity.player.EntityPlayer; @@ -12,11 +13,11 @@ public class ContainerFluidInterface extends ContainerBase { super(fluidInterface, player); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(fluidInterface.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeFluidInterface) fluidInterface.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } - addSlotToContainer(new SlotItemHandler(fluidInterface.getIn(), 0, 44, 32)); - addSlotToContainer(new SlotFilterFluid(!fluidInterface.getWorld().isRemote, fluidInterface.getOut(), 0, 116, 32)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeFluidInterface) fluidInterface.getNode()).getIn(), 0, 44, 32)); + addSlotToContainer(new SlotFilterFluid(!fluidInterface.getWorld().isRemote, ((NetworkNodeFluidInterface) fluidInterface.getNode()).getOut(), 0, 116, 32)); addPlayerInventory(8, 122); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidStorage.java index afd40fed9..013654ac5 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidStorage.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidStorage; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterFluid; import com.raoulvdberge.refinedstorage.tile.TileFluidStorage; import net.minecraft.entity.player.EntityPlayer; @@ -11,7 +12,7 @@ public class ContainerFluidStorage extends ContainerBase { super(tile, player); for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterFluid(!tile.getWorld().isRemote, tile.getFilters(), i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilterFluid(!tile.getWorld().isRemote, ((NetworkNodeFluidStorage) tile.getNode()).getFilters(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 141); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java index f24cf31cc..dd56f12e3 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java @@ -1,6 +1,7 @@ package com.raoulvdberge.refinedstorage.container; import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.block.EnumGridType; import com.raoulvdberge.refinedstorage.container.slot.*; import com.raoulvdberge.refinedstorage.gui.grid.IGridDisplay; @@ -42,12 +43,13 @@ public class ContainerGrid extends ContainerBase { addPlayerInventory(8, display.getYPlayerInventory()); + // @todo: move crafting logic to IGrid.. if (grid.getType() == EnumGridType.CRAFTING) { int x = 26; int y = headerAndSlots + 4; for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotGridCrafting(((TileGrid) grid).getMatrix(), i, x, y)); + addSlotToContainer(new SlotGridCrafting(((NetworkNodeGrid) ((TileGrid) grid).getNode()).getMatrix(), i, x, y)); x += 18; @@ -63,7 +65,7 @@ public class ContainerGrid extends ContainerBase { int y = headerAndSlots + 4; for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterLegacy(((TileGrid) grid).getMatrix(), i, x, y)); + addSlotToContainer(new SlotFilterLegacy(((NetworkNodeGrid) ((TileGrid) grid).getNode()).getMatrix(), i, x, y)); x += 18; @@ -73,10 +75,10 @@ public class ContainerGrid extends ContainerBase { } } - addSlotToContainer(patternResultSlot = new SlotDisabled(((TileGrid) grid).getResult(), 0, 112 + 4, headerAndSlots + 22)); + addSlotToContainer(patternResultSlot = new SlotDisabled(((NetworkNodeGrid) ((TileGrid) grid).getNode()).getResult(), 0, 112 + 4, headerAndSlots + 22)); - addSlotToContainer(new SlotItemHandler(((TileGrid) grid).getPatterns(), 0, 152, headerAndSlots + 4)); - addSlotToContainer(new SlotOutput(((TileGrid) grid).getPatterns(), 1, 152, headerAndSlots + 40)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeGrid) ((TileGrid) grid).getNode()).getPatterns(), 0, 152, headerAndSlots + 4)); + addSlotToContainer(new SlotOutput(((NetworkNodeGrid) ((TileGrid) grid).getNode()).getPatterns(), 1, 152, headerAndSlots + 40)); } if (grid.getType() != EnumGridType.FLUID) { @@ -127,7 +129,7 @@ public class ContainerGrid extends ContainerBase { if (slot.getHasStack()) { if (slot == craftingResultSlot) { - ((TileGrid) grid).onCraftedShift(this, player); + ((NetworkNodeGrid) ((TileGrid) grid).getNode()).onCraftedShift(this, player); } else if (slot != patternResultSlot && !(slot instanceof SlotFilterLegacy)) { if (grid.getType() != EnumGridType.FLUID && grid.getItemHandler() != null) { slot.putStack(RSUtils.getStack(grid.getItemHandler().onInsert((EntityPlayerMP) player, slot.getStack()))); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerImporter.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerImporter.java index 2b4829254..d871b785d 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerImporter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerImporter.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeImporter; import com.raoulvdberge.refinedstorage.container.slot.SlotFilterType; import com.raoulvdberge.refinedstorage.tile.TileImporter; import net.minecraft.entity.player.EntityPlayer; @@ -12,11 +13,11 @@ public class ContainerImporter extends ContainerBase { super(importer, player); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(importer.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeImporter) importer.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilterType(importer, i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilterType((NetworkNodeImporter) importer.getNode(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 55); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerInterface.java index 3be521156..f3070d709 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerInterface.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerInterface.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeInterface; import com.raoulvdberge.refinedstorage.container.slot.SlotFilter; import com.raoulvdberge.refinedstorage.container.slot.SlotOutput; import com.raoulvdberge.refinedstorage.tile.TileInterface; @@ -13,19 +14,19 @@ public class ContainerInterface extends ContainerBase { super(tile, player); for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotItemHandler(tile.getImportItems(), i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeInterface) tile.getNode()).getImportItems(), i, 8 + (18 * i), 20)); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilter(tile.getExportSpecimenItems(), i, 8 + (18 * i), 54, SlotFilter.FILTER_ALLOW_SIZE)); + addSlotToContainer(new SlotFilter(((NetworkNodeInterface) tile.getNode()).getExportSpecimenItems(), i, 8 + (18 * i), 54, SlotFilter.FILTER_ALLOW_SIZE)); } for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotOutput(tile.getExportItems(), i, 8 + (18 * i), 100)); + addSlotToContainer(new SlotOutput(((NetworkNodeInterface) tile.getNode()).getExportItems(), i, 8 + (18 * i), 100)); } for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(tile.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeInterface) tile.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } addPlayerInventory(8, 134); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerNetworkTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerNetworkTransmitter.java index 16ed0bead..9cc219e4d 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerNetworkTransmitter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerNetworkTransmitter.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeNetworkTransmitter; import com.raoulvdberge.refinedstorage.tile.TileNetworkTransmitter; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Slot; @@ -10,9 +11,9 @@ public class ContainerNetworkTransmitter extends ContainerBase { public ContainerNetworkTransmitter(TileNetworkTransmitter networkTransmitter, EntityPlayer player) { super(networkTransmitter, player); - addSlotToContainer(new SlotItemHandler(networkTransmitter.getNetworkCard(), 0, 8, 20)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeNetworkTransmitter) networkTransmitter.getNode()).getNetworkCard(), 0, 8, 20)); - addSlotToContainer(new SlotItemHandler(networkTransmitter.getUpgrades(), 0, 187, 6)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeNetworkTransmitter) networkTransmitter.getNode()).getUpgrades(), 0, 187, 6)); addPlayerInventory(8, 55); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSecurityManager.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSecurityManager.java index 3aa4a9be4..62308b3eb 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSecurityManager.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSecurityManager.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSecurityManager; import com.raoulvdberge.refinedstorage.tile.TileSecurityManager; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Slot; @@ -14,7 +15,7 @@ public class ContainerSecurityManager extends ContainerBase { int y = 20; for (int i = 0; i < 9 * 2; ++i) { - addSlotToContainer(new SlotItemHandler(tile.getCardsItems(), i, x, y)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeSecurityManager) tile.getNode()).getCardsItems(), i, x, y)); if (((i + 1) % 9) == 0) { x = 8; @@ -24,7 +25,7 @@ public class ContainerSecurityManager extends ContainerBase { } } - addSlotToContainer(new SlotItemHandler(tile.getEditCard(), 0, 80, 70)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeSecurityManager) tile.getNode()).getEditCard(), 0, 80, 70)); addPlayerInventory(8, 152); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSolderer.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSolderer.java index 81f34eeaa..199412fdc 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSolderer.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerSolderer.java @@ -1,6 +1,7 @@ package com.raoulvdberge.refinedstorage.container; import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSolderer; import com.raoulvdberge.refinedstorage.container.slot.SlotOutput; import com.raoulvdberge.refinedstorage.tile.TileSolderer; import net.minecraft.entity.player.EntityPlayer; @@ -16,15 +17,15 @@ public class ContainerSolderer extends ContainerBase { int y = 20; for (int i = 0; i < 3; ++i) { - addSlotToContainer(new SlotItemHandler(solderer.getItems(), i, x, y)); + addSlotToContainer(new SlotItemHandler(((NetworkNodeSolderer) solderer.getNode()).getItems(), i, x, y)); y += 18; } - addSlotToContainer(new SlotOutput(solderer.getResult(), 0, 127, 38)); + addSlotToContainer(new SlotOutput(((NetworkNodeSolderer) solderer.getNode()).getResult(), 0, 127, 38)); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(solderer.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeSolderer) solderer.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } addPlayerInventory(8, 89); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorage.java index 98ca7c389..34fe5c329 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorage.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorage; import com.raoulvdberge.refinedstorage.container.slot.SlotFilter; import com.raoulvdberge.refinedstorage.tile.TileStorage; import net.minecraft.entity.player.EntityPlayer; @@ -11,7 +12,7 @@ public class ContainerStorage extends ContainerBase { super(tile, player); for (int i = 0; i < 9; ++i) { - addSlotToContainer(new SlotFilter(tile.getFilters(), i, 8 + (18 * i), 20)); + addSlotToContainer(new SlotFilter(((NetworkNodeStorage) tile.getNode()).getFilters(), i, 8 + (18 * i), 20)); } addPlayerInventory(8, 141); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerWirelessTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerWirelessTransmitter.java index fbe7b3126..6070ee88c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerWirelessTransmitter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/ContainerWirelessTransmitter.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeWirelessTransmitter; import com.raoulvdberge.refinedstorage.tile.TileWirelessTransmitter; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Slot; @@ -11,7 +12,7 @@ public class ContainerWirelessTransmitter extends ContainerBase { super(wirelessTransmitter, player); for (int i = 0; i < 4; ++i) { - addSlotToContainer(new SlotItemHandler(wirelessTransmitter.getUpgrades(), i, 187, 6 + (i * 18))); + addSlotToContainer(new SlotItemHandler(((NetworkNodeWirelessTransmitter) wirelessTransmitter.getNode()).getUpgrades(), i, 187, 6 + (i * 18))); } addPlayerInventory(8, 55); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCraftingResult.java b/src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCraftingResult.java index 6e60cd96f..493c0c461 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCraftingResult.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCraftingResult.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.container.slot; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.container.ContainerGrid; import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.entity.player.EntityPlayer; @@ -14,7 +15,7 @@ public class SlotGridCraftingResult extends SlotCrafting { private TileGrid grid; public SlotGridCraftingResult(ContainerGrid container, EntityPlayer player, TileGrid grid, int id, int x, int y) { - super(player, grid.getMatrix(), grid.getResult(), id, x, y); + super(player, ((NetworkNodeGrid) grid.getNode()).getMatrix(), ((NetworkNodeGrid) grid.getNode()).getResult(), id, x, y); this.container = container; this.grid = grid; @@ -23,12 +24,12 @@ public class SlotGridCraftingResult extends SlotCrafting { @Override @Nonnull public ItemStack onTake(EntityPlayer player, @Nonnull ItemStack stack) { - FMLCommonHandler.instance().firePlayerCraftingEvent(player, stack, grid.getMatrix()); + FMLCommonHandler.instance().firePlayerCraftingEvent(player, stack, ((NetworkNodeGrid) grid.getNode()).getMatrix()); onCrafting(stack); if (!player.getEntityWorld().isRemote) { - grid.onCrafted(player); + ((NetworkNodeGrid) grid.getNode()).onCrafted(player); container.sendCraftingSlots(); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiFluidInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiFluidInterface.java index a745c8e3d..42aeb036b 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiFluidInterface.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiFluidInterface.java @@ -2,13 +2,14 @@ package com.raoulvdberge.refinedstorage.gui; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidInterface; import com.raoulvdberge.refinedstorage.container.ContainerFluidInterface; import com.raoulvdberge.refinedstorage.gui.sidebutton.SideButtonCompare; import com.raoulvdberge.refinedstorage.gui.sidebutton.SideButtonRedstoneMode; import com.raoulvdberge.refinedstorage.tile.TileFluidInterface; public class GuiFluidInterface extends GuiBase { - private static final RSUtils.FluidRenderer TANK_RENDERER = new RSUtils.FluidRenderer(TileFluidInterface.TANK_CAPACITY, 12, 47); + private static final RSUtils.FluidRenderer TANK_RENDERER = new RSUtils.FluidRenderer(NetworkNodeFluidInterface.TANK_CAPACITY, 12, 47); public GuiFluidInterface(ContainerFluidInterface container) { super(container, 211, 204); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiHandler.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiHandler.java index 0b0c56499..8cc39fc5f 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiHandler.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiHandler.java @@ -3,13 +3,17 @@ package com.raoulvdberge.refinedstorage.gui; import com.raoulvdberge.refinedstorage.RSGui; import com.raoulvdberge.refinedstorage.apiimpl.network.item.NetworkItemWirelessFluidGrid; import com.raoulvdberge.refinedstorage.apiimpl.network.item.NetworkItemWirelessGrid; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCraftingMonitor; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidStorage; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorage; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.NetworkNodeExternalStorage; import com.raoulvdberge.refinedstorage.container.*; import com.raoulvdberge.refinedstorage.gui.grid.GridDisplayDummy; import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid; import com.raoulvdberge.refinedstorage.tile.*; import com.raoulvdberge.refinedstorage.tile.craftingmonitor.TileCraftingMonitor; import com.raoulvdberge.refinedstorage.tile.craftingmonitor.WirelessCraftingMonitor; -import com.raoulvdberge.refinedstorage.tile.externalstorage.TileExternalStorage; import com.raoulvdberge.refinedstorage.tile.grid.IGrid; import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import com.raoulvdberge.refinedstorage.tile.grid.WirelessFluidGrid; @@ -29,7 +33,7 @@ public class GuiHandler implements IGuiHandler { case RSGui.CONTROLLER: return new ContainerController((TileController) tile, player); case RSGui.GRID: - return new ContainerGrid((TileGrid) tile, new GridDisplayDummy(), player); + return new ContainerGrid((NetworkNodeGrid) ((TileGrid) tile).getNode(), new GridDisplayDummy(), player); case RSGui.DISK_DRIVE: return new ContainerDiskDrive((TileDiskDrive) tile, player); case RSGui.IMPORTER: @@ -53,7 +57,7 @@ public class GuiHandler implements IGuiHandler { case RSGui.INTERFACE: return new ContainerInterface((TileInterface) tile, player); case RSGui.CRAFTING_MONITOR: - return new ContainerCraftingMonitor((TileCraftingMonitor) tile, player); + return new ContainerCraftingMonitor((NetworkNodeCraftingMonitor) ((TileCraftingMonitor) tile).getNode(), player); case RSGui.WIRELESS_TRANSMITTER: return new ContainerWirelessTransmitter((TileWirelessTransmitter) tile, player); case RSGui.CRAFTER: @@ -98,8 +102,9 @@ public class GuiHandler implements IGuiHandler { case RSGui.CONTROLLER: return new GuiController((ContainerController) getContainer(ID, player, tile), (TileController) tile); case RSGui.GRID: - GuiGrid gui = new GuiGrid(null, (TileGrid) tile); - gui.inventorySlots = new ContainerGrid((TileGrid) tile, gui, player); + IGrid grid = (NetworkNodeGrid) ((TileGrid) tile).getNode(); + GuiGrid gui = new GuiGrid(null, grid); + gui.inventorySlots = new ContainerGrid(grid, gui, player); return gui; case RSGui.WIRELESS_GRID: return getWirelessGridGui(player, x, y, z); @@ -118,15 +123,15 @@ public class GuiHandler implements IGuiHandler { case RSGui.CONSTRUCTOR: return new GuiConstructor((ContainerConstructor) getContainer(ID, player, tile)); case RSGui.STORAGE: - return new GuiStorage((ContainerStorage) getContainer(ID, player, tile), (TileStorage) tile); + return new GuiStorage((ContainerStorage) getContainer(ID, player, tile), (NetworkNodeStorage) ((TileStorage) tile).getNode()); case RSGui.EXTERNAL_STORAGE: - return new GuiStorage((ContainerExternalStorage) getContainer(ID, player, tile), (TileExternalStorage) tile); + return new GuiStorage((ContainerExternalStorage) getContainer(ID, player, tile), (NetworkNodeExternalStorage) ((TileExternalStorage) tile).getNode()); case RSGui.RELAY: return new GuiRelay((ContainerRelay) getContainer(ID, player, tile)); case RSGui.INTERFACE: return new GuiInterface((ContainerInterface) getContainer(ID, player, tile)); case RSGui.CRAFTING_MONITOR: - return new GuiCraftingMonitor((ContainerCraftingMonitor) getContainer(ID, player, tile), (TileCraftingMonitor) tile); + return new GuiCraftingMonitor((ContainerCraftingMonitor) getContainer(ID, player, tile), (NetworkNodeCraftingMonitor) ((TileCraftingMonitor) tile).getNode()); case RSGui.WIRELESS_TRANSMITTER: return new GuiWirelessTransmitter((ContainerWirelessTransmitter) getContainer(ID, player, tile)); case RSGui.CRAFTER: @@ -140,7 +145,7 @@ public class GuiHandler implements IGuiHandler { case RSGui.FLUID_INTERFACE: return new GuiFluidInterface((ContainerFluidInterface) getContainer(ID, player, tile)); case RSGui.FLUID_STORAGE: - return new GuiStorage((ContainerFluidStorage) getContainer(ID, player, tile), (TileFluidStorage) tile); + return new GuiStorage((ContainerFluidStorage) getContainer(ID, player, tile), (NetworkNodeFluidStorage) ((TileFluidStorage) tile).getNode()); case RSGui.DISK_MANIPULATOR: return new GuiDiskManipulator((ContainerDiskManipulator) getContainer(ID, player, tile)); case RSGui.WIRELESS_CRAFTING_MONITOR: diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiNetworkTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiNetworkTransmitter.java index 934cedebf..b867e7635 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiNetworkTransmitter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiNetworkTransmitter.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.gui; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeNetworkTransmitter; import com.raoulvdberge.refinedstorage.container.ContainerNetworkTransmitter; import com.raoulvdberge.refinedstorage.gui.sidebutton.SideButtonRedstoneMode; import com.raoulvdberge.refinedstorage.tile.TileNetworkTransmitter; @@ -35,7 +36,7 @@ public class GuiNetworkTransmitter extends GuiBase { String distance; - if (networkTransmitter.getNetworkCard().getStackInSlot(0).isEmpty()) { + if (((NetworkNodeNetworkTransmitter) networkTransmitter.getNode()).getNetworkCard().getStackInSlot(0).isEmpty()) { distance = t("gui.refinedstorage:network_transmitter.missing_card"); } else if (!TileNetworkTransmitter.RECEIVER_DIMENSION_SUPPORTED.getValue()) { distance = t("gui.refinedstorage:network_transmitter.missing_upgrade"); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiReaderWriter.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiReaderWriter.java index 372d8698a..1829e282e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiReaderWriter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiReaderWriter.java @@ -193,6 +193,6 @@ public class GuiReaderWriter extends GuiBase { } private List getChannels() { - return readerWriter.isActive() ? CHANNELS : Collections.emptyList(); + return readerWriter.canUpdate() ? CHANNELS : Collections.emptyList(); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiSecurityManager.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiSecurityManager.java index dc5cb2f54..daf5b9076 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiSecurityManager.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/GuiSecurityManager.java @@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.gui; import com.raoulvdberge.refinedstorage.RS; import com.raoulvdberge.refinedstorage.api.network.security.Permission; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSecurityManager; import com.raoulvdberge.refinedstorage.container.ContainerSecurityManager; import com.raoulvdberge.refinedstorage.gui.sidebutton.SideButtonRedstoneMode; import com.raoulvdberge.refinedstorage.item.ItemSecurityCard; @@ -40,7 +41,7 @@ public class GuiSecurityManager extends GuiBase { @Override public void update(int x, int y) { - ItemStack card = securityManager.getEditCard().getStackInSlot(0); + ItemStack card = ((NetworkNodeSecurityManager) securityManager.getNode()).getEditCard().getStackInSlot(0); for (Permission permission : Permission.values()) { permissions[permission.getId()].setIsChecked(!card.isEmpty() && ItemSecurityCard.hasPermission(card, permission)); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/GuiGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/GuiGrid.java index 4b7830b61..fa097cce0 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/GuiGrid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/GuiGrid.java @@ -5,6 +5,7 @@ import com.google.common.collect.ListMultimap; import com.google.common.collect.Multimaps; import com.raoulvdberge.refinedstorage.RS; import com.raoulvdberge.refinedstorage.api.network.grid.IItemGridHandler; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.block.EnumGridType; import com.raoulvdberge.refinedstorage.container.ContainerGrid; import com.raoulvdberge.refinedstorage.gui.GuiBase; @@ -187,7 +188,7 @@ public class GuiGrid extends GuiBase implements IGridDisplay { Collections.sort(stacks, SORTING_NAME); - if (grid.getSortingType() == TileGrid.SORTING_TYPE_QUANTITY) { + if (grid.getSortingType() == NetworkNodeGrid.SORTING_TYPE_QUANTITY) { Collections.sort(stacks, SORTING_QUANTITY); } } @@ -289,7 +290,7 @@ public class GuiGrid extends GuiBase implements IGridDisplay { } private boolean isOverCreatePattern(int mouseX, int mouseY) { - return grid.getType() == EnumGridType.PATTERN && inBounds(152, getTabDelta() + getHeader() + (getVisibleRows() * 18) + 22, 16, 16, mouseX, mouseY) && ((TileGrid) grid).canCreatePattern(); + return grid.getType() == EnumGridType.PATTERN && inBounds(152, getTabDelta() + getHeader() + (getVisibleRows() * 18) + 22, 16, 16, mouseX, mouseY) && ((NetworkNodeGrid) ((TileGrid) grid).getNode()).canCreatePattern(); } private int getTabDelta() { @@ -389,7 +390,7 @@ public class GuiGrid extends GuiBase implements IGridDisplay { ty = 1; } - if (!((TileGrid) grid).canCreatePattern()) { + if (!((NetworkNodeGrid) ((TileGrid) grid).getNode()).canCreatePattern()) { ty = 2; } @@ -564,15 +565,15 @@ public class GuiGrid extends GuiBase implements IGridDisplay { } private void updateJEI() { - if (IntegrationJEI.isLoaded() && (grid.getSearchBoxMode() == TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED || grid.getSearchBoxMode() == TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED)) { + if (IntegrationJEI.isLoaded() && (grid.getSearchBoxMode() == NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED || grid.getSearchBoxMode() == NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED)) { RSJEIPlugin.INSTANCE.getRuntime().getItemListOverlay().setFilterText(searchField.getText()); } } public void updateSearchFieldFocus(int mode) { if (searchField != null) { - searchField.setCanLoseFocus(!TileGrid.isSearchBoxModeWithAutoselection(mode)); - searchField.setFocused(TileGrid.isSearchBoxModeWithAutoselection(mode)); + searchField.setCanLoseFocus(!NetworkNodeGrid.isSearchBoxModeWithAutoselection(mode)); + searchField.setFocused(NetworkNodeGrid.isSearchBoxModeWithAutoselection(mode)); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/filtering/GridFilterParser.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/filtering/GridFilterParser.java index f8233a750..7a39a2933 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/filtering/GridFilterParser.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/filtering/GridFilterParser.java @@ -1,9 +1,9 @@ package com.raoulvdberge.refinedstorage.gui.grid.filtering; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.grid.GridFilter; import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack; import com.raoulvdberge.refinedstorage.tile.grid.IGrid; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import java.util.LinkedList; import java.util.List; @@ -23,9 +23,9 @@ public class GridFilterParser { } } - if (grid.getViewType() == TileGrid.VIEW_TYPE_NON_CRAFTABLES) { + if (grid.getViewType() == NetworkNodeGrid.VIEW_TYPE_NON_CRAFTABLES) { filters.add(new GridFilterCraftable(false)); - } else if (grid.getViewType() == TileGrid.VIEW_TYPE_CRAFTABLES) { + } else if (grid.getViewType() == NetworkNodeGrid.VIEW_TYPE_CRAFTABLES) { filters.add(new GridFilterCraftable(true)); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingName.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingName.java index 5609d353d..8f2694cd1 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingName.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingName.java @@ -1,7 +1,7 @@ package com.raoulvdberge.refinedstorage.gui.grid.sorting; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; public class GridSortingName extends GridSorting { @Override @@ -9,9 +9,9 @@ public class GridSortingName extends GridSorting { String leftName = left.getName(); String rightName = right.getName(); - if (sortingDirection == TileGrid.SORTING_DIRECTION_ASCENDING) { + if (sortingDirection == NetworkNodeGrid.SORTING_DIRECTION_ASCENDING) { return leftName.compareTo(rightName); - } else if (sortingDirection == TileGrid.SORTING_DIRECTION_DESCENDING) { + } else if (sortingDirection == NetworkNodeGrid.SORTING_DIRECTION_DESCENDING) { return rightName.compareTo(leftName); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingQuantity.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingQuantity.java index e6336779e..da5e800d7 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingQuantity.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/grid/sorting/GridSortingQuantity.java @@ -1,7 +1,7 @@ package com.raoulvdberge.refinedstorage.gui.grid.sorting; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; public class GridSortingQuantity extends GridSorting { @Override @@ -10,9 +10,9 @@ public class GridSortingQuantity extends GridSorting { int rightSize = right.getQuantity(); if (leftSize != rightSize) { - if (sortingDirection == TileGrid.SORTING_DIRECTION_ASCENDING) { + if (sortingDirection == NetworkNodeGrid.SORTING_DIRECTION_ASCENDING) { return (leftSize > rightSize) ? 1 : -1; - } else if (sortingDirection == TileGrid.SORTING_DIRECTION_DESCENDING) { + } else if (sortingDirection == NetworkNodeGrid.SORTING_DIRECTION_DESCENDING) { return (rightSize > leftSize) ? 1 : -1; } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonDetectorMode.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonDetectorMode.java index eb8c7c609..369c128d7 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonDetectorMode.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonDetectorMode.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.gui.sidebutton; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDetector; import com.raoulvdberge.refinedstorage.gui.GuiBase; import com.raoulvdberge.refinedstorage.tile.TileDetector; import com.raoulvdberge.refinedstorage.tile.data.TileDataManager; @@ -24,14 +25,14 @@ public class SideButtonDetectorMode extends SideButton { public void actionPerformed() { int mode = TileDetector.MODE.getValue(); - if (mode == TileDetector.MODE_EQUAL) { - mode = TileDetector.MODE_ABOVE; - } else if (mode == TileDetector.MODE_ABOVE) { - mode = TileDetector.MODE_UNDER; - } else if (mode == TileDetector.MODE_UNDER) { - mode = TileDetector.MODE_AUTOCRAFTING; - } else if (mode == TileDetector.MODE_AUTOCRAFTING) { - mode = TileDetector.MODE_EQUAL; + if (mode == NetworkNodeDetector.MODE_EQUAL) { + mode = NetworkNodeDetector.MODE_ABOVE; + } else if (mode == NetworkNodeDetector.MODE_ABOVE) { + mode = NetworkNodeDetector.MODE_UNDER; + } else if (mode == NetworkNodeDetector.MODE_UNDER) { + mode = NetworkNodeDetector.MODE_AUTOCRAFTING; + } else if (mode == NetworkNodeDetector.MODE_AUTOCRAFTING) { + mode = NetworkNodeDetector.MODE_EQUAL; } TileDataManager.setParameter(TileDetector.MODE, mode); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSearchBoxMode.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSearchBoxMode.java index 3c136c5c5..669adfdfe 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSearchBoxMode.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSearchBoxMode.java @@ -1,9 +1,9 @@ package com.raoulvdberge.refinedstorage.gui.sidebutton; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.GuiBase; import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid; import com.raoulvdberge.refinedstorage.integration.jei.IntegrationJEI; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.util.text.TextFormatting; public class SideButtonGridSearchBoxMode extends SideButton { @@ -20,25 +20,25 @@ public class SideButtonGridSearchBoxMode extends SideButton { protected void drawButtonIcon(int x, int y) { int mode = ((GuiGrid) gui).getGrid().getSearchBoxMode(); - gui.drawTexture(x, y, mode == TileGrid.SEARCH_BOX_MODE_NORMAL_AUTOSELECTED || mode == TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED ? 16 : 0, 96, 16, 16); + gui.drawTexture(x, y, mode == NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL_AUTOSELECTED || mode == NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED ? 16 : 0, 96, 16, 16); } @Override public void actionPerformed() { int mode = ((GuiGrid) gui).getGrid().getSearchBoxMode(); - if (mode == TileGrid.SEARCH_BOX_MODE_NORMAL) { - mode = TileGrid.SEARCH_BOX_MODE_NORMAL_AUTOSELECTED; - } else if (mode == TileGrid.SEARCH_BOX_MODE_NORMAL_AUTOSELECTED) { + if (mode == NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL) { + mode = NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL_AUTOSELECTED; + } else if (mode == NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL_AUTOSELECTED) { if (IntegrationJEI.isLoaded()) { - mode = TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED; + mode = NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED; } else { - mode = TileGrid.SEARCH_BOX_MODE_NORMAL; + mode = NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL; } - } else if (mode == TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED) { - mode = TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED; - } else if (mode == TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED) { - mode = TileGrid.SEARCH_BOX_MODE_NORMAL; + } else if (mode == NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED) { + mode = NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED; + } else if (mode == NetworkNodeGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED) { + mode = NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL; } ((GuiGrid) gui).getGrid().onSearchBoxModeChanged(mode); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingDirection.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingDirection.java index 76d51d2dc..5f2a4533f 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingDirection.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingDirection.java @@ -1,8 +1,8 @@ package com.raoulvdberge.refinedstorage.gui.sidebutton; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.GuiBase; import com.raoulvdberge.refinedstorage.tile.grid.IGrid; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.util.text.TextFormatting; public class SideButtonGridSortingDirection extends SideButton { @@ -28,10 +28,10 @@ public class SideButtonGridSortingDirection extends SideButton { public void actionPerformed() { int dir = grid.getSortingDirection(); - if (dir == TileGrid.SORTING_DIRECTION_ASCENDING) { - dir = TileGrid.SORTING_DIRECTION_DESCENDING; - } else if (dir == TileGrid.SORTING_DIRECTION_DESCENDING) { - dir = TileGrid.SORTING_DIRECTION_ASCENDING; + if (dir == NetworkNodeGrid.SORTING_DIRECTION_ASCENDING) { + dir = NetworkNodeGrid.SORTING_DIRECTION_DESCENDING; + } else if (dir == NetworkNodeGrid.SORTING_DIRECTION_DESCENDING) { + dir = NetworkNodeGrid.SORTING_DIRECTION_ASCENDING; } grid.onSortingDirectionChanged(dir); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingType.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingType.java index 5979bffb7..24ad26234 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingType.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridSortingType.java @@ -1,8 +1,8 @@ package com.raoulvdberge.refinedstorage.gui.sidebutton; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.GuiBase; import com.raoulvdberge.refinedstorage.tile.grid.IGrid; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.util.text.TextFormatting; public class SideButtonGridSortingType extends SideButton { @@ -28,10 +28,10 @@ public class SideButtonGridSortingType extends SideButton { public void actionPerformed() { int type = grid.getSortingType(); - if (type == TileGrid.SORTING_TYPE_QUANTITY) { - type = TileGrid.SORTING_TYPE_NAME; - } else if (type == TileGrid.SORTING_TYPE_NAME) { - type = TileGrid.SORTING_TYPE_QUANTITY; + if (type == NetworkNodeGrid.SORTING_TYPE_QUANTITY) { + type = NetworkNodeGrid.SORTING_TYPE_NAME; + } else if (type == NetworkNodeGrid.SORTING_TYPE_NAME) { + type = NetworkNodeGrid.SORTING_TYPE_QUANTITY; } grid.onSortingTypeChanged(type); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridViewType.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridViewType.java index ef5e09e40..216ea4993 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridViewType.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonGridViewType.java @@ -1,8 +1,8 @@ package com.raoulvdberge.refinedstorage.gui.sidebutton; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.GuiBase; import com.raoulvdberge.refinedstorage.tile.grid.IGrid; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.util.text.TextFormatting; public class SideButtonGridViewType extends SideButton { @@ -28,12 +28,12 @@ public class SideButtonGridViewType extends SideButton { public void actionPerformed() { int type = grid.getViewType(); - if (type == TileGrid.VIEW_TYPE_NORMAL) { - type = TileGrid.VIEW_TYPE_NON_CRAFTABLES; - } else if (type == TileGrid.VIEW_TYPE_NON_CRAFTABLES) { - type = TileGrid.VIEW_TYPE_CRAFTABLES; - } else if (type == TileGrid.VIEW_TYPE_CRAFTABLES) { - type = TileGrid.VIEW_TYPE_NORMAL; + if (type == NetworkNodeGrid.VIEW_TYPE_NORMAL) { + type = NetworkNodeGrid.VIEW_TYPE_NON_CRAFTABLES; + } else if (type == NetworkNodeGrid.VIEW_TYPE_NON_CRAFTABLES) { + type = NetworkNodeGrid.VIEW_TYPE_CRAFTABLES; + } else if (type == NetworkNodeGrid.VIEW_TYPE_CRAFTABLES) { + type = NetworkNodeGrid.VIEW_TYPE_NORMAL; } grid.onViewTypeChanged(type); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonIOMode.java b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonIOMode.java index 199db81ce..ce6352191 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonIOMode.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonIOMode.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.gui.sidebutton; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskManipulator; import com.raoulvdberge.refinedstorage.gui.GuiBase; import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator; import com.raoulvdberge.refinedstorage.tile.data.TileDataManager; @@ -12,16 +13,16 @@ public class SideButtonIOMode extends SideButton { @Override public String getTooltip() { - return TextFormatting.GREEN + GuiBase.t("sidebutton.refinedstorage:iomode") + TextFormatting.RESET + "\n" + GuiBase.t("sidebutton.refinedstorage:iomode." + (TileDiskManipulator.IO_MODE.getValue() == TileDiskManipulator.IO_MODE_INSERT ? "insert" : "extract")); + return TextFormatting.GREEN + GuiBase.t("sidebutton.refinedstorage:iomode") + TextFormatting.RESET + "\n" + GuiBase.t("sidebutton.refinedstorage:iomode." + (TileDiskManipulator.IO_MODE.getValue() == NetworkNodeDiskManipulator.IO_MODE_INSERT ? "insert" : "extract")); } @Override protected void drawButtonIcon(int x, int y) { - gui.drawTexture(x, y, TileDiskManipulator.IO_MODE.getValue() == TileDiskManipulator.IO_MODE_EXTRACT ? 0 : 16, 160, 16, 16); + gui.drawTexture(x, y, TileDiskManipulator.IO_MODE.getValue() == NetworkNodeDiskManipulator.IO_MODE_EXTRACT ? 0 : 16, 160, 16, 16); } @Override public void actionPerformed() { - TileDataManager.setParameter(TileDiskManipulator.IO_MODE, TileDiskManipulator.IO_MODE.getValue() == TileDiskManipulator.IO_MODE_INSERT ? TileDiskManipulator.IO_MODE_EXTRACT : TileDiskManipulator.IO_MODE_INSERT); + TileDataManager.setParameter(TileDiskManipulator.IO_MODE, TileDiskManipulator.IO_MODE.getValue() == NetworkNodeDiskManipulator.IO_MODE_INSERT ? NetworkNodeDiskManipulator.IO_MODE_EXTRACT : NetworkNodeDiskManipulator.IO_MODE_INSERT); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/IItemHandlerChangeListener.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/IItemHandlerChangeListener.java new file mode 100755 index 000000000..8c79cbad9 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/IItemHandlerChangeListener.java @@ -0,0 +1,5 @@ +package com.raoulvdberge.refinedstorage.inventory; + +public interface IItemHandlerChangeListener { + void onChanged(int slot); +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerBasic.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerBasic.java index 24254ae57..ed0947592 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerBasic.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerBasic.java @@ -1,20 +1,19 @@ package com.raoulvdberge.refinedstorage.inventory; import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntity; import net.minecraftforge.items.ItemStackHandler; import javax.annotation.Nonnull; public class ItemHandlerBasic extends ItemStackHandler { - private TileEntity tile; + private IItemHandlerChangeListener listener; protected IItemValidator[] validators; - public ItemHandlerBasic(int size, TileEntity tile, IItemValidator... validators) { + public ItemHandlerBasic(int size, IItemHandlerChangeListener listener, IItemValidator... validators) { super(size); - this.tile = tile; + this.listener = listener; this.validators = validators; } @@ -51,8 +50,8 @@ public class ItemHandlerBasic extends ItemStackHandler { protected void onContentsChanged(int slot) { super.onContentsChanged(slot); - if (tile != null) { - tile.markDirty(); + if (listener != null) { + listener.onChanged(slot); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerNode.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerNode.java new file mode 100755 index 000000000..fd0e8e6ec --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerNode.java @@ -0,0 +1,16 @@ +package com.raoulvdberge.refinedstorage.inventory; + +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; + +public class ItemHandlerChangeListenerNode implements IItemHandlerChangeListener { + private INetworkNode node; + + public ItemHandlerChangeListenerNode(INetworkNode node) { + this.node = node; + } + + @Override + public void onChanged(int slot) { + node.markDirty(); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerTile.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerTile.java new file mode 100755 index 000000000..78f447453 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerChangeListenerTile.java @@ -0,0 +1,16 @@ +package com.raoulvdberge.refinedstorage.inventory; + +import net.minecraft.tileentity.TileEntity; + +public class ItemHandlerChangeListenerTile implements IItemHandlerChangeListener { + private TileEntity tile; + + public ItemHandlerChangeListenerTile(TileEntity tile) { + this.tile = tile; + } + + @Override + public void onChanged(int slot) { + tile.markDirty(); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFluid.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFluid.java index 90c70a5e9..6da70938c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFluid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFluid.java @@ -2,15 +2,14 @@ package com.raoulvdberge.refinedstorage.inventory; import com.raoulvdberge.refinedstorage.RSUtils; import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntity; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.items.ItemHandlerHelper; public class ItemHandlerFluid extends ItemHandlerBasic { private FluidStack[] fluids; - public ItemHandlerFluid(int size, TileEntity tile) { - super(size, tile, s -> RSUtils.getFluidFromStack(ItemHandlerHelper.copyStackWithSize(s, 1), true).getValue() != null); + public ItemHandlerFluid(int size, IItemHandlerChangeListener listener) { + super(size, listener, s -> RSUtils.getFluidFromStack(ItemHandlerHelper.copyStackWithSize(s, 1), true).getValue() != null); this.fluids = new FluidStack[size]; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerUpgrade.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerUpgrade.java index 4abdda603..e8a6b86cc 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerUpgrade.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerUpgrade.java @@ -2,11 +2,10 @@ package com.raoulvdberge.refinedstorage.inventory; import com.raoulvdberge.refinedstorage.RSItems; import com.raoulvdberge.refinedstorage.item.ItemUpgrade; -import net.minecraft.tileentity.TileEntity; public class ItemHandlerUpgrade extends ItemHandlerBasic { - public ItemHandlerUpgrade(int size, TileEntity tile, int... supportedUpgrades) { - super(size, tile, new IItemValidator[supportedUpgrades.length]); + public ItemHandlerUpgrade(int size, IItemHandlerChangeListener listener, int... supportedUpgrades) { + super(size, listener, new IItemValidator[supportedUpgrades.length]); for (int i = 0; i < supportedUpgrades.length; ++i) { this.validators[i] = new ItemValidatorBasic(RSItems.UPGRADE, supportedUpgrades[i]); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockFluidStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockFluidStorage.java index 697784d6f..65e196e88 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockFluidStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockFluidStorage.java @@ -2,9 +2,9 @@ package com.raoulvdberge.refinedstorage.item; import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidStorage; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; -import com.raoulvdberge.refinedstorage.tile.TileFluidStorage; import net.minecraft.client.resources.I18n; import net.minecraft.entity.Entity; import net.minecraft.entity.player.EntityPlayer; @@ -28,7 +28,7 @@ public class ItemBlockFluidStorage extends ItemBlockBase { EnumFluidStorageType type = EnumFluidStorageType.getById(stack.getMetadata()); if (type != null && isValid(stack)) { - NBTTagCompound tag = stack.getTagCompound().getCompoundTag(TileFluidStorage.NBT_STORAGE); + NBTTagCompound tag = stack.getTagCompound().getCompoundTag(NetworkNodeFluidStorage.NBT_STORAGE); if (type == EnumFluidStorageType.TYPE_CREATIVE) { tooltip.add(I18n.format("misc.refinedstorage:storage.stored", StorageFluidNBT.getStoredFromNBT(tag))); @@ -44,7 +44,7 @@ public class ItemBlockFluidStorage extends ItemBlockBase { EnumFluidStorageType type = EnumFluidStorageType.getById(stack.getMetadata()); - if (type != null && stack.getCount() == 1 && isValid(stack) && StorageFluidNBT.getStoredFromNBT(stack.getTagCompound().getCompoundTag(TileFluidStorage.NBT_STORAGE)) <= 0 && stack.getMetadata() != ItemFluidStorageDisk.TYPE_CREATIVE && !world.isRemote && player.isSneaking()) { + if (type != null && stack.getCount() == 1 && isValid(stack) && StorageFluidNBT.getStoredFromNBT(stack.getTagCompound().getCompoundTag(NetworkNodeFluidStorage.NBT_STORAGE)) <= 0 && stack.getMetadata() != ItemFluidStorageDisk.TYPE_CREATIVE && !world.isRemote && player.isSneaking()) { ItemStack storagePart = new ItemStack(RSItems.FLUID_STORAGE_PART, 1, stack.getMetadata()); if (!player.inventory.addItemStackToInventory(storagePart.copy())) { @@ -64,7 +64,7 @@ public class ItemBlockFluidStorage extends ItemBlockBase { } private static boolean isValid(ItemStack stack) { - return stack.getTagCompound() != null && stack.getTagCompound().hasKey(TileFluidStorage.NBT_STORAGE); + return stack.getTagCompound() != null && stack.getTagCompound().hasKey(NetworkNodeFluidStorage.NBT_STORAGE); } @Override @@ -94,14 +94,14 @@ public class ItemBlockFluidStorage extends ItemBlockBase { return super.getNBTShareTag(stack); } else { NBTTagCompound shareTag = new NBTTagCompound(); - shareTag.setTag(TileFluidStorage.NBT_STORAGE, StorageFluidNBT.getNBTShareTag(stack.getTagCompound().getCompoundTag(TileFluidStorage.NBT_STORAGE))); + shareTag.setTag(NetworkNodeFluidStorage.NBT_STORAGE, StorageFluidNBT.getNBTShareTag(stack.getTagCompound().getCompoundTag(NetworkNodeFluidStorage.NBT_STORAGE))); return shareTag; } } public static ItemStack initNBT(ItemStack stack) { NBTTagCompound tag = new NBTTagCompound(); - tag.setTag(TileFluidStorage.NBT_STORAGE, StorageFluidNBT.createNBT()); + tag.setTag(NetworkNodeFluidStorage.NBT_STORAGE, StorageFluidNBT.createNBT()); stack.setTagCompound(tag); return stack; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockStorage.java index d88b462fe..89115bdc9 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemBlockStorage.java @@ -2,9 +2,9 @@ package com.raoulvdberge.refinedstorage.item; import com.raoulvdberge.refinedstorage.RSBlocks; import com.raoulvdberge.refinedstorage.RSItems; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorage; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; -import com.raoulvdberge.refinedstorage.tile.TileStorage; import net.minecraft.client.resources.I18n; import net.minecraft.entity.Entity; import net.minecraft.entity.player.EntityPlayer; @@ -28,7 +28,7 @@ public class ItemBlockStorage extends ItemBlockBase { EnumItemStorageType type = EnumItemStorageType.getById(stack.getMetadata()); if (type != null && isValid(stack)) { - NBTTagCompound tag = stack.getTagCompound().getCompoundTag(TileStorage.NBT_STORAGE); + NBTTagCompound tag = stack.getTagCompound().getCompoundTag(NetworkNodeStorage.NBT_STORAGE); if (type == EnumItemStorageType.TYPE_CREATIVE) { tooltip.add(I18n.format("misc.refinedstorage:storage.stored", StorageItemNBT.getStoredFromNBT(tag))); @@ -44,7 +44,7 @@ public class ItemBlockStorage extends ItemBlockBase { EnumItemStorageType type = EnumItemStorageType.getById(stack.getMetadata()); - if (type != null && stack.getCount() == 1 && isValid(stack) && StorageItemNBT.getStoredFromNBT(stack.getTagCompound().getCompoundTag(TileStorage.NBT_STORAGE)) <= 0 && stack.getMetadata() != ItemStorageDisk.TYPE_CREATIVE && !world.isRemote && player.isSneaking()) { + if (type != null && stack.getCount() == 1 && isValid(stack) && StorageItemNBT.getStoredFromNBT(stack.getTagCompound().getCompoundTag(NetworkNodeStorage.NBT_STORAGE)) <= 0 && stack.getMetadata() != ItemStorageDisk.TYPE_CREATIVE && !world.isRemote && player.isSneaking()) { ItemStack storagePart = new ItemStack(RSItems.STORAGE_PART, 1, stack.getMetadata()); if (!player.inventory.addItemStackToInventory(storagePart.copy())) { @@ -64,7 +64,7 @@ public class ItemBlockStorage extends ItemBlockBase { } private static boolean isValid(ItemStack stack) { - return stack.getTagCompound() != null && stack.getTagCompound().hasKey(TileStorage.NBT_STORAGE); + return stack.getTagCompound() != null && stack.getTagCompound().hasKey(NetworkNodeStorage.NBT_STORAGE); } @Override @@ -94,14 +94,14 @@ public class ItemBlockStorage extends ItemBlockBase { return super.getNBTShareTag(stack); } else { NBTTagCompound shareTag = new NBTTagCompound(); - shareTag.setTag(TileStorage.NBT_STORAGE, StorageItemNBT.getNBTShareTag(stack.getTagCompound().getCompoundTag(TileStorage.NBT_STORAGE))); + shareTag.setTag(NetworkNodeStorage.NBT_STORAGE, StorageItemNBT.getNBTShareTag(stack.getTagCompound().getCompoundTag(NetworkNodeStorage.NBT_STORAGE))); return shareTag; } } public static ItemStack initNBT(ItemStack stack) { NBTTagCompound tag = new NBTTagCompound(); - tag.setTag(TileStorage.NBT_STORAGE, StorageItemNBT.createNBT()); + tag.setTag(NetworkNodeStorage.NBT_STORAGE, StorageItemNBT.createNBT()); stack.setTagCompound(tag); return stack; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessFluidGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessFluidGrid.java index aba91da4a..bbb9d1e8e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessFluidGrid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessFluidGrid.java @@ -3,7 +3,7 @@ package com.raoulvdberge.refinedstorage.item; import com.raoulvdberge.refinedstorage.api.network.item.INetworkItem; import com.raoulvdberge.refinedstorage.api.network.item.INetworkItemHandler; import com.raoulvdberge.refinedstorage.apiimpl.network.item.NetworkItemWirelessFluidGrid; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; @@ -17,17 +17,17 @@ public class ItemWirelessFluidGrid extends ItemNetworkItem { public void initializeDefaults(NBTTagCompound tag) { super.initializeDefaults(tag); - tag.setInteger(TileGrid.NBT_SORTING_DIRECTION, TileGrid.SORTING_DIRECTION_DESCENDING); - tag.setInteger(TileGrid.NBT_SORTING_TYPE, TileGrid.SORTING_TYPE_QUANTITY); - tag.setInteger(TileGrid.NBT_SEARCH_BOX_MODE, TileGrid.SEARCH_BOX_MODE_NORMAL); + tag.setInteger(NetworkNodeGrid.NBT_SORTING_DIRECTION, NetworkNodeGrid.SORTING_DIRECTION_DESCENDING); + tag.setInteger(NetworkNodeGrid.NBT_SORTING_TYPE, NetworkNodeGrid.SORTING_TYPE_QUANTITY); + tag.setInteger(NetworkNodeGrid.NBT_SEARCH_BOX_MODE, NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL); } @Override public boolean isValid(ItemStack stack) { return super.isValid(stack) - && stack.getTagCompound().hasKey(TileGrid.NBT_SORTING_DIRECTION) - && stack.getTagCompound().hasKey(TileGrid.NBT_SORTING_TYPE) - && stack.getTagCompound().hasKey(TileGrid.NBT_SEARCH_BOX_MODE); + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_SORTING_DIRECTION) + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_SORTING_TYPE) + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_SEARCH_BOX_MODE); } @Override @@ -36,14 +36,14 @@ public class ItemWirelessFluidGrid extends ItemNetworkItem { } public static int getSortingType(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_SORTING_TYPE); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_SORTING_TYPE); } public static int getSortingDirection(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_SORTING_DIRECTION); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_SORTING_DIRECTION); } public static int getSearchBoxMode(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_SEARCH_BOX_MODE); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_SEARCH_BOX_MODE); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessGrid.java index 77ba454d1..be6d0cfba 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessGrid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/item/ItemWirelessGrid.java @@ -3,7 +3,7 @@ package com.raoulvdberge.refinedstorage.item; import com.raoulvdberge.refinedstorage.api.network.item.INetworkItem; import com.raoulvdberge.refinedstorage.api.network.item.INetworkItemHandler; import com.raoulvdberge.refinedstorage.apiimpl.network.item.NetworkItemWirelessGrid; -import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; @@ -17,20 +17,20 @@ public class ItemWirelessGrid extends ItemNetworkItem { public void initializeDefaults(NBTTagCompound tag) { super.initializeDefaults(tag); - tag.setInteger(TileGrid.NBT_VIEW_TYPE, TileGrid.VIEW_TYPE_NORMAL); - tag.setInteger(TileGrid.NBT_SORTING_DIRECTION, TileGrid.SORTING_DIRECTION_DESCENDING); - tag.setInteger(TileGrid.NBT_SORTING_TYPE, TileGrid.SORTING_TYPE_QUANTITY); - tag.setInteger(TileGrid.NBT_SEARCH_BOX_MODE, TileGrid.SEARCH_BOX_MODE_NORMAL); - tag.setInteger(TileGrid.NBT_TAB_SELECTED, -1); + tag.setInteger(NetworkNodeGrid.NBT_VIEW_TYPE, NetworkNodeGrid.VIEW_TYPE_NORMAL); + tag.setInteger(NetworkNodeGrid.NBT_SORTING_DIRECTION, NetworkNodeGrid.SORTING_DIRECTION_DESCENDING); + tag.setInteger(NetworkNodeGrid.NBT_SORTING_TYPE, NetworkNodeGrid.SORTING_TYPE_QUANTITY); + tag.setInteger(NetworkNodeGrid.NBT_SEARCH_BOX_MODE, NetworkNodeGrid.SEARCH_BOX_MODE_NORMAL); + tag.setInteger(NetworkNodeGrid.NBT_TAB_SELECTED, -1); } @Override public boolean isValid(ItemStack stack) { return super.isValid(stack) - && stack.getTagCompound().hasKey(TileGrid.NBT_VIEW_TYPE) - && stack.getTagCompound().hasKey(TileGrid.NBT_SORTING_DIRECTION) - && stack.getTagCompound().hasKey(TileGrid.NBT_SORTING_TYPE) - && stack.getTagCompound().hasKey(TileGrid.NBT_SEARCH_BOX_MODE); + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_VIEW_TYPE) + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_SORTING_DIRECTION) + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_SORTING_TYPE) + && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_SEARCH_BOX_MODE); } @Override @@ -39,22 +39,22 @@ public class ItemWirelessGrid extends ItemNetworkItem { } public static int getViewType(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_VIEW_TYPE); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_VIEW_TYPE); } public static int getSortingType(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_SORTING_TYPE); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_SORTING_TYPE); } public static int getSortingDirection(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_SORTING_DIRECTION); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_SORTING_DIRECTION); } public static int getSearchBoxMode(ItemStack stack) { - return stack.getTagCompound().getInteger(TileGrid.NBT_SEARCH_BOX_MODE); + return stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_SEARCH_BOX_MODE); } public static int getTabSelected(ItemStack stack) { - return (stack.hasTagCompound() && stack.getTagCompound().hasKey(TileGrid.NBT_TAB_SELECTED)) ? stack.getTagCompound().getInteger(TileGrid.NBT_TAB_SELECTED) : -1; + return (stack.hasTagCompound() && stack.getTagCompound().hasKey(NetworkNodeGrid.NBT_TAB_SELECTED)) ? stack.getTagCompound().getInteger(NetworkNodeGrid.NBT_TAB_SELECTED) : -1; } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridCraftingClear.java b/src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridCraftingClear.java index 4a0aa4e0e..6c1e8e5f2 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridCraftingClear.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridCraftingClear.java @@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.network; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.network.security.Permission; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.block.EnumGridType; import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import io.netty.buffer.ByteBuf; @@ -44,9 +45,9 @@ public class MessageGridCraftingClear extends MessageHandlerPlayerToServer NETWORK_NODE_CAPABILITY = null; - - public static void register() { - CapabilityManager.INSTANCE.register(INetworkNode.class, new Capability.IStorage() { - public NBTBase writeNBT(Capability capability, INetworkNode instance, EnumFacing side) { - return new NBTTagCompound(); - } - - public void readNBT(Capability capability, INetworkNode instance, EnumFacing side, NBTBase base) { - // NO OP - } - }, () -> new INetworkNode() { - private INetworkMaster network; - - @Override - public int getEnergyUsage() { - return 0; - } - - @Nonnull - @Override - public ItemStack getItemStack() { - return ItemStack.EMPTY; - } - - @Override - public void onConnected(INetworkMaster network) { - this.network = network; - } - - @Override - public void onDisconnected(INetworkMaster network) { - } - - @Override - public boolean canUpdate() { - return false; - } - - @Override - public INetworkMaster getNetwork() { - return network; - } - }); - - Preconditions.checkNotNull(NETWORK_NODE_CAPABILITY, "Capability not registered"); - } -} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/proxy/CapabilityNetworkNodeProxy.java b/src/main/java/com/raoulvdberge/refinedstorage/proxy/CapabilityNetworkNodeProxy.java new file mode 100755 index 000000000..05a7ce5e8 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/proxy/CapabilityNetworkNodeProxy.java @@ -0,0 +1,40 @@ +package com.raoulvdberge.refinedstorage.proxy; + +import com.google.common.base.Preconditions; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.CapabilityInject; +import net.minecraftforge.common.capabilities.CapabilityManager; + +public class CapabilityNetworkNodeProxy { + @CapabilityInject(INetworkNodeProxy.class) + public static Capability NETWORK_NODE_PROXY_CAPABILITY = null; + + public static void register() { + CapabilityManager.INSTANCE.register(INetworkNodeProxy.class, new Capability.IStorage() { + public NBTBase writeNBT(Capability capability, INetworkNodeProxy instance, EnumFacing side) { + return new NBTTagCompound(); + } + + public void readNBT(Capability capability, INetworkNodeProxy instance, EnumFacing side, NBTBase base) { + // NO OP + } + }, () -> new INetworkNodeProxy() { + @Override + public INetworkNode getNode() { + return null; + } + + @Override + public INetworkNode createNode() { + return null; + } + }); + + Preconditions.checkNotNull(NETWORK_NODE_PROXY_CAPABILITY, "Capability not registered"); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java b/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java index 86a29e3a3..64394920e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java @@ -28,7 +28,6 @@ import com.raoulvdberge.refinedstorage.tile.*; import com.raoulvdberge.refinedstorage.tile.craftingmonitor.TileCraftingMonitor; import com.raoulvdberge.refinedstorage.tile.data.ContainerListener; import com.raoulvdberge.refinedstorage.tile.data.TileDataManager; -import com.raoulvdberge.refinedstorage.tile.externalstorage.TileExternalStorage; import com.raoulvdberge.refinedstorage.tile.grid.TileGrid; import net.minecraft.block.Block; import net.minecraft.init.Blocks; @@ -59,7 +58,7 @@ public class ProxyCommon { IntegrationCraftingTweaks.register(); } - CapabilityNetworkNode.register(); + CapabilityNetworkNodeProxy.register(); API.deliver(e.getAsmData()); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/INetworkNodeHolder.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/INetworkNodeHolder.java new file mode 100755 index 000000000..6ce6bfbf4 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/INetworkNodeHolder.java @@ -0,0 +1,15 @@ +package com.raoulvdberge.refinedstorage.tile; + +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +public interface INetworkNodeHolder { + EnumFacing getDirection(); + + void setDirection(EnumFacing direction); + + World world(); + + BlockPos pos(); +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/IReaderWriter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/IReaderWriter.java index 6d0c8bdfa..16ef68568 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/IReaderWriter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/IReaderWriter.java @@ -13,8 +13,6 @@ public interface IReaderWriter extends INetworkNode { TileDataParameter getChannelParameter(); - boolean isActive(); - default void onAdd(String name) { INetworkMaster network = getNetwork(); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileBase.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileBase.java index 15e343ac2..73850ef89 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileBase.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileBase.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile; +import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.tile.data.TileDataManager; import net.minecraft.block.state.IBlockState; import net.minecraft.nbt.NBTTagCompound; @@ -25,18 +26,12 @@ public abstract class TileBase extends TileEntity implements ITickable { @Override public void update() { if (!getWorld().isRemote) { - ticks++; + ++ticks; dataManager.detectAndSendChanges(); } } - public void updateBlock() { - if (getWorld() != null) { - getWorld().notifyBlockUpdate(pos, getWorld().getBlockState(pos), getWorld().getBlockState(pos), 1 | 2); - } - } - public void setDirection(EnumFacing direction) { this.direction = direction; @@ -70,7 +65,7 @@ public abstract class TileBase extends TileEntity implements ITickable { public void readUpdate(NBTTagCompound tag) { direction = EnumFacing.getFront(tag.getInteger(NBT_DIRECTION)); - updateBlock(); + RSUtils.updateBlock(getWorld(), pos); } @Override @@ -113,10 +108,6 @@ public abstract class TileBase extends TileEntity implements ITickable { return oldState.getBlock() != newState.getBlock(); } - public TileEntity getFacingTile() { - return getWorld().getTileEntity(pos.offset(direction)); - } - public IItemHandler getDrops() { return null; } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCable.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCable.java index 825ac9d71..c294a0ba1 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCable.java @@ -1,15 +1,12 @@ package com.raoulvdberge.refinedstorage.tile; import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeBasic; public class TileCable extends TileNode { @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.cableUsage; - } - - @Override - public void updateNode() { - // NO OP + public INetworkNode createNode() { + return new NetworkNodeBasic(this, RS.INSTANCE.config.cableUsage, false); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileConstructor.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileConstructor.java index b5f697cfd..9d3d8327a 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileConstructor.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileConstructor.java @@ -1,90 +1,31 @@ package com.raoulvdberge.refinedstorage.tile; -import com.mojang.authlib.GameProfile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.container.slot.SlotFilter; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeConstructor; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.config.IType; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.block.Block; -import net.minecraft.block.BlockSkull; -import net.minecraft.block.SoundType; -import net.minecraft.block.state.IBlockState; -import net.minecraft.dispenser.BehaviorDefaultDispenseItem; -import net.minecraft.dispenser.PositionImpl; -import net.minecraft.entity.item.EntityFireworkRocket; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.nbt.NBTUtil; import net.minecraft.network.datasync.DataSerializers; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.tileentity.TileEntitySkull; -import net.minecraft.util.EnumFacing; -import net.minecraft.util.SoundCategory; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.WorldServer; -import net.minecraftforge.common.MinecraftForge; -import net.minecraftforge.common.util.BlockSnapshot; -import net.minecraftforge.common.util.FakePlayerFactory; -import net.minecraftforge.event.world.BlockEvent; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.items.IItemHandler; -public class TileConstructor extends TileNode implements IComparable, IType { +public class TileConstructor extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); public static final TileDataParameter DROP = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileConstructor tile) { - return tile.drop; + return ((NetworkNodeConstructor) tile.getNode()).isDrop(); } }, new ITileDataConsumer() { @Override public void setValue(TileConstructor tile, Boolean value) { - tile.drop = value; + ((NetworkNodeConstructor) tile.getNode()).setDrop(value); - tile.markDirty(); + tile.getNode().markDirty(); } }); - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_TYPE = "Type"; - private static final String NBT_DROP = "Drop"; - - private static final int BASE_SPEED = 20; - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(1, this) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - item = getStackInSlot(slot).isEmpty() ? null : getStackInSlot(slot).copy(); - block = SlotFilter.getBlockState(getWorld(), pos.offset(getDirection()), getStackInSlot(slot)); - } - }; - - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, this); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING); - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int type = IType.ITEMS; - private boolean drop = false; - - private IBlockState block; - private ItemStack item; - public TileConstructor() { dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(TYPE); @@ -92,238 +33,7 @@ public class TileConstructor extends TileNode implements IComparable, IType { } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.constructorUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - if (ticks % upgrades.getSpeed(BASE_SPEED, 4) == 0) { - if (type == IType.ITEMS) { - if (block != null) { - if (drop && item != null) { - dropItem(); - } else { - placeBlock(); - } - } else if (item != null) { - if (item.getItem() == Items.FIREWORKS && !drop) { - ItemStack took = network.extractItem(item, 1, false); - - if (took != null) { - getWorld().spawnEntity(new EntityFireworkRocket(getWorld(), getDispensePositionX(), getDispensePositionY(), getDispensePositionZ(), took)); - } - } else { - dropItem(); - } - } - } else if (type == IType.FLUIDS) { - FluidStack stack = fluidFilters.getFluidStackInSlot(0); - - if (stack != null && stack.getFluid().canBePlacedInWorld() && stack.amount >= Fluid.BUCKET_VOLUME) { - BlockPos front = pos.offset(getDirection()); - - Block block = stack.getFluid().getBlock(); - - if (getWorld().isAirBlock(front) && block.canPlaceBlockAt(getWorld(), front)) { - FluidStack took = network.extractFluid(stack, Fluid.BUCKET_VOLUME, compare, false); - - if (took != null) { - IBlockState state = block.getDefaultState(); - - if (state.getBlock() == Blocks.WATER) { - state = Blocks.FLOWING_WATER.getDefaultState(); - } else if (state.getBlock() == Blocks.LAVA) { - state = Blocks.FLOWING_LAVA.getDefaultState(); - } - - getWorld().setBlockState(front, state, 1 | 2); - } - } - } - } - } - } - - private void placeBlock() { - BlockPos front = pos.offset(getDirection()); - - if (getWorld().isAirBlock(front) && block.getBlock().canPlaceBlockAt(getWorld(), front)) { - ItemStack took = network.extractItem(itemFilters.getStackInSlot(0), 1, compare, true); - - if (took != null) { - @SuppressWarnings("deprecation") - IBlockState state = block.getBlock().getStateFromMeta(took.getMetadata()); - - BlockEvent.PlaceEvent e = new BlockEvent.PlaceEvent(new BlockSnapshot(getWorld(), front, state), getWorld().getBlockState(pos), FakePlayerFactory.getMinecraft((WorldServer) getWorld()), null); - - if (MinecraftForge.EVENT_BUS.post(e)) { - return; - } - - network.extractItem(itemFilters.getStackInSlot(0), 1, compare, false); - - getWorld().setBlockState(front, state, 1 | 2); - - // From ItemBlock#onItemUse - SoundType blockSound = block.getBlock().getSoundType(state, getWorld(), pos, null); - getWorld().playSound(null, front, blockSound.getPlaceSound(), SoundCategory.BLOCKS, (blockSound.getVolume() + 1.0F) / 2.0F, blockSound.getPitch() * 0.8F); - - if (block.getBlock() == Blocks.SKULL) { - getWorld().setBlockState(front, getWorld().getBlockState(front).withProperty(BlockSkull.FACING, getDirection())); - - TileEntity tile = getWorld().getTileEntity(front); - - if (tile instanceof TileEntitySkull) { - TileEntitySkull skullTile = (TileEntitySkull) tile; - - if (item.getItemDamage() == 3) { - GameProfile playerInfo = null; - - if (item.hasTagCompound()) { - NBTTagCompound tag = item.getTagCompound(); - - if (tag.hasKey("SkullOwner", 10)) { - playerInfo = NBTUtil.readGameProfileFromNBT(tag.getCompoundTag("SkullOwner")); - } else if (tag.hasKey("SkullOwner", 8) && !tag.getString("SkullOwner").isEmpty()) { - playerInfo = new GameProfile(null, tag.getString("SkullOwner")); - } - } - - skullTile.setPlayerProfile(playerInfo); - } else { - skullTile.setType(item.getMetadata()); - } - - Blocks.SKULL.checkWitherSpawn(getWorld(), front, skullTile); - } - - } - } else if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { - ItemStack craft = itemFilters.getStackInSlot(0); - - network.scheduleCraftingTask(craft, 1, compare); - } - } - } - - private void dropItem() { - ItemStack took = network.extractItem(item, 1, false); - - if (took != null) { - BehaviorDefaultDispenseItem.doDispense(getWorld(), took, 6, getDirection(), new PositionImpl(getDispensePositionX(), getDispensePositionY(), getDispensePositionZ())); - } else if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { - ItemStack craft = itemFilters.getStackInSlot(0); - - network.scheduleCraftingTask(craft, 1, compare); - } - } - - // From BlockDispenser#getDispensePosition - private double getDispensePositionX() { - return (double) pos.getX() + 0.5D + 0.8D * (double) getDirection().getFrontOffsetX(); - } - - // From BlockDispenser#getDispensePosition - private double getDispensePositionY() { - return (double) pos.getY() + (getDirection() == EnumFacing.DOWN ? 0.45D : 0.5D) + 0.8D * (double) getDirection().getFrontOffsetY(); - } - - // From BlockDispenser#getDispensePosition - private double getDispensePositionZ() { - return (double) pos.getZ() + 0.5D + 0.8D * (double) getDirection().getFrontOffsetZ(); - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 1, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(upgrades, 1, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_TYPE, type); - tag.setBoolean(NBT_DROP, drop); - - RSUtils.writeItems(itemFilters, 0, tag); - RSUtils.writeItems(fluidFilters, 2, tag); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - if (tag.hasKey(NBT_DROP)) { - drop = tag.getBoolean(NBT_DROP); - } - - RSUtils.readItems(itemFilters, 0, tag); - RSUtils.readItems(fluidFilters, 2, tag); - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return upgrades; - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; - } - - @Override - public void setType(int type) { - this.type = type; - - markDirty(); - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; + public INetworkNode createNode() { + return new NetworkNodeConstructor(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileController.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileController.java index d1cce663f..3c9479b05 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileController.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileController.java @@ -14,6 +14,7 @@ import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask; import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.network.INetworkNodeGraph; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.api.network.grid.IFluidGridHandler; import com.raoulvdberge.refinedstorage.api.network.grid.IItemGridHandler; import com.raoulvdberge.refinedstorage.api.network.item.INetworkItemHandler; @@ -31,6 +32,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.NetworkNodeGraph; import com.raoulvdberge.refinedstorage.apiimpl.network.grid.FluidGridHandler; import com.raoulvdberge.refinedstorage.apiimpl.network.grid.ItemGridHandler; import com.raoulvdberge.refinedstorage.apiimpl.network.item.NetworkItemHandler; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.StorageFluidExternal; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.StorageItemExternal; import com.raoulvdberge.refinedstorage.apiimpl.network.security.SecurityManager; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem; @@ -44,14 +47,12 @@ import com.raoulvdberge.refinedstorage.integration.forgeenergy.ControllerEnergyF import com.raoulvdberge.refinedstorage.integration.tesla.ControllerEnergyTesla; import com.raoulvdberge.refinedstorage.integration.tesla.IntegrationTesla; import com.raoulvdberge.refinedstorage.network.*; -import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode; +import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.config.IRedstoneConfigurable; import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.RSSerializers; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import com.raoulvdberge.refinedstorage.tile.externalstorage.StorageFluidExternal; -import com.raoulvdberge.refinedstorage.tile.externalstorage.StorageItemExternal; import com.raoulvdberge.refinedstorage.tile.grid.IGrid; import net.darkhax.tesla.capability.TeslaCapabilities; import net.minecraft.block.state.IBlockState; @@ -77,7 +78,7 @@ import javax.annotation.Nullable; import java.util.*; import java.util.stream.Collectors; -public class TileController extends TileBase implements INetworkMaster, IRedstoneConfigurable, INetworkNode { +public class TileController extends TileBase implements INetworkMaster, IRedstoneConfigurable, INetworkNode, INetworkNodeProxy { public static final TileDataParameter REDSTONE_MODE = RedstoneMode.createParameter(); public static final TileDataParameter ENERGY_USAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @@ -108,15 +109,16 @@ public class TileController extends TileBase implements INetworkMaster, IRedston for (INetworkNode node : tile.nodeGraph.all()) { if (node.canUpdate()) { - ItemStack itemStack = node.getItemStack(); - if (itemStack.isEmpty()) { + ItemStack stack = node.getItemStack(); + + if (stack.isEmpty()) { continue; } ClientNode clientNode = new ClientNode( - itemStack, - 1, - node.getEnergyUsage() + stack, + 1, + node.getEnergyUsage() ); if (nodes.contains(clientNode)) { @@ -318,7 +320,7 @@ public class TileController extends TileBase implements INetworkMaster, IRedston if (getEnergyScaledForDisplay() != lastEnergyDisplay) { lastEnergyDisplay = getEnergyScaledForDisplay(); - updateBlock(); + RSUtils.updateBlock(world, pos); } } @@ -471,8 +473,8 @@ public class TileController extends TileBase implements INetworkMaster, IRedston @Override public void sendItemStorageToClient() { getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> isWatchingGrid(player, EnumGridType.NORMAL, EnumGridType.CRAFTING, EnumGridType.PATTERN)) - .forEach(this::sendItemStorageToClient); + .filter(player -> isWatchingGrid(player, EnumGridType.NORMAL, EnumGridType.CRAFTING, EnumGridType.PATTERN)) + .forEach(this::sendItemStorageToClient); } @Override @@ -483,15 +485,15 @@ public class TileController extends TileBase implements INetworkMaster, IRedston @Override public void sendItemStorageDeltaToClient(ItemStack stack, int delta) { getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> isWatchingGrid(player, EnumGridType.NORMAL, EnumGridType.CRAFTING, EnumGridType.PATTERN)) - .forEach(player -> RS.INSTANCE.network.sendTo(new MessageGridItemDelta(this, stack, delta), player)); + .filter(player -> isWatchingGrid(player, EnumGridType.NORMAL, EnumGridType.CRAFTING, EnumGridType.PATTERN)) + .forEach(player -> RS.INSTANCE.network.sendTo(new MessageGridItemDelta(this, stack, delta), player)); } @Override public void sendFluidStorageToClient() { getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> isWatchingGrid(player, EnumGridType.FLUID)) - .forEach(this::sendFluidStorageToClient); + .filter(player -> isWatchingGrid(player, EnumGridType.FLUID)) + .forEach(this::sendFluidStorageToClient); } @Override @@ -502,8 +504,8 @@ public class TileController extends TileBase implements INetworkMaster, IRedston @Override public void sendFluidStorageDeltaToClient(FluidStack stack, int delta) { getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> isWatchingGrid(player, EnumGridType.FLUID)) - .forEach(player -> RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(stack, delta), player)); + .filter(player -> isWatchingGrid(player, EnumGridType.FLUID)) + .forEach(player -> RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(stack, delta), player)); } private boolean isWatchingGrid(EntityPlayer player, EnumGridType... types) { @@ -526,8 +528,8 @@ public class TileController extends TileBase implements INetworkMaster, IRedston @Override public void sendCraftingMonitorUpdate() { List watchers = getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> player.openContainer instanceof ContainerCraftingMonitor && pos.equals(((ContainerCraftingMonitor) player.openContainer).getCraftingMonitor().getNetworkPosition())) - .collect(Collectors.toList()); + .filter(player -> player.openContainer instanceof ContainerCraftingMonitor && pos.equals(((ContainerCraftingMonitor) player.openContainer).getCraftingMonitor().getNetworkPosition())) + .collect(Collectors.toList()); if (!watchers.isEmpty()) { List elements = getElements(); @@ -571,10 +573,10 @@ public class TileController extends TileBase implements INetworkMaster, IRedston @Override public void sendReaderWriterChannelUpdate() { getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> player.openContainer instanceof ContainerReaderWriter && - ((ContainerReaderWriter) player.openContainer).getReaderWriter().getNetwork() != null && - pos.equals(((ContainerReaderWriter) player.openContainer).getReaderWriter().getNetwork().getPosition())) - .forEach(this::sendReaderWriterChannelUpdate); + .filter(player -> player.openContainer instanceof ContainerReaderWriter && + ((ContainerReaderWriter) player.openContainer).getReaderWriter().getNetwork() != null && + pos.equals(((ContainerReaderWriter) player.openContainer).getReaderWriter().getNetwork().getPosition())) + .forEach(this::sendReaderWriterChannelUpdate); } @Override @@ -973,8 +975,8 @@ public class TileController extends TileBase implements INetworkMaster, IRedston } } - if (capability == CapabilityNetworkNode.NETWORK_NODE_CAPABILITY) { - return CapabilityNetworkNode.NETWORK_NODE_CAPABILITY.cast(this); + if (capability == CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY) { + return CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY.cast(this); } return super.getCapability(capability, facing); @@ -983,8 +985,18 @@ public class TileController extends TileBase implements INetworkMaster, IRedston @Override public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { return capability == CapabilityEnergy.ENERGY - || (energyTesla != null && (capability == TeslaCapabilities.CAPABILITY_HOLDER || capability == TeslaCapabilities.CAPABILITY_CONSUMER)) - || capability == CapabilityNetworkNode.NETWORK_NODE_CAPABILITY - || super.hasCapability(capability, facing); + || (energyTesla != null && (capability == TeslaCapabilities.CAPABILITY_HOLDER || capability == TeslaCapabilities.CAPABILITY_CONSUMER)) + || capability == CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY + || super.hasCapability(capability, facing); + } + + @Override + public INetworkNode getNode() { + return this; + } + + @Override + public INetworkNode createNode() { + return this; } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCrafter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCrafter.java index 328fba1bc..cb3fe4bf6 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCrafter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileCrafter.java @@ -1,227 +1,33 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPattern; -import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPatternContainer; -import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPatternProvider; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCrafter; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraft.util.EnumFacing; -import net.minecraft.util.math.BlockPos; -import net.minecraftforge.common.capabilities.Capability; -import net.minecraftforge.items.CapabilityItemHandler; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; -import javax.annotation.Nullable; -import java.util.ArrayList; -import java.util.List; - -public class TileCrafter extends TileNode implements ICraftingPatternContainer { +public class TileCrafter extends TileNode { public static final TileDataParameter TRIGGERED_AUTOCRAFTING = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileCrafter tile) { - return tile.triggeredAutocrafting; + return ((NetworkNodeCrafter) tile.getNode()).isTriggeredAutocrafting(); } }, new ITileDataConsumer() { @Override public void setValue(TileCrafter tile, Boolean value) { - tile.triggeredAutocrafting = value; + ((NetworkNodeCrafter) tile.getNode()).setTriggeredAutocrafting(value); - tile.markDirty(); + tile.getNode().markDirty(); } }); - private static final String NBT_TRIGGERED_AUTOCRAFTING = "TriggeredAutocrafting"; - - private ItemHandlerBasic patterns = new ItemHandlerBasic(9, this, s -> { - // We can only validate the crafting pattern if the world exists. - // If the world doesn't exist, this is probably called while reading and in that case it doesn't matter. - if (getWorld() != null) { - return s.getItem() instanceof ICraftingPatternProvider && ((ICraftingPatternProvider) s.getItem()).create(getWorld(), s, this).isValid(); - } - - return true; - }) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - if (getWorld() != null && !getWorld().isRemote) { - rebuildPatterns(); - } - - if (network != null) { - network.rebuildPatterns(); - } - } - }; - - private List actualPatterns = new ArrayList<>(); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED); - - private boolean triggeredAutocrafting = false; - public TileCrafter() { dataManager.addWatchedParameter(TRIGGERED_AUTOCRAFTING); } - private void rebuildPatterns() { - actualPatterns.clear(); - - for (int i = 0; i < patterns.getSlots(); ++i) { - ItemStack patternStack = patterns.getStackInSlot(i); - - if (!patternStack.isEmpty()) { - ICraftingPattern pattern = ((ICraftingPatternProvider) patternStack.getItem()).create(getWorld(), patternStack, this); - - if (pattern.isValid()) { - actualPatterns.add(pattern); - } - } - } - } - @Override - public int getEnergyUsage() { - int usage = RS.INSTANCE.config.crafterUsage + upgrades.getEnergyUsage(); - - for (int i = 0; i < patterns.getSlots(); ++i) { - if (!patterns.getStackInSlot(i).isEmpty()) { - usage += RS.INSTANCE.config.crafterPerPatternUsage; - } - } - - return usage; - } - - @Override - public void update() { - if (!getWorld().isRemote && ticks == 0) { - rebuildPatterns(); - } - - super.update(); - } - - @Override - public void updateNode() { - if (triggeredAutocrafting && getWorld().isBlockPowered(pos)) { - for (ICraftingPattern pattern : actualPatterns) { - for (ItemStack output : pattern.getOutputs()) { - network.scheduleCraftingTask(output, 1, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT); - } - } - } - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - if (!state) { - network.getCraftingTasks().stream() - .filter(task -> task.getPattern().getContainer().getPosition().equals(pos)) - .forEach(network::cancelCraftingTask); - } - - network.rebuildPatterns(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(patterns, 0, tag); - RSUtils.readItems(upgrades, 1, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(patterns, 0, tag); - RSUtils.writeItems(upgrades, 1, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setBoolean(NBT_TRIGGERED_AUTOCRAFTING, triggeredAutocrafting); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_TRIGGERED_AUTOCRAFTING)) { - triggeredAutocrafting = tag.getBoolean(NBT_TRIGGERED_AUTOCRAFTING); - } - } - - @Override - public int getSpeedUpdateCount() { - return upgrades.getUpgradeCount(ItemUpgrade.TYPE_SPEED); - } - - @Override - public IItemHandler getFacingInventory() { - return RSUtils.getItemHandler(getFacingTile(), getDirection().getOpposite()); - } - - @Override - public List getPatterns() { - return actualPatterns; - } - - @Override - public BlockPos getPosition() { - return pos; - } - - public IItemHandler getPatternItems() { - return patterns; - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return new CombinedInvWrapper(patterns, upgrades); - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public T getCapability(Capability capability, @Nullable EnumFacing facing) { - if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && facing != getDirection()) { - return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(patterns); - } - - return super.getCapability(capability, facing); - } - - @Override - public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { - return (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && facing != getDirection()) || super.hasCapability(capability, facing); + public INetworkNode createNode() { + return new NetworkNodeCrafter(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDestructor.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDestructor.java index f4c1f75d0..b04365b7d 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDestructor.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDestructor.java @@ -1,81 +1,33 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDestructor; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.config.IFilterable; import com.raoulvdberge.refinedstorage.tile.config.IType; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.block.Block; -import net.minecraft.block.BlockLiquid; -import net.minecraft.block.state.IBlockState; -import net.minecraft.entity.Entity; -import net.minecraft.entity.item.EntityItem; -import net.minecraft.inventory.InventoryHelper; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraft.util.math.AxisAlignedBB; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.WorldServer; -import net.minecraft.world.chunk.Chunk; -import net.minecraftforge.common.MinecraftForge; -import net.minecraftforge.common.util.FakePlayerFactory; -import net.minecraftforge.event.world.BlockEvent; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.IFluidBlock; -import net.minecraftforge.fluids.capability.IFluidHandler; -import net.minecraftforge.fluids.capability.wrappers.BlockLiquidWrapper; -import net.minecraftforge.fluids.capability.wrappers.FluidBlockWrapper; -import net.minecraftforge.items.IItemHandler; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -public class TileDestructor extends TileNode implements IComparable, IFilterable, IType { +public class TileDestructor extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter MODE = IFilterable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); public static final TileDataParameter PICKUP = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileDestructor tile) { - return tile.pickupItem; + return ((NetworkNodeDestructor) tile.getNode()).isPickupItem(); } }, new ITileDataConsumer() { @Override public void setValue(TileDestructor tile, Boolean value) { - tile.pickupItem = value; + ((NetworkNodeDestructor) tile.getNode()).setPickupItem(value); - tile.markDirty(); + tile.getNode().markDirty(); } }); - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_TYPE = "Type"; - private static final String NBT_PICKUP = "Pickup"; - - private static final int BASE_SPEED = 20; - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_SILK_TOUCH, ItemUpgrade.TYPE_FORTUNE); - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int mode = IFilterable.WHITELIST; - private int type = IType.ITEMS; - private boolean pickupItem = false; - public TileDestructor() { dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(MODE); @@ -84,209 +36,7 @@ public class TileDestructor extends TileNode implements IComparable, IFilterable } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.destructorUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - if (ticks % upgrades.getSpeed(BASE_SPEED, 4) == 0) { - BlockPos front = pos.offset(getDirection()); - - if (pickupItem && type == IType.ITEMS) { - List droppedItems = new ArrayList<>(); - - Chunk chunk = getWorld().getChunkFromBlockCoords(front); - chunk.getEntitiesWithinAABBForEntity(null, new AxisAlignedBB(front), droppedItems, null); - - for (Entity entity : droppedItems) { - if (entity instanceof EntityItem) { - ItemStack droppedItem = ((EntityItem) entity).getEntityItem(); - - if (IFilterable.canTake(itemFilters, mode, compare, droppedItem) && network.insertItem(droppedItem, droppedItem.getCount(), true) == null) { - network.insertItem(droppedItem.copy(), droppedItem.getCount(), false); - - getWorld().removeEntity(entity); - - break; - } - } - } - } else if (type == IType.ITEMS) { - IBlockState frontBlockState = getWorld().getBlockState(front); - Block frontBlock = frontBlockState.getBlock(); - - @SuppressWarnings("deprecation") - ItemStack frontStack = frontBlock.getItem(getWorld(), front, frontBlockState); - - if (!frontStack.isEmpty()) { - if (IFilterable.canTake(itemFilters, mode, compare, frontStack) && frontBlockState.getBlockHardness(getWorld(), front) != -1.0) { - List drops; - if (upgrades.hasUpgrade(ItemUpgrade.TYPE_SILK_TOUCH) && frontBlock.canSilkHarvest(getWorld(), front, frontBlockState, null)) { - drops = Collections.singletonList(frontStack); - } else { - drops = frontBlock.getDrops(getWorld(), front, frontBlockState, upgrades.getFortuneLevel()); - } - - for (ItemStack drop : drops) { - if (network.insertItem(drop, drop.getCount(), true) != null) { - return; - } - } - - BlockEvent.BreakEvent e = new BlockEvent.BreakEvent(getWorld(), front, frontBlockState, FakePlayerFactory.getMinecraft((WorldServer) getWorld())); - - if (!MinecraftForge.EVENT_BUS.post(e)) { - getWorld().playEvent(null, 2001, front, Block.getStateId(frontBlockState)); - getWorld().setBlockToAir(front); - - for (ItemStack drop : drops) { - // We check if the controller isn't null here because when a destructor faces a node and removes it - // it will essentially remove this block itself from the network without knowing - if (network == null) { - InventoryHelper.spawnItemStack(getWorld(), front.getX(), front.getY(), front.getZ(), drop); - } else { - network.insertItem(drop, drop.getCount(), false); - } - } - } - } - } - } else if (type == IType.FLUIDS) { - Block frontBlock = getWorld().getBlockState(front).getBlock(); - - IFluidHandler handler = null; - - if (frontBlock instanceof BlockLiquid) { - handler = new BlockLiquidWrapper((BlockLiquid) frontBlock, getWorld(), front); - } else if (frontBlock instanceof IFluidBlock) { - handler = new FluidBlockWrapper((IFluidBlock) frontBlock, getWorld(), front); - } - - if (handler != null) { - FluidStack stack = handler.drain(Fluid.BUCKET_VOLUME, false); - - if (stack != null && IFilterable.canTakeFluids(fluidFilters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { - FluidStack drained = handler.drain(Fluid.BUCKET_VOLUME, true); - - network.insertFluid(drained, drained.amount, false); - } - } - } - } - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public int getMode() { - return mode; - } - - @Override - public void setMode(int mode) { - this.mode = mode; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 1, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(upgrades, 1, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setInteger(NBT_TYPE, type); - tag.setBoolean(NBT_PICKUP, pickupItem); - - RSUtils.writeItems(itemFilters, 0, tag); - RSUtils.writeItems(fluidFilters, 2, tag); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - if (tag.hasKey(NBT_PICKUP)) { - pickupItem = tag.getBoolean(NBT_PICKUP); - } - - RSUtils.readItems(itemFilters, 0, tag); - RSUtils.readItems(fluidFilters, 2, tag); - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - public IItemHandler getInventory() { - return itemFilters; - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public IItemHandler getDrops() { - return upgrades; - } - - @Override - public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; - } - - @Override - public void setType(int type) { - this.type = type; - - markDirty(); - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; + public INetworkNode createNode() { + return new NetworkNodeDestructor(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDetector.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDetector.java index dd0ecbce1..0167114a8 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDetector.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDetector.java @@ -1,47 +1,37 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSBlocks; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDetector; import com.raoulvdberge.refinedstorage.gui.GuiDetector; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.config.IType; -import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.GuiScreen; -import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fml.common.FMLCommonHandler; import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.items.IItemHandler; -public class TileDetector extends TileNode implements IComparable, IType { +public class TileDetector extends TileNode { + private static final String NBT_POWERED = "Powered"; + public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); public static final TileDataParameter MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileDetector tile) { - return tile.mode; + return ((NetworkNodeDetector) tile.getNode()).getMode(); } }, new ITileDataConsumer() { @Override public void setValue(TileDetector tile, Integer value) { - if (value == MODE_UNDER || value == MODE_EQUAL || value == MODE_ABOVE || value == MODE_AUTOCRAFTING) { - tile.mode = value; - - tile.markDirty(); + if (value == NetworkNodeDetector.MODE_UNDER || value == NetworkNodeDetector.MODE_EQUAL || value == NetworkNodeDetector.MODE_ABOVE || value == NetworkNodeDetector.MODE_AUTOCRAFTING) { + ((NetworkNodeDetector) tile.getNode()).setMode(value); + tile.getNode().markDirty(); } } }); @@ -49,14 +39,13 @@ public class TileDetector extends TileNode implements IComparable, IType { public static final TileDataParameter AMOUNT = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileDetector tile) { - return tile.amount; + return ((NetworkNodeDetector) tile.getNode()).getAmount(); } }, new ITileDataConsumer() { @Override public void setValue(TileDetector tile, Integer value) { - tile.amount = value; - - tile.markDirty(); + ((NetworkNodeDetector) tile.getNode()).setAmount(value); + tile.getNode().markDirty(); } }, parameter -> { if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) { @@ -68,29 +57,7 @@ public class TileDetector extends TileNode implements IComparable, IType { } }); - private static final int SPEED = 5; - - public static final int MODE_UNDER = 0; - public static final int MODE_EQUAL = 1; - public static final int MODE_ABOVE = 2; - public static final int MODE_AUTOCRAFTING = 3; - - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_AMOUNT = "Amount"; - private static final String NBT_POWERED = "Powered"; - private static final String NBT_TYPE = "Type"; - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(1, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, this); - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int type = IType.ITEMS; - private int mode = MODE_EQUAL; - private int amount = 0; - - private boolean powered = false; - private boolean wasPowered; + private boolean powered; public TileDetector() { dataManager.addWatchedParameter(COMPARE); @@ -99,157 +66,6 @@ public class TileDetector extends TileNode implements IComparable, IType { dataManager.addWatchedParameter(AMOUNT); } - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.detectorUsage; - } - - @Override - public void updateNode() { - if (ticks % SPEED == 0) { - if (type == IType.ITEMS) { - ItemStack slot = itemFilters.getStackInSlot(0); - - if (!slot.isEmpty()) { - if (mode == MODE_AUTOCRAFTING) { - boolean found = false; - - for (ICraftingTask task : network.getCraftingTasks()) { - for (ItemStack output : task.getPattern().getOutputs()) { - if (API.instance().getComparer().isEqualNoQuantity(slot, output)) { - found = true; - - break; - } - } - - if (found) { - break; - } - } - - powered = found; - } else { - ItemStack stack = network.getItemStorageCache().getList().get(slot, compare); - - powered = isPowered(stack == null ? null : stack.getCount()); - } - } else { - powered = mode == MODE_AUTOCRAFTING ? !network.getCraftingTasks().isEmpty() : isPowered(network.getItemStorageCache().getList().getStacks().stream().map(s -> s.getCount()).mapToInt(Number::intValue).sum()); - } - } else if (type == IType.FLUIDS) { - FluidStack slot = fluidFilters.getFluidStackInSlot(0); - - if (slot != null) { - FluidStack stack = network.getFluidStorageCache().getList().get(slot, compare); - - powered = isPowered(stack == null ? null : stack.amount); - } else { - powered = isPowered(network.getFluidStorageCache().getList().getStacks().stream().map(s -> s.amount).mapToInt(Number::intValue).sum()); - } - } - } - } - - @Override - public void update() { - if (powered != wasPowered) { - wasPowered = powered; - - getWorld().notifyNeighborsOfStateChange(pos, RSBlocks.DETECTOR, true); - - updateBlock(); - } - - super.update(); - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - super.onConnectionChange(network, state); - - if (!state) { - powered = false; - } - } - - public boolean isPowered() { - return powered; - } - - private boolean isPowered(Integer size) { - if (size != null) { - switch (mode) { - case MODE_UNDER: - return size < amount; - case MODE_EQUAL: - return size == amount; - case MODE_ABOVE: - return size > amount; - } - } else { - if (mode == MODE_UNDER && amount != 0) { - return true; - } else if (mode == MODE_EQUAL && amount == 0) { - return true; - } else { - return false; - } - } - - return false; - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setInteger(NBT_AMOUNT, amount); - tag.setInteger(NBT_TYPE, type); - - RSUtils.writeItems(itemFilters, 0, tag); - RSUtils.writeItems(fluidFilters, 1, tag); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_AMOUNT)) { - amount = tag.getInteger(NBT_AMOUNT); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - RSUtils.readItems(itemFilters, 0, tag); - RSUtils.readItems(fluidFilters, 1, tag); - } @Override public void readUpdate(NBTTagCompound tag) { @@ -267,29 +83,12 @@ public class TileDetector extends TileNode implements IComparable, IType { return tag; } - public IItemHandler getInventory() { - return itemFilters; + public boolean isPowered() { + return world.isRemote ? powered : ((NetworkNodeDetector) getNode()).isPowered(); } @Override - public void setRedstoneMode(RedstoneMode mode) { - // NO OP - } - - @Override - public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; - } - - @Override - public void setType(int type) { - this.type = type; - - markDirty(); - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; + public INetworkNode createNode() { + return new NetworkNodeDetector(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskDrive.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskDrive.java index 1f5dcdea7..313699c4c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskDrive.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskDrive.java @@ -1,38 +1,20 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSItems; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.storage.AccessType; -import com.raoulvdberge.refinedstorage.api.storage.IStorage; -import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; -import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskDrive; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; -import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; -import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; -import com.raoulvdberge.refinedstorage.inventory.IItemValidator; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; import com.raoulvdberge.refinedstorage.tile.config.*; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fml.common.FMLCommonHandler; -import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.items.CapabilityItemHandler; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.ItemHandlerHelper; -import javax.annotation.Nonnull; import javax.annotation.Nullable; -import java.util.List; -public class TileDiskDrive extends TileNode implements IStorageProvider, IStorageGui, IComparable, IFilterable, IPrioritizable, IType, IExcessVoidable, IAccessType { +public class TileDiskDrive extends TileNode { public static final TileDataParameter PRIORITY = IPrioritizable.createParameter(); public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter MODE = IFilterable.createParameter(); @@ -40,105 +22,6 @@ public class TileDiskDrive extends TileNode implements IStorageProvider, IStorag public static final TileDataParameter VOID_EXCESS = IExcessVoidable.createParameter(); public static final TileDataParameter ACCESS_TYPE = IAccessType.createParameter(); - public class StorageItem extends StorageItemNBT { - private int lastState; - - public StorageItem(ItemStack disk) { - super(disk.getTagCompound(), EnumItemStorageType.getById(disk.getItemDamage()).getCapacity(), TileDiskDrive.this); - - lastState = getDiskState(getStored(), getCapacity()); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { - if (!IFilterable.canTake(itemFilters, mode, getCompare(), stack)) { - return ItemHandlerHelper.copyStackWithSize(stack, size); - } - - return super.insert(stack, size, simulate); - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public boolean isVoiding() { - return voidExcess; - } - - @Override - public void onStorageChanged() { - super.onStorageChanged(); - - int currentState = getDiskState(getStored(), getCapacity()); - - if (lastState != currentState) { - lastState = currentState; - - updateBlock(); - } - } - } - - public class StorageFluid extends StorageFluidNBT { - private int lastState; - - public StorageFluid(ItemStack disk) { - super(disk.getTagCompound(), EnumFluidStorageType.getById(disk.getItemDamage()).getCapacity(), TileDiskDrive.this); - - lastState = getDiskState(getStored(), getCapacity()); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public FluidStack insert(FluidStack stack, int size, boolean simulate) { - if (!IFilterable.canTakeFluids(fluidFilters, mode, getCompare(), stack)) { - return RSUtils.copyStackWithSize(stack, size); - } - - return super.insert(stack, size, simulate); - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public boolean isVoiding() { - return voidExcess; - } - - @Override - public void onStorageChanged() { - super.onStorageChanged(); - - int currentState = getDiskState(getStored(), getCapacity()); - - if (lastState != currentState) { - lastState = currentState; - - updateBlock(); - } - } - } - - private static final String NBT_PRIORITY = "Priority"; - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_TYPE = "Type"; - private static final String NBT_VOID_EXCESS = "VoidExcess"; private static final String NBT_DISK_STATE = "DiskState_%d"; public static final int DISK_STATE_NORMAL = 0; @@ -147,50 +30,6 @@ public class TileDiskDrive extends TileNode implements IStorageProvider, IStorag public static final int DISK_STATE_DISCONNECTED = 3; public static final int DISK_STATE_NONE = 4; - private ItemHandlerBasic disks = new ItemHandlerBasic(8, this, IItemValidator.STORAGE_DISK) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { - RSUtils.createStorages(getStackInSlot(slot), slot, itemStorages, fluidStorages, s -> new StorageItem(s), s -> new StorageFluid(s)); - - if (network != null) { - network.getItemStorageCache().invalidate(); - network.getFluidStorageCache().invalidate(); - } - - updateBlock(); - } - } - - @Override - public ItemStack extractItem(int slot, int amount, boolean simulate) { - if (itemStorages[slot] != null) { - itemStorages[slot].writeToNBT(); - } - - if (fluidStorages[slot] != null) { - fluidStorages[slot].writeToNBT(); - } - - return super.extractItem(slot, amount, simulate); - } - }; - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this); - - private StorageItem itemStorages[] = new StorageItem[8]; - private StorageFluid fluidStorages[] = new StorageFluid[8]; - - private AccessType accessType = AccessType.INSERT_EXTRACT; - private int priority = 0; - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int mode = IFilterable.WHITELIST; - private int type = IType.ITEMS; - private boolean voidExcess = false; - private Integer[] diskState = new Integer[8]; public TileDiskDrive() { @@ -204,144 +43,11 @@ public class TileDiskDrive extends TileNode implements IStorageProvider, IStorag initDiskState(diskState); } - @Override - public int getEnergyUsage() { - int usage = RS.INSTANCE.config.diskDriveUsage; - - for (int i = 0; i < disks.getSlots(); ++i) { - if (!disks.getStackInSlot(i).isEmpty()) { - usage += RS.INSTANCE.config.diskDrivePerDiskUsage; - } - } - - return usage; - } - - @Override - public void updateNode() { - } - - public void onBreak() { - for (StorageItem storage : this.itemStorages) { - if (storage != null) { - storage.writeToNBT(); - } - } - - for (StorageFluid storage : this.fluidStorages) { - if (storage != null) { - storage.writeToNBT(); - } - } - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - super.onConnectionChange(network, state); - - network.getItemStorageCache().invalidate(); - network.getFluidStorageCache().invalidate(); - - updateBlock(); - } - - @Override - public void addItemStorages(List> storages) { - for (IStorage storage : this.itemStorages) { - if (storage != null) { - storages.add(storage); - } - } - } - - @Override - public void addFluidStorages(List> storages) { - for (IStorage storage : this.fluidStorages) { - if (storage != null) { - storages.add(storage); - } - } - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(disks, 0, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - for (int i = 0; i < disks.getSlots(); ++i) { - if (itemStorages[i] != null) { - itemStorages[i].writeToNBT(); - } - - if (fluidStorages[i] != null) { - fluidStorages[i].writeToNBT(); - } - } - - RSUtils.writeItems(disks, 0, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - RSUtils.writeItems(itemFilters, 1, tag); - RSUtils.writeItems(fluidFilters, 2, tag); - - tag.setInteger(NBT_PRIORITY, priority); - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setInteger(NBT_TYPE, type); - tag.setBoolean(NBT_VOID_EXCESS, voidExcess); - - RSUtils.writeAccessType(tag, accessType); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - RSUtils.readItems(itemFilters, 1, tag); - RSUtils.readItems(fluidFilters, 2, tag); - - if (tag.hasKey(NBT_PRIORITY)) { - priority = tag.getInteger(NBT_PRIORITY); - } - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - if (tag.hasKey(NBT_VOID_EXCESS)) { - voidExcess = tag.getBoolean(NBT_VOID_EXCESS); - } - - accessType = RSUtils.readAccessType(tag); - } - @Override public NBTTagCompound writeUpdate(NBTTagCompound tag) { super.writeUpdate(tag); - writeDiskState(tag, 8, hasNetwork(), itemStorages, fluidStorages); + writeDiskState(tag, 8, getNode().getNetwork() != null, ((NetworkNodeDiskDrive) getNode()).getItemStorages(), ((NetworkNodeDiskDrive) getNode()).getFluidStorages()); return tag; } @@ -366,8 +72,8 @@ public class TileDiskDrive extends TileNode implements IStorageProvider, IStorag state = DISK_STATE_DISCONNECTED; } else { state = getDiskState( - itemStorages[i] != null ? itemStorages[i].getStored() : fluidStorages[i].getStored(), - itemStorages[i] != null ? itemStorages[i].getCapacity() : fluidStorages[i].getCapacity() + itemStorages[i] != null ? itemStorages[i].getStored() : fluidStorages[i].getStored(), + itemStorages[i] != null ? itemStorages[i].getCapacity() : fluidStorages[i].getCapacity() ); } } @@ -399,188 +105,21 @@ public class TileDiskDrive extends TileNode implements IStorageProvider, IStorag } @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public int getMode() { - return mode; - } - - @Override - public void setMode(int mode) { - this.mode = mode; - - markDirty(); - } - - @Override - public String getGuiTitle() { - return "block.refinedstorage:disk_drive.name"; - } - - @Override - public TileDataParameter getTypeParameter() { - return TYPE; - } - - @Override - public TileDataParameter getRedstoneModeParameter() { - return REDSTONE_MODE; - } - - @Override - public TileDataParameter getCompareParameter() { - return COMPARE; - } - - @Override - public TileDataParameter getFilterParameter() { - return MODE; - } - - @Override - public TileDataParameter getPriorityParameter() { - return PRIORITY; - } - - @Override - public TileDataParameter getVoidExcessParameter() { - return VOID_EXCESS; - } - - @Override - public TileDataParameter getAccessTypeParameter() { - return ACCESS_TYPE; - } - - @Override - public String getVoidExcessType() { - return "items_fluids"; - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public void setAccessType(AccessType value) { - this.accessType = value; - - if (network != null) { - network.getFluidStorageCache().invalidate(); - network.getItemStorageCache().invalidate(); - } - - markDirty(); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public void setPriority(int priority) { - this.priority = priority; - - markDirty(); - } - - @Override - public int getStored() { - int stored = 0; - - for (int i = 0; i < disks.getSlots(); ++i) { - ItemStack disk = disks.getStackInSlot(i); - - if (!disk.isEmpty()) { - stored += disk.getItem() == RSItems.STORAGE_DISK ? StorageItemNBT.getStoredFromNBT(disk.getTagCompound()) : StorageFluidNBT.getStoredFromNBT(disk.getTagCompound()); - } - } - - return stored; - } - - @Override - public int getCapacity() { - int capacity = 0; - - for (int i = 0; i < disks.getSlots(); ++i) { - ItemStack disk = disks.getStackInSlot(i); - - if (!disk.isEmpty()) { - int diskCapacity = disk.getItem() == RSItems.STORAGE_DISK ? EnumItemStorageType.getById(disk.getItemDamage()).getCapacity() : EnumFluidStorageType.getById(disk.getItemDamage()).getCapacity(); - - if (diskCapacity == -1) { - return -1; - } - - capacity += diskCapacity; - } - } - - return capacity; - } - - public IItemHandler getDisks() { - return disks; - } - - @Override - public boolean getVoidExcess() { - return voidExcess; - } - - @Override - public void setVoidExcess(boolean voidExcess) { - this.voidExcess = voidExcess; - - markDirty(); - } - - @Override - public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; - } - - @Override - public void setType(int type) { - this.type = type; - - markDirty(); - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; - } - - @Override - public IItemHandler getDrops() { - return disks; + public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { + return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); } @Override public T getCapability(Capability capability, @Nullable EnumFacing facing) { if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { - return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(disks); + return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(((NetworkNodeDiskDrive) getNode()).getDisks()); } return super.getCapability(capability, facing); } @Override - public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { - return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); + public INetworkNode createNode() { + return new NetworkNodeDiskDrive(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskManipulator.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskManipulator.java index 62a39f453..9179d76e6 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskManipulator.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskManipulator.java @@ -1,223 +1,41 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; -import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; -import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; -import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; -import com.raoulvdberge.refinedstorage.inventory.IItemValidator; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDiskManipulator; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.config.IFilterable; import com.raoulvdberge.refinedstorage.tile.config.IType; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fml.common.FMLCommonHandler; -import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.items.CapabilityItemHandler; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.ItemHandlerHelper; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; -import javax.annotation.Nonnull; import javax.annotation.Nullable; -import java.util.ArrayList; -public class TileDiskManipulator extends TileNode implements IComparable, IFilterable, IType { +public class TileDiskManipulator extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter MODE = IFilterable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); - public static final int IO_MODE_INSERT = 0; - public static final int IO_MODE_EXTRACT = 1; - - public static final TileDataParameter IO_MODE = new TileDataParameter<>(DataSerializers.VARINT, IO_MODE_INSERT, new ITileDataProducer() { + public static final TileDataParameter IO_MODE = new TileDataParameter<>(DataSerializers.VARINT, NetworkNodeDiskManipulator.IO_MODE_INSERT, new ITileDataProducer() { @Override public Integer getValue(TileDiskManipulator tile) { - return tile.ioMode; + return ((NetworkNodeDiskManipulator) tile.getNode()).getIoMode(); } }, new ITileDataConsumer() { @Override public void setValue(TileDiskManipulator tile, Integer value) { - tile.ioMode = value; - tile.markDirty(); + ((NetworkNodeDiskManipulator) tile.getNode()).setIoMode(value); + tile.getNode().markDirty(); } }); - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_TYPE = "Type"; - private static final String NBT_IO_MODE = "IOMode"; - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int mode = IFilterable.WHITELIST; - private int type = IType.ITEMS; - private int ioMode = IO_MODE_INSERT; - - private StorageItem[] itemStorages = new StorageItem[6]; - private StorageFluid[] fluidStorages = new StorageFluid[6]; - private Integer[] diskState = new Integer[6]; - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK); - - private ItemHandlerBasic inputDisks = new ItemHandlerBasic(3, this, IItemValidator.STORAGE_DISK) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { - RSUtils.createStorages(getStackInSlot(slot), slot, itemStorages, fluidStorages, s -> new StorageItem(s), s -> new StorageFluid(s)); - - updateBlock(); - } - } - - @Override - @Nonnull - public ItemStack extractItem(int slot, int amount, boolean simulate) { - if (itemStorages[slot] != null) { - itemStorages[slot].writeToNBT(); - } - - if (fluidStorages[slot] != null) { - fluidStorages[slot].writeToNBT(); - } - - return super.extractItem(slot, amount, simulate); - } - }; - - private ItemHandlerBasic outputDisks = new ItemHandlerBasic(3, this, IItemValidator.STORAGE_DISK) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { - RSUtils.createStorages(getStackInSlot(slot), 3 + slot, itemStorages, fluidStorages, s -> new StorageItem(s), s -> new StorageFluid(s)); - - updateBlock(); - } - } - }; - - public class StorageItem extends StorageItemNBT { - private int lastState; - - public StorageItem(ItemStack disk) { - super(disk.getTagCompound(), EnumItemStorageType.getById(disk.getItemDamage()).getCapacity(), TileDiskManipulator.this); - - lastState = TileDiskDrive.getDiskState(getStored(), getCapacity()); - } - - @Override - public int getPriority() { - return 0; - } - - @Override - public boolean isVoiding() { - return false; - } - - @Override - public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { - if (!IFilterable.canTake(itemFilters, mode, getCompare(), stack)) { - return ItemHandlerHelper.copyStackWithSize(stack, size); - } - - return super.insert(stack, size, simulate); - } - - @Override - public ItemStack extract(@Nonnull ItemStack stack, int size, int flags, boolean simulate) { - if (!IFilterable.canTake(itemFilters, mode, getCompare(), stack)) { - return null; - } - - return super.extract(stack, size, flags, simulate); - } - - @Override - public void onStorageChanged() { - super.onStorageChanged(); - - int currentState = TileDiskDrive.getDiskState(getStored(), getCapacity()); - - if (lastState != currentState) { - lastState = currentState; - - updateBlock(); - } - } - } - - public class StorageFluid extends StorageFluidNBT { - private int lastState; - - public StorageFluid(ItemStack disk) { - super(disk.getTagCompound(), EnumFluidStorageType.getById(disk.getItemDamage()).getCapacity(), TileDiskManipulator.this); - - lastState = TileDiskDrive.getDiskState(getStored(), getCapacity()); - } - - @Override - public int getPriority() { - return 0; - } - - @Override - public boolean isVoiding() { - return false; - } - - @Override - public FluidStack insert(FluidStack stack, int size, boolean simulate) { - if (!IFilterable.canTakeFluids(fluidFilters, mode, getCompare(), stack)) { - return RSUtils.copyStackWithSize(stack, size); - } - - return super.insert(stack, size, simulate); - } - - @Override - public FluidStack extract(FluidStack stack, int size, int flags, boolean simulate) { - if (!IFilterable.canTakeFluids(fluidFilters, mode, getCompare(), stack)) { - return null; - } - - return super.extract(stack, size, flags, simulate); - } - - @Override - public void onStorageChanged() { - super.onStorageChanged(); - - int currentState = TileDiskDrive.getDiskState(getStored(), getCapacity()); - - if (lastState != currentState) { - lastState = currentState; - - updateBlock(); - } - } - } - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this); - public TileDiskManipulator() { dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(MODE); @@ -227,358 +45,11 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte TileDiskDrive.initDiskState(diskState); } - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.diskManipulatorUsage + upgrades.getEnergyUsage(); - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public void updateNode() { - if (ticks % upgrades.getSpeed() != 0) { - return; - } - int slot = 0; - if (type == IType.ITEMS) { - while (slot < 3 && itemStorages[slot] == null) { - slot++; - } - - if (slot == 3) { - return; - } - - StorageItem storage = itemStorages[slot]; - - if (ioMode == IO_MODE_INSERT) { - insertIntoNetwork(storage, slot); - } else if (ioMode == IO_MODE_EXTRACT) { - extractFromNetwork(storage, slot); - } - } else if (type == IType.FLUIDS) { - while (slot < 3 && fluidStorages[slot] == null) { - slot++; - } - - if (slot == 3) { - return; - } - - StorageFluid storage = fluidStorages[slot]; - - if (ioMode == IO_MODE_INSERT) { - insertIntoNetwork(storage, slot); - } else if (ioMode == IO_MODE_EXTRACT) { - extractFromNetwork(storage, slot); - } - } - } - - private void insertIntoNetwork(StorageItem storage, int slot) { - if (storage.getStored() == 0) { - moveDriveToOutput(slot); - return; - } - - for (int i = 0; i < storage.getStacks().size(); i++) { - ItemStack stack = storage.getStacks().get(i); - if (stack == null) { - continue; - } - - ItemStack extracted = storage.extract(stack, upgrades.getItemInteractCount(), compare, false); - if (extracted == null) { - continue; - } - - ItemStack remainder = network.insertItem(extracted, extracted.getCount(), false); - if (remainder == null) { - break; - } - - // We need to check if the stack was inserted - storage.insert(((extracted == remainder) ? remainder.copy() : remainder), remainder.getCount(), false); - } - - if (storage.getStacks().size() == 0) { - moveDriveToOutput(slot); - } - } - - private void extractFromNetwork(StorageItem storage, int slot) { - if (storage.getStored() == storage.getCapacity()) { - moveDriveToOutput(slot); - return; - } - - ItemStack extracted = null; - int i = 0; - - if (IFilterable.isEmpty(itemFilters)) { - ItemStack toExtract = null; - ArrayList networkItems = new ArrayList<>(network.getItemStorageCache().getList().getStacks()); - - int j = 0; - - while ((toExtract == null || toExtract.getCount() == 0) && j < networkItems.size()) { - toExtract = networkItems.get(j++); - } - - if (toExtract != null) { - extracted = network.extractItem(toExtract, upgrades.getItemInteractCount(), compare, false); - } - } else { - while (itemFilters.getSlots() > i && extracted == null) { - ItemStack stack = null; - - while (itemFilters.getSlots() > i && stack == null) { - stack = itemFilters.getStackInSlot(i++); - } - - if (stack != null) { - extracted = network.extractItem(stack, upgrades.getItemInteractCount(), compare, false); - } - } - } - - if (extracted == null) { - moveDriveToOutput(slot); - return; - } - - ItemStack remainder = storage.insert(extracted, extracted.getCount(), false); - - if (remainder != null) { - network.insertItem(remainder, remainder.getCount(), false); - } - } - - private void insertIntoNetwork(StorageFluid storage, int slot) { - if (storage.getStored() == 0) { - moveDriveToOutput(slot); - return; - } - - FluidStack extracted = null; - int i = 0; - - while (extracted == null && storage.getStacks().size() > i) { - FluidStack stack = storage.getStacks().get(i); - - while (stack == null && storage.getStacks().size() > i) { - i++; - } - - if (stack != null) { - extracted = storage.extract(stack, upgrades.getItemInteractCount(), compare, false); - } - } - - if (extracted == null) { - moveDriveToOutput(slot); - return; - } - - FluidStack remainder = network.insertFluid(extracted, extracted.amount, false); - - if (remainder != null) { - storage.insert(remainder, remainder.amount, false); - } - } - - private void extractFromNetwork(StorageFluid storage, int slot) { - if (storage.getStored() == storage.getCapacity()) { - moveDriveToOutput(slot); - return; - } - - FluidStack extracted = null; - int i = 0; - - if (IFilterable.isEmpty(itemFilters)) { - FluidStack toExtract = null; - ArrayList networkFluids = new ArrayList<>(network.getFluidStorageCache().getList().getStacks()); - - int j = 0; - - while ((toExtract == null || toExtract.amount == 0) && j < networkFluids.size()) { - toExtract = networkFluids.get(j++); - } - - if (toExtract != null) { - extracted = network.extractFluid(toExtract, upgrades.getItemInteractCount(), compare, false); - } - } else { - while (fluidFilters.getSlots() > i && extracted == null) { - FluidStack stack = null; - - while (fluidFilters.getSlots() > i && stack == null) { - stack = fluidFilters.getFluidStackInSlot(i++); - } - - if (stack != null) { - extracted = network.extractFluid(stack, upgrades.getItemInteractCount(), compare, false); - } - } - } - - if (extracted == null) { - moveDriveToOutput(slot); - return; - } - - FluidStack remainder = storage.insert(extracted, extracted.amount, false); - - if (remainder != null) { - network.insertFluid(remainder, remainder.amount, false); - } - } - - private void moveDriveToOutput(int slot) { - ItemStack disk = inputDisks.getStackInSlot(slot); - if (!disk.isEmpty()) { - int i = 0; - while (i < 3 && !outputDisks.getStackInSlot(i).isEmpty()) { - i++; - } - - if (i == 3) { - return; - } - - if (slot < 3) { - if (itemStorages[slot] != null) { - itemStorages[slot].writeToNBT(); - itemStorages[slot] = null; - } - - if (fluidStorages[slot] != null) { - fluidStorages[slot].writeToNBT(); - fluidStorages[slot] = null; - } - } - inputDisks.extractItem(slot, 1, false); - outputDisks.insertItem(i, disk, false); - } - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - } - - @Override - public int getType() { - return this.type; - } - - @Override - public void setType(int type) { - this.type = type; - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; - } - - @Override - public void setMode(int mode) { - this.mode = mode; - } - - @Override - public int getMode() { - return this.mode; - } - - public IItemHandler getInputDisks() { - return inputDisks; - } - - public IItemHandler getOutputDisks() { - return outputDisks; - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 3, tag); - RSUtils.readItems(inputDisks, 4, tag); - RSUtils.readItems(outputDisks, 5, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - onBreak(); - - RSUtils.writeItems(upgrades, 3, tag); - RSUtils.writeItems(inputDisks, 4, tag); - RSUtils.writeItems(outputDisks, 5, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - RSUtils.writeItems(itemFilters, 1, tag); - RSUtils.writeItems(fluidFilters, 2, tag); - - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setInteger(NBT_TYPE, type); - tag.setInteger(NBT_IO_MODE, ioMode); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - RSUtils.readItems(itemFilters, 1, tag); - RSUtils.readItems(fluidFilters, 2, tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - if (tag.hasKey(NBT_IO_MODE)) { - ioMode = tag.getInteger(NBT_IO_MODE); - } - } - @Override public NBTTagCompound writeUpdate(NBTTagCompound tag) { super.writeUpdate(tag); - TileDiskDrive.writeDiskState(tag, 6, hasNetwork(), itemStorages, fluidStorages); + TileDiskDrive.writeDiskState(tag, 6, getNode().getNetwork() != null, ((NetworkNodeDiskManipulator) getNode()).getItemStorages(), ((NetworkNodeDiskManipulator) getNode()).getFluidStorages()); return tag; } @@ -594,15 +65,10 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte return diskState; } - @Override - public IItemHandler getDrops() { - return new CombinedInvWrapper(inputDisks, outputDisks, upgrades); - } - @Override public T getCapability(Capability capability, @Nullable EnumFacing facing) { if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { - return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(facing == EnumFacing.DOWN ? outputDisks : inputDisks); + return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(facing == EnumFacing.DOWN ? ((NetworkNodeDiskManipulator) getNode()).getOutputDisks() : ((NetworkNodeDiskManipulator) getNode()).getInputDisks()); } return super.getCapability(capability, facing); @@ -613,17 +79,8 @@ public class TileDiskManipulator extends TileNode implements IComparable, IFilte return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); } - public void onBreak() { - for (StorageItem storage : itemStorages) { - if (storage != null) { - storage.writeToNBT(); - } - } - - for (StorageFluid storage : fluidStorages) { - if (storage != null) { - storage.writeToNBT(); - } - } + @Override + public INetworkNode createNode() { + return new NetworkNodeDiskManipulator(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExporter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExporter.java index f350f93dd..df9df74a5 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExporter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExporter.java @@ -1,15 +1,9 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeExporter; import com.raoulvdberge.refinedstorage.container.ContainerExporter; import com.raoulvdberge.refinedstorage.gui.GuiExporter; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.config.IType; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; @@ -18,47 +12,39 @@ import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; import net.minecraft.client.Minecraft; import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.capability.IFluidHandler; -import net.minecraftforge.fluids.capability.IFluidTankProperties; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.ItemHandlerHelper; -public class TileExporter extends TileNode implements IComparable, IType { +public class TileExporter extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); public static final TileDataParameter REGULATOR = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileExporter tile) { - return tile.regulator; + return ((NetworkNodeExporter) tile.getNode()).isRegulator(); } }, new ITileDataConsumer() { @Override public void setValue(TileExporter tile, Boolean value) { - if (!value && tile.regulator) { - for (int i = 0; i < tile.itemFilters.getSlots() + tile.fluidFilters.getSlots(); ++i) { - ItemStack slot = i >= tile.itemFilters.getSlots() ? tile.fluidFilters.getStackInSlot(i - tile.itemFilters.getSlots()) : tile.itemFilters.getStackInSlot(i); + NetworkNodeExporter exporter = (NetworkNodeExporter) tile.getNode(); - if (!slot.isEmpty()) { - slot.setCount(1); - } + for (int i = 0; i < exporter.getItemFilters().getSlots() + exporter.getFluidFilters().getSlots(); ++i) { + ItemStack slot = i >= exporter.getItemFilters().getSlots() ? exporter.getFluidFilters().getStackInSlot(i - exporter.getItemFilters().getSlots()) : exporter.getItemFilters().getStackInSlot(i); + + if (!slot.isEmpty()) { + slot.setCount(1); } } - tile.regulator = value; - - tile.markDirty(); + exporter.setRegulator(value); + exporter.markDirty(); tile.getWorld().getMinecraftServer().getPlayerList().getPlayers().stream() - .filter(player -> player.openContainer instanceof ContainerExporter && ((ContainerExporter) player.openContainer).getTile().getPos().equals(tile.getPos())) - .forEach(player -> { - ((ContainerExporter) player.openContainer).initSlots(); + .filter(player -> player.openContainer instanceof ContainerExporter && ((ContainerExporter) player.openContainer).getTile().getPos().equals(tile.getPos())) + .forEach(player -> { + ((ContainerExporter) player.openContainer).initSlots(); - player.openContainer.detectAndSendChanges(); - }); + player.openContainer.detectAndSendChanges(); + }); } }, new ITileDataListener() { @Override @@ -69,19 +55,6 @@ public class TileExporter extends TileNode implements IComparable, IType { } }); - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_TYPE = "Type"; - private static final String NBT_REGULATOR = "Regulator"; - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK); - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int type = IType.ITEMS; - private boolean regulator = false; - public TileExporter() { dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(TYPE); @@ -89,201 +62,7 @@ public class TileExporter extends TileNode implements IComparable, IType { } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.exporterUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - if (ticks % upgrades.getSpeed() == 0) { - if (type == IType.ITEMS) { - IItemHandler handler = RSUtils.getItemHandler(getFacingTile(), getDirection().getOpposite()); - - if (handler != null) { - for (int i = 0; i < itemFilters.getSlots(); ++i) { - ItemStack slot = itemFilters.getStackInSlot(i); - - if (!slot.isEmpty()) { - int stackSize = upgrades.getItemInteractCount(); - - boolean skipSlot = false; - - if (regulator) { - for (int index = 0; i < handler.getSlots() && !skipSlot; i++) { - ItemStack exporterStack = handler.getStackInSlot(index); - - if (API.instance().getComparer().isEqual(slot, exporterStack, compare)) { - if (exporterStack.getCount() >= slot.getCount()) { - skipSlot = true; - } else { - stackSize = upgrades.hasUpgrade(ItemUpgrade.TYPE_STACK) ? slot.getCount() - exporterStack.getCount() : 1; - } - } - } - } - - if (skipSlot) { - continue; - } - - ItemStack took = network.extractItem(slot, stackSize, compare, true); - - if (took == null) { - if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { - network.scheduleCraftingTask(slot, 1, compare); - } - } else if (ItemHandlerHelper.insertItem(handler, took, true).isEmpty()) { - took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false); - - ItemHandlerHelper.insertItem(handler, took, false); - } - } - } - } - } else if (type == IType.FLUIDS) { - IFluidHandler handler = RSUtils.getFluidHandler(getFacingTile(), getDirection().getOpposite()); - - if (handler != null) { - for (FluidStack stack : fluidFilters.getFluids()) { - if (stack != null) { - FluidStack stackInStorage = network.getFluidStorageCache().getList().get(stack, compare); - - if (stackInStorage != null) { - int toExtract = Math.min(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), stackInStorage.amount); - - boolean skipSlot = false; - - if (regulator) { - for (IFluidTankProperties tankProperty : handler.getTankProperties()) { - FluidStack exporterStack = tankProperty.getContents(); - - if (API.instance().getComparer().isEqual(stackInStorage, exporterStack, compare)) { - if (exporterStack.amount >= stack.amount * Fluid.BUCKET_VOLUME) { - skipSlot = true; - - break; - } else { - toExtract = upgrades.hasUpgrade(ItemUpgrade.TYPE_STACK) ? stack.amount * Fluid.BUCKET_VOLUME - exporterStack.amount : Fluid.BUCKET_VOLUME; - toExtract = Math.min(toExtract, stackInStorage.amount); - } - } - } - } - - if (skipSlot) { - continue; - } - - FluidStack took = network.extractFluid(stack, toExtract, compare, true); - - if (took != null) { - int filled = handler.fill(took, false); - - if (filled > 0) { - took = network.extractFluid(stack, filled, compare, false); - - handler.fill(took, true); - - break; - } - } - } - } - } - } - } - } - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 1, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(upgrades, 1, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_TYPE, type); - tag.setBoolean(NBT_REGULATOR, regulator); - - RSUtils.writeItems(itemFilters, 0, tag); - RSUtils.writeItems(fluidFilters, 2, tag); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - if (tag.hasKey(NBT_REGULATOR)) { - regulator = tag.getBoolean(NBT_REGULATOR); - } - - RSUtils.readItems(itemFilters, 0, tag); - RSUtils.readItems(fluidFilters, 2, tag); - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return upgrades; - } - - @Override - public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; - } - - @Override - public void setType(int type) { - this.type = type; - - markDirty(); - } - - public boolean isRegulator() { - return !getWorld().isRemote ? regulator : REGULATOR.getValue(); - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; + public INetworkNode createNode() { + return new NetworkNodeExporter(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExternalStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExternalStorage.java new file mode 100755 index 000000000..4dfa1b7f6 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileExternalStorage.java @@ -0,0 +1,68 @@ +package com.raoulvdberge.refinedstorage.tile; + +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.api.storage.AccessType; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.NetworkNodeExternalStorage; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.StorageFluidExternal; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.StorageItemExternal; +import com.raoulvdberge.refinedstorage.tile.config.*; +import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; +import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; +import net.minecraft.network.datasync.DataSerializers; + +public class TileExternalStorage extends TileNode { + public static final TileDataParameter PRIORITY = IPrioritizable.createParameter(); + public static final TileDataParameter COMPARE = IComparable.createParameter(); + public static final TileDataParameter MODE = IFilterable.createParameter(); + public static final TileDataParameter TYPE = IType.createParameter(); + public static final TileDataParameter ACCESS_TYPE = IAccessType.createParameter(); + + public static final TileDataParameter STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { + @Override + public Integer getValue(TileExternalStorage tile) { + int stored = 0; + + for (StorageItemExternal storage : ((NetworkNodeExternalStorage) tile.getNode()).getItemStorages()) { + stored += storage.getStored(); + } + + for (StorageFluidExternal storage : ((NetworkNodeExternalStorage) tile.getNode()).getFluidStorages()) { + stored += storage.getStored(); + } + + return stored; + } + }); + + public static final TileDataParameter CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { + @Override + public Integer getValue(TileExternalStorage tile) { + int capacity = 0; + + for (StorageItemExternal storage : ((NetworkNodeExternalStorage) tile.getNode()).getItemStorages()) { + capacity += storage.getCapacity(); + } + + for (StorageFluidExternal storage : ((NetworkNodeExternalStorage) tile.getNode()).getFluidStorages()) { + capacity += storage.getCapacity(); + } + + return capacity; + } + }); + + public TileExternalStorage() { + dataManager.addWatchedParameter(PRIORITY); + dataManager.addWatchedParameter(COMPARE); + dataManager.addWatchedParameter(MODE); + dataManager.addWatchedParameter(STORED); + dataManager.addWatchedParameter(CAPACITY); + dataManager.addWatchedParameter(TYPE); + dataManager.addWatchedParameter(ACCESS_TYPE); + } + + @Override + public INetworkNode createNode() { + return new NetworkNodeExternalStorage(this); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidInterface.java index f6056feb7..ac83efd72 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidInterface.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidInterface.java @@ -1,235 +1,39 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidInterface; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.RSSerializers; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; -import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.FluidTank; import net.minecraftforge.fluids.capability.CapabilityFluidHandler; -import org.apache.commons.lang3.tuple.Pair; import javax.annotation.Nullable; -public class TileFluidInterface extends TileNode implements IComparable { - public static final int TANK_CAPACITY = 16000; - +public class TileFluidInterface extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter TANK_IN = new TileDataParameter<>(RSSerializers.FLUID_STACK_SERIALIZER, null, new ITileDataProducer() { @Override public FluidStack getValue(TileFluidInterface tile) { - return tile.tankIn.getFluid(); + return ((NetworkNodeFluidInterface) tile.getNode()).getTankIn().getFluid(); } }); public static final TileDataParameter TANK_OUT = new TileDataParameter<>(RSSerializers.FLUID_STACK_SERIALIZER, null, new ITileDataProducer() { @Override public FluidStack getValue(TileFluidInterface tile) { - return tile.tankOut.getFluid(); + return ((NetworkNodeFluidInterface) tile.getNode()).getTankOut().getFluid(); } }); - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_TANK_IN = "TankIn"; - private static final String NBT_TANK_OUT = "TankOut"; - - private int compare = IComparer.COMPARE_NBT; - - private FluidTank tankIn = new FluidTank(TANK_CAPACITY) { - @Override - protected void onContentsChanged() { - super.onContentsChanged(); - - if (getWorld() != null && !getWorld().isRemote) { - dataManager.sendParameterToWatchers(TANK_IN); - } - - markDirty(); - } - }; - - private FluidTank tankOut = new FluidTank(TANK_CAPACITY) { - @Override - protected void onContentsChanged() { - super.onContentsChanged(); - - if (getWorld() != null && !getWorld().isRemote) { - dataManager.sendParameterToWatchers(TANK_OUT); - } - - markDirty(); - } - }; - - private ItemHandlerBasic in = new ItemHandlerBasic(1, this); - private ItemHandlerFluid out = new ItemHandlerFluid(1, this); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK); - public TileFluidInterface() { dataManager.addWatchedParameter(COMPARE); dataManager.addParameter(TANK_IN); dataManager.addParameter(TANK_OUT); - - tankIn.setCanDrain(false); - tankIn.setCanFill(true); - - tankOut.setCanDrain(true); - tankOut.setCanFill(false); - } - - @Override - public void updateNode() { - ItemStack container = in.getStackInSlot(0); - - if (!container.isEmpty()) { - Pair result = RSUtils.getFluidFromStack(container, true); - - if (result.getValue() != null && tankIn.fillInternal(result.getValue(), false) == result.getValue().amount) { - result = RSUtils.getFluidFromStack(container, false); - - tankIn.fillInternal(result.getValue(), true); - - in.setStackInSlot(0, result.getLeft()); - } - } - - if (ticks % upgrades.getSpeed() == 0) { - FluidStack drained = tankIn.drainInternal(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), true); - - // Drain in tank - if (drained != null) { - FluidStack remainder = network.insertFluid(drained, drained.amount, false); - - if (remainder != null) { - tankIn.fillInternal(remainder, true); - } - } - - FluidStack stack = out.getFluidStackInSlot(0); - - // Fill out tank - - // If our out fluid doesn't match the new fluid, empty it first - if (tankOut.getFluid() != null && (stack == null || (tankOut.getFluid().getFluid() != stack.getFluid()))) { - FluidStack remainder = tankOut.drainInternal(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), true); - - if (remainder != null) { - network.insertFluid(remainder, remainder.amount, false); - } - } else if (stack != null) { - // Fill the out fluid - FluidStack stackInStorage = network.getFluidStorageCache().getList().get(stack, compare); - - if (stackInStorage != null) { - int toExtract = Math.min(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), stackInStorage.amount); - - FluidStack took = network.extractFluid(stack, toExtract, compare, true); - - if (took != null && (toExtract - tankOut.fillInternal(took, false)) == 0) { - took = network.extractFluid(stack, toExtract, compare, false); - - tankOut.fillInternal(took, true); - } - } - } - } - } - - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.fluidInterfaceUsage; - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(upgrades, 0, tag); - RSUtils.writeItems(in, 1, tag); - - tag.setTag(NBT_TANK_IN, tankIn.writeToNBT(new NBTTagCompound())); - tag.setTag(NBT_TANK_OUT, tankOut.writeToNBT(new NBTTagCompound())); - - return tag; - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 0, tag); - RSUtils.readItems(in, 1, tag); - - if (tag.hasKey(NBT_TANK_IN)) { - tankIn.readFromNBT(tag.getCompoundTag(NBT_TANK_IN)); - } - - if (tag.hasKey(NBT_TANK_OUT)) { - tankOut.readFromNBT(tag.getCompoundTag(NBT_TANK_OUT)); - } - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - RSUtils.writeItems(out, 2, tag); - - tag.setInteger(NBT_COMPARE, compare); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - RSUtils.readItems(out, 2, tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - } - - public ItemHandlerUpgrade getUpgrades() { - return upgrades; - } - - public ItemHandlerBasic getIn() { - return in; - } - - public ItemHandlerFluid getOut() { - return out; - } - - @Override - public boolean hasConnectivityState() { - return true; } @Override @@ -240,9 +44,14 @@ public class TileFluidInterface extends TileNode implements IComparable { @Override public T getCapability(Capability capability, @Nullable EnumFacing facing) { if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { - return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(facing == EnumFacing.DOWN ? tankOut : tankIn); + return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(facing == EnumFacing.DOWN ? ((NetworkNodeFluidInterface) getNode()).getTankOut() : ((NetworkNodeFluidInterface) getNode()).getTankIn()); } return super.getCapability(capability, facing); } + + @Override + public INetworkNode createNode() { + return new NetworkNodeFluidInterface(this); + } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidStorage.java index ab6e25295..53b5c8f80 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidStorage.java @@ -1,28 +1,15 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSBlocks; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.storage.AccessType; -import com.raoulvdberge.refinedstorage.api.storage.IStorage; -import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; -import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidStorage; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageFluidNBT; -import com.raoulvdberge.refinedstorage.block.BlockFluidStorage; -import com.raoulvdberge.refinedstorage.block.EnumFluidStorageType; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; import com.raoulvdberge.refinedstorage.tile.config.*; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraftforge.fluids.FluidStack; -import java.util.List; - -public class TileFluidStorage extends TileNode implements IStorageProvider, IStorageGui, IComparable, IFilterable, IPrioritizable, IExcessVoidable, IAccessType { +public class TileFluidStorage extends TileNode { public static final TileDataParameter PRIORITY = IPrioritizable.createParameter(); public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter VOID_EXCESS = IExcessVoidable.createParameter(); @@ -31,61 +18,10 @@ public class TileFluidStorage extends TileNode implements IStorageProvider, ISto public static final TileDataParameter STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileFluidStorage tile) { - return StorageFluidNBT.getStoredFromNBT(tile.storageTag); + return StorageFluidNBT.getStoredFromNBT(((NetworkNodeFluidStorage) tile.getNode()).getStorageTag()); } }); - class StorageFluid extends StorageFluidNBT { - public StorageFluid() { - super(TileFluidStorage.this.getStorageTag(), TileFluidStorage.this.getCapacity(), TileFluidStorage.this); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public FluidStack insert(FluidStack stack, int size, boolean simulate) { - if (!IFilterable.canTakeFluids(filters, mode, compare, stack)) { - return RSUtils.copyStackWithSize(stack, size); - } - - return super.insert(stack, size, simulate); - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public boolean isVoiding() { - return voidExcess; - } - } - - public static final String NBT_STORAGE = "Storage"; - - private static final String NBT_PRIORITY = "Priority"; - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_VOID_EXCESS = "VoidExcess"; - - private ItemHandlerFluid filters = new ItemHandlerFluid(9, this); - - private NBTTagCompound storageTag = StorageFluidNBT.createNBT(); - - private StorageFluid storage; - - private EnumFluidStorageType type; - - private AccessType accessType = AccessType.INSERT_EXTRACT; - private int priority = 0; - private int compare = IComparer.COMPARE_NBT; - private int mode = IFilterable.WHITELIST; - private boolean voidExcess = false; - public TileFluidStorage() { dataManager.addWatchedParameter(PRIORITY); dataManager.addWatchedParameter(COMPARE); @@ -96,256 +32,8 @@ public class TileFluidStorage extends TileNode implements IStorageProvider, ISto } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.fluidStorageUsage; - } - - @Override - public void updateNode() { - } - - @Override - public void update() { - super.update(); - - if (storage == null && storageTag != null) { - storage = new StorageFluid(); - - if (network != null) { - network.getFluidStorageCache().invalidate(); - } - } - } - - public void onBreak() { - if (storage != null) { - storage.writeToNBT(); - } - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - super.onConnectionChange(network, state); - - network.getFluidStorageCache().invalidate(); - } - - @Override - public void addItemStorages(List> storages) { - // NO OP - } - - @Override - public void addFluidStorages(List> storages) { - if (storage != null) { - storages.add(storage); - } - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - if (tag.hasKey(NBT_STORAGE)) { - storageTag = tag.getCompoundTag(NBT_STORAGE); - } - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - if (storage != null) { - storage.writeToNBT(); - } - - tag.setTag(NBT_STORAGE, storageTag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - RSUtils.writeItems(filters, 0, tag); - - tag.setInteger(NBT_PRIORITY, priority); - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setBoolean(NBT_VOID_EXCESS, voidExcess); - - RSUtils.writeAccessType(tag, accessType); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - RSUtils.readItems(filters, 0, tag); - - if (tag.hasKey(NBT_PRIORITY)) { - priority = tag.getInteger(NBT_PRIORITY); - } - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_VOID_EXCESS)) { - voidExcess = tag.getBoolean(NBT_VOID_EXCESS); - } - - accessType = RSUtils.readAccessType(tag); - } - - public EnumFluidStorageType getType() { - if (type == null && getWorld().getBlockState(pos).getBlock() == RSBlocks.FLUID_STORAGE) { - this.type = ((EnumFluidStorageType) getWorld().getBlockState(pos).getValue(BlockFluidStorage.TYPE)); - } - - return type == null ? EnumFluidStorageType.TYPE_64K : type; - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public int getMode() { - return mode; - } - - @Override - public void setMode(int mode) { - this.mode = mode; - - markDirty(); - } - - @Override - public String getGuiTitle() { - return "block.refinedstorage:fluid_storage." + getType().getId() + ".name"; - } - - @Override - public TileDataParameter getTypeParameter() { - return null; - } - - @Override - public TileDataParameter getRedstoneModeParameter() { - return REDSTONE_MODE; - } - - @Override - public TileDataParameter getCompareParameter() { - return COMPARE; - } - - @Override - public TileDataParameter getFilterParameter() { - return MODE; - } - - @Override - public TileDataParameter getPriorityParameter() { - return PRIORITY; - } - - @Override - public TileDataParameter getVoidExcessParameter() { - return VOID_EXCESS; - } - - @Override - public TileDataParameter getAccessTypeParameter() { - return ACCESS_TYPE; - } - - @Override - public String getVoidExcessType() { - return "fluids"; - } - - public NBTTagCompound getStorageTag() { - return storageTag; - } - - public void setStorageTag(NBTTagCompound storageTag) { - this.storageTag = storageTag; - } - - public StorageFluidNBT getStorage() { - return storage; - } - - public ItemHandlerFluid getFilters() { - return filters; - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public void setAccessType(AccessType value) { - this.accessType = value; - - if (network != null) { - network.getFluidStorageCache().invalidate(); - } - - markDirty(); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public void setPriority(int priority) { - this.priority = priority; - - markDirty(); - } - - @Override - public int getStored() { - return STORED.getValue(); - } - - @Override - public int getCapacity() { - return getType().getCapacity(); - } - - @Override - public boolean getVoidExcess() { - return voidExcess; - } - - @Override - public void setVoidExcess(boolean value) { - this.voidExcess = value; - - markDirty(); + public INetworkNode createNode() { + return new NetworkNodeFluidStorage(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileImporter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileImporter.java index 5a54f2857..38280028e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileImporter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileImporter.java @@ -1,43 +1,17 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeImporter; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.config.IFilterable; import com.raoulvdberge.refinedstorage.tile.config.IType; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.capability.IFluidHandler; -import net.minecraftforge.items.IItemHandler; -public class TileImporter extends TileNode implements IComparable, IFilterable, IType { +public class TileImporter extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter MODE = IFilterable.createParameter(); public static final TileDataParameter TYPE = IType.createParameter(); - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_TYPE = "Type"; - - private ItemHandlerBasic itemFilters = new ItemHandlerBasic(9, this); - private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, this); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK); - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int mode = IFilterable.WHITELIST; - private int type = IType.ITEMS; - - private int currentSlot; - public TileImporter() { dataManager.addWatchedParameter(COMPARE); dataManager.addWatchedParameter(MODE); @@ -45,159 +19,7 @@ public class TileImporter extends TileNode implements IComparable, IFilterable, } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.importerUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - if (type == IType.ITEMS) { - IItemHandler handler = RSUtils.getItemHandler(getFacingTile(), getDirection().getOpposite()); - - if (getFacingTile() instanceof TileDiskDrive || handler == null) { - return; - } - - if (currentSlot >= handler.getSlots()) { - currentSlot = 0; - } - - if (handler.getSlots() > 0) { - ItemStack stack = handler.getStackInSlot(currentSlot); - - if (stack.isEmpty() || !IFilterable.canTake(itemFilters, mode, compare, stack)) { - currentSlot++; - } else if (ticks % upgrades.getSpeed() == 0) { - ItemStack result = handler.extractItem(currentSlot, upgrades.getItemInteractCount(), true); - - if (!result.isEmpty() && network.insertItem(result, result.getCount(), true) == null) { - network.insertItem(result, result.getCount(), false); - - handler.extractItem(currentSlot, upgrades.getItemInteractCount(), false); - } else { - currentSlot++; - } - } - } - } else if (type == IType.FLUIDS && ticks % upgrades.getSpeed() == 0) { - IFluidHandler handler = RSUtils.getFluidHandler(getFacingTile(), getDirection().getOpposite()); - - if (handler != null) { - FluidStack stack = handler.drain(Fluid.BUCKET_VOLUME, false); - - if (stack != null && IFilterable.canTakeFluids(fluidFilters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { - FluidStack toDrain = handler.drain(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), false); - - if (toDrain != null) { - FluidStack remainder = network.insertFluid(toDrain, toDrain.amount, false); - if (remainder != null) { - toDrain.amount -= remainder.amount; - } - handler.drain(toDrain, true); - } - } - } - } - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public int getMode() { - return mode; - } - - @Override - public void setMode(int mode) { - this.mode = mode; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 1, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(upgrades, 1, tag); - - return tag; - } - - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setInteger(NBT_TYPE, type); - - RSUtils.writeItems(itemFilters, 0, tag); - RSUtils.writeItems(fluidFilters, 2, tag); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_TYPE)) { - type = tag.getInteger(NBT_TYPE); - } - - RSUtils.readItems(itemFilters, 0, tag); - RSUtils.readItems(fluidFilters, 2, tag); - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return upgrades; - } - - @Override - public int getType() { - return getWorld().isRemote ? TYPE.getValue() : type; - } - - @Override - public void setType(int type) { - this.type = type; - - markDirty(); - } - - @Override - public IItemHandler getFilterInventory() { - return getType() == IType.ITEMS ? itemFilters : fluidFilters; + public INetworkNode createNode() { + return new NetworkNodeImporter(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileInterface.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileInterface.java index 79b726951..c063f1c1c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileInterface.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileInterface.java @@ -1,195 +1,26 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.util.IComparer; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerInterface; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeInterface; import com.raoulvdberge.refinedstorage.tile.config.IComparable; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.items.CapabilityItemHandler; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; import javax.annotation.Nullable; -public class TileInterface extends TileNode implements IComparable { +public class TileInterface extends TileNode { public static final TileDataParameter COMPARE = IComparable.createParameter(); - private static final String NBT_COMPARE = "Compare"; - - private ItemHandlerBasic importItems = new ItemHandlerBasic(9, this); - - private ItemHandlerBasic exportSpecimenItems = new ItemHandlerBasic(9, this); - private ItemHandlerBasic exportItems = new ItemHandlerBasic(9, this); - - private ItemHandlerInterface items = new ItemHandlerInterface(importItems, exportItems); - - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING); - - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - - private int currentSlot = 0; - public TileInterface() { dataManager.addWatchedParameter(COMPARE); } - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.interfaceUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - if (currentSlot >= importItems.getSlots()) { - currentSlot = 0; - } - - ItemStack slot = importItems.getStackInSlot(currentSlot); - - if (slot.isEmpty()) { - currentSlot++; - } else if (ticks % upgrades.getSpeed() == 0) { - int size = Math.min(slot.getCount(), upgrades.getItemInteractCount()); - - ItemStack remainder = network.insertItem(slot, size, false); - - if (remainder == null) { - importItems.extractItemInternal(currentSlot, size, false); - } else { - importItems.extractItemInternal(currentSlot, size - remainder.getCount(), false); - - currentSlot++; - } - } - - for (int i = 0; i < 9; ++i) { - ItemStack wanted = exportSpecimenItems.getStackInSlot(i); - ItemStack got = exportItems.getStackInSlot(i); - - if (wanted.isEmpty()) { - if (!got.isEmpty()) { - exportItems.setStackInSlot(i, RSUtils.getStack(network.insertItem(got, got.getCount(), false))); - } - } else { - int delta = got.isEmpty() ? wanted.getCount() : (wanted.getCount() - got.getCount()); - - if (delta > 0) { - ItemStack result = network.extractItem(wanted, delta, compare, false); - - if (result != null) { - if (exportItems.getStackInSlot(i).isEmpty()) { - exportItems.setStackInSlot(i, result); - } else { - exportItems.getStackInSlot(i).grow(result.getCount()); - } - } else if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { - network.scheduleCraftingTask(wanted, delta, compare); - } - } else if (delta < 0) { - ItemStack remainder = network.insertItem(got, Math.abs(delta), false); - - if (remainder == null) { - exportItems.extractItem(i, Math.abs(delta), false); - } else { - exportItems.extractItem(i, Math.abs(delta) - remainder.getCount(), false); - } - } - } - } - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(importItems, 0, tag); - RSUtils.readItems(exportItems, 2, tag); - RSUtils.readItems(upgrades, 3, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(importItems, 0, tag); - RSUtils.writeItems(exportItems, 2, tag); - RSUtils.writeItems(upgrades, 3, tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - RSUtils.writeItems(exportSpecimenItems, 1, tag); - - tag.setInteger(NBT_COMPARE, compare); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - RSUtils.readItems(exportSpecimenItems, 1, tag); - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - } - - public IItemHandler getImportItems() { - return importItems; - } - - public IItemHandler getExportSpecimenItems() { - return exportSpecimenItems; - } - - public IItemHandler getExportItems() { - return exportItems; - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return new CombinedInvWrapper(importItems, exportItems, upgrades); - } - - @Override - public boolean hasConnectivityState() { - return true; - } - @Override public T getCapability(Capability capability, @Nullable EnumFacing facing) { if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { - return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(items); + return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(((NetworkNodeInterface) getNode()).getItems()); } return super.getCapability(capability, facing); @@ -199,4 +30,9 @@ public class TileInterface extends TileNode implements IComparable { public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); } + + @Override + public INetworkNode createNode() { + return new NetworkNodeInterface(this); + } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkReceiver.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkReceiver.java index fd2be0afb..22ef25100 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkReceiver.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkReceiver.java @@ -1,25 +1,12 @@ package com.raoulvdberge.refinedstorage.tile; import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeBasic; public class TileNetworkReceiver extends TileNode { @Override - public void updateNode() { - } - - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.networkReceiverUsage; - } - - @Override - public void setRedstoneMode(RedstoneMode mode) { - // NO OP - } - - @Override - public boolean hasConnectivityState() { - return true; + public INetworkNode createNode() { + return new NetworkNodeBasic(this, RS.INSTANCE.config.networkReceiverUsage, true); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkTransmitter.java index c9ae3faed..3db73e368 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkTransmitter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkTransmitter.java @@ -1,176 +1,43 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSItems; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; -import com.raoulvdberge.refinedstorage.item.ItemNetworkCard; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeNetworkTransmitter; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; -import net.minecraftforge.common.DimensionManager; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; public class TileNetworkTransmitter extends TileNode { public static final TileDataParameter DISTANCE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileNetworkTransmitter tile) { - return (tile.receiver != null && tile.isSameDimension()) ? tile.getDistance() : -1; + NetworkNodeNetworkTransmitter transmitter = (NetworkNodeNetworkTransmitter) tile.getNode(); + + return (transmitter.getReceiver() != null && transmitter.isSameDimension()) ? transmitter.getDistance() : -1; } }); public static final TileDataParameter RECEIVER_DIMENSION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileNetworkTransmitter tile) { - return tile.receiverDimension; + return ((NetworkNodeNetworkTransmitter) tile.getNode()).getReceiverDimension(); } }); public static final TileDataParameter RECEIVER_DIMENSION_SUPPORTED = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileNetworkTransmitter tile) { - return tile.isDimensionSupported(); + return ((NetworkNodeNetworkTransmitter) tile.getNode()).isDimensionSupported(); } }); - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(1, this, ItemUpgrade.TYPE_INTERDIMENSIONAL) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - if (network != null) { - network.getNodeGraph().rebuild(); - } - } - }; - - private ItemHandlerBasic networkCard = new ItemHandlerBasic(1, this, new ItemValidatorBasic(RSItems.NETWORK_CARD)) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - ItemStack card = getStackInSlot(slot); - - if (card.isEmpty()) { - receiver = null; - } else { - receiver = ItemNetworkCard.getReceiver(card); - receiverDimension = ItemNetworkCard.getDimension(card); - } - - if (network != null) { - network.getNodeGraph().rebuild(); - } - } - }; - - private BlockPos receiver; - private int receiverDimension; - public TileNetworkTransmitter() { dataManager.addWatchedParameter(DISTANCE); dataManager.addWatchedParameter(RECEIVER_DIMENSION); dataManager.addWatchedParameter(RECEIVER_DIMENSION_SUPPORTED); - - rebuildOnUpdateChange = true; } @Override - public void updateNode() { - } - - public boolean canTransmit() { - return canUpdate() && receiver != null && isDimensionSupported(); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(networkCard, 0, tag); - RSUtils.writeItems(upgrades, 1, tag); - - return tag; - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(networkCard, 0, tag); - RSUtils.readItems(upgrades, 1, tag); - } - - @Override - public int getEnergyUsage() { - return Math.min( - RS.INSTANCE.config.interdimensionalUpgradeUsage, - RS.INSTANCE.config.networkTransmitterUsage + (isSameDimension() ? (int) Math.ceil(RS.INSTANCE.config.networkTransmitterPerBlockUsage * getDistance()) : 0) + upgrades.getEnergyUsage() - ); - } - - public ItemHandlerBasic getNetworkCard() { - return networkCard; - } - - public ItemHandlerUpgrade getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return new CombinedInvWrapper(networkCard, upgrades); - } - - public BlockPos getReceiver() { - return receiver; - } - - public int getReceiverDimension() { - return receiverDimension; - } - - private int getDistance() { - if (receiver == null) { - return 0; - } - - return (int) Math.sqrt(Math.pow(pos.getX() - receiver.getX(), 2) + Math.pow(pos.getY() - receiver.getY(), 2) + Math.pow(pos.getZ() - receiver.getZ(), 2)); - } - - public boolean isSameDimension() { - return getWorld().provider.getDimension() == receiverDimension; - } - - private boolean isDimensionSupported() { - return isSameDimension() || upgrades.hasUpgrade(ItemUpgrade.TYPE_INTERDIMENSIONAL); - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public void walkNeighborhood(Operator operator) { - super.walkNeighborhood(operator); - if (canTransmit()) { - if (!isSameDimension()) { - final World dimensionWorld = DimensionManager.getWorld(receiverDimension); - if (dimensionWorld != null) { - operator.apply(dimensionWorld, receiver, null); - } - } else { - operator.apply(getWorld(), receiver, null); - } - } + public INetworkNode createNode() { + return new NetworkNodeNetworkTransmitter(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNode.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNode.java index a43a95a10..8c45a6218 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNode.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileNode.java @@ -1,116 +1,115 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; -import com.raoulvdberge.refinedstorage.api.network.INetworkNeighborhoodAware; import com.raoulvdberge.refinedstorage.api.network.INetworkNode; -import com.raoulvdberge.refinedstorage.api.util.IWrenchable; -import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNode; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode; +import com.raoulvdberge.refinedstorage.proxy.CapabilityNetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.config.IRedstoneConfigurable; import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.block.state.IBlockState; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; +import net.minecraftforge.items.IItemHandler; -import javax.annotation.Nonnull; import javax.annotation.Nullable; -public abstract class TileNode extends TileBase implements INetworkNode, IRedstoneConfigurable, IWrenchable, INetworkNeighborhoodAware { +public abstract class TileNode extends TileBase implements INetworkNodeProxy, INetworkNodeHolder, IRedstoneConfigurable { public static final TileDataParameter REDSTONE_MODE = RedstoneMode.createParameter(); private static final String NBT_ACTIVE = "Active"; - private RedstoneMode redstoneMode = RedstoneMode.IGNORE; private boolean active; - protected boolean rebuildOnUpdateChange; - - protected INetworkMaster network; public TileNode() { dataManager.addWatchedParameter(REDSTONE_MODE); } @Override - public boolean canUpdate() { - return redstoneMode.isEnabled(getWorld(), pos); + public void update() { + super.update(); + + getNode().update(); } + @Override + public World world() { + return getWorld(); + } + + @Override + public BlockPos pos() { + return pos; + } + + @Override + public RedstoneMode getRedstoneMode() { + return ((NetworkNode) getNode()).getRedstoneMode(); + } + + @Override + public void setRedstoneMode(RedstoneMode mode) { + ((NetworkNode) getNode()).setRedstoneMode(mode); + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + getNode().read(tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + getNode().write(tag); + + return tag; + } + + public NBTTagCompound writeUpdate(NBTTagCompound tag) { + super.writeUpdate(tag); + + if (((NetworkNode) getNode()).hasConnectivityState()) { + tag.setBoolean(NBT_ACTIVE, getNode().getNetwork() != null && getNode().canUpdate()); + } + + return tag; + } + + public void readUpdate(NBTTagCompound tag) { + if (((NetworkNode) getNode()).hasConnectivityState()) { + active = tag.getBoolean(NBT_ACTIVE); + } + + super.readUpdate(tag); + } + + public IItemHandler getDrops() { + return ((NetworkNode) getNode()).getDrops(); + } + + // @TODO + private INetworkNode node; + + @Override + public INetworkNode getNode() { + return node == null ? (node = createNode()) : node; + } + + @SideOnly(Side.CLIENT) public boolean isActive() { return active; } - public abstract void updateNode(); - - @Override - public void update() { - if (!getWorld().isRemote) { - boolean wasActive = active; - - active = hasNetwork() && canUpdate(); - - if (active != wasActive) { - if (hasConnectivityState()) { - updateBlock(); - } - - if (network != null) { - onConnectionChange(network, active); - - if (rebuildOnUpdateChange) { - network.getNodeGraph().rebuild(); - } - } - } - - if (active) { - updateNode(); - } - } - - super.update(); - } - - @Override - public void invalidate() { - super.invalidate(); - - if (getWorld() != null && !getWorld().isRemote && hasNetwork()) { - network.getNodeGraph().rebuild(); - } - } - - @Override - public void onConnected(INetworkMaster network) { - this.network = network; - - onConnectionChange(network, true); - - markDirty(); - } - - @Override - public void onDisconnected(INetworkMaster network) { - onConnectionChange(network, false); - - this.network = null; - - markDirty(); - } - - public void onConnectionChange(INetworkMaster network, boolean state) { - // NO OP - } - - public boolean canConduct(@Nullable EnumFacing direction) { - return true; - } - @Override public boolean hasCapability(Capability capability, @Nullable EnumFacing side) { - if (capability == CapabilityNetworkNode.NETWORK_NODE_CAPABILITY) { + if (capability == CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY) { return true; } @@ -119,99 +118,10 @@ public abstract class TileNode extends TileBase implements INetworkNode, IRedsto @Override public T getCapability(Capability capability, @Nullable EnumFacing side) { - if (capability == CapabilityNetworkNode.NETWORK_NODE_CAPABILITY) { - return CapabilityNetworkNode.NETWORK_NODE_CAPABILITY.cast(this); + if (capability == CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY) { + return CapabilityNetworkNodeProxy.NETWORK_NODE_PROXY_CAPABILITY.cast(this); } return super.getCapability(capability, side); } - - @Override - @Nullable - public INetworkMaster getNetwork() { - return network; - } - - public boolean hasNetwork() { - return network != null; - } - - @Nonnull - @Override - public ItemStack getItemStack() { - IBlockState state = getWorld().getBlockState(pos); - Item item = Item.getItemFromBlock(state.getBlock()); - return new ItemStack(item, 1, state.getBlock().getMetaFromState(state)); - } - - @Override - public RedstoneMode getRedstoneMode() { - return redstoneMode; - } - - @Override - public void setRedstoneMode(RedstoneMode mode) { - this.redstoneMode = mode; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - readConfiguration(tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - writeConfiguration(tag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - redstoneMode.write(tag); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - redstoneMode = RedstoneMode.read(tag); - } - - public NBTTagCompound writeUpdate(NBTTagCompound tag) { - super.writeUpdate(tag); - - if (hasConnectivityState()) { - tag.setBoolean(NBT_ACTIVE, active); - } - - return tag; - } - - public void readUpdate(NBTTagCompound tag) { - if (hasConnectivityState()) { - active = tag.getBoolean(NBT_ACTIVE); - } - - super.readUpdate(tag); - } - - public boolean hasConnectivityState() { - return false; - } - - @Override - public void walkNeighborhood(Operator operator) { - for (EnumFacing facing : EnumFacing.VALUES) { - if (canConduct(facing)) { - operator.apply(getWorld(), pos.offset(facing), facing.getOpposite()); - } - } - } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileProcessingPatternEncoder.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileProcessingPatternEncoder.java index 75f33af6f..1a45dbc15 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileProcessingPatternEncoder.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileProcessingPatternEncoder.java @@ -4,6 +4,7 @@ import com.raoulvdberge.refinedstorage.RSItems; import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.gui.GuiProcessingPatternEncoder; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerChangeListenerTile; import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; import com.raoulvdberge.refinedstorage.item.ItemPattern; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; @@ -41,8 +42,8 @@ public class TileProcessingPatternEncoder extends TileBase { } }); - private ItemHandlerBasic patterns = new ItemHandlerBasic(2, this, new ItemValidatorBasic(RSItems.PATTERN)); - private ItemHandlerBasic configuration = new ItemHandlerBasic(9 * 2, this); + private ItemHandlerBasic patterns = new ItemHandlerBasic(2, new ItemHandlerChangeListenerTile(this), new ItemValidatorBasic(RSItems.PATTERN)); + private ItemHandlerBasic configuration = new ItemHandlerBasic(9 * 2, new ItemHandlerChangeListenerTile(this)); private boolean oredictPattern; diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileReader.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileReader.java index cd2641ecb..e4cbf66cc 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileReader.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileReader.java @@ -1,17 +1,15 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReader; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterChannel; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterHandler; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeReader; import com.raoulvdberge.refinedstorage.gui.GuiReaderWriter; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.entity.player.EntityPlayerMP; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; @@ -19,9 +17,7 @@ import net.minecraftforge.common.capabilities.Capability; import javax.annotation.Nullable; -public class TileReader extends TileNode implements IReader { - private static final String NBT_CHANNEL = "Channel"; - +public class TileReader extends TileNode { static TileDataParameter createChannelParameter() { return new TileDataParameter<>(DataSerializers.STRING, "", new ITileDataProducer() { @Override @@ -44,70 +40,30 @@ public class TileReader extends TileNode implements IReader { public static final TileDataParameter CHANNEL = createChannelParameter(); - private String channel = ""; - public TileReader() { dataManager.addWatchedParameter(CHANNEL); } - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.readerUsage; - } - - @Override - public void updateNode() { - // NO OP - } - - @Override - public int getRedstoneStrength() { - return getWorld().getRedstonePower(pos.offset(getDirection()), getDirection()); - } - - @Override - public String getTitle() { - return "gui.refinedstorage:reader"; - } - - @Override - public String getChannel() { - return channel; - } - - @Override - public void setChannel(String channel) { - this.channel = channel; - } - - @Override - public TileDataParameter getChannelParameter() { - return CHANNEL; - } - - @Override - public boolean hasConnectivityState() { - return true; - } - @Override public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { if (super.hasCapability(capability, facing)) { return true; } - if (facing != getDirection() || network == null) { + IReader reader = (IReader) getNode(); + + if (facing != getDirection() || reader.getNetwork() == null) { return false; } - IReaderWriterChannel channel = network.getReaderWriterChannel(this.channel); + IReaderWriterChannel channel = reader.getNetwork().getReaderWriterChannel(reader.getChannel()); if (channel == null) { return false; } for (IReaderWriterHandler handler : channel.getHandlers()) { - if (handler.hasCapability(this, capability)) { + if (handler.hasCapability(reader, capability)) { return true; } } @@ -120,18 +76,20 @@ public class TileReader extends TileNode implements IReader { T foundCapability = super.getCapability(capability, facing); if (foundCapability == null) { - if (facing != getDirection() || network == null) { + IReader reader = (IReader) getNode(); + + if (facing != getDirection() || reader.getNetwork() == null) { return null; } - IReaderWriterChannel channel = network.getReaderWriterChannel(this.channel); + IReaderWriterChannel channel = reader.getNetwork().getReaderWriterChannel(reader.getChannel()); if (channel == null) { return null; } for (IReaderWriterHandler handler : channel.getHandlers()) { - foundCapability = handler.getCapability(this, capability); + foundCapability = handler.getCapability(reader, capability); if (foundCapability != null) { return foundCapability; @@ -143,26 +101,7 @@ public class TileReader extends TileNode implements IReader { } @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - if (tag.hasKey(NBT_CHANNEL)) { - channel = tag.getString(NBT_CHANNEL); - } - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - tag.setString(NBT_CHANNEL, channel); - - return tag; - } - - public void onOpened(EntityPlayer entity) { - if (hasNetwork()) { - network.sendReaderWriterChannelUpdate((EntityPlayerMP) entity); - } + public INetworkNode createNode() { + return new NetworkNodeReader(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileRelay.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileRelay.java index 8e2a9acb6..566d6ea3b 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileRelay.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileRelay.java @@ -1,34 +1,11 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode; -import net.minecraft.util.EnumFacing; - -import javax.annotation.Nullable; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeRelay; public class TileRelay extends TileNode { - public TileRelay() { - setRedstoneMode(RedstoneMode.LOW); - - rebuildOnUpdateChange = true; - } - @Override - public int getEnergyUsage() { - return getRedstoneMode() == RedstoneMode.IGNORE ? 0 : RS.INSTANCE.config.relayUsage; - } - - @Override - public void updateNode() { - } - - @Override - public boolean canConduct(@Nullable EnumFacing direction) { - return canUpdate(); - } - - @Override - public boolean hasConnectivityState() { - return true; + public INetworkNode createNode() { + return new NetworkNodeRelay(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSecurityManager.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSecurityManager.java index 15e237ba3..5bf8efc8e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSecurityManager.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSecurityManager.java @@ -1,171 +1,11 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSItems; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; -import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCard; -import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCardContainer; -import com.raoulvdberge.refinedstorage.api.network.security.Permission; -import com.raoulvdberge.refinedstorage.apiimpl.network.security.SecurityCard; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; -import com.raoulvdberge.refinedstorage.item.ItemSecurityCard; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; - -import javax.annotation.Nullable; -import java.util.ArrayList; -import java.util.List; -import java.util.UUID; - -public class TileSecurityManager extends TileNode implements ISecurityCardContainer { - private static final String NBT_OWNER = "Owner"; - - private List actualCards = new ArrayList<>(); - - private ItemHandlerBasic cards = new ItemHandlerBasic(9 * 2, this, new ItemValidatorBasic(RSItems.SECURITY_CARD)) { - @Override - protected void onContentsChanged(int slot) { - super.onContentsChanged(slot); - - if (getWorld() != null && !getWorld().isRemote) { - rebuildCards(); - } - - if (network != null) { - network.getSecurityManager().rebuild(); - } - } - }; - private ItemHandlerBasic editCard = new ItemHandlerBasic(1, this, new ItemValidatorBasic(RSItems.SECURITY_CARD)); - - @Nullable - private UUID owner; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSecurityManager; +public class TileSecurityManager extends TileNode { @Override - public int getEnergyUsage() { - int usage = RS.INSTANCE.config.securityManagerUsage; - - for (int i = 0; i < cards.getSlots(); ++i) { - if (!cards.getStackInSlot(i).isEmpty()) { - usage += RS.INSTANCE.config.securityManagerPerSecurityCardUsage; - } - } - - return usage; - } - - @Override - public void update() { - if (!getWorld().isRemote && ticks == 0) { - rebuildCards(); - } - - super.update(); - } - - public void setOwner(@Nullable UUID owner) { - this.owner = owner; - - markDirty(); - } - - @Nullable - public UUID getOwner() { - return owner; - } - - @Override - public void updateNode() { - // NO OP - } - - private void rebuildCards() { - actualCards.clear(); - - for (int i = 0; i < cards.getSlots(); ++i) { - ItemStack stack = cards.getStackInSlot(i); - - if (!stack.isEmpty()) { - UUID uuid = ItemSecurityCard.getOwner(stack); - - if (uuid == null) { - continue; - } - - SecurityCard card = new SecurityCard(uuid); - - for (Permission permission : Permission.values()) { - card.getPermissions().put(permission, ItemSecurityCard.hasPermission(stack, permission)); - } - - actualCards.add(card); - } - } - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - if (tag.hasKey(NBT_OWNER)) { - owner = UUID.fromString(tag.getString(NBT_OWNER)); - } - - RSUtils.readItems(cards, 0, tag); - RSUtils.readItems(editCard, 1, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - if (owner != null) { - tag.setString(NBT_OWNER, owner.toString()); - } - - RSUtils.writeItems(cards, 0, tag); - RSUtils.writeItems(editCard, 1, tag); - - return tag; - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - network.getSecurityManager().rebuild(); - } - - public ItemHandlerBasic getCardsItems() { - return cards; - } - - public ItemHandlerBasic getEditCard() { - return editCard; - } - - public void updatePermission(Permission permission, boolean state) { - ItemStack card = getEditCard().getStackInSlot(0); - - if (!card.isEmpty()) { - ItemSecurityCard.setPermission(card, permission, state); - } - } - - @Override - public List getCards() { - return actualCards; - } - - @Override - public IItemHandler getDrops() { - return new CombinedInvWrapper(cards, editCard); - } - - @Override - public boolean hasConnectivityState() { - return true; + public INetworkNode createNode() { + return new NetworkNodeSecurityManager(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSolderer.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSolderer.java index 42c93c92f..d584e2ec0 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSolderer.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileSolderer.java @@ -1,206 +1,50 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; -import com.raoulvdberge.refinedstorage.api.solderer.ISoldererRecipe; -import com.raoulvdberge.refinedstorage.apiimpl.API; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSolderer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.items.CapabilityItemHandler; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; -import javax.annotation.Nonnull; import javax.annotation.Nullable; public class TileSolderer extends TileNode { public static final TileDataParameter DURATION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileSolderer tile) { - return tile.recipe != null ? tile.recipe.getDuration() : 0; + NetworkNodeSolderer solderer = (NetworkNodeSolderer) tile.getNode(); + + return solderer.getRecipe() != null ? solderer.getRecipe().getDuration() : 0; } }); public static final TileDataParameter PROGRESS = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileSolderer tile) { - return tile.progress; + return ((NetworkNodeSolderer) tile.getNode()).getProgress(); } }); public static final TileDataParameter WORKING = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileSolderer tile) { - return tile.working; + return ((NetworkNodeSolderer) tile.getNode()).isWorking(); } }); - private static final String NBT_WORKING = "Working"; - private static final String NBT_PROGRESS = "Progress"; - - private ItemHandlerBasic items = new ItemHandlerBasic(3, this) { - @Override - @Nonnull - public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) { - for (ISoldererRecipe recipe : API.instance().getSoldererRegistry().getRecipes()) { - if (API.instance().getComparer().isEqualNoQuantity(recipe.getRow(slot), stack) || API.instance().getComparer().isEqualOredict(recipe.getRow(slot), stack)) { - return super.insertItem(slot, stack, simulate); - } - } - - return stack; - } - }; - private ItemHandlerBasic result = new ItemHandlerBasic(1, this) { - @Override - @Nonnull - public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) { - return stack; - } - }; - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED); - - private ISoldererRecipe recipe; - - private boolean working = false; - private int progress = 0; - public TileSolderer() { dataManager.addWatchedParameter(DURATION); dataManager.addWatchedParameter(PROGRESS); dataManager.addWatchedParameter(WORKING); } - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.soldererUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - if (items.getStackInSlot(1).isEmpty() && items.getStackInSlot(2).isEmpty() && result.getStackInSlot(0).isEmpty()) { - stop(); - } else { - ISoldererRecipe newRecipe = API.instance().getSoldererRegistry().getRecipe(items); - - if (newRecipe == null) { - stop(); - } else if (newRecipe != recipe) { - boolean sameItem = !result.getStackInSlot(0).isEmpty() && API.instance().getComparer().isEqualNoQuantity(result.getStackInSlot(0), newRecipe.getResult()); - - if (result.getStackInSlot(0).isEmpty() || (sameItem && ((result.getStackInSlot(0).getCount() + newRecipe.getResult().getCount()) <= result.getStackInSlot(0).getMaxStackSize()))) { - recipe = newRecipe; - progress = 0; - working = true; - - markDirty(); - } - } else if (working) { - progress += 1 + upgrades.getUpgradeCount(ItemUpgrade.TYPE_SPEED); - - if (progress >= recipe.getDuration()) { - if (!result.getStackInSlot(0).isEmpty()) { - result.getStackInSlot(0).grow(recipe.getResult().getCount()); - } else { - result.setStackInSlot(0, recipe.getResult().copy()); - } - - for (int i = 0; i < 3; ++i) { - if (recipe.getRow(i) != null) { - items.extractItem(i, recipe.getRow(i).getCount(), false); - } - } - - recipe = null; - progress = 0; - // Don't set working to false yet, wait till the next update because we may have another stack waiting. - - markDirty(); - } - } - } - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - super.onConnectionChange(network, state); - - if (!state) { - stop(); - } - } - - private void stop() { - progress = 0; - working = false; - recipe = null; - - markDirty(); - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(items, 0, tag); - RSUtils.readItems(upgrades, 1, tag); - RSUtils.readItems(result, 2, tag); - - recipe = API.instance().getSoldererRegistry().getRecipe(items); - - if (tag.hasKey(NBT_WORKING)) { - working = tag.getBoolean(NBT_WORKING); - } - - if (tag.hasKey(NBT_PROGRESS)) { - progress = tag.getInteger(NBT_PROGRESS); - } - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(items, 0, tag); - RSUtils.writeItems(upgrades, 1, tag); - RSUtils.writeItems(result, 2, tag); - - tag.setBoolean(NBT_WORKING, working); - tag.setInteger(NBT_PROGRESS, progress); - - return tag; - } - - public ItemHandlerBasic getItems() { - return items; - } - - public ItemHandlerBasic getResult() { - return result; - } - - public IItemHandler getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return new CombinedInvWrapper(items, result, upgrades); - } - @Override public T getCapability(Capability capability, @Nullable EnumFacing facing) { if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { - return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(facing == EnumFacing.DOWN ? result : items); + return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(facing == EnumFacing.DOWN ? ((NetworkNodeSolderer) getNode()).getResult() : ((NetworkNodeSolderer) getNode()).getItems()); } return super.getCapability(capability, facing); @@ -210,4 +54,9 @@ public class TileSolderer extends TileNode { public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); } + + @Override + public INetworkNode createNode() { + return new NetworkNodeSolderer(this); + } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorage.java index 948db5b5c..6f00ff151 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorage.java @@ -1,30 +1,15 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSBlocks; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.storage.AccessType; -import com.raoulvdberge.refinedstorage.api.storage.IStorage; -import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider; -import com.raoulvdberge.refinedstorage.api.util.IComparer; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorage; import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageItemNBT; -import com.raoulvdberge.refinedstorage.block.BlockStorage; -import com.raoulvdberge.refinedstorage.block.EnumItemStorageType; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; import com.raoulvdberge.refinedstorage.tile.config.*; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.items.ItemHandlerHelper; -import javax.annotation.Nonnull; -import java.util.List; - -public class TileStorage extends TileNode implements IStorageProvider, IStorageGui, IComparable, IFilterable, IPrioritizable, IExcessVoidable, IAccessType { +public class TileStorage extends TileNode { public static final TileDataParameter PRIORITY = IPrioritizable.createParameter(); public static final TileDataParameter COMPARE = IComparable.createParameter(); public static final TileDataParameter MODE = IFilterable.createParameter(); @@ -32,62 +17,11 @@ public class TileStorage extends TileNode implements IStorageProvider, IStorageG public static final TileDataParameter STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileStorage tile) { - return StorageItemNBT.getStoredFromNBT(tile.storageTag); + return StorageItemNBT.getStoredFromNBT(((NetworkNodeStorage) tile.getNode()).getStorageTag()); } }); public static final TileDataParameter VOID_EXCESS = IExcessVoidable.createParameter(); - class StorageItem extends StorageItemNBT { - public StorageItem() { - super(TileStorage.this.getStorageTag(), TileStorage.this.getCapacity(), TileStorage.this); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { - if (!IFilterable.canTake(filters, mode, compare, stack)) { - return ItemHandlerHelper.copyStackWithSize(stack, size); - } - - return super.insert(stack, size, simulate); - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public boolean isVoiding() { - return voidExcess; - } - } - - public static final String NBT_STORAGE = "Storage"; - - private static final String NBT_PRIORITY = "Priority"; - private static final String NBT_COMPARE = "Compare"; - private static final String NBT_MODE = "Mode"; - private static final String NBT_VOID_EXCESS = "VoidExcess"; - - private ItemHandlerBasic filters = new ItemHandlerBasic(9, this); - - private NBTTagCompound storageTag = StorageItemNBT.createNBT(); - - private StorageItem storage; - - private EnumItemStorageType type; - - private AccessType accessType = AccessType.INSERT_EXTRACT; - private int priority = 0; - private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE; - private int mode = IFilterable.WHITELIST; - private boolean voidExcess = false; - public TileStorage() { dataManager.addWatchedParameter(PRIORITY); dataManager.addWatchedParameter(COMPARE); @@ -98,255 +32,7 @@ public class TileStorage extends TileNode implements IStorageProvider, IStorageG } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.storageUsage; - } - - @Override - public void updateNode() { - } - - @Override - public void update() { - super.update(); - - if (storage == null && storageTag != null) { - storage = new StorageItem(); - - if (network != null) { - network.getItemStorageCache().invalidate(); - } - } - } - - public void onBreak() { - if (storage != null) { - storage.writeToNBT(); - } - } - - @Override - public void onConnectionChange(INetworkMaster network, boolean state) { - super.onConnectionChange(network, state); - - network.getItemStorageCache().invalidate(); - } - - @Override - public void addItemStorages(List> storages) { - if (storage != null) { - storages.add(storage); - } - } - - @Override - public void addFluidStorages(List> storages) { - // NO OP - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - if (tag.hasKey(NBT_STORAGE)) { - storageTag = tag.getCompoundTag(NBT_STORAGE); - } - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - if (storage != null) { - storage.writeToNBT(); - } - - tag.setTag(NBT_STORAGE, storageTag); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - RSUtils.writeItems(filters, 0, tag); - - tag.setInteger(NBT_PRIORITY, priority); - tag.setInteger(NBT_COMPARE, compare); - tag.setInteger(NBT_MODE, mode); - tag.setBoolean(NBT_VOID_EXCESS, voidExcess); - - RSUtils.writeAccessType(tag, accessType); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - RSUtils.readItems(filters, 0, tag); - - if (tag.hasKey(NBT_PRIORITY)) { - priority = tag.getInteger(NBT_PRIORITY); - } - - if (tag.hasKey(NBT_COMPARE)) { - compare = tag.getInteger(NBT_COMPARE); - } - - if (tag.hasKey(NBT_MODE)) { - mode = tag.getInteger(NBT_MODE); - } - - if (tag.hasKey(NBT_VOID_EXCESS)) { - voidExcess = tag.getBoolean(NBT_VOID_EXCESS); - } - - accessType = RSUtils.readAccessType(tag); - } - - public EnumItemStorageType getType() { - if (type == null && getWorld().getBlockState(pos).getBlock() == RSBlocks.STORAGE) { - this.type = ((EnumItemStorageType) getWorld().getBlockState(pos).getValue(BlockStorage.TYPE)); - } - - return type == null ? EnumItemStorageType.TYPE_1K : type; - } - - @Override - public int getCompare() { - return compare; - } - - @Override - public void setCompare(int compare) { - this.compare = compare; - - markDirty(); - } - - @Override - public int getMode() { - return mode; - } - - @Override - public void setMode(int mode) { - this.mode = mode; - - markDirty(); - } - - @Override - public boolean getVoidExcess() { - return voidExcess; - } - - @Override - public void setVoidExcess(boolean voidExcess) { - this.voidExcess = voidExcess; - - markDirty(); - } - - @Override - public String getGuiTitle() { - return "block.refinedstorage:storage." + getType().getId() + ".name"; - } - - @Override - public TileDataParameter getTypeParameter() { - return null; - } - - @Override - public TileDataParameter getRedstoneModeParameter() { - return REDSTONE_MODE; - } - - @Override - public TileDataParameter getCompareParameter() { - return COMPARE; - } - - @Override - public TileDataParameter getFilterParameter() { - return MODE; - } - - @Override - public TileDataParameter getPriorityParameter() { - return PRIORITY; - } - - @Override - public TileDataParameter getVoidExcessParameter() { - return VOID_EXCESS; - } - - @Override - public TileDataParameter getAccessTypeParameter() { - return ACCESS_TYPE; - } - - @Override - public String getVoidExcessType() { - return "items"; - } - - public NBTTagCompound getStorageTag() { - return storageTag; - } - - public void setStorageTag(NBTTagCompound storageTag) { - this.storageTag = storageTag; - } - - public StorageItemNBT getStorage() { - return storage; - } - - public ItemHandlerBasic getFilters() { - return filters; - } - - @Override - public AccessType getAccessType() { - return accessType; - } - - @Override - public void setAccessType(AccessType value) { - this.accessType = value; - - if (network != null) { - network.getItemStorageCache().invalidate(); - } - - markDirty(); - } - - @Override - public int getPriority() { - return priority; - } - - @Override - public void setPriority(int priority) { - this.priority = priority; - - markDirty(); - } - - @Override - public int getStored() { - return STORED.getValue(); - } - - @Override - public int getCapacity() { - return getType().getCapacity(); + public INetworkNode createNode() { + return new NetworkNodeStorage(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWirelessTransmitter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWirelessTransmitter.java index 72bdaa3d3..396878769 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWirelessTransmitter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWirelessTransmitter.java @@ -1,96 +1,25 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.IWirelessTransmitter; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; -import com.raoulvdberge.refinedstorage.item.ItemUpgrade; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeWirelessTransmitter; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraft.util.EnumFacing; -import net.minecraft.util.math.BlockPos; -import net.minecraftforge.items.IItemHandler; -import javax.annotation.Nullable; - -public class TileWirelessTransmitter extends TileNode implements IWirelessTransmitter { +public class TileWirelessTransmitter extends TileNode { public static final TileDataParameter RANGE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileWirelessTransmitter tile) { - return tile.getRange(); + return ((NetworkNodeWirelessTransmitter) tile.getNode()).getRange(); } }); - private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_RANGE); - public TileWirelessTransmitter() { dataManager.addWatchedParameter(RANGE); } @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.wirelessTransmitterUsage + upgrades.getEnergyUsage(); - } - - @Override - public void updateNode() { - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItems(upgrades, 0, tag); - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItems(upgrades, 0, tag); - - return tag; - } - - @Override - public int getRange() { - return RS.INSTANCE.config.wirelessTransmitterBaseRange + (upgrades.getUpgradeCount(ItemUpgrade.TYPE_RANGE) * RS.INSTANCE.config.wirelessTransmitterRangePerUpgrade); - } - - @Override - public BlockPos getOrigin() { - return pos; - } - - @Override - public int getDimension() { - return getWorld().provider.getDimension(); - } - - public ItemHandlerBasic getUpgrades() { - return upgrades; - } - - @Override - public IItemHandler getDrops() { - return upgrades; - } - - @Override - public boolean canConduct(@Nullable EnumFacing direction) { - return direction != null && EnumFacing.DOWN.equals(direction); - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public void walkNeighborhood(Operator operator) { - operator.apply(getWorld(), pos.offset(EnumFacing.DOWN), EnumFacing.UP); + public INetworkNode createNode() { + return new NetworkNodeWirelessTransmitter(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWriter.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWriter.java index 5cbe283a1..6ca712678 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWriter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/TileWriter.java @@ -1,135 +1,43 @@ package com.raoulvdberge.refinedstorage.tile; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSBlocks; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterChannel; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IReaderWriterHandler; import com.raoulvdberge.refinedstorage.api.network.readerwriter.IWriter; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeWriter; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.entity.player.EntityPlayerMP; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; import javax.annotation.Nullable; -public class TileWriter extends TileNode implements IWriter { - private static final String NBT_CHANNEL = "Channel"; - - private static final TileDataParameter CHANNEL = TileReader.createChannelParameter(); - - private String channel = ""; - - private int redstoneStrength; - private int lastRedstoneStrength; +public class TileWriter extends TileNode { + public static final TileDataParameter CHANNEL = TileReader.createChannelParameter(); public TileWriter() { dataManager.addWatchedParameter(CHANNEL); } - @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.writerUsage; - } - - @Override - public void update() { - super.update(); - - if (!getWorld().isRemote && getRedstoneStrength() != lastRedstoneStrength) { - lastRedstoneStrength = getRedstoneStrength(); - - getWorld().notifyNeighborsOfStateChange(pos, RSBlocks.WRITER, true); - } - } - - @Override - public void updateNode() { - // NO OP - } - - @Override - public int getRedstoneStrength() { - return network != null ? redstoneStrength : 0; - } - - @Override - public void setRedstoneStrength(int strength) { - redstoneStrength = strength; - } - - @Override - public String getTitle() { - return "gui.refinedstorage:writer"; - } - - @Override - public String getChannel() { - return channel; - } - - @Override - public void setChannel(String channel) { - if (network != null && channel.equals("")) { - IReaderWriterChannel networkChannel = network.getReaderWriterChannel(this.channel); - - if (networkChannel != null) { - for (IReaderWriterHandler handler : networkChannel.getHandlers()) { - handler.onWriterDisabled(this); - } - } - } - - this.channel = channel; - } - - @Override - public TileDataParameter getChannelParameter() { - return CHANNEL; - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - if (tag.hasKey(NBT_CHANNEL)) { - channel = tag.getString(NBT_CHANNEL); - } - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - tag.setString(NBT_CHANNEL, channel); - - return tag; - } - @Override public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { if (super.hasCapability(capability, facing)) { return true; } - if (facing != getDirection() || network == null) { + IWriter writer = (NetworkNodeWriter) getNode(); + + if (facing != getDirection() || writer.getNetwork() == null) { return false; } - IReaderWriterChannel channel = network.getReaderWriterChannel(this.channel); + IReaderWriterChannel channel = writer.getNetwork().getReaderWriterChannel(writer.getChannel()); if (channel == null) { return false; } for (IReaderWriterHandler handler : channel.getHandlers()) { - if (handler.hasCapability(this, capability)) { + if (handler.hasCapability(writer, capability)) { return true; } } @@ -142,18 +50,20 @@ public class TileWriter extends TileNode implements IWriter { T foundCapability = super.getCapability(capability, facing); if (foundCapability == null) { - if (facing != getDirection() || network == null) { + IWriter writer = (NetworkNodeWriter) getNode(); + + if (facing != getDirection() || writer.getNetwork() == null) { return null; } - IReaderWriterChannel channel = network.getReaderWriterChannel(this.channel); + IReaderWriterChannel channel = writer.getNetwork().getReaderWriterChannel(writer.getChannel()); if (channel == null) { return null; } for (IReaderWriterHandler handler : channel.getHandlers()) { - foundCapability = handler.getCapability(this, capability); + foundCapability = handler.getCapability(writer, capability); if (foundCapability != null) { return foundCapability; @@ -165,15 +75,7 @@ public class TileWriter extends TileNode implements IWriter { } @Override - public void setDirection(EnumFacing direction) { - super.setDirection(direction); - - getWorld().notifyNeighborsOfStateChange(pos, RSBlocks.WRITER, true); - } - - public void onOpened(EntityPlayer entity) { - if (hasNetwork()) { - network.sendReaderWriterChannelUpdate((EntityPlayerMP) entity); - } + public INetworkNode createNode() { + return new NetworkNodeWriter(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IAccessType.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IAccessType.java index 48d30d509..af64d48bf 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IAccessType.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IAccessType.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile.config; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.api.storage.AccessType; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; @@ -8,16 +9,16 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; import net.minecraft.tileentity.TileEntity; public interface IAccessType { - static TileDataParameter createParameter() { + static TileDataParameter createParameter() { return new TileDataParameter<>(RSSerializers.ACCESS_TYPE_SERIALIZER, AccessType.INSERT_EXTRACT, new ITileDataProducer() { @Override public AccessType getValue(T tile) { - return tile.getAccessType(); + return ((IAccessType) tile.getNode()).getAccessType(); } }, new ITileDataConsumer() { @Override public void setValue(T tile, AccessType value) { - tile.setAccessType(value); + ((IAccessType) tile.getNode()).setAccessType(value); } }); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IComparable.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IComparable.java index 8cbdcb35b..6aefbb63f 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IComparable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IComparable.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile.config; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; @@ -7,16 +8,16 @@ import net.minecraft.network.datasync.DataSerializers; import net.minecraft.tileentity.TileEntity; public interface IComparable { - static TileDataParameter createParameter() { + static TileDataParameter createParameter() { return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(T tile) { - return tile.getCompare(); + return ((IComparable) tile.getNode()).getCompare(); } }, new ITileDataConsumer() { @Override public void setValue(T tile, Integer value) { - tile.setCompare(value); + ((IComparable) tile.getNode()).setCompare(value); } }); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IExcessVoidable.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IExcessVoidable.java index dff6d139d..c1aa08591 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IExcessVoidable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IExcessVoidable.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile.config; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; @@ -7,16 +8,16 @@ import net.minecraft.network.datasync.DataSerializers; import net.minecraft.tileentity.TileEntity; public interface IExcessVoidable { - static TileDataParameter createParameter() { + static TileDataParameter createParameter() { return new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(T tile) { - return tile.getVoidExcess(); + return ((IExcessVoidable) tile.getNode()).getVoidExcess(); } }, new ITileDataConsumer() { @Override public void setValue(T tile, Boolean value) { - tile.setVoidExcess(value); + ((IExcessVoidable) tile.getNode()).setVoidExcess(value); } }); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java index 17bc3939a..68b7da86a 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile.config; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.apiimpl.API; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; @@ -15,17 +16,17 @@ public interface IFilterable { int WHITELIST = 0; int BLACKLIST = 1; - static TileDataParameter createParameter() { + static TileDataParameter createParameter() { return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(T tile) { - return tile.getMode(); + return ((IFilterable) tile.getNode()).getMode(); } }, new ITileDataConsumer() { @Override public void setValue(T tile, Integer value) { if (value == WHITELIST || value == BLACKLIST) { - tile.setMode(value); + ((IFilterable) tile.getNode()).setMode(value); } } }); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IPrioritizable.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IPrioritizable.java index a898913af..b3b4b608f 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IPrioritizable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IPrioritizable.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile.config; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; @@ -7,16 +8,16 @@ import net.minecraft.network.datasync.DataSerializers; import net.minecraft.tileentity.TileEntity; public interface IPrioritizable { - static TileDataParameter createParameter() { + static TileDataParameter createParameter() { return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(T tile) { - return tile.getPriority(); + return ((IPrioritizable) tile.getNode()).getPriority(); } }, new ITileDataConsumer() { @Override public void setValue(T tile, Integer value) { - tile.setPriority(value); + ((IPrioritizable) tile.getNode()).setPriority(value); } }); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java index 5dfb8aee3..a70ddfa2c 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java @@ -1,5 +1,6 @@ package com.raoulvdberge.refinedstorage.tile.config; +import com.raoulvdberge.refinedstorage.api.network.INetworkNodeProxy; import com.raoulvdberge.refinedstorage.container.ContainerBase; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; @@ -12,21 +13,21 @@ public interface IType { int ITEMS = 0; int FLUIDS = 1; - static TileDataParameter createParameter() { + static TileDataParameter createParameter() { return new TileDataParameter<>(DataSerializers.VARINT, ITEMS, new ITileDataProducer() { @Override public Integer getValue(T tile) { - return tile.getType(); + return ((IType) tile.getNode()).getType(); } }, new ITileDataConsumer() { @Override public void setValue(T tile, Integer value) { if (value == 0 || value == 1) { - tile.setType(value); + ((IType) tile.getNode()).setType(value); tile.getWorld().playerEntities.stream() - .filter(p -> p.openContainer instanceof ContainerBase && ((ContainerBase) p.openContainer).getTile().getPos().equals(tile.getPos())) - .forEach(p -> p.openContainer.detectAndSendChanges()); + .filter(p -> p.openContainer instanceof ContainerBase && ((ContainerBase) p.openContainer).getTile().getPos().equals(tile.getPos())) + .forEach(p -> p.openContainer.detectAndSendChanges()); } } }); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/TileCraftingMonitor.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/TileCraftingMonitor.java index 24737ecd4..1fadc6830 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/TileCraftingMonitor.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/TileCraftingMonitor.java @@ -1,55 +1,12 @@ package com.raoulvdberge.refinedstorage.tile.craftingmonitor; -import com.raoulvdberge.refinedstorage.RS; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCraftingMonitor; import com.raoulvdberge.refinedstorage.tile.TileNode; -import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.entity.player.EntityPlayerMP; -import net.minecraft.util.math.BlockPos; -import javax.annotation.Nullable; - -public class TileCraftingMonitor extends TileNode implements ICraftingMonitor { +public class TileCraftingMonitor extends TileNode { @Override - public int getEnergyUsage() { - return RS.INSTANCE.config.craftingMonitorUsage; - } - - @Override - public void updateNode() { - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public String getGuiTitle() { - return "gui.refinedstorage:crafting_monitor"; - } - - @Override - public void onCancelled(EntityPlayerMP player, int id) { - if (hasNetwork()) { - network.getItemGridHandler().onCraftingCancelRequested(player, id); - } - } - - @Override - public TileDataParameter getRedstoneModeParameter() { - return REDSTONE_MODE; - } - - @Nullable - @Override - public BlockPos getNetworkPosition() { - return network != null ? network.getPosition() : null; - } - - public void onOpened(EntityPlayer player) { - if (hasNetwork()) { - network.sendCraftingMonitorUpdate((EntityPlayerMP) player); - } + public INetworkNode createNode() { + return new NetworkNodeCraftingMonitor(this); } } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/tile/grid/TileGrid.java b/src/main/java/com/raoulvdberge/refinedstorage/tile/grid/TileGrid.java index 8a824e558..01c7a59d1 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/tile/grid/TileGrid.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/tile/grid/TileGrid.java @@ -1,60 +1,29 @@ package com.raoulvdberge.refinedstorage.tile.grid; -import com.raoulvdberge.refinedstorage.RS; -import com.raoulvdberge.refinedstorage.RSBlocks; -import com.raoulvdberge.refinedstorage.RSItems; -import com.raoulvdberge.refinedstorage.RSUtils; -import com.raoulvdberge.refinedstorage.api.network.grid.IFluidGridHandler; -import com.raoulvdberge.refinedstorage.api.network.grid.IItemGridHandler; -import com.raoulvdberge.refinedstorage.api.network.security.Permission; -import com.raoulvdberge.refinedstorage.apiimpl.API; -import com.raoulvdberge.refinedstorage.block.BlockGrid; -import com.raoulvdberge.refinedstorage.block.EnumGridType; -import com.raoulvdberge.refinedstorage.container.ContainerGrid; -import com.raoulvdberge.refinedstorage.gui.grid.GridFilter; -import com.raoulvdberge.refinedstorage.gui.grid.GridTab; +import com.raoulvdberge.refinedstorage.api.network.INetworkNode; +import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid; import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerGridFilterInGrid; -import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic; -import com.raoulvdberge.refinedstorage.item.ItemPattern; import com.raoulvdberge.refinedstorage.tile.TileNode; import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer; import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer; -import com.raoulvdberge.refinedstorage.tile.data.TileDataManager; import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.entity.player.EntityPlayerMP; -import net.minecraft.inventory.*; -import net.minecraft.item.ItemStack; -import net.minecraft.item.crafting.CraftingManager; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.datasync.DataSerializers; -import net.minecraft.util.NonNullList; -import net.minecraft.util.math.BlockPos; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.items.ItemHandlerHelper; -import net.minecraftforge.items.wrapper.CombinedInvWrapper; -import net.minecraftforge.items.wrapper.InvWrapper; -import javax.annotation.Nullable; -import java.util.ArrayList; -import java.util.List; - -public class TileGrid extends TileNode implements IGrid { +public class TileGrid extends TileNode { public static final TileDataParameter VIEW_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileGrid tile) { - return tile.viewType; + return ((NetworkNodeGrid) tile.getNode()).getViewType(); } }, new ITileDataConsumer() { @Override public void setValue(TileGrid tile, Integer value) { - if (isValidViewType(value)) { - tile.viewType = value; + if (NetworkNodeGrid.isValidViewType(value)) { + NetworkNodeGrid grid = (NetworkNodeGrid) tile.getNode(); - tile.markDirty(); + grid.setViewType(value); + grid.markDirty(); } } }, parameter -> GuiGrid.markForSorting()); @@ -62,15 +31,16 @@ public class TileGrid extends TileNode implements IGrid { public static final TileDataParameter SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileGrid tile) { - return tile.sortingDirection; + return ((NetworkNodeGrid) tile.getNode()).getSortingDirection(); } }, new ITileDataConsumer() { @Override public void setValue(TileGrid tile, Integer value) { - if (isValidSortingDirection(value)) { - tile.sortingDirection = value; + if (NetworkNodeGrid.isValidSortingDirection(value)) { + NetworkNodeGrid grid = (NetworkNodeGrid) tile.getNode(); - tile.markDirty(); + grid.setSortingDirection(value); + grid.markDirty(); } } }, parameter -> GuiGrid.markForSorting()); @@ -78,15 +48,16 @@ public class TileGrid extends TileNode implements IGrid { public static final TileDataParameter SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileGrid tile) { - return tile.sortingType; + return ((NetworkNodeGrid) tile.getNode()).getSortingType(); } }, new ITileDataConsumer() { @Override public void setValue(TileGrid tile, Integer value) { - if (isValidSortingType(value)) { - tile.sortingType = value; + if (NetworkNodeGrid.isValidSortingType(value)) { + NetworkNodeGrid grid = (NetworkNodeGrid) tile.getNode(); - tile.markDirty(); + grid.setSortingType(value); + grid.markDirty(); } } }, parameter -> GuiGrid.markForSorting()); @@ -94,15 +65,16 @@ public class TileGrid extends TileNode implements IGrid { public static final TileDataParameter SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileGrid tile) { - return tile.searchBoxMode; + return ((NetworkNodeGrid) tile.getNode()).getSearchBoxMode(); } }, new ITileDataConsumer() { @Override public void setValue(TileGrid tile, Integer value) { - if (isValidSearchBoxMode(value)) { - tile.searchBoxMode = value; + if (NetworkNodeGrid.isValidSearchBoxMode(value)) { + NetworkNodeGrid grid = (NetworkNodeGrid) tile.getNode(); - tile.markDirty(); + grid.setSearchBoxMode(value); + grid.markDirty(); } } }, parameter -> { @@ -114,14 +86,15 @@ public class TileGrid extends TileNode implements IGrid { public static final TileDataParameter TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { @Override public Integer getValue(TileGrid tile) { - return tile.tabSelected; + return ((NetworkNodeGrid) tile.getNode()).getTabSelected(); } }, new ITileDataConsumer() { @Override public void setValue(TileGrid tile, Integer value) { - tile.tabSelected = value == tile.tabSelected ? -1 : value; + NetworkNodeGrid grid = (NetworkNodeGrid) tile.getNode(); - tile.markDirty(); + grid.setTabSelected(value == grid.getTabSelected() ? -1 : value); + grid.markDirty(); } }, parameter -> { if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) { @@ -132,14 +105,15 @@ public class TileGrid extends TileNode implements IGrid { public static final TileDataParameter OREDICT_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer() { @Override public Boolean getValue(TileGrid tile) { - return tile.oredictPattern; + return ((NetworkNodeGrid) tile.getNode()).isOredictPattern(); } }, new ITileDataConsumer() { @Override public void setValue(TileGrid tile, Boolean value) { - tile.oredictPattern = value; + NetworkNodeGrid grid = (NetworkNodeGrid) tile.getNode(); - tile.markDirty(); + grid.setOredictPattern(value); + grid.markDirty(); } }, parameter -> { if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) { @@ -147,58 +121,6 @@ public class TileGrid extends TileNode implements IGrid { } }); - public static final String NBT_VIEW_TYPE = "ViewType"; - public static final String NBT_SORTING_DIRECTION = "SortingDirection"; - public static final String NBT_SORTING_TYPE = "SortingType"; - public static final String NBT_SEARCH_BOX_MODE = "SearchBoxMode"; - public static final String NBT_OREDICT_PATTERN = "OredictPattern"; - public static final String NBT_TAB_SELECTED = "TabSelected"; - - public static final int SORTING_DIRECTION_ASCENDING = 0; - public static final int SORTING_DIRECTION_DESCENDING = 1; - - public static final int SORTING_TYPE_QUANTITY = 0; - public static final int SORTING_TYPE_NAME = 1; - - public static final int SEARCH_BOX_MODE_NORMAL = 0; - public static final int SEARCH_BOX_MODE_NORMAL_AUTOSELECTED = 1; - public static final int SEARCH_BOX_MODE_JEI_SYNCHRONIZED = 2; - public static final int SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED = 3; - - public static final int VIEW_TYPE_NORMAL = 0; - public static final int VIEW_TYPE_NON_CRAFTABLES = 1; - public static final int VIEW_TYPE_CRAFTABLES = 2; - - private Container craftingContainer = new Container() { - @Override - public boolean canInteractWith(EntityPlayer player) { - return false; - } - - @Override - public void onCraftMatrixChanged(IInventory inventory) { - onCraftingMatrixChanged(); - } - }; - private InventoryCrafting matrix = new InventoryCrafting(craftingContainer, 3, 3); - private InventoryCraftResult result = new InventoryCraftResult(); - - private ItemHandlerBasic patterns = new ItemHandlerBasic(2, this, new ItemValidatorBasic(RSItems.PATTERN)); - private List filteredItems = new ArrayList<>(); - private List tabs = new ArrayList<>(); - private ItemHandlerGridFilterInGrid filter = new ItemHandlerGridFilterInGrid(filteredItems, tabs); - - private EnumGridType type; - - private int viewType = VIEW_TYPE_NORMAL; - private int sortingDirection = SORTING_DIRECTION_DESCENDING; - private int sortingType = SORTING_TYPE_QUANTITY; - private int searchBoxMode = SEARCH_BOX_MODE_NORMAL; - - private int tabSelected = -1; - - private boolean oredictPattern = false; - public TileGrid() { dataManager.addWatchedParameter(VIEW_TYPE); dataManager.addWatchedParameter(SORTING_DIRECTION); @@ -209,426 +131,7 @@ public class TileGrid extends TileNode implements IGrid { } @Override - public int getEnergyUsage() { - switch (getType()) { - case NORMAL: - return RS.INSTANCE.config.gridUsage; - case CRAFTING: - return RS.INSTANCE.config.craftingGridUsage; - case PATTERN: - return RS.INSTANCE.config.patternGridUsage; - case FLUID: - return RS.INSTANCE.config.fluidGridUsage; - default: - return 0; - } - } - - @Override - public void updateNode() { - } - - public EnumGridType getType() { - if (type == null && getWorld().getBlockState(pos).getBlock() == RSBlocks.GRID) { - this.type = (EnumGridType) getWorld().getBlockState(pos).getValue(BlockGrid.TYPE); - } - - return type == null ? EnumGridType.NORMAL : type; - } - - @Nullable - @Override - public BlockPos getNetworkPosition() { - return network != null ? network.getPosition() : null; - } - - public void onOpened(EntityPlayer player) { - if (hasNetwork()) { - if (getType() == EnumGridType.FLUID) { - network.sendFluidStorageToClient((EntityPlayerMP) player); - } else { - network.sendItemStorageToClient((EntityPlayerMP) player); - } - } - } - - @Override - public IItemGridHandler getItemHandler() { - return hasNetwork() ? network.getItemGridHandler() : null; - } - - @Override - public IFluidGridHandler getFluidHandler() { - return hasNetwork() ? network.getFluidGridHandler() : null; - } - - @Override - public String getGuiTitle() { - return getType() == EnumGridType.FLUID ? "gui.refinedstorage:fluid_grid" : "gui.refinedstorage:grid"; - } - - public InventoryCrafting getMatrix() { - return matrix; - } - - public InventoryCraftResult getResult() { - return result; - } - - public IItemHandler getPatterns() { - return patterns; - } - - @Override - public ItemHandlerBasic getFilter() { - return filter; - } - - @Override - public List getFilteredItems() { - return filteredItems; - } - - @Override - public List getTabs() { - return tabs; - } - - public void onCraftingMatrixChanged() { - markDirty(); - - result.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(matrix, getWorld())); - } - - public void onCrafted(EntityPlayer player) { - NonNullList remainder = CraftingManager.getInstance().getRemainingItems(matrix, getWorld()); - - for (int i = 0; i < matrix.getSizeInventory(); ++i) { - ItemStack slot = matrix.getStackInSlot(i); - - if (i < remainder.size() && !remainder.get(i).isEmpty()) { - // If there is no space for the remainder, dump it in the player inventory - if (!slot.isEmpty() && slot.getCount() > 1) { - if (!player.inventory.addItemStackToInventory(remainder.get(i).copy())) { - ItemStack remainderStack = network.insertItem(remainder.get(i).copy(), remainder.get(i).getCount(), false); - - if (remainderStack != null) { - InventoryHelper.spawnItemStack(player.getEntityWorld(), player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), remainderStack); - } - } - - matrix.decrStackSize(i, 1); - } else { - matrix.setInventorySlotContents(i, remainder.get(i).copy()); - } - } else if (!slot.isEmpty()) { - if (slot.getCount() == 1 && hasNetwork()) { - matrix.setInventorySlotContents(i, RSUtils.getStack(network.extractItem(slot, 1, false))); - } else { - matrix.decrStackSize(i, 1); - } - } - } - - onCraftingMatrixChanged(); - } - - public void onCraftedShift(ContainerGrid container, EntityPlayer player) { - List craftedItemsList = new ArrayList<>(); - int craftedItems = 0; - ItemStack crafted = result.getStackInSlot(0); - - while (true) { - onCrafted(player); - - craftedItemsList.add(crafted.copy()); - - craftedItems += crafted.getCount(); - - if (!API.instance().getComparer().isEqual(crafted, result.getStackInSlot(0)) || craftedItems + crafted.getCount() > crafted.getMaxStackSize()) { - break; - } - } - - for (ItemStack craftedItem : craftedItemsList) { - if (!player.inventory.addItemStackToInventory(craftedItem.copy())) { - ItemStack remainder = network.insertItem(craftedItem, craftedItem.getCount(), false); - if (remainder != null) { - InventoryHelper.spawnItemStack(player.getEntityWorld(), player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), remainder); - } - } - } - - container.sendCraftingSlots(); - container.detectAndSendChanges(); - } - - public void onCreatePattern() { - if (canCreatePattern()) { - patterns.extractItem(0, 1, false); - - ItemStack pattern = new ItemStack(RSItems.PATTERN); - - ItemPattern.setOredict(pattern, oredictPattern); - - for (int i = 0; i < 9; ++i) { - ItemStack ingredient = matrix.getStackInSlot(i); - - if (!ingredient.isEmpty()) { - ItemPattern.setSlot(pattern, i, ingredient); - } - } - - patterns.setStackInSlot(1, pattern); - } - } - - public boolean canCreatePattern() { - return !result.getStackInSlot(0).isEmpty() && patterns.getStackInSlot(1).isEmpty() && !patterns.getStackInSlot(0).isEmpty(); - } - - public void onRecipeTransfer(EntityPlayer player, ItemStack[][] recipe) { - if (hasNetwork() && getType() == EnumGridType.CRAFTING && !network.getSecurityManager().hasPermission(Permission.EXTRACT, player)) { - return; - } - - // First try to empty the crafting matrix - for (int i = 0; i < matrix.getSizeInventory(); ++i) { - ItemStack slot = matrix.getStackInSlot(i); - - if (!slot.isEmpty()) { - // Only if we are a crafting grid. Pattern grids can just be emptied. - if (getType() == EnumGridType.CRAFTING) { - // If we are connected, try to insert into network. If it fails, stop. - if (hasNetwork()) { - if (network.insertItem(slot, slot.getCount(), true) != null) { - return; - } else { - network.insertItem(slot, slot.getCount(), false); - } - } else { - // If we aren't connected, try to insert into player inventory. If it fails, stop. - if (!player.inventory.addItemStackToInventory(slot.copy())) { - return; - } - } - } - - matrix.setInventorySlotContents(i, ItemStack.EMPTY); - } - } - - // Now let's fill the matrix - for (int i = 0; i < matrix.getSizeInventory(); ++i) { - if (recipe[i] != null) { - ItemStack[] possibilities = recipe[i]; - - // If we are a crafting grid - if (getType() == EnumGridType.CRAFTING) { - boolean found = false; - - // If we are connected, first try to get the possibilities from the network - if (hasNetwork()) { - for (ItemStack possibility : possibilities) { - ItemStack took = network.extractItem(possibility, 1, false); - - if (took != null) { - matrix.setInventorySlotContents(i, RSUtils.getStack(took)); - - found = true; - - break; - } - } - } - - // If we haven't found anything in the network (or we are disconnected), go look in the player inventory - if (!found) { - for (ItemStack possibility : possibilities) { - for (int j = 0; j < player.inventory.getSizeInventory(); ++j) { - if (API.instance().getComparer().isEqualNoQuantity(possibility, player.inventory.getStackInSlot(j))) { - matrix.setInventorySlotContents(i, ItemHandlerHelper.copyStackWithSize(player.inventory.getStackInSlot(j), 1)); - - player.inventory.decrStackSize(j, 1); - - found = true; - - break; - } - } - - if (found) { - break; - } - } - } - } else if (getType() == EnumGridType.PATTERN) { - // If we are a pattern grid we can just set the slot - matrix.setInventorySlotContents(i, possibilities[0]); - } - } - } - } - - @Override - public int getViewType() { - return getWorld().isRemote ? VIEW_TYPE.getValue() : viewType; - } - - @Override - public int getSortingDirection() { - return getWorld().isRemote ? SORTING_DIRECTION.getValue() : sortingDirection; - } - - @Override - public int getSortingType() { - return getWorld().isRemote ? SORTING_TYPE.getValue() : sortingType; - } - - @Override - public int getSearchBoxMode() { - return getWorld().isRemote ? SEARCH_BOX_MODE.getValue() : searchBoxMode; - } - - @Override - public int getTabSelected() { - return getWorld().isRemote ? TAB_SELECTED.getValue() : tabSelected; - } - - @Override - public void onViewTypeChanged(int type) { - TileDataManager.setParameter(VIEW_TYPE, type); - } - - @Override - public void onSortingTypeChanged(int type) { - TileDataManager.setParameter(SORTING_TYPE, type); - } - - @Override - public void onSortingDirectionChanged(int direction) { - TileDataManager.setParameter(SORTING_DIRECTION, direction); - } - - @Override - public void onSearchBoxModeChanged(int searchBoxMode) { - TileDataManager.setParameter(SEARCH_BOX_MODE, searchBoxMode); - } - - @Override - public void onTabSelectionChanged(int tab) { - TileDataManager.setParameter(TAB_SELECTED, tab); - } - - @Override - public TileDataParameter getRedstoneModeConfig() { - return REDSTONE_MODE; - } - - @Override - public boolean hasConnectivityState() { - return true; - } - - @Override - public void read(NBTTagCompound tag) { - super.read(tag); - - RSUtils.readItemsLegacy(matrix, 0, tag); - RSUtils.readItems(patterns, 1, tag); - RSUtils.readItems(filter, 2, tag); - - if (tag.hasKey(NBT_TAB_SELECTED)) { - tabSelected = tag.getInteger(NBT_TAB_SELECTED); - } - } - - @Override - public NBTTagCompound write(NBTTagCompound tag) { - super.write(tag); - - RSUtils.writeItemsLegacy(matrix, 0, tag); - RSUtils.writeItems(patterns, 1, tag); - RSUtils.writeItems(filter, 2, tag); - - tag.setInteger(NBT_TAB_SELECTED, tabSelected); - - return tag; - } - - @Override - public NBTTagCompound writeConfiguration(NBTTagCompound tag) { - super.writeConfiguration(tag); - - tag.setInteger(NBT_VIEW_TYPE, viewType); - tag.setInteger(NBT_SORTING_DIRECTION, sortingDirection); - tag.setInteger(NBT_SORTING_TYPE, sortingType); - tag.setInteger(NBT_SEARCH_BOX_MODE, searchBoxMode); - - tag.setBoolean(NBT_OREDICT_PATTERN, oredictPattern); - - return tag; - } - - @Override - public void readConfiguration(NBTTagCompound tag) { - super.readConfiguration(tag); - - if (tag.hasKey(NBT_VIEW_TYPE)) { - viewType = tag.getInteger(NBT_VIEW_TYPE); - } - - if (tag.hasKey(NBT_SORTING_DIRECTION)) { - sortingDirection = tag.getInteger(NBT_SORTING_DIRECTION); - } - - if (tag.hasKey(NBT_SORTING_TYPE)) { - sortingType = tag.getInteger(NBT_SORTING_TYPE); - } - - if (tag.hasKey(NBT_SEARCH_BOX_MODE)) { - searchBoxMode = tag.getInteger(NBT_SEARCH_BOX_MODE); - } - - if (tag.hasKey(NBT_OREDICT_PATTERN)) { - oredictPattern = tag.getBoolean(NBT_OREDICT_PATTERN); - } - } - - @Override - public IItemHandler getDrops() { - switch (getType()) { - case CRAFTING: - return new CombinedInvWrapper(filter, new InvWrapper(matrix)); - case PATTERN: - return new CombinedInvWrapper(filter, patterns); - default: - return new CombinedInvWrapper(filter); - } - } - - public static boolean isValidViewType(int type) { - return type == VIEW_TYPE_NORMAL || - type == VIEW_TYPE_CRAFTABLES || - type == VIEW_TYPE_NON_CRAFTABLES; - } - - public static boolean isValidSearchBoxMode(int mode) { - return mode == SEARCH_BOX_MODE_NORMAL || - mode == SEARCH_BOX_MODE_NORMAL_AUTOSELECTED || - mode == SEARCH_BOX_MODE_JEI_SYNCHRONIZED || - mode == SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED; - } - - public static boolean isSearchBoxModeWithAutoselection(int mode) { - return mode == SEARCH_BOX_MODE_NORMAL_AUTOSELECTED || mode == TileGrid.SEARCH_BOX_MODE_JEI_SYNCHRONIZED_AUTOSELECTED; - } - - public static boolean isValidSortingType(int type) { - return type == SORTING_TYPE_QUANTITY || type == TileGrid.SORTING_TYPE_NAME; - } - - public static boolean isValidSortingDirection(int direction) { - return direction == SORTING_DIRECTION_ASCENDING || direction == SORTING_DIRECTION_DESCENDING; + public INetworkNode createNode() { + return new NetworkNodeGrid(this); } } diff --git a/src/main/resources/assets/refinedstorage/lang/en_US.lang b/src/main/resources/assets/refinedstorage/lang/en_US.lang index a72f7ce25..b489d5d3d 100755 --- a/src/main/resources/assets/refinedstorage/lang/en_US.lang +++ b/src/main/resources/assets/refinedstorage/lang/en_US.lang @@ -6,7 +6,6 @@ gui.refinedstorage:grid=Grid gui.refinedstorage:grid.craft=Craft gui.refinedstorage:grid.pattern_create=Create Pattern gui.refinedstorage:wireless_grid=Wireless Grid -gui.refinedstorage:wireless_fluid_grid=Wireless Fluid Grid gui.refinedstorage:fluid_grid=Fluid Grid gui.refinedstorage:disk_drive=Drive gui.refinedstorage:disk_drive.disks=Disks