diff --git a/src/main/java/refinedstorage/RefinedStorage.java b/src/main/java/refinedstorage/RefinedStorage.java index 105a4a828..b3d749c36 100755 --- a/src/main/java/refinedstorage/RefinedStorage.java +++ b/src/main/java/refinedstorage/RefinedStorage.java @@ -59,6 +59,7 @@ public final class RefinedStorage { public int externalStoragePerStorageUsage; public int exporterUsage; public int importerUsage; + public int fluidImporterUsage; public int interfaceUsage; public int relayUsage; public int soldererUsage; @@ -108,6 +109,7 @@ public final class RefinedStorage { externalStoragePerStorageUsage = config.getInt("externalStoragePerStorage", "energy", 1, 0, Integer.MAX_VALUE, "The additional energy used per connected storage to an External Storage"); exporterUsage = config.getInt("exporter", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Exporters"); importerUsage = config.getInt("importer", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Importers"); + fluidImporterUsage = config.getInt("fluidImporter", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Fluid Importers"); interfaceUsage = config.getInt("interface", "energy", 3, 0, Integer.MAX_VALUE, "The energy used by Interfaces"); relayUsage = config.getInt("relay", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Relays"); soldererUsage = config.getInt("solderer", "energy", 3, 0, Integer.MAX_VALUE, "The energy used by Solderers"); diff --git a/src/main/java/refinedstorage/RefinedStorageBlocks.java b/src/main/java/refinedstorage/RefinedStorageBlocks.java index 0abad81c3..422e2df0d 100755 --- a/src/main/java/refinedstorage/RefinedStorageBlocks.java +++ b/src/main/java/refinedstorage/RefinedStorageBlocks.java @@ -27,4 +27,5 @@ public final class RefinedStorageBlocks { public static final BlockFluidDiskDrive FLUID_DISK_DRIVE = new BlockFluidDiskDrive(); public static final BlockFluidConstructor FLUID_CONSTRUCTOR = new BlockFluidConstructor(); public static final BlockFluidDestructor FLUID_DESTRUCTOR = new BlockFluidDestructor(); + public static final BlockFluidImporter FLUID_IMPORTER = new BlockFluidImporter(); } \ No newline at end of file diff --git a/src/main/java/refinedstorage/RefinedStorageGui.java b/src/main/java/refinedstorage/RefinedStorageGui.java index 697d347b0..900d19510 100755 --- a/src/main/java/refinedstorage/RefinedStorageGui.java +++ b/src/main/java/refinedstorage/RefinedStorageGui.java @@ -23,4 +23,5 @@ public final class RefinedStorageGui { public static final int FLUID_DISK_DRIVE = 19; public static final int FLUID_CONSTRUCTOR = 20; public static final int FLUID_DESTRUCTOR = 21; + public static final int FLUID_IMPORTER = 22; } diff --git a/src/main/java/refinedstorage/block/BlockFluidImporter.java b/src/main/java/refinedstorage/block/BlockFluidImporter.java new file mode 100755 index 000000000..b9857e581 --- /dev/null +++ b/src/main/java/refinedstorage/block/BlockFluidImporter.java @@ -0,0 +1,37 @@ +package refinedstorage.block; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import refinedstorage.RefinedStorage; +import refinedstorage.RefinedStorageGui; +import refinedstorage.tile.TileFluidImporter; + +public class BlockFluidImporter extends BlockImporter { + public BlockFluidImporter() { + super("fluid_importer"); + } + + @Override + public TileEntity createTileEntity(World world, IBlockState state) { + return new TileFluidImporter(); + } + + @Override + public boolean onBlockActivatedDefault(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ) { + if (hitCablePart(state, world, pos, hitX, hitY, hitZ)) { + return false; + } + + if (!world.isRemote) { + player.openGui(RefinedStorage.INSTANCE, RefinedStorageGui.FLUID_IMPORTER, world, pos.getX(), pos.getY(), pos.getZ()); + } + + return true; + } +} diff --git a/src/main/java/refinedstorage/block/BlockImporter.java b/src/main/java/refinedstorage/block/BlockImporter.java index 0db3bd463..1e574576e 100755 --- a/src/main/java/refinedstorage/block/BlockImporter.java +++ b/src/main/java/refinedstorage/block/BlockImporter.java @@ -36,8 +36,12 @@ public class BlockImporter extends BlockCable { public static final AxisAlignedBB LINE_DOWN_2_AABB = createAABB(5, 2, 5, 11, 4, 11); public static final AxisAlignedBB LINE_DOWN_3_AABB = createAABB(3, 0, 3, 13, 2, 13); + public BlockImporter(String name) { + super(name); + } + public BlockImporter() { - super("importer"); + this("importer"); } @Override diff --git a/src/main/java/refinedstorage/container/ContainerFluidImporter.java b/src/main/java/refinedstorage/container/ContainerFluidImporter.java new file mode 100755 index 000000000..b3d04d2c4 --- /dev/null +++ b/src/main/java/refinedstorage/container/ContainerFluidImporter.java @@ -0,0 +1,51 @@ +package refinedstorage.container; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import net.minecraftforge.items.SlotItemHandler; +import refinedstorage.container.slot.SlotSpecimenFluid; +import refinedstorage.tile.TileFluidImporter; + +public class ContainerFluidImporter extends ContainerBase { + public ContainerFluidImporter(TileFluidImporter fluidImporter, EntityPlayer player) { + super(fluidImporter, player); + + for (int i = 0; i < 4; ++i) { + addSlotToContainer(new SlotItemHandler(fluidImporter.getUpgrades(), i, 187, 6 + (i * 18))); + } + + for (int i = 0; i < 9; ++i) { + addSlotToContainer(new SlotSpecimenFluid(!fluidImporter.getWorld().isRemote, fluidImporter.getFilters(), i, 8 + (18 * i), 20)); + } + + addPlayerInventory(8, 55); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer player, int index) { + ItemStack stack = null; + + Slot slot = getSlot(index); + + if (slot != null && slot.getHasStack()) { + stack = slot.getStack(); + + if (index < 4) { + if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) { + return null; + } + } else if (!mergeItemStack(stack, 0, 4, false)) { + return mergeItemStackToSpecimen(stack, 4, 4 + 9); + } + + if (stack.stackSize == 0) { + slot.putStack(null); + } else { + slot.onSlotChanged(); + } + } + + return stack; + } +} diff --git a/src/main/java/refinedstorage/gui/GuiFluidImporter.java b/src/main/java/refinedstorage/gui/GuiFluidImporter.java new file mode 100755 index 000000000..1eb2859da --- /dev/null +++ b/src/main/java/refinedstorage/gui/GuiFluidImporter.java @@ -0,0 +1,40 @@ +package refinedstorage.gui; + +import refinedstorage.api.storage.CompareUtils; +import refinedstorage.container.ContainerFluidImporter; +import refinedstorage.gui.sidebutton.SideButtonCompare; +import refinedstorage.gui.sidebutton.SideButtonMode; +import refinedstorage.gui.sidebutton.SideButtonRedstoneMode; +import refinedstorage.tile.TileFluidImporter; + +public class GuiFluidImporter extends GuiBase { + public GuiFluidImporter(ContainerFluidImporter container) { + super(container, 211, 137); + } + + @Override + public void init(int x, int y) { + addSideButton(new SideButtonRedstoneMode(TileFluidImporter.REDSTONE_MODE)); + + addSideButton(new SideButtonMode(TileFluidImporter.MODE)); + + addSideButton(new SideButtonCompare(TileFluidImporter.COMPARE, CompareUtils.COMPARE_NBT)); + } + + @Override + public void update(int x, int y) { + } + + @Override + public void drawBackground(int x, int y, int mouseX, int mouseY) { + bindTexture("gui/importer.png"); + + drawTexture(x, y, 0, 0, width, height); + } + + @Override + public void drawForeground(int mouseX, int mouseY) { + drawString(7, 7, t("gui.refinedstorage:fluid_importer")); + drawString(7, 43, t("container.inventory")); + } +} diff --git a/src/main/java/refinedstorage/gui/GuiHandler.java b/src/main/java/refinedstorage/gui/GuiHandler.java index a2f5c02e5..6a62e62ca 100755 --- a/src/main/java/refinedstorage/gui/GuiHandler.java +++ b/src/main/java/refinedstorage/gui/GuiHandler.java @@ -57,6 +57,8 @@ public class GuiHandler implements IGuiHandler { return new ContainerFluidConstructor((TileFluidConstructor) tile, player); case RefinedStorageGui.FLUID_DESTRUCTOR: return new ContainerFluidDestructor((TileFluidDestructor) tile, player); + case RefinedStorageGui.FLUID_IMPORTER: + return new ContainerFluidImporter((TileFluidImporter) tile, player); default: return null; } @@ -134,6 +136,8 @@ public class GuiHandler implements IGuiHandler { return new GuiFluidConstructor((ContainerFluidConstructor) getContainer(ID, player, tile)); case RefinedStorageGui.FLUID_DESTRUCTOR: return new GuiFluidDestructor((ContainerFluidDestructor) getContainer(ID, player, tile)); + case RefinedStorageGui.FLUID_IMPORTER: + return new GuiFluidImporter((ContainerFluidImporter) getContainer(ID, player, tile)); default: return null; } diff --git a/src/main/java/refinedstorage/proxy/ClientProxy.java b/src/main/java/refinedstorage/proxy/ClientProxy.java index 73c4f6a07..061248e64 100755 --- a/src/main/java/refinedstorage/proxy/ClientProxy.java +++ b/src/main/java/refinedstorage/proxy/ClientProxy.java @@ -260,5 +260,6 @@ public class ClientProxy extends CommonProxy { ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RefinedStorageBlocks.FLUID_DISK_DRIVE), 0, new ModelResourceLocation("refinedstorage:disk_drive", "inventory")); ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RefinedStorageBlocks.FLUID_CONSTRUCTOR), 0, new ModelResourceLocation("refinedstorage:fluid_constructor", "inventory")); ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RefinedStorageBlocks.FLUID_DESTRUCTOR), 0, new ModelResourceLocation("refinedstorage:fluid_destructor", "inventory")); + ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RefinedStorageBlocks.FLUID_IMPORTER), 0, new ModelResourceLocation("refinedstorage:fluid_importer", "inventory")); } } diff --git a/src/main/java/refinedstorage/proxy/CommonProxy.java b/src/main/java/refinedstorage/proxy/CommonProxy.java index c8da6af95..f849504dd 100755 --- a/src/main/java/refinedstorage/proxy/CommonProxy.java +++ b/src/main/java/refinedstorage/proxy/CommonProxy.java @@ -88,6 +88,7 @@ public class CommonProxy { registerTile(TileFluidDiskDrive.class, "fluid_disk_drive"); registerTile(TileFluidConstructor.class, "fluid_constructor"); registerTile(TileFluidDestructor.class, "fluid_destructor"); + registerTile(TileFluidImporter.class, "fluid_importer"); registerBlock(RefinedStorageBlocks.CONTROLLER); registerBlock(RefinedStorageBlocks.GRID); @@ -113,6 +114,7 @@ public class CommonProxy { registerBlock(RefinedStorageBlocks.FLUID_DISK_DRIVE); registerBlock(RefinedStorageBlocks.FLUID_CONSTRUCTOR); registerBlock(RefinedStorageBlocks.FLUID_DESTRUCTOR); + registerBlock(RefinedStorageBlocks.FLUID_IMPORTER); registerItem(RefinedStorageItems.QUARTZ_ENRICHED_IRON); registerItem(RefinedStorageItems.STORAGE_DISK); @@ -331,6 +333,14 @@ public class CommonProxy { new ItemStack(RefinedStorageItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED) ); + // Fluid Importer + GameRegistry.addShapelessRecipe(new ItemStack(RefinedStorageBlocks.FLUID_IMPORTER), + new ItemStack(RefinedStorageBlocks.CABLE), + new ItemStack(RefinedStorageItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION), + new ItemStack(RefinedStorageItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED), + new ItemStack(Items.BUCKET) + ); + // Exporter GameRegistry.addShapelessRecipe(new ItemStack(RefinedStorageBlocks.EXPORTER), new ItemStack(RefinedStorageBlocks.CABLE), diff --git a/src/main/java/refinedstorage/tile/TileBase.java b/src/main/java/refinedstorage/tile/TileBase.java index 9cac1603a..dce0d386b 100755 --- a/src/main/java/refinedstorage/tile/TileBase.java +++ b/src/main/java/refinedstorage/tile/TileBase.java @@ -14,6 +14,9 @@ import net.minecraft.util.ITickable; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; import net.minecraftforge.common.util.Constants; +import net.minecraftforge.fluids.capability.CapabilityFluidHandler; +import net.minecraftforge.fluids.capability.IFluidHandler; +import net.minecraftforge.fluids.capability.wrappers.FluidHandlerWrapper; import net.minecraftforge.items.CapabilityItemHandler; import net.minecraftforge.items.IItemHandler; import net.minecraftforge.items.wrapper.InvWrapper; @@ -217,4 +220,20 @@ public abstract class TileBase extends TileEntity implements ITickable { return handler; } + + protected IFluidHandler getFluidHandler(TileEntity tile, EnumFacing side) { + if (tile == null) { + return null; + } + + IFluidHandler handler = null; + + if (tile.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side)) { + handler = tile.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side); + } else if (tile instanceof net.minecraftforge.fluids.IFluidHandler) { + handler = new FluidHandlerWrapper((net.minecraftforge.fluids.IFluidHandler) tile, side); + } + + return handler; + } } diff --git a/src/main/java/refinedstorage/tile/TileFluidDestructor.java b/src/main/java/refinedstorage/tile/TileFluidDestructor.java index e39fb7547..521f41d65 100755 --- a/src/main/java/refinedstorage/tile/TileFluidDestructor.java +++ b/src/main/java/refinedstorage/tile/TileFluidDestructor.java @@ -71,7 +71,7 @@ public class TileFluidDestructor extends TileMultipartNode implements IComparabl if (handler != null) { FluidStack stack = handler.drain(Fluid.BUCKET_VOLUME, false); - if (IFilterable.canTakeFluids(filters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { + if (stack != null && IFilterable.canTakeFluids(filters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { FluidStack drained = handler.drain(Fluid.BUCKET_VOLUME, true); network.insertFluid(drained, drained.amount, false); diff --git a/src/main/java/refinedstorage/tile/TileFluidImporter.java b/src/main/java/refinedstorage/tile/TileFluidImporter.java new file mode 100755 index 000000000..f737beb31 --- /dev/null +++ b/src/main/java/refinedstorage/tile/TileFluidImporter.java @@ -0,0 +1,142 @@ +package refinedstorage.tile; + +import mcmultipart.microblock.IMicroblock; +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.capability.IFluidHandler; +import net.minecraftforge.items.CapabilityItemHandler; +import net.minecraftforge.items.IItemHandler; +import refinedstorage.RefinedStorage; +import refinedstorage.inventory.ItemHandlerFluid; +import refinedstorage.inventory.ItemHandlerUpgrade; +import refinedstorage.item.ItemUpgrade; +import refinedstorage.tile.config.IComparable; +import refinedstorage.tile.config.IFilterable; +import refinedstorage.tile.data.TileDataParameter; + +public class TileFluidImporter extends TileMultipartNode implements IComparable, IFilterable { + public static final TileDataParameter COMPARE = IComparable.createParameter(); + public static final TileDataParameter MODE = IFilterable.createParameter(); + + private static final String NBT_COMPARE = "Compare"; + private static final String NBT_MODE = "Mode"; + + private ItemHandlerFluid filters = new ItemHandlerFluid(9, this); + private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, this, ItemUpgrade.TYPE_SPEED); + + private int compare = 0; + private int mode = IFilterable.WHITELIST; + + public TileFluidImporter() { + dataManager.addWatchedParameter(COMPARE); + dataManager.addWatchedParameter(MODE); + } + + @Override + public boolean canAddMicroblock(IMicroblock microblock) { + return !isBlockingMicroblock(microblock, getDirection()); + } + + @Override + public int getEnergyUsage() { + return RefinedStorage.INSTANCE.fluidImporterUsage + upgrades.getEnergyUsage(); + } + + @Override + public void updateNode() { + IFluidHandler handler = getFluidHandler(getFacingTile(), getDirection().getOpposite()); + + if (handler != null) { + FluidStack stack = handler.drain(Fluid.BUCKET_VOLUME, false); + + if (stack != null && IFilterable.canTakeFluids(filters, mode, compare, stack) && network.insertFluid(stack, stack.amount, true) == null) { + FluidStack drain = handler.drain(Fluid.BUCKET_VOLUME, true); + + network.insertFluid(drain, drain.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); + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + + readItems(filters, 0, tag); + readItems(upgrades, 1, tag); + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + + writeItems(filters, 0, tag); + writeItems(upgrades, 1, tag); + + return tag; + } + + public IItemHandler getUpgrades() { + return upgrades; + } + + public IItemHandler getFilters() { + return filters; + } + + @Override + public IItemHandler getDrops() { + return upgrades; + } + + @Override + public T getCapability(Capability capability, EnumFacing facing) { + if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { + return (T) upgrades; + } + + return super.getCapability(capability, facing); + } + + @Override + public boolean hasCapability(Capability capability, EnumFacing facing) { + return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing); + } +} diff --git a/src/main/resources/assets/refinedstorage/blockstates/fluid_importer.json b/src/main/resources/assets/refinedstorage/blockstates/fluid_importer.json new file mode 100755 index 000000000..ccbadf616 --- /dev/null +++ b/src/main/resources/assets/refinedstorage/blockstates/fluid_importer.json @@ -0,0 +1,82 @@ +{ + "forge_marker": 1, + "defaults": { + "textures": { + "all": "refinedstorage:blocks/cable", + "particle": "refinedstorage:blocks/cable", + "line": "refinedstorage:blocks/cable_part" + }, + "model": "refinedstorage:cable_core", + "uvlock": true + }, + "variants": { + "inventory": [ + { + "model": "refinedstorage:importer", + "transform": "forge:default-block" + } + ], + "direction": { + "north": { + "submodel": "refinedstorage:importer_north" + }, + "east": { + "submodel": "refinedstorage:importer_east" + }, + "south": { + "submodel": "refinedstorage:importer_south" + }, + "west": { + "submodel": "refinedstorage:importer_west" + }, + "up": { + "submodel": "refinedstorage:importer_up" + }, + "down": { + "submodel": "refinedstorage:importer_down" + } + }, + "north": { + "true": { + "submodel": "refinedstorage:cable_north" + }, + "false": { + } + }, + "east": { + "true": { + "submodel": "refinedstorage:cable_east" + }, + "false": { + } + }, + "south": { + "true": { + "submodel": "refinedstorage:cable_south" + }, + "false": { + } + }, + "west": { + "true": { + "submodel": "refinedstorage:cable_west" + }, + "false": { + } + }, + "up": { + "true": { + "submodel": "refinedstorage:cable_up" + }, + "false": { + } + }, + "down": { + "true": { + "submodel": "refinedstorage:cable_down" + }, + "false": { + } + } + } +} \ No newline at end of file diff --git a/src/main/resources/assets/refinedstorage/lang/en_US.lang b/src/main/resources/assets/refinedstorage/lang/en_US.lang index 0f4806dcd..fdc440480 100755 --- a/src/main/resources/assets/refinedstorage/lang/en_US.lang +++ b/src/main/resources/assets/refinedstorage/lang/en_US.lang @@ -42,6 +42,7 @@ gui.refinedstorage:network_transmitter.missing_upgrade=Insert upgrade gui.refinedstorage:fluid_disk_drive=Fluid Disk Drive gui.refinedstorage:fluid_constructor=Fluid Constructor gui.refinedstorage:fluid_destructor=Fluid Destructor +gui.refinedstorage:fluid_importer=Fluid Importer misc.refinedstorage:energy_stored=%d / %d RS misc.refinedstorage:energy_usage=Usage: %d RS/t @@ -132,6 +133,7 @@ block.refinedstorage:network_transmitter.name=Network Transmitter block.refinedstorage:fluid_disk_drive.name=Fluid Disk Drive block.refinedstorage:fluid_constructor.name=Fluid Constructor block.refinedstorage:fluid_destructor.name=Fluid Destructor +block.refinedstorage:fluid_importer.name=Fluid Importer item.refinedstorage:storage_disk.0.name=1k Storage Disk item.refinedstorage:storage_disk.1.name=4k Storage Disk