diff --git a/build.gradle b/build.gradle index eb8f8a906..7677056ec 100755 --- a/build.gradle +++ b/build.gradle @@ -28,7 +28,7 @@ sourceCompatibility = 1.8 targetCompatibility = 1.8 minecraft { - version = "1.11-13.19.1.2188" + version = "1.11.2-13.20.0.2226" runDir = "run" useDepAts = true mappings = "snapshot_20161206" @@ -41,12 +41,18 @@ repositories { maven { url "http://maven.epoxide.xyz" } + maven { + name "Cyclops Repo" + url "https://dl.bintray.com/cyclopsmc/dev/" + } } dependencies { - deobfCompile "mezz.jei:jei_1.11:4.0.4.199:api" - runtime "mezz.jei:jei_1.11:4.0.4.199" + deobfCompile "mezz.jei:jei_1.11.2:4.2.4.226:api" + runtime "mezz.jei:jei_1.11.2:4.2.4.226" deobfCompile "net.darkhax.tesla:Tesla:1.11-1.3.0.51" + deobfCompile "org.cyclops.cyclopscore:CyclopsCore:1.11.2-0.9.1-476" + deobfCompile "org.cyclops.commoncapabilities:CommonCapabilities:1.11.2-1.3.0-81" } processResources { diff --git a/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java b/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java index 31e7665f3..a638e899e 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java @@ -54,11 +54,12 @@ import javax.annotation.Nullable; import java.math.RoundingMode; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Locale; +import java.util.*; +import java.util.function.BiConsumer; +import java.util.function.BinaryOperator; import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collector; public final class RSUtils { private static final NonNullList EMPTY_NON_NULL_LIST = new NonNullList(Collections.emptyList(), null) { @@ -527,4 +528,42 @@ public final class RSUtils { vertexBuffer.pos(xCoord, yCoord + maskTop, zLevel).tex(uMin, vMin).endVertex(); tessellator.draw(); } + + public static Collector> toNonNullList() { + return new Collector, NonNullList>() { + @Override + public Supplier> supplier() { + return NonNullList::create; + } + + @Override + public BiConsumer, T> accumulator() { + return (list, item) -> { + if (item != null) { + list.add(item); + } + }; + } + + @Override + public BinaryOperator> combiner() { + return (a, b) -> { + NonNullList list = NonNullList.create(); + a.forEach(list::add); + b.forEach(list::add); + return list; + }; + } + + @Override + public Function, NonNullList> finisher() { + return (list) -> list; + } + + @Override + public Set characteristics() { + return EnumSet.of(Characteristics.IDENTITY_FINISH); + } + }; + } } 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 index 728ccdd64..c1ce47744 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java @@ -5,6 +5,8 @@ import com.raoulvdberge.refinedstorage.RSUtils; import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask; import com.raoulvdberge.refinedstorage.api.util.IComparer; import com.raoulvdberge.refinedstorage.apiimpl.API; +import com.raoulvdberge.refinedstorage.integration.cyclopscore.IntegrationCyclopsCore; +import com.raoulvdberge.refinedstorage.integration.cyclopscore.SlotlessItemHandlerHelper; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode; @@ -116,16 +118,24 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy continue; } - ItemStack took = network.extractItem(slot, stackSize, compare, true); + ItemStack took = network.extractItem(slot, Math.min(slot.getMaxStackSize(), stackSize), compare, true); if (took == null) { if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) { network.getCraftingManager().schedule(slot, 1, compare); } - } else if (ItemHandlerHelper.insertItem(handler, took, true).isEmpty()) { - took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false); + } else { + if (IntegrationCyclopsCore.isLoaded() + && SlotlessItemHandlerHelper.isSlotless(getFacingTile(), holder.getDirection().getOpposite()) + && SlotlessItemHandlerHelper.insertItem(getFacingTile(), holder.getDirection().getOpposite(), took, true).isEmpty()) { + took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false); - ItemHandlerHelper.insertItem(handler, took, false); + SlotlessItemHandlerHelper.insertItem(getFacingTile(), holder.getDirection().getOpposite(), took, false); + } else if (ItemHandlerHelper.insertItem(handler, took, true).isEmpty()) { + took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false); + + ItemHandlerHelper.insertItem(handler, took, false); + } } } } 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 index c24042d5c..0ca52b7cf 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java @@ -3,19 +3,16 @@ 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.ItemHandlerFluid; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode; -import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.integration.cyclopscore.ImportingBehaviorCyclops; +import com.raoulvdberge.refinedstorage.integration.cyclopscore.IntegrationCyclopsCore; +import com.raoulvdberge.refinedstorage.integration.cyclopscore.SlotlessItemHandlerHelper; +import com.raoulvdberge.refinedstorage.inventory.*; import com.raoulvdberge.refinedstorage.item.ItemUpgrade; -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; @@ -57,34 +54,11 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi } if (type == IType.ITEMS) { - TileEntity tile = getFacingTile(); - 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.insertItemTracked(result, result.getCount()); - - handler.extractItem(currentSlot, upgrades.getItemInteractCount(), false); - } else { - currentSlot++; - } - } + IImportingBehavior behavior = ImportingBehaviorItemHandler.INSTANCE; + if (IntegrationCyclopsCore.isLoaded() && SlotlessItemHandlerHelper.isSlotless(getFacingTile(), holder.getDirection().getOpposite())) { + behavior = ImportingBehaviorCyclops.INSTANCE; } + currentSlot = behavior.doImport(getFacingTile(), holder.getDirection().getOpposite(), currentSlot, itemFilters, mode, compare, ticks, upgrades, network); } else if (type == IType.FLUIDS && ticks % upgrades.getSpeed() == 0) { IFluidHandler handler = RSUtils.getFluidHandler(getFacingTile(), holder.getDirection().getOpposite()); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java index 64881af72..f06841393 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java @@ -11,6 +11,7 @@ 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.integration.cyclopscore.IntegrationCyclopsCore; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid; import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode; @@ -196,6 +197,8 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP itemStorages.add(new StorageItemDrawer(this, () -> (IDrawer) getFacingTile())); } else if (facing instanceof IDeepStorageUnit) { itemStorages.add(new StorageItemDSU(this, () -> (IDeepStorageUnit) getFacingTile())); + } else if (IntegrationCyclopsCore.isLoaded() && StorageItemCyclops.isValid(facing, holder.getDirection().getOpposite())) { + itemStorages.add(new StorageItemCyclops(this)); } else if (!(facing instanceof TileNode)) { IItemHandler itemHandler = RSUtils.getItemHandler(facing, holder.getDirection().getOpposite()); diff --git a/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemCyclops.java b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemCyclops.java new file mode 100644 index 000000000..3fac97c6e --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemCyclops.java @@ -0,0 +1,104 @@ +package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage; + +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.integration.cyclopscore.SlotlessItemHandlerHelper; +import com.raoulvdberge.refinedstorage.tile.config.IFilterable; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.NonNullList; +import net.minecraftforge.items.ItemHandlerHelper; +import org.cyclops.cyclopscore.inventory.IndexedSlotlessItemHandlerWrapper; +import org.cyclops.cyclopscore.inventory.SimpleInventory; +import org.cyclops.cyclopscore.tileentity.InventoryTileEntityBase; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.*; +import java.util.function.Supplier; + +public class StorageItemCyclops extends StorageItemExternal { + private NetworkNodeExternalStorage externalStorage; + private EnumFacing opposite; + private Supplier cyclopsInv; + private int oldInventoryHash = -1; + + public StorageItemCyclops(NetworkNodeExternalStorage externalStorage) { + this.externalStorage = externalStorage; + this.opposite = externalStorage.getHolder().getDirection().getOpposite(); + this.cyclopsInv = () -> (InventoryTileEntityBase) externalStorage.getFacingTile(); + } + + @Override + public void detectChanges(INetworkMaster network) { + InventoryTileEntityBase inv = cyclopsInv.get(); + if (inv != null) { + int inventoryHash = inv.getInventoryHash(); + if (inventoryHash != oldInventoryHash) { + super.detectChanges(network); + oldInventoryHash = inventoryHash; + } + } + } + + @Override + public NonNullList getStacks() { + return getStacks(cyclopsInv.get()); + } + + @Override + public int getStored() { + return getStacks(cyclopsInv.get()).stream().mapToInt(s -> s.getCount()).sum(); + } + + @Override + public int getPriority() { + return this.externalStorage.getPriority(); + } + + @Override + public int getCapacity() { + InventoryTileEntityBase inv = cyclopsInv.get(); + + return inv != null ? inv.getInventory().getSizeInventory() * 64 : 0; + } + + @Nullable + @Override + public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { + InventoryTileEntityBase inv = cyclopsInv.get(); + + if (IFilterable.canTake(externalStorage.getItemFilters(), externalStorage.getMode(), externalStorage.getCompare(), stack)) { + return SlotlessItemHandlerHelper.insertItem(inv, opposite, stack, size, simulate); + } + + return ItemHandlerHelper.copyStackWithSize(stack, size); + } + + @Nullable + @Override + public ItemStack extract(@Nonnull ItemStack stack, int size, int flags, boolean simulate) { + InventoryTileEntityBase inv = cyclopsInv.get(); + return SlotlessItemHandlerHelper.extractItem(inv, opposite, stack, size, flags, simulate); + } + + private NonNullList getStacks(@Nullable InventoryTileEntityBase inv) { + if (inv != null) { + if (inv.getInventory() instanceof IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) { + return ((IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) inv.getInventory()) + .getIndex().values().stream().flatMap(m -> m.valueCollection().stream()).map(ItemStack::copy).collect(RSUtils.toNonNullList()); + } else { + return Arrays.stream(((SimpleInventory)inv.getInventory()).getItemStacks()).map(ItemStack::copy).collect(RSUtils.toNonNullList()); + } + } else { + return RSUtils.emptyNonNullList(); + } + } + + public static boolean isValid(TileEntity facingTE, EnumFacing facing) { + return facingTE instanceof InventoryTileEntityBase + && (SlotlessItemHandlerHelper.isSlotless(facingTE, facing) + || ((InventoryTileEntityBase) facingTE).getInventory() instanceof SimpleInventory); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java index 0c24aac42..74fecc029 100755 --- a/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java +++ b/src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java @@ -159,7 +159,7 @@ public class BlockCable extends BlockNode { @Override @SuppressWarnings("deprecation") - public void addCollisionBoxToList(IBlockState state, World world, BlockPos pos, AxisAlignedBB entityBox, List collidingBoxes, Entity entityIn) { + public void addCollisionBoxToList(IBlockState state, World world, BlockPos pos, AxisAlignedBB entityBox, List collidingBoxes, Entity entityIn, boolean p_185477_7_) { for (AxisAlignedBB aabb : getCollisionBoxes(this.getActualState(state, world, pos))) { addCollisionBoxToList(pos, entityBox, collidingBoxes, aabb); } diff --git a/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/CyclopsComparer.java b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/CyclopsComparer.java new file mode 100644 index 000000000..8cc672125 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/CyclopsComparer.java @@ -0,0 +1,34 @@ +package com.raoulvdberge.refinedstorage.integration.cyclopscore; + +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch; + +public class CyclopsComparer { + public static int comparerFlagsToItemMatch(int flags) { + int itemMatch = 0; + if ((flags & IComparer.COMPARE_DAMAGE) == IComparer.COMPARE_DAMAGE) { + itemMatch |= ItemMatch.DAMAGE; + } + if ((flags & IComparer.COMPARE_NBT) == IComparer.COMPARE_NBT) { + itemMatch |= ItemMatch.NBT; + } + if ((flags & IComparer.COMPARE_QUANTITY) == IComparer.COMPARE_QUANTITY) { + itemMatch |= ItemMatch.STACKSIZE; + } + return itemMatch; + } + + public static int itemMatchToComparerFlags(int itemMatch) { + int flags = 0; + if ((itemMatch & ItemMatch.DAMAGE) == ItemMatch.DAMAGE) { + flags |= IComparer.COMPARE_DAMAGE; + } + if ((itemMatch & ItemMatch.NBT) == ItemMatch.NBT) { + flags |= IComparer.COMPARE_NBT; + } + if ((itemMatch & ItemMatch.STACKSIZE) == ItemMatch.STACKSIZE) { + flags |= IComparer.COMPARE_QUANTITY; + } + return flags; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/ImportingBehaviorCyclops.java b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/ImportingBehaviorCyclops.java new file mode 100644 index 000000000..da57b71ec --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/ImportingBehaviorCyclops.java @@ -0,0 +1,32 @@ +package com.raoulvdberge.refinedstorage.integration.cyclopscore; + +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.inventory.IImportingBehavior; +import com.raoulvdberge.refinedstorage.inventory.ImportingBehaviorItemHandler; +import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade; +import com.raoulvdberge.refinedstorage.tile.config.IFilterable; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.items.IItemHandler; + +public class ImportingBehaviorCyclops implements IImportingBehavior { + + public static final IImportingBehavior INSTANCE = new ImportingBehaviorCyclops(); + + @Override + public int doImport(TileEntity entity, EnumFacing facing, int currentSlot, IItemHandler itemFilters, int mode, int compare, int ticks, ItemHandlerUpgrade upgrades, INetworkMaster network) { + if (IFilterable.isEmpty(itemFilters)) { + if (ticks % upgrades.getSpeed() == 0) { + ItemStack result = SlotlessItemHandlerHelper.extractItem(entity, facing, upgrades.getItemInteractCount(), true); + if (result != null && !result.isEmpty() && network.insertItem(result, result.getCount(), true) == null) { + network.insertItem(result, result.getCount(), false); + SlotlessItemHandlerHelper.extractItem(entity, facing, result.copy(), upgrades.getItemInteractCount(), false); + } + } + } else { + return ImportingBehaviorItemHandler.INSTANCE.doImport(entity, facing, currentSlot, itemFilters, mode, compare, ticks, upgrades, network); + } + return 0; + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/IntegrationCyclopsCore.java b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/IntegrationCyclopsCore.java new file mode 100644 index 000000000..bce359641 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/IntegrationCyclopsCore.java @@ -0,0 +1,9 @@ +package com.raoulvdberge.refinedstorage.integration.cyclopscore; + +import net.minecraftforge.fml.common.Loader; + +public final class IntegrationCyclopsCore { + public static boolean isLoaded() { + return Loader.isModLoaded("cyclopscore"); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/SlotlessItemHandlerHelper.java b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/SlotlessItemHandlerHelper.java new file mode 100644 index 000000000..a79cd385e --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/SlotlessItemHandlerHelper.java @@ -0,0 +1,74 @@ +package com.raoulvdberge.refinedstorage.integration.cyclopscore; + +import com.raoulvdberge.refinedstorage.api.util.IComparer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.items.ItemHandlerHelper; +import org.cyclops.commoncapabilities.api.capability.itemhandler.ISlotlessItemHandler; +import org.cyclops.commoncapabilities.capability.itemhandler.SlotlessItemHandlerConfig; + +import javax.annotation.Nonnull; + +public class SlotlessItemHandlerHelper { + public static boolean isSlotless(TileEntity entity, EnumFacing facing) { + return entity != null && entity.hasCapability(SlotlessItemHandlerConfig.CAPABILITY, facing); + } + + public static ISlotlessItemHandler getSlotlessHandler(TileEntity entity, EnumFacing facing) { + return entity.getCapability(SlotlessItemHandlerConfig.CAPABILITY, facing); + } + + public static ItemStack insertItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, boolean simulate) { + return insertItem(getSlotlessHandler(entity, facing), stack, stack.getCount(), simulate); + } + + public static ItemStack insertItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) { + return insertItem(getSlotlessHandler(entity, facing), stack, size, simulate); + } + + public static ItemStack insertItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, boolean simulate) { + ItemStack remainder = slotlessItemHandler.insertItem(ItemHandlerHelper.copyStackWithSize(stack, size), simulate); + int remainderCount = -1; + while (!remainder.isEmpty() && remainder.getCount() != remainderCount) + { + remainderCount = remainder.getCount(); + remainder = slotlessItemHandler.insertItem(remainder.copy(), simulate); + } + return remainder; + } + + public static ItemStack extractItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, int flags, boolean simulate) { + return extractItem(getSlotlessHandler(entity, facing), stack, size, flags, simulate); + } + + public static ItemStack extractItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) { + return extractItem(getSlotlessHandler(entity, facing), stack, size, simulate); + } + + public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, boolean simulate) { + return extractItem(slotlessItemHandler, stack, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, simulate); + } + + public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, int flags, boolean simulate) { + ItemStack extracted = slotlessItemHandler.extractItem(ItemHandlerHelper.copyStackWithSize(stack, size), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate); + while (!extracted.isEmpty() && extracted.getCount() < size) { + ItemStack extraExtract = slotlessItemHandler.extractItem(ItemHandlerHelper.copyStackWithSize(extracted, size - extracted.getCount()), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate); + if (!extraExtract.isEmpty()) { + extracted.grow(extraExtract.getCount()); + } else { + // Nothing more to extract + break; + } + } + return extracted; + } + + public static ItemStack extractItem(TileEntity entity, EnumFacing facing, int size, boolean simulate) { + return extractItem(getSlotlessHandler(entity, facing), size, simulate); + } + + public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, int size, boolean simulate) { + return slotlessItemHandler.extractItem(size, simulate); + } +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/IImportingBehavior.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/IImportingBehavior.java new file mode 100644 index 000000000..baaa8af57 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/IImportingBehavior.java @@ -0,0 +1,10 @@ +package com.raoulvdberge.refinedstorage.inventory; + +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.items.IItemHandler; + +public interface IImportingBehavior { + int doImport(TileEntity entity, EnumFacing facing, int currentSlot, IItemHandler itemFilters, int mode, int compare, int ticks, ItemHandlerUpgrade upgrades, INetworkMaster network); +} diff --git a/src/main/java/com/raoulvdberge/refinedstorage/inventory/ImportingBehaviorItemHandler.java b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ImportingBehaviorItemHandler.java new file mode 100644 index 000000000..203570227 --- /dev/null +++ b/src/main/java/com/raoulvdberge/refinedstorage/inventory/ImportingBehaviorItemHandler.java @@ -0,0 +1,48 @@ +package com.raoulvdberge.refinedstorage.inventory; + +import com.raoulvdberge.refinedstorage.RSUtils; +import com.raoulvdberge.refinedstorage.api.network.INetworkMaster; +import com.raoulvdberge.refinedstorage.tile.TileDiskDrive; +import com.raoulvdberge.refinedstorage.tile.config.IFilterable; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.items.IItemHandler; + +public class ImportingBehaviorItemHandler implements IImportingBehavior { + + public static final IImportingBehavior INSTANCE = new ImportingBehaviorItemHandler(); + + @Override + public int doImport(TileEntity entity, EnumFacing facing, int currentSlot, IItemHandler itemFilters, int mode, int compare, int ticks, ItemHandlerUpgrade upgrades, INetworkMaster network) { + IItemHandler handler = RSUtils.getItemHandler(entity, facing); + + if (entity instanceof TileDiskDrive || handler == null) { + return currentSlot; + } + + if (currentSlot >= handler.getSlots()) { + currentSlot = 0; + } + + if (handler.getSlots() > 0) { + ItemStack stack = handler.getStackInSlot(currentSlot); + + if (stack == null || 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 != null && !stack.isEmpty() && network.insertItem(result, result.getCount(), true) == null) { + network.insertItem(result, result.getCount(), false); + + handler.extractItem(currentSlot, upgrades.getItemInteractCount(), false); + } else { + currentSlot++; + } + } + } + + return currentSlot; + } +}