diff --git a/src/main/java/refinedstorage/RefinedStorage.java b/src/main/java/refinedstorage/RefinedStorage.java index 4a1265527..1a0eade82 100755 --- a/src/main/java/refinedstorage/RefinedStorage.java +++ b/src/main/java/refinedstorage/RefinedStorage.java @@ -60,6 +60,7 @@ public final class RefinedStorage { public int relayUsage; public int soldererUsage; public int storageUsage; + public int fluidStorageUsage; public int wirelessTransmitterUsage; public int gridUsage; public int craftingGridUsage; @@ -106,6 +107,7 @@ public final class RefinedStorage { 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"); storageUsage = config.getInt("storage", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Storage Blocks"); + fluidStorageUsage = config.getInt("fluidStorage", "energy", 1, 0, Integer.MAX_VALUE, "The energy used by Fluid Storage Blocks"); wirelessTransmitterUsage = config.getInt("wirelessTransmitter", "energy", 8, 0, Integer.MAX_VALUE, "The energy used by Wireless Transmitters"); gridUsage = config.getInt("grid", "energy", 2, 0, Integer.MAX_VALUE, "The energy used by Grids"); craftingGridUsage = config.getInt("craftingGrid", "energy", 4, 0, Integer.MAX_VALUE, "The energy used by Crafting Grids"); diff --git a/src/main/java/refinedstorage/RefinedStorageBlocks.java b/src/main/java/refinedstorage/RefinedStorageBlocks.java index 113e8f3d8..b28804898 100755 --- a/src/main/java/refinedstorage/RefinedStorageBlocks.java +++ b/src/main/java/refinedstorage/RefinedStorageBlocks.java @@ -25,4 +25,5 @@ public final class RefinedStorageBlocks { public static final BlockNetworkTransmitter NETWORK_TRANSMITTER = new BlockNetworkTransmitter(); public static final BlockNetworkReceiver NETWORK_RECEIVER = new BlockNetworkReceiver(); public static final BlockFluidInterface FLUID_INTERFACE = new BlockFluidInterface(); + public static final BlockFluidStorage FLUID_STORAGE = new BlockFluidStorage(); } \ No newline at end of file diff --git a/src/main/java/refinedstorage/RefinedStorageGui.java b/src/main/java/refinedstorage/RefinedStorageGui.java index 4cb2a2354..0bf90311d 100755 --- a/src/main/java/refinedstorage/RefinedStorageGui.java +++ b/src/main/java/refinedstorage/RefinedStorageGui.java @@ -22,4 +22,5 @@ public final class RefinedStorageGui { public static final int NETWORK_TRANSMITTER = 18; public static final int FLUID_INTERFACE = 19; public static final int EXTERNAL_STORAGE = 20; + public static final int FLUID_STORAGE = 21; } diff --git a/src/main/java/refinedstorage/apiimpl/solderer/SoldererRecipeFluidStorage.java b/src/main/java/refinedstorage/apiimpl/solderer/SoldererRecipeFluidStorage.java new file mode 100755 index 000000000..08da59181 --- /dev/null +++ b/src/main/java/refinedstorage/apiimpl/solderer/SoldererRecipeFluidStorage.java @@ -0,0 +1,38 @@ +package refinedstorage.apiimpl.solderer; + +import net.minecraft.item.ItemStack; +import refinedstorage.RefinedStorageBlocks; +import refinedstorage.RefinedStorageItems; +import refinedstorage.api.solderer.ISoldererRecipe; +import refinedstorage.block.EnumFluidStorageType; +import refinedstorage.item.ItemBlockFluidStorage; +import refinedstorage.item.ItemProcessor; + +public class SoldererRecipeFluidStorage implements ISoldererRecipe { + private EnumFluidStorageType type; + private ItemStack[] rows; + + public SoldererRecipeFluidStorage(EnumFluidStorageType type, int storagePart) { + this.type = type; + this.rows = new ItemStack[]{ + new ItemStack(RefinedStorageItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC), + new ItemStack(RefinedStorageBlocks.MACHINE_CASING), + new ItemStack(RefinedStorageItems.FLUID_STORAGE_PART, 1, storagePart) + }; + } + + @Override + public ItemStack getRow(int row) { + return rows[row]; + } + + @Override + public ItemStack getResult() { + return ItemBlockFluidStorage.initNBT(new ItemStack(RefinedStorageBlocks.FLUID_STORAGE, 1, type.getId())); + } + + @Override + public int getDuration() { + return 200; + } +} diff --git a/src/main/java/refinedstorage/block/BlockFluidStorage.java b/src/main/java/refinedstorage/block/BlockFluidStorage.java new file mode 100755 index 000000000..774c57818 --- /dev/null +++ b/src/main/java/refinedstorage/block/BlockFluidStorage.java @@ -0,0 +1,114 @@ +package refinedstorage.block; + +import net.minecraft.block.properties.PropertyEnum; +import net.minecraft.block.state.BlockStateContainer; +import net.minecraft.block.state.IBlockState; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +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.IBlockAccess; +import net.minecraft.world.World; +import refinedstorage.RefinedStorage; +import refinedstorage.RefinedStorageBlocks; +import refinedstorage.RefinedStorageGui; +import refinedstorage.item.ItemBlockFluidStorage; +import refinedstorage.tile.TileFluidStorage; + +import java.util.ArrayList; +import java.util.List; + +public class BlockFluidStorage extends BlockNode { + public static final PropertyEnum TYPE = PropertyEnum.create("type", EnumFluidStorageType.class); + + public BlockFluidStorage() { + super("fluid_storage"); + + setHardness(5.8F); + } + + @Override + public void getSubBlocks(Item item, CreativeTabs tab, List subItems) { + for (int i = 0; i <= 4; ++i) { + subItems.add(ItemBlockFluidStorage.initNBT(new ItemStack(item, 1, i))); + } + } + + @Override + protected BlockStateContainer createBlockState() { + return createBlockStateBuilder() + .add(TYPE) + .build(); + } + + @Override + public IBlockState getStateFromMeta(int meta) { + return getDefaultState().withProperty(TYPE, EnumFluidStorageType.getById(meta)); + } + + @Override + public int getMetaFromState(IBlockState state) { + return ((EnumFluidStorageType) state.getValue(TYPE)).getId(); + } + + @Override + public TileEntity createTileEntity(World world, IBlockState state) { + return new TileFluidStorage(); + } + + @Override + public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ) { + if (!world.isRemote) { + player.openGui(RefinedStorage.INSTANCE, RefinedStorageGui.FLUID_STORAGE, world, pos.getX(), pos.getY(), pos.getZ()); + } + + return true; + } + + @Override + 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)); + } + } + + @Override + public void breakBlock(World world, BlockPos pos, IBlockState state) { + ((TileFluidStorage) world.getTileEntity(pos)).onBreak(); + + super.breakBlock(world, pos, state); + } + + @Override + public List getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) { + TileFluidStorage storage = (TileFluidStorage) world.getTileEntity(pos); + + List drops = new ArrayList<>(); + + ItemStack stack = new ItemStack(RefinedStorageBlocks.FLUID_STORAGE, 1, getMetaFromState(state)); + stack.setTagCompound(new NBTTagCompound()); + stack.getTagCompound().setTag(TileFluidStorage.NBT_STORAGE, storage.getStorageTag()); + + drops.add(stack); + + return drops; + } + + @Override + public Item createItem() { + return new ItemBlockFluidStorage(); + } + + @Override + public EnumPlacementType getPlacementType() { + return null; + } +} diff --git a/src/main/java/refinedstorage/block/BlockStorage.java b/src/main/java/refinedstorage/block/BlockStorage.java index 528fad467..c2880d805 100755 --- a/src/main/java/refinedstorage/block/BlockStorage.java +++ b/src/main/java/refinedstorage/block/BlockStorage.java @@ -93,7 +93,7 @@ public class BlockStorage extends BlockNode { List drops = new ArrayList<>(); - ItemStack stack = new ItemStack(RefinedStorageBlocks.STORAGE, 1, RefinedStorageBlocks.STORAGE.getMetaFromState(state)); + ItemStack stack = new ItemStack(RefinedStorageBlocks.STORAGE, 1, getMetaFromState(state)); stack.setTagCompound(new NBTTagCompound()); stack.getTagCompound().setTag(TileStorage.NBT_STORAGE, storage.getStorageTag()); diff --git a/src/main/java/refinedstorage/container/ContainerFluidStorage.java b/src/main/java/refinedstorage/container/ContainerFluidStorage.java new file mode 100755 index 000000000..85f8a4445 --- /dev/null +++ b/src/main/java/refinedstorage/container/ContainerFluidStorage.java @@ -0,0 +1,30 @@ +package refinedstorage.container; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import refinedstorage.container.slot.SlotSpecimenFluid; +import refinedstorage.tile.TileFluidStorage; + +public class ContainerFluidStorage extends ContainerBase { + public ContainerFluidStorage(TileFluidStorage tile, EntityPlayer player) { + super(tile, player); + + for (int i = 0; i < 9; ++i) { + addSlotToContainer(new SlotSpecimenFluid(!tile.getWorld().isRemote, tile.getFilters(), i, 8 + (18 * i), 20)); + } + + addPlayerInventory(8, 129); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer player, int index) { + Slot slot = getSlot(index); + + if (slot != null && slot.getHasStack() && index >= 8) { + return mergeItemStackToSpecimen(slot.getStack(), 0, 9); + } + + return null; + } +} diff --git a/src/main/java/refinedstorage/gui/GuiHandler.java b/src/main/java/refinedstorage/gui/GuiHandler.java index 5f7adcb08..899719eeb 100755 --- a/src/main/java/refinedstorage/gui/GuiHandler.java +++ b/src/main/java/refinedstorage/gui/GuiHandler.java @@ -56,6 +56,8 @@ public class GuiHandler implements IGuiHandler { return new ContainerNetworkTransmitter((TileNetworkTransmitter) tile, player); case RefinedStorageGui.FLUID_INTERFACE: return new ContainerFluidInterface((TileFluidInterface) tile, player); + case RefinedStorageGui.FLUID_STORAGE: + return new ContainerFluidStorage((TileFluidStorage) tile, player); default: return null; } @@ -131,6 +133,8 @@ public class GuiHandler implements IGuiHandler { return new GuiNetworkTransmitter((ContainerNetworkTransmitter) getContainer(ID, player, tile), (TileNetworkTransmitter) tile); case RefinedStorageGui.FLUID_INTERFACE: return new GuiFluidInterface((ContainerFluidInterface) getContainer(ID, player, tile)); + case RefinedStorageGui.FLUID_STORAGE: + return new GuiStorage((ContainerFluidStorage) getContainer(ID, player, tile), (TileFluidStorage) tile); default: return null; } diff --git a/src/main/java/refinedstorage/item/ItemBlockFluidStorage.java b/src/main/java/refinedstorage/item/ItemBlockFluidStorage.java new file mode 100755 index 000000000..f4d484798 --- /dev/null +++ b/src/main/java/refinedstorage/item/ItemBlockFluidStorage.java @@ -0,0 +1,90 @@ +package refinedstorage.item; + +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.InventoryHelper; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ActionResult; +import net.minecraft.util.EnumActionResult; +import net.minecraft.util.EnumHand; +import net.minecraft.world.World; +import refinedstorage.RefinedStorageBlocks; +import refinedstorage.RefinedStorageItems; +import refinedstorage.apiimpl.storage.fluid.FluidStorageNBT; +import refinedstorage.block.EnumFluidStorageType; +import refinedstorage.tile.TileFluidStorage; + +import java.util.List; + +public class ItemBlockFluidStorage extends ItemBlockBase { + public ItemBlockFluidStorage() { + super(RefinedStorageBlocks.FLUID_STORAGE, true); + } + + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List tooltip, boolean advanced) { + EnumFluidStorageType type = EnumFluidStorageType.getById(stack.getMetadata()); + + if (type != null && isValid(stack)) { + NBTTagCompound tag = stack.getTagCompound().getCompoundTag(TileFluidStorage.NBT_STORAGE); + + if (type == EnumFluidStorageType.TYPE_CREATIVE) { + tooltip.add(I18n.format("misc.refinedstorage:storage.stored", FluidStorageNBT.getStoredFromNBT(tag))); + } else { + tooltip.add(I18n.format("misc.refinedstorage:storage.stored_capacity", FluidStorageNBT.getStoredFromNBT(tag), type.getCapacity())); + } + } + } + + @Override + public ActionResult onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand) { + EnumFluidStorageType type = EnumFluidStorageType.getById(stack.getMetadata()); + + if (type != null && isValid(stack) && FluidStorageNBT.getStoredFromNBT(stack.getTagCompound().getCompoundTag(TileFluidStorage.NBT_STORAGE)) == 0 && stack.getMetadata() != ItemFluidStorageDisk.TYPE_CREATIVE && !world.isRemote && player.isSneaking()) { + ItemStack storagePart = new ItemStack(RefinedStorageItems.FLUID_STORAGE_PART, 1, stack.getMetadata()); + + if (!player.inventory.addItemStackToInventory(storagePart.copy())) { + InventoryHelper.spawnItemStack(world, player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), storagePart); + } + + ItemStack processor = new ItemStack(RefinedStorageItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC); + + if (!player.inventory.addItemStackToInventory(processor.copy())) { + InventoryHelper.spawnItemStack(world, player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), processor); + } + + return new ActionResult<>(EnumActionResult.SUCCESS, new ItemStack(RefinedStorageBlocks.MACHINE_CASING)); + } + + return new ActionResult<>(EnumActionResult.PASS, stack); + } + + private static boolean isValid(ItemStack stack) { + return stack.getTagCompound() != null && stack.getTagCompound().hasKey(TileFluidStorage.NBT_STORAGE); + } + + @Override + public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean selected) { + super.onUpdate(stack, world, entity, slot, selected); + + if (!stack.hasTagCompound()) { + initNBT(stack); + } + } + + @Override + public void onCreated(ItemStack stack, World world, EntityPlayer player) { + super.onCreated(stack, world, player); + + initNBT(stack); + } + + public static ItemStack initNBT(ItemStack stack) { + NBTTagCompound tag = new NBTTagCompound(); + tag.setTag(TileFluidStorage.NBT_STORAGE, FluidStorageNBT.createNBT()); + stack.setTagCompound(tag); + return stack; + } +} diff --git a/src/main/java/refinedstorage/item/ItemFluidStorageDisk.java b/src/main/java/refinedstorage/item/ItemFluidStorageDisk.java index 4aa2e99a8..d33e4463b 100755 --- a/src/main/java/refinedstorage/item/ItemFluidStorageDisk.java +++ b/src/main/java/refinedstorage/item/ItemFluidStorageDisk.java @@ -4,9 +4,14 @@ import net.minecraft.client.resources.I18n; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.Entity; import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.InventoryHelper; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; +import net.minecraft.util.ActionResult; +import net.minecraft.util.EnumActionResult; +import net.minecraft.util.EnumHand; import net.minecraft.world.World; +import refinedstorage.RefinedStorageItems; import refinedstorage.apiimpl.storage.fluid.FluidStorageNBT; import refinedstorage.block.EnumFluidStorageType; @@ -43,6 +48,21 @@ public class ItemFluidStorageDisk extends ItemBase { } } + @Override + public ActionResult onItemRightClick(ItemStack disk, World world, EntityPlayer player, EnumHand hand) { + if (!world.isRemote && player.isSneaking() && FluidStorageNBT.isValid(disk) && FluidStorageNBT.getStoredFromNBT(disk.getTagCompound()) == 0 && disk.getMetadata() != TYPE_CREATIVE) { + ItemStack storagePart = new ItemStack(RefinedStorageItems.FLUID_STORAGE_PART, 1, disk.getMetadata()); + + if (!player.inventory.addItemStackToInventory(storagePart.copy())) { + InventoryHelper.spawnItemStack(world, player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), storagePart); + } + + return new ActionResult<>(EnumActionResult.SUCCESS, new ItemStack(RefinedStorageItems.STORAGE_HOUSING)); + } + + return new ActionResult<>(EnumActionResult.PASS, disk); + } + @Override public void addInformation(ItemStack disk, EntityPlayer player, List tooltip, boolean advanced) { if (FluidStorageNBT.isValid(disk)) { diff --git a/src/main/java/refinedstorage/proxy/CommonProxy.java b/src/main/java/refinedstorage/proxy/CommonProxy.java index 3c5ebbd82..96da659e5 100755 --- a/src/main/java/refinedstorage/proxy/CommonProxy.java +++ b/src/main/java/refinedstorage/proxy/CommonProxy.java @@ -86,6 +86,7 @@ public class CommonProxy { registerTile(TileNetworkReceiver.class, "network_receiver"); registerTile(TileNetworkTransmitter.class, "network_transmitter"); registerTile(TileFluidInterface.class, "fluid_interface"); + registerTile(TileFluidStorage.class, "fluid_storage"); registerBlock(RefinedStorageBlocks.CONTROLLER); registerBlock(RefinedStorageBlocks.GRID); @@ -109,6 +110,7 @@ public class CommonProxy { registerBlock(RefinedStorageBlocks.NETWORK_TRANSMITTER); registerBlock(RefinedStorageBlocks.NETWORK_RECEIVER); registerBlock(RefinedStorageBlocks.FLUID_INTERFACE); + registerBlock(RefinedStorageBlocks.FLUID_STORAGE); registerItem(RefinedStorageItems.QUARTZ_ENRICHED_IRON); registerItem(RefinedStorageItems.STORAGE_DISK); @@ -532,6 +534,12 @@ public class CommonProxy { RefinedStorageAPI.SOLDERER_REGISTRY.addRecipe(new SoldererRecipeStorage(EnumItemStorageType.TYPE_16K, ItemStoragePart.TYPE_16K)); RefinedStorageAPI.SOLDERER_REGISTRY.addRecipe(new SoldererRecipeStorage(EnumItemStorageType.TYPE_64K, ItemStoragePart.TYPE_64K)); + // Fluid Storage Blocks + RefinedStorageAPI.SOLDERER_REGISTRY.addRecipe(new SoldererRecipeFluidStorage(EnumFluidStorageType.TYPE_64K, ItemFluidStoragePart.TYPE_64K)); + RefinedStorageAPI.SOLDERER_REGISTRY.addRecipe(new SoldererRecipeFluidStorage(EnumFluidStorageType.TYPE_128K, ItemFluidStoragePart.TYPE_128K)); + RefinedStorageAPI.SOLDERER_REGISTRY.addRecipe(new SoldererRecipeFluidStorage(EnumFluidStorageType.TYPE_256K, ItemFluidStoragePart.TYPE_256K)); + RefinedStorageAPI.SOLDERER_REGISTRY.addRecipe(new SoldererRecipeFluidStorage(EnumFluidStorageType.TYPE_512K, ItemFluidStoragePart.TYPE_512K)); + // Crafting Monitor GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(RefinedStorageBlocks.CRAFTING_MONITOR), "EGE", diff --git a/src/main/java/refinedstorage/tile/TileFluidStorage.java b/src/main/java/refinedstorage/tile/TileFluidStorage.java new file mode 100755 index 000000000..cedf6479b --- /dev/null +++ b/src/main/java/refinedstorage/tile/TileFluidStorage.java @@ -0,0 +1,264 @@ +package refinedstorage.tile; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.datasync.DataSerializers; +import net.minecraftforge.fluids.FluidStack; +import refinedstorage.RefinedStorage; +import refinedstorage.RefinedStorageBlocks; +import refinedstorage.api.network.INetworkMaster; +import refinedstorage.api.storage.fluid.IFluidStorage; +import refinedstorage.api.storage.fluid.IFluidStorageProvider; +import refinedstorage.apiimpl.storage.fluid.FluidStorageNBT; +import refinedstorage.apiimpl.storage.fluid.FluidUtils; +import refinedstorage.block.BlockFluidStorage; +import refinedstorage.block.EnumFluidStorageType; +import refinedstorage.inventory.ItemHandlerFluid; +import refinedstorage.tile.config.IComparable; +import refinedstorage.tile.config.IFilterable; +import refinedstorage.tile.config.IPrioritizable; +import refinedstorage.tile.data.ITileDataProducer; +import refinedstorage.tile.data.TileDataParameter; + +import java.util.List; + +public class TileFluidStorage extends TileNode implements IFluidStorageProvider, IStorageGui, IComparable, IFilterable, IPrioritizable { + 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 STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer() { + @Override + public Integer getValue(TileFluidStorage tile) { + return FluidStorageNBT.getStoredFromNBT(tile.storageTag); + } + }); + + class FluidStorage extends FluidStorageNBT { + public FluidStorage() { + super(TileFluidStorage.this.getStorageTag(), TileFluidStorage.this.getCapacity(), TileFluidStorage.this); + } + + @Override + public int getPriority() { + return priority; + } + + @Override + public FluidStack insertFluid(FluidStack stack, int size, boolean simulate) { + if (!IFilterable.canTakeFluids(filters, mode, compare, stack)) { + return FluidUtils.copyStackWithSize(stack, size); + } + + return super.insertFluid(stack, size, simulate); + } + } + + 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 ItemHandlerFluid filters = new ItemHandlerFluid(9, this); + + private NBTTagCompound storageTag = FluidStorageNBT.createNBT(); + + private FluidStorage storage; + + private EnumFluidStorageType type; + + private int priority = 0; + private int compare = 0; + private int mode = IFilterable.WHITELIST; + + public TileFluidStorage() { + dataManager.addWatchedParameter(PRIORITY); + dataManager.addWatchedParameter(COMPARE); + dataManager.addWatchedParameter(MODE); + dataManager.addWatchedParameter(STORED); + } + + @Override + public int getEnergyUsage() { + return RefinedStorage.INSTANCE.fluidStorageUsage; + } + + @Override + public void updateNode() { + } + + @Override + public void update() { + super.update(); + + if (storage == null && storageTag != null) { + storage = new FluidStorage(); + + if (network != null) { + network.getFluidStorage().rebuild(); + } + } + } + + public void onBreak() { + if (storage != null) { + storage.writeToNBT(); + } + } + + @Override + public void onConnectionChange(INetworkMaster network, boolean state) { + super.onConnectionChange(network, state); + + network.getFluidStorage().rebuild(); + } + + @Override + public void addFluidStorages(List storages) { + if (storage != null) { + storages.add(storage); + } + } + + @Override + public void read(NBTTagCompound tag) { + super.read(tag); + + readItems(filters, 0, tag); + + if (tag.hasKey(NBT_PRIORITY)) { + priority = tag.getInteger(NBT_PRIORITY); + } + + if (tag.hasKey(NBT_STORAGE)) { + storageTag = tag.getCompoundTag(NBT_STORAGE); + } + + if (tag.hasKey(NBT_COMPARE)) { + compare = tag.getInteger(NBT_COMPARE); + } + + if (tag.hasKey(NBT_MODE)) { + mode = tag.getInteger(NBT_MODE); + } + } + + @Override + public NBTTagCompound write(NBTTagCompound tag) { + super.write(tag); + + writeItems(filters, 0, tag); + + tag.setInteger(NBT_PRIORITY, priority); + + if (storage != null) { + storage.writeToNBT(); + } + + tag.setTag(NBT_STORAGE, storageTag); + tag.setInteger(NBT_COMPARE, compare); + tag.setInteger(NBT_MODE, mode); + + return tag; + } + + public EnumFluidStorageType getType() { + if (type == null && worldObj.getBlockState(pos).getBlock() == RefinedStorageBlocks.FLUID_STORAGE) { + this.type = ((EnumFluidStorageType) worldObj.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; + } + + public NBTTagCompound getStorageTag() { + return storageTag; + } + + public void setStorageTag(NBTTagCompound storageTag) { + this.storageTag = storageTag; + } + + public FluidStorageNBT getStorage() { + return storage; + } + + public ItemHandlerFluid getFilters() { + return filters; + } + + @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(); + } +} + diff --git a/src/main/resources/assets/refinedstorage/lang/en_US.lang b/src/main/resources/assets/refinedstorage/lang/en_US.lang index deaac37c7..d9a0dbaad 100755 --- a/src/main/resources/assets/refinedstorage/lang/en_US.lang +++ b/src/main/resources/assets/refinedstorage/lang/en_US.lang @@ -134,6 +134,11 @@ block.refinedstorage:processing_pattern_encoder.name=Processing Pattern Encoder block.refinedstorage:network_receiver.name=Network Receiver block.refinedstorage:network_transmitter.name=Network Transmitter block.refinedstorage:fluid_interface.name=Fluid Interface +block.refinedstorage:fluid_storage.0.name=64k Fluid Storage Block +block.refinedstorage:fluid_storage.1.name=128k Fluid Storage Block +block.refinedstorage:fluid_storage.2.name=256k Fluid Storage Block +block.refinedstorage:fluid_storage.3.name=512k Fluid Storage Block +block.refinedstorage:fluid_storage.4.name=Creative Fluid Storage Block item.refinedstorage:storage_disk.0.name=1k Storage Disk item.refinedstorage:storage_disk.1.name=4k Storage Disk