diff --git a/src/com/jaquadro/minecraft/storagedrawers/api/storage/ISmartGroup.java b/src/com/jaquadro/minecraft/storagedrawers/api/storage/ISmartGroup.java new file mode 100644 index 0000000..c441a76 --- /dev/null +++ b/src/com/jaquadro/minecraft/storagedrawers/api/storage/ISmartGroup.java @@ -0,0 +1,18 @@ +package com.jaquadro.minecraft.storagedrawers.api.storage; + +import net.minecraft.item.ItemStack; + +public interface ISmartGroup +{ + /** + * Gets a lazy enumeration of all slots that will accept at least one item of the given stack, ordered by + * insertion preference. + */ + Iterable enumerateDrawersForInsertion (ItemStack stack, boolean strict); + + /** + * Gets a lazy enumeration of all slots that will provide at least one item of the given stack, ordered by + * extraction preference. + */ + Iterable enumerateDrawersForExtraction (ItemStack stack, boolean strict); +} diff --git a/src/com/jaquadro/minecraft/storagedrawers/block/tile/TileEntityController.java b/src/com/jaquadro/minecraft/storagedrawers/block/tile/TileEntityController.java index 4d8d89b..85469e2 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/block/tile/TileEntityController.java +++ b/src/com/jaquadro/minecraft/storagedrawers/block/tile/TileEntityController.java @@ -8,9 +8,13 @@ import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.IShroudable; import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.IVoidable; import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.LockAttribute; import com.jaquadro.minecraft.storagedrawers.block.BlockSlave; +import com.jaquadro.minecraft.storagedrawers.util.ItemMetaListRegistry; +import com.jaquadro.minecraft.storagedrawers.util.ItemMetaRegistry; +import com.jaquadro.minecraft.storagedrawers.util.UniqueMetaIdentifier; import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.NetworkManager; @@ -22,13 +26,14 @@ import net.minecraftforge.common.util.ForgeDirection; import java.util.*; -public class TileEntityController extends TileEntity implements IDrawerGroup, IPriorityGroup, ISidedInventory +public class TileEntityController extends TileEntity implements IDrawerGroup, IPriorityGroup, ISmartGroup, ISidedInventory { private static final int PRI_VOID = 0; private static final int PRI_LOCKED = 1; private static final int PRI_NORMAL = 2; private static final int PRI_EMPTY = 3; - private static final int PRI_DISABLED = 4; + private static final int PRI_LOCKED_EMPTY = 4; + private static final int PRI_DISABLED = 5; private static final int DEPTH_LIMIT = 12; private static final int[] emptySlots = new int[0]; @@ -85,7 +90,12 @@ public class TileEntityController extends TileEntity implements IDrawerGroup, IP IDrawer drawer = group.getDrawer(drawerSlot); if (drawer.isEmpty()) { - return PRI_EMPTY; + if ((drawer instanceof ILockable && ((ILockable) drawer).isLocked(LockAttribute.LOCK_EMPTY)) || + (group instanceof ILockable && ((ILockable) group).isLocked(LockAttribute.LOCK_EMPTY))) { + return PRI_LOCKED_EMPTY; + } + else + return PRI_EMPTY; } if ((drawer instanceof IVoidable && ((IVoidable) drawer).isVoid()) || @@ -108,6 +118,9 @@ public class TileEntityController extends TileEntity implements IDrawerGroup, IP private List invSlotList = new ArrayList(); private List drawerSlotList = new ArrayList(); + private ItemMetaListRegistry invPrimaryLookup = new ItemMetaListRegistry(); + private ItemMetaListRegistry drawerPrimaryLookup = new ItemMetaListRegistry(); + private int[] inventorySlots = new int[0]; private int[] drawerSlots = new int[0]; private int[] autoSides = new int[] { 0, 1, 2, 3, 4, 5 }; @@ -261,9 +274,12 @@ public class TileEntityController extends TileEntity implements IDrawerGroup, IP populateNodes(xCoord, yCoord, zCoord); flattenLists(); - inventorySlots = sortSlotRecords(invSlotList, true); //sortInventorySlots(); + inventorySlots = sortSlotRecords(invSlotList, true); drawerSlots = sortSlotRecords(drawerSlotList, false); + rebuildPrimaryLookup(invPrimaryLookup, invSlotList, true); + rebuildPrimaryLookup(drawerPrimaryLookup, drawerSlotList, false); + if (preCount != inventorySlots.length && (preCount == 0 || inventorySlots.length == 0)) { if (!worldObj.isRemote) markDirty(); @@ -293,6 +309,27 @@ public class TileEntityController extends TileEntity implements IDrawerGroup, IP return slotMap; } + private void rebuildPrimaryLookup (ItemMetaListRegistry lookup, List records, boolean invBased) { + lookup.clear(); + + for (SlotRecord record : records) { + IDrawerGroup group = getGroupForCoord(record.coord); + if (group == null) + continue; + + int drawerSlot = (invBased) ? group.getDrawerInventory().getDrawerSlot(record.slot) : record.slot; + if (!group.isDrawerEnabled(drawerSlot)) + continue; + + IDrawer drawer = group.getDrawer(drawerSlot); + if (drawer.isEmpty()) + continue; + + ItemStack item = drawer.getStoredItemPrototype(); + lookup.register(item.getItem(), item.getItemDamage(), record); + } + } + private boolean containsNullEntries (List list) { int nullCount = 0; for (int i = 0, n = list.size(); i < n; i++) { @@ -638,6 +675,20 @@ public class TileEntityController extends TileEntity implements IDrawerGroup, IP if (inventory == null) return false; + if (slot >= invSlotList.size()) + return false; + + SlotRecord record = invSlotList.get(slot); + List primaryRecords = invPrimaryLookup.getEntries(stack.getItem(), stack.getItemDamage()); + if (primaryRecords != null && !primaryRecords.contains(record)) { + for (SlotRecord candidate : primaryRecords) { + IDrawerGroup candidateGroup = getGroupForCoord(candidate.coord); + IDrawerInventory candidateInventory = candidateGroup.getDrawerInventory(); + if (candidateInventory.canInsertItem(candidate.slot, stack)) + return false; + } + } + return inventory.canInsertItem(getLocalInvSlot(slot), stack); } @@ -728,6 +779,127 @@ public class TileEntityController extends TileEntity implements IDrawerGroup, IP if (inventory == null) return false; + if (slot >= invSlotList.size()) + return false; + + SlotRecord record = invSlotList.get(slot); + List primaryRecords = invPrimaryLookup.getEntries(stack.getItem(), stack.getItemDamage()); + if (primaryRecords != null && !primaryRecords.contains(record)) { + for (SlotRecord candidate : primaryRecords) { + IDrawerGroup candidateGroup = getGroupForCoord(candidate.coord); + IDrawerInventory candidateInventory = candidateGroup.getDrawerInventory(); + if (candidateInventory.isItemValidForSlot(candidate.slot, stack)) + return false; + } + } + return inventory.isItemValidForSlot(getLocalInvSlot(slot), stack); } + + private class DrawerStackIterator implements Iterable + { + private ItemStack stack; + private boolean strict; + private boolean insert; + + public DrawerStackIterator (ItemStack stack, boolean strict, boolean insert) { + this.stack = stack; + this.strict = strict; + this.insert = insert; + } + + @Override + public Iterator iterator () { + return new Iterator () + { + List primaryRecords = drawerPrimaryLookup.getEntries(stack.getItem(), stack.getItemDamage()); + Iterator iter1; + int index2; + Integer nextSlot = null; + + @Override + public boolean hasNext () { + if (nextSlot == null) + advance(); + return nextSlot != null; + } + + @Override + public Integer next () { + if (nextSlot == null) + advance(); + + Integer slot = nextSlot; + nextSlot = null; + return slot; + } + + private void advance () { + if (iter1 == null && primaryRecords != null && primaryRecords.size() > 0) + iter1 = primaryRecords.iterator(); + + if (iter1 != null) { + while (iter1.hasNext()) { + SlotRecord candidate = iter1.next(); + IDrawerGroup candidateGroup = getGroupForCoord(candidate.coord); + IDrawer drawer = candidateGroup.getDrawer(candidate.slot); + + if (insert) { + if (!(drawer.canItemBeStored(stack) && (drawer.isEmpty() || drawer.getRemainingCapacity() > 0))) + continue; + } + else { + if (!(drawer.canItemBeExtracted(stack) && drawer.getStoredItemCount() > 0)) + continue; + } + + int slot = drawerSlotList.indexOf(candidate); + if (slot > -1) { + nextSlot = slot; + return; + } + } + } + + for (; index2 < drawerSlots.length; index2++) { + int slot = drawerSlots[index2]; + if (!isDrawerEnabled(slot)) + continue; + + IDrawer drawer = getDrawer(slot); + if (strict) { + ItemStack proto = drawer.getStoredItemPrototype(); + if (proto != null && !proto.isItemEqual(stack)) + continue; + } + + if (insert) { + if (!(drawer.canItemBeStored(stack) && (drawer.isEmpty() || drawer.getRemainingCapacity() > 0))) + continue; + } + else { + if (!(drawer.canItemBeExtracted(stack) && drawer.getStoredItemCount() > 0)) + continue; + } + + SlotRecord record = drawerSlotList.get(slot); + if (primaryRecords != null && primaryRecords.contains(record)) + continue; + + nextSlot = slot; + index2++; + return; + } + } + }; + } + }; + + public Iterable enumerateDrawersForInsertion (ItemStack stack, boolean strict) { + return new DrawerStackIterator(stack, strict, true); + } + + public Iterable enumerateDrawersForExtraction (ItemStack stack, boolean strict) { + return new DrawerStackIterator(stack, strict, false); + } } diff --git a/src/com/jaquadro/minecraft/storagedrawers/integration/ae2/DrawerMEInventory.java b/src/com/jaquadro/minecraft/storagedrawers/integration/ae2/DrawerMEInventory.java index 451b24d..1671857 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/integration/ae2/DrawerMEInventory.java +++ b/src/com/jaquadro/minecraft/storagedrawers/integration/ae2/DrawerMEInventory.java @@ -7,15 +7,14 @@ import appeng.api.storage.IMEInventory; import appeng.api.storage.StorageChannel; import appeng.api.storage.data.IAEItemStack; import appeng.api.storage.data.IItemList; -import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer; -import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawerGroup; -import com.jaquadro.minecraft.storagedrawers.api.storage.IFractionalDrawer; -import com.jaquadro.minecraft.storagedrawers.api.storage.IPriorityGroup; +import com.jaquadro.minecraft.storagedrawers.api.storage.*; import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.ILockable; import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.IVoidable; import com.jaquadro.minecraft.storagedrawers.api.storage.attribute.LockAttribute; import net.minecraft.item.ItemStack; +import java.util.Iterator; + public class DrawerMEInventory implements IMEInventory { final IDrawerGroup group; @@ -26,52 +25,71 @@ public class DrawerMEInventory implements IMEInventory @Override public IAEItemStack injectItems (IAEItemStack input, Actionable type, BaseActionSource src) { - int[] order = null; - if (group instanceof IPriorityGroup) - order = ((IPriorityGroup) group).getAccessibleDrawerSlots(); - long itemsLeft = input.getStackSize(); - for (int i = 0, n = group.getDrawerCount(); i < n; i++) { - int slot = (order != null) ? order[i] : i; - if (!group.isDrawerEnabled(slot)) - continue; - IDrawer drawer = group.getDrawer(slot); - ItemStack itemProto = drawer.getStoredItemPrototype(); - if (itemProto != null) { - if (drawer.canItemBeStored(input.getItemStack())) { - itemsLeft = injectItemsIntoDrawer(drawer, itemsLeft, type); - if (drawer instanceof IVoidable && ((IVoidable) drawer).isVoid()) - itemsLeft = 0; - if (itemsLeft == 0) - return null; - } + if (group instanceof ISmartGroup) { + for (int slot : ((ISmartGroup) group).enumerateDrawersForInsertion(input.getItemStack(), false)) { + IDrawer drawer = group.getDrawer(slot); + ItemStack itemProto = drawer.getStoredItemPrototype(); + if (itemProto == null) + drawer.setStoredItem(input.getItemStack(), 0); + + itemsLeft = injectItemsIntoDrawer(drawer, itemsLeft, type); + + if (drawer instanceof IVoidable && ((IVoidable) drawer).isVoid()) + itemsLeft = 0; + if (itemsLeft == 0) + return null; } } + else { + int[] order = null; + if (group instanceof IPriorityGroup) + order = ((IPriorityGroup) group).getAccessibleDrawerSlots(); - for (int i = 0, n = group.getDrawerCount(); i < n; i++) { - int slot = (order != null) ? order[i] : i; - if (!group.isDrawerEnabled(slot)) - continue; - if (group instanceof ILockable && ((ILockable) group).isLocked(LockAttribute.LOCK_EMPTY)) - continue; + for (int i = 0, n = group.getDrawerCount(); i < n; i++) { + int slot = (order != null) ? order[i] : i; + if (!group.isDrawerEnabled(slot)) + continue; - IDrawer drawer = group.getDrawer(slot); - ItemStack itemProto = drawer.getStoredItemPrototype(); + IDrawer drawer = group.getDrawer(slot); + ItemStack itemProto = drawer.getStoredItemPrototype(); + if (itemProto != null) { + if (drawer.canItemBeStored(input.getItemStack())) { + itemsLeft = injectItemsIntoDrawer(drawer, itemsLeft, type); + if (drawer instanceof IVoidable && ((IVoidable) drawer).isVoid()) + itemsLeft = 0; + if (itemsLeft == 0) + return null; + } + } + } - if (itemProto == null && drawer instanceof ILockable && ((ILockable) drawer).isLocked(LockAttribute.LOCK_EMPTY)) - continue; + for (int i = 0, n = group.getDrawerCount(); i < n; i++) { + int slot = (order != null) ? order[i] : i; + if (!group.isDrawerEnabled(slot)) + continue; - if (itemProto == null) { - itemProto = input.getItemStack(); - if (drawer.canItemBeStored(itemProto)) { - drawer.setStoredItem(itemProto, 0); - itemsLeft = injectItemsIntoDrawer(drawer, itemsLeft, type); - if (drawer instanceof IVoidable && ((IVoidable) drawer).isVoid()) - itemsLeft = 0; - if (itemsLeft == 0) - return null; + if (group instanceof ILockable && ((ILockable) group).isLocked(LockAttribute.LOCK_EMPTY)) + continue; + + IDrawer drawer = group.getDrawer(slot); + ItemStack itemProto = drawer.getStoredItemPrototype(); + + if (itemProto == null && drawer instanceof ILockable && ((ILockable) drawer).isLocked(LockAttribute.LOCK_EMPTY)) + continue; + + if (itemProto == null) { + itemProto = input.getItemStack(); + if (drawer.canItemBeStored(itemProto)) { + drawer.setStoredItem(itemProto, 0); + itemsLeft = injectItemsIntoDrawer(drawer, itemsLeft, type); + if (drawer instanceof IVoidable && ((IVoidable) drawer).isVoid()) + itemsLeft = 0; + if (itemsLeft == 0) + return null; + } } } } @@ -110,18 +128,13 @@ public class DrawerMEInventory implements IMEInventory @Override public IAEItemStack extractItems (IAEItemStack request, Actionable mode, BaseActionSource src) { - int[] order = null; - if (group instanceof IPriorityGroup) - order = ((IPriorityGroup) group).getAccessibleDrawerSlots(); - long itemsLeft = request.getStackSize(); - for (int i = 0, n = group.getDrawerCount(); i < n; i++) { - int slot = (order != null) ? order[i] : i; - if (!group.isDrawerEnabled(slot)) - continue; + if (group instanceof ISmartGroup) { + for (int slot : ((ISmartGroup) group).enumerateDrawersForExtraction(request.getItemStack(), true)) { + if (itemsLeft == 0) + break; - IDrawer drawer = group.getDrawer(slot); - if (drawer.canItemBeExtracted(request.getItemStack())) { + IDrawer drawer = group.getDrawer(slot); int itemCount = drawer.getStoredItemCount(); if (itemsLeft > itemCount) { if (mode == Actionable.MODULATE) @@ -136,6 +149,33 @@ public class DrawerMEInventory implements IMEInventory } } } + else { + int[] order = null; + if (group instanceof IPriorityGroup) + order = ((IPriorityGroup) group).getAccessibleDrawerSlots(); + + + for (int i = 0, n = group.getDrawerCount(); i < n; i++) { + int slot = (order != null) ? order[i] : i; + if (!group.isDrawerEnabled(slot)) + continue; + + IDrawer drawer = group.getDrawer(slot); + if (drawer.canItemBeExtracted(request.getItemStack())) { + int itemCount = drawer.getStoredItemCount(); + if (itemsLeft > itemCount) { + if (mode == Actionable.MODULATE) + drawer.setStoredItemCount(0); + itemsLeft -= itemCount; + } else { + if (mode == Actionable.MODULATE) + drawer.setStoredItemCount(itemCount - (int) itemsLeft); + itemsLeft = 0; + break; + } + } + } + } if (itemsLeft < request.getStackSize()) { ItemStack fulfillment = request.getItemStack().copy(); diff --git a/src/com/jaquadro/minecraft/storagedrawers/util/ItemMetaListRegistry.java b/src/com/jaquadro/minecraft/storagedrawers/util/ItemMetaListRegistry.java new file mode 100644 index 0000000..49e3240 --- /dev/null +++ b/src/com/jaquadro/minecraft/storagedrawers/util/ItemMetaListRegistry.java @@ -0,0 +1,63 @@ +package com.jaquadro.minecraft.storagedrawers.util; + +import net.minecraft.item.Item; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class ItemMetaListRegistry +{ + private ItemMetaRegistry> registry; + private boolean compactTopLevel; + + public ItemMetaListRegistry () { + this(false); + } + + public ItemMetaListRegistry (boolean compactTopLevel) { + this.registry = new ItemMetaRegistry>(compactTopLevel); + this.compactTopLevel = compactTopLevel; + } + + public void register (Item item, int meta, E entry) { + List list = registry.getEntry(item, meta); + if (list == null) { + list = new ArrayList(); + registry.register(item, meta, list); + } + + list.add(entry); + } + + public List getEntries (Item item, int meta) { + return registry.getEntry(item, meta); + } + + public void remove (Item item, int meta) { + registry.remove(item, meta); + } + + public void clear (Item item, int meta) { + List list = registry.getEntry(item, meta); + if (list != null) + list.clear(); + } + + public void clear (Item item) { + for (Map.Entry> map : registry.entrySet(item)) + map.getValue().clear(); + } + + public void clear () { + for (Map.Entry>> map : registry.entrySet()) { + for (List list : map.getValue().values()) + list.clear(); + } + } + + public Set>>> entrySet () { + return registry.entrySet(); + } +} diff --git a/src/com/jaquadro/minecraft/storagedrawers/util/ItemMetaRegistry.java b/src/com/jaquadro/minecraft/storagedrawers/util/ItemMetaRegistry.java new file mode 100644 index 0000000..9a02e22 --- /dev/null +++ b/src/com/jaquadro/minecraft/storagedrawers/util/ItemMetaRegistry.java @@ -0,0 +1,83 @@ +package com.jaquadro.minecraft.storagedrawers.util; + +import net.minecraft.item.Item; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class ItemMetaRegistry +{ + private Map> registry; + private boolean compactTopLevel; + + public ItemMetaRegistry () { + registry = new HashMap>(); + } + + public ItemMetaRegistry (boolean compactTopLevel) { + this(); + this.compactTopLevel = compactTopLevel; + } + + public void register (Item item, int meta, E entry) { + Map metamap = registry.get(item); + if (metamap == null) { + metamap = new HashMap(); + registry.put(item, metamap); + } + + metamap.put(meta, entry); + } + + public E getEntry (Item item, int meta) { + Map metamap = registry.get(item); + if (metamap == null) + return null; + + return metamap.get(meta); + } + + public void remove (Item item, int meta) { + Map metamap = registry.get(item); + if (metamap == null) + return; + + metamap.remove(meta); + if (compactTopLevel && metamap.isEmpty()) + registry.remove(item); + } + + public void clear (Item item) { + Map metamap = registry.get(item); + if (metamap == null) + return; + + metamap.clear(); + if (compactTopLevel) + registry.remove(item); + } + + public void clear () { + if (compactTopLevel) + registry.clear(); + else { + for (Item item : registry.keySet()) + clear(item); + } + } + + public Set>> entrySet () { + return registry.entrySet(); + } + + public Set> entrySet (Item item) { + Map metamap = registry.get(item); + if (metamap == null) { + metamap = new HashMap(); + registry.put(item, metamap); + } + + return metamap.entrySet(); + } +}