Fluid Importer

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");

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();
 }

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;
 }

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;
+    }
+}

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

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;
+    }
+}

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"));
+    }
+}

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;
         }

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"));
     }
 }

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),

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;
+    }
 }

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);

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<Integer> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer> 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> T getCapability(Capability<T> 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);
+    }
+}

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": {
+      }
+    }
+  }
+}

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