From 9f3f8243f9f95ee79265f5d670f831445462be9d Mon Sep 17 00:00:00 2001 From: Tuorp <46055617+Tu0rp@users.noreply.github.com> Date: Wed, 20 Dec 2023 19:50:55 +0100 Subject: [PATCH] Limited Item Filter (#143) * Limited Item Filter * simplify inverted limit Co-authored-by: Alexander Anishin * Update src/main/java/crazypants/enderio/conduit/item/filter/ItemFilterLimited.java Co-authored-by: Alexander Anishin * Update src/main/java/crazypants/enderio/conduit/item/filter/ItemFilterLimited.java Co-authored-by: Alexander Anishin * Update ItemFilterLimited.java --------- Co-authored-by: Alexander Anishin Co-authored-by: Martin Robertz --- src/main/java/crazypants/enderio/EnderIO.java | 3 + .../java/crazypants/enderio/ModObject.java | 1 + .../enderio/conduit/ConduitRecipes.java | 3 + .../gui/item/LimitedItemFilterGui.java | 202 +++++++++++++++ .../conduit/item/NetworkedInventory.java | 46 +++- .../conduit/item/filter/IItemFilter.java | 8 + .../conduit/item/filter/ItemFilter.java | 8 +- .../item/filter/ItemFilterLimited.java | 242 ++++++++++++++++++ .../item/filter/ItemLimitedItemFilter.java | 73 ++++++ .../resources/assets/enderio/lang/en_US.lang | 5 + .../textures/items/limitedItemFilter.png | Bin 0 -> 1506 bytes 11 files changed, 579 insertions(+), 12 deletions(-) create mode 100644 src/main/java/crazypants/enderio/conduit/gui/item/LimitedItemFilterGui.java create mode 100644 src/main/java/crazypants/enderio/conduit/item/filter/ItemFilterLimited.java create mode 100644 src/main/java/crazypants/enderio/conduit/item/filter/ItemLimitedItemFilter.java create mode 100644 src/main/resources/assets/enderio/textures/items/limitedItemFilter.png diff --git a/src/main/java/crazypants/enderio/EnderIO.java b/src/main/java/crazypants/enderio/EnderIO.java index f4b15cd7..4890cfcb 100644 --- a/src/main/java/crazypants/enderio/EnderIO.java +++ b/src/main/java/crazypants/enderio/EnderIO.java @@ -62,6 +62,7 @@ import crazypants.enderio.conduit.item.ItemItemConduit; import crazypants.enderio.conduit.item.filter.ItemBasicItemFilter; import crazypants.enderio.conduit.item.filter.ItemBigItemFilter; import crazypants.enderio.conduit.item.filter.ItemExistingItemFilter; +import crazypants.enderio.conduit.item.filter.ItemLimitedItemFilter; import crazypants.enderio.conduit.item.filter.ItemModItemFilter; import crazypants.enderio.conduit.item.filter.ItemPowerItemFilter; import crazypants.enderio.conduit.liquid.ItemLiquidConduit; @@ -264,6 +265,7 @@ public class EnderIO { public static ItemBasicItemFilter itemBasicFilterUpgrade; public static ItemBigItemFilter itemBigFilterUpgrade; public static ItemExistingItemFilter itemExistingItemFilter; + public static ItemLimitedItemFilter itemLimitedItemFilter; public static ItemModItemFilter itemModItemFilter; public static ItemPowerItemFilter itemPowerItemFilter; public static ItemExtractSpeedUpgrade itemExtractSpeedUpgrade; @@ -469,6 +471,7 @@ public class EnderIO { itemBasicFilterUpgrade = ItemBasicItemFilter.create(); itemBigFilterUpgrade = ItemBigItemFilter.create(); itemExistingItemFilter = ItemExistingItemFilter.create(); + itemLimitedItemFilter = ItemLimitedItemFilter.create(); itemModItemFilter = ItemModItemFilter.create(); itemPowerItemFilter = ItemPowerItemFilter.create(); itemExtractSpeedUpgrade = ItemExtractSpeedUpgrade.create(); diff --git a/src/main/java/crazypants/enderio/ModObject.java b/src/main/java/crazypants/enderio/ModObject.java index 3535372a..a2a268d0 100644 --- a/src/main/java/crazypants/enderio/ModObject.java +++ b/src/main/java/crazypants/enderio/ModObject.java @@ -18,6 +18,7 @@ public enum ModObject { itemBasicFilterUpgrade, itemBigFilterUpgrade, itemExistingItemFilter, + itemLimitedItemFilter, itemModItemFilter, itemPowerItemFilter, itemExtractSpeedUpgrade, diff --git a/src/main/java/crazypants/enderio/conduit/ConduitRecipes.java b/src/main/java/crazypants/enderio/conduit/ConduitRecipes.java index 212b3f02..8cfd55f4 100644 --- a/src/main/java/crazypants/enderio/conduit/ConduitRecipes.java +++ b/src/main/java/crazypants/enderio/conduit/ConduitRecipes.java @@ -601,6 +601,9 @@ public class ConduitRecipes { 'f', advFilter); + ItemStack limitedFilter = new ItemStack(EnderIO.itemLimitedItemFilter, 1, 0); + addShaped(limitedFilter, " ", "cfc", " ", 'c', new ItemStack(Items.comparator, 1, 0), 'f', advFilter); + ItemStack powerFilt = new ItemStack(EnderIO.itemPowerItemFilter); addShaped(powerFilt, " p ", "pcp", " p ", 'p', Items.paper, 'c', EnderIO.itemConduitProbe); diff --git a/src/main/java/crazypants/enderio/conduit/gui/item/LimitedItemFilterGui.java b/src/main/java/crazypants/enderio/conduit/gui/item/LimitedItemFilterGui.java new file mode 100644 index 00000000..c4f63658 --- /dev/null +++ b/src/main/java/crazypants/enderio/conduit/gui/item/LimitedItemFilterGui.java @@ -0,0 +1,202 @@ +package crazypants.enderio.conduit.gui.item; + +import net.minecraft.client.gui.GuiButton; + +import org.lwjgl.opengl.GL11; + +import com.enderio.core.client.gui.button.CycleButton; +import com.enderio.core.client.gui.button.IconButton; +import com.enderio.core.client.gui.button.ToggleButton; + +import crazypants.enderio.EnderIO; +import crazypants.enderio.conduit.gui.GuiExternalConnection; +import crazypants.enderio.conduit.item.filter.FuzzyMode; +import crazypants.enderio.conduit.item.filter.ItemFilter; +import crazypants.enderio.gui.GuiContainerBaseEIO; +import crazypants.enderio.gui.IconEIO; + +public class LimitedItemFilterGui implements IItemFilterGui { + + private static final int ID_WHITELIST = GuiExternalConnection.nextButtonId(); + private static final int ID_NBT = GuiExternalConnection.nextButtonId(); + private static final int ID_META = GuiExternalConnection.nextButtonId(); + private static final int ID_ORE_DICT = GuiExternalConnection.nextButtonId(); + private static final int ID_STICKY = GuiExternalConnection.nextButtonId(); + private static final int ID_FUZZY = GuiExternalConnection.nextButtonId(); + + private final GuiContainerBaseEIO gui; + + private final ToggleButton useMetaB; + private final ToggleButton useNbtB; + private final IconButton whiteListB; + private final ToggleButton useOreDictB; + private final ToggleButton stickyB; + private final CycleButton fuzzyB; + + private final IItemFilterContainer filterContainer; + private final ItemFilter filter; + private int buttonIdOffset; + private int xOffset; + private int yOffset; + final boolean isStickyModeAvailable; + private boolean isInput; + + public LimitedItemFilterGui(GuiContainerBaseEIO gui, IItemFilterContainer filterContainer, + boolean isStickyModeAvailable, boolean isInput) { + this(gui, filterContainer, isStickyModeAvailable, isInput, isInput ? 104 : 6, 96, isInput ? 0 : 256); + } + + public LimitedItemFilterGui(GuiContainerBaseEIO gui, IItemFilterContainer filterContainer, + boolean isStickyModeAvailable, boolean isInput, int xOffset, int yOffset, int buttonIdOffset) { + this.gui = gui; + this.isStickyModeAvailable = isStickyModeAvailable; + this.filterContainer = filterContainer; + this.xOffset = xOffset; + this.yOffset = yOffset; + this.buttonIdOffset = buttonIdOffset; + this.isInput = isInput; + + filter = filterContainer.getItemFilter(); + + int butLeft = xOffset; + int x = butLeft; + int y = yOffset + 40; + whiteListB = new IconButton(gui, ID_WHITELIST + buttonIdOffset, x, y, IconEIO.FILTER_WHITELIST); + whiteListB.setToolTip(getWhitelistTooltips(false)); + + x += 16; + useMetaB = new ToggleButton(gui, ID_META + buttonIdOffset, x, y, IconEIO.FILTER_META_OFF, IconEIO.FILTER_META); + useMetaB.setSelectedToolTip(EnderIO.lang.localize("gui.conduit.item.matchMetaData")); + useMetaB.setUnselectedToolTip(EnderIO.lang.localize("gui.conduit.item.ignoreMetaData")); + useMetaB.setPaintSelectedBorder(false); + + x += 16; + stickyB = new ToggleButton( + gui, + ID_STICKY + buttonIdOffset, + x, + y, + IconEIO.FILTER_STICKY_OFF, + IconEIO.FILTER_STICKY); + stickyB.setSelectedToolTip(EnderIO.lang.localizeList("gui.conduit.item.stickyEnabled")); + stickyB.setUnselectedToolTip(EnderIO.lang.localize("gui.conduit.item.stickyDisbaled")); + stickyB.setPaintSelectedBorder(false); + + if (isStickyModeAvailable) x += 16; + useOreDictB = new ToggleButton( + gui, + ID_ORE_DICT + buttonIdOffset, + x, + y, + IconEIO.FILTER_ORE_DICT_OFF, + IconEIO.FILTER_ORE_DICT); + useOreDictB.setSelectedToolTip(EnderIO.lang.localize("gui.conduit.item.oreDicEnabled")); + useOreDictB.setUnselectedToolTip(EnderIO.lang.localize("gui.conduit.item.oreDicDisabled")); + useOreDictB.setPaintSelectedBorder(false); + + x += 16; + useNbtB = new ToggleButton(gui, ID_NBT + buttonIdOffset, x, y, IconEIO.FILTER_NBT_OFF, IconEIO.FILTER_NBT); + useNbtB.setSelectedToolTip(EnderIO.lang.localize("gui.conduit.item.matchNBT")); + useNbtB.setUnselectedToolTip(EnderIO.lang.localize("gui.conduit.item.ignoreNBT")); + useNbtB.setPaintSelectedBorder(false); + + x += 16; + fuzzyB = new CycleButton(gui, ID_FUZZY + buttonIdOffset, x, y, FuzzyMode.class); + } + + public void createFilterSlots() { + filter.createGhostSlots(gui.getGhostSlots(), xOffset + 1, yOffset + 1, new Runnable() { + + @Override + public void run() { + sendFilterChange(); + } + }); + } + + @Override + public void mouseClicked(int x, int y, int par3) {} + + @Override + public void updateButtons() { + ItemFilter activeFilter = filter; + + useNbtB.onGuiInit(); + useNbtB.setSelected(activeFilter.isMatchNBT()); + + useOreDictB.onGuiInit(); + useOreDictB.setSelected(activeFilter.isUseOreDict()); + + if (isStickyModeAvailable) { + stickyB.onGuiInit(); + stickyB.setSelected(activeFilter.isSticky()); + } + + fuzzyB.onGuiInit(); + fuzzyB.setMode(activeFilter.getFuzzyMode()); + + useMetaB.onGuiInit(); + useMetaB.setSelected(activeFilter.isMatchMeta()); + + } + + @Override + public void actionPerformed(GuiButton guiButton) { + + if (guiButton.id == ID_META + buttonIdOffset) { + filter.setMatchMeta(useMetaB.isSelected()); + sendFilterChange(); + } else if (guiButton.id == ID_NBT + buttonIdOffset) { + filter.setMatchNBT(useNbtB.isSelected()); + sendFilterChange(); + } else if (guiButton.id == ID_STICKY + buttonIdOffset) { + filter.setSticky(stickyB.isSelected()); + sendFilterChange(); + } else if (guiButton.id == ID_ORE_DICT + buttonIdOffset) { + filter.setUseOreDict(useOreDictB.isSelected()); + sendFilterChange(); + } else if (guiButton.id == ID_FUZZY + buttonIdOffset) { + filter.setFuzzyMode(fuzzyB.getMode()); + sendFilterChange(); + } else if (guiButton.id == ID_WHITELIST + buttonIdOffset) { + filter.setBlacklist(!filter.isBlacklist()); + sendFilterChange(); + } + } + + private void sendFilterChange() { + updateButtons(); + filterContainer.onFilterChanged(); + } + + @Override + public void deactivate() { + useNbtB.detach(); + useMetaB.detach(); + useOreDictB.detach(); + whiteListB.detach(); + stickyB.detach(); + fuzzyB.detach(); + } + + @Override + public void renderCustomOptions(int top, float par1, int par2, int par3) { + GL11.glColor3f(1, 1, 1); + gui.bindGuiTexture(1); + gui.drawTexturedModalRect(gui.getGuiLeft() + xOffset, gui.getGuiTop() + yOffset, 0, 238, 18 * 5, 18); + gui.drawTexturedModalRect(gui.getGuiLeft() + xOffset, gui.getGuiTop() + yOffset + 20, 0, 238, 18 * 5, 18); + + } + + private String[] getWhitelistTooltips(boolean isBlacklist) { + if (isBlacklist) { + return new String[] { EnderIO.lang.localize("gui.conduit.item.blacklist"), + EnderIO.lang.localize("gui.conduit.item.blacklist.tooltip.0"), + EnderIO.lang.localize("gui.conduit.item.blacklist.tooltip.1") }; + } else { + return new String[] { EnderIO.lang.localize("gui.conduit.item.whitelist"), + EnderIO.lang.localize("gui.conduit.item.whitelist.tooltip.0"), + EnderIO.lang.localize("gui.conduit.item.whitelist.tooltip.1") }; + } + } +} diff --git a/src/main/java/crazypants/enderio/conduit/item/NetworkedInventory.java b/src/main/java/crazypants/enderio/conduit/item/NetworkedInventory.java index f46e725c..76cf2d68 100644 --- a/src/main/java/crazypants/enderio/conduit/item/NetworkedInventory.java +++ b/src/main/java/crazypants/enderio/conduit/item/NetworkedInventory.java @@ -22,6 +22,7 @@ import com.enderio.core.common.util.RoundRobinIterator; import crazypants.enderio.conduit.ConnectionMode; import crazypants.enderio.conduit.item.filter.IItemFilter; +import crazypants.enderio.conduit.item.filter.ItemFilterLimited; import crazypants.enderio.config.Config; import crazypants.enderio.machine.invpanel.TileInventoryPanel; @@ -155,6 +156,7 @@ public class NetworkedInventory { int numSlots = slotIndices.length; ItemStack extractItem = null; int maxExtracted = con.getMaximumExtracted(conDir); + final IItemFilter filter = con.getInputFilter(conDir); int slot = -1; int slotChecksPerTick = Math.min(numSlots, ItemConduitNetwork.MAX_SLOT_CHECK_PER_TICK); @@ -162,12 +164,23 @@ public class NetworkedInventory { int index = nextSlot(numSlots); slot = slotIndices[index]; ItemStack item = getInventory().getStackInSlot(slot); - if (canExtractItem(item)) { - extractItem = item.copy(); - if (getInventory().canExtractItem(slot, extractItem, inventorySide)) { - if (doTransfer(extractItem, slot, maxExtracted)) { - setNextStartingSlot(slot); - return true; + if (item != null) { + if (filter != null && filter.isLimited()) { + final int count = ((ItemFilterLimited) filter).getInsertLimitInv(getInventory(), item); + if (count <= 0) { + continue; + } else if (count < item.stackSize) { + item = item.copy(); + item.stackSize = count; + } + } + if (canExtractItem(item)) { + extractItem = item.copy(); + if (getInventory().canExtractItem(slot, extractItem, inventorySide)) { + if (doTransfer(extractItem, slot, maxExtracted)) { + setNextStartingSlot(slot); + return true; + } } } } @@ -183,7 +196,11 @@ public class NetworkedInventory { if (filter == null) { return true; } - return filter.doesItemPassFilter(this, itemStack); + if (filter.isLimited()) { + return filter.isValid() && ((ItemFilterLimited) filter).doesItemPassFilterInv(this, itemStack); + } else { + return filter.doesItemPassFilter(this, itemStack); + } } private boolean doTransfer(ItemStack extractedItem, int slot, int maxExtract) { @@ -278,7 +295,20 @@ public class NetworkedInventory { } IItemFilter filter = con.getOutputFilter(conDir); if (filter != null) { - if (!filter.doesItemPassFilter(this, item)) { + if (filter.isLimited()) { + final int count = filter.getMaxCountThatCanPassFilter(item); + if (count <= 0) { + return 0; + } else { + final int maxInsert = ((ItemFilterLimited) filter).getInsertLimit(getInventory(), item); + if (maxInsert <= 0) { + return 0; + } else if (maxInsert < item.stackSize) { + item = item.copy(); + item.stackSize = maxInsert; + } + } + } else if (!filter.doesItemPassFilter(this, item)) { return 0; } } diff --git a/src/main/java/crazypants/enderio/conduit/item/filter/IItemFilter.java b/src/main/java/crazypants/enderio/conduit/item/filter/IItemFilter.java index 58d3bbbd..ad997112 100644 --- a/src/main/java/crazypants/enderio/conduit/item/filter/IItemFilter.java +++ b/src/main/java/crazypants/enderio/conduit/item/filter/IItemFilter.java @@ -41,10 +41,18 @@ public interface IItemFilter { boolean isValid(); + default boolean isLimited() { + return false; + } + boolean isSticky(); void createGhostSlots(List slots, int xOffset, int yOffset, Runnable cb); + default int getMaxCountThatCanPassFilter(ItemStack item) { + return 1; + } + int getSlotCount(); default String getUnlocalizedName() { diff --git a/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilter.java b/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilter.java index 8ccd2652..d1bc8941 100644 --- a/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilter.java +++ b/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilter.java @@ -98,7 +98,7 @@ public class ItemFilter implements IInventory, IItemFilter { return isBlacklist ? !allow : allow; } - private boolean itemMatched(ItemStack item) { + protected boolean itemMatched(ItemStack item) { if (item == null) { return false; } @@ -145,7 +145,7 @@ public class ItemFilter implements IInventory, IItemFilter { return matched; } - private boolean isOreDicMatch(int filterItemIndex, ItemStack item) { + protected boolean isOreDicMatch(int filterItemIndex, ItemStack item) { int[] ids1 = getCachedIds(filterItemIndex); if (ids1 == null || ids1.length == 0) { return false; @@ -164,7 +164,7 @@ public class ItemFilter implements IInventory, IItemFilter { return false; } - private boolean isNBTMatch(ItemStack filter, ItemStack item) { + protected boolean isNBTMatch(ItemStack filter, ItemStack item) { if (filter.stackTagCompound == null && (item.stackTagCompound == null || item.stackTagCompound.hasNoTags())) return true; if (filter.stackTagCompound == null || item.stackTagCompound == null) return false; @@ -203,7 +203,7 @@ public class ItemFilter implements IInventory, IItemFilter { return !isItemListEmpty(); } - private boolean isItemListEmpty() { + protected boolean isItemListEmpty() { for (ItemStack item : items) { if (item != null) { return false; diff --git a/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilterLimited.java b/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilterLimited.java new file mode 100644 index 00000000..eceb7d62 --- /dev/null +++ b/src/main/java/crazypants/enderio/conduit/item/filter/ItemFilterLimited.java @@ -0,0 +1,242 @@ +package crazypants.enderio.conduit.item.filter; + +import java.util.List; + +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.lwjgl.input.Keyboard; +import org.lwjgl.input.Mouse; + +import com.enderio.core.client.gui.widget.GhostSlot; + +import cofh.lib.util.helpers.MathHelper; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import crazypants.enderio.conduit.gui.GuiExternalConnection; +import crazypants.enderio.conduit.gui.item.IItemFilterGui; +import crazypants.enderio.conduit.gui.item.ItemConduitFilterContainer; +import crazypants.enderio.conduit.gui.item.LimitedItemFilterGui; +import crazypants.enderio.conduit.item.IItemConduit; +import crazypants.enderio.conduit.item.NetworkedInventory; + +public class ItemFilterLimited extends ItemFilter { + + public ItemFilterLimited() { + this(10, true); + } + + public ItemFilterLimited(int numItems, boolean isAdvanced) { + super(numItems, isAdvanced); + } + + @Override + public String getInventoryName() { + return "Limited Item Filter"; + } + + @Override + @SideOnly(Side.CLIENT) + public IItemFilterGui getGui(GuiExternalConnection gui, IItemConduit itemConduit, boolean isInput) { + ItemConduitFilterContainer cont = new ItemConduitFilterContainer(itemConduit, gui.getDir(), isInput); + LimitedItemFilterGui limitedItemFilterGui = new LimitedItemFilterGui(gui, cont, !isInput, isInput); + limitedItemFilterGui.createFilterSlots(); + return limitedItemFilterGui; + } + + @Override + public void createGhostSlots(List slots, int xOffset, int yOffset, Runnable cb) { + int index = 0; + int numRows = (int) (double) (items.length / 5); + for (int row = 0; row < numRows; ++row) { + for (int col = 0; col < 5; ++col) { + int x = xOffset + col * 18; + int y = yOffset + row * 20; + slots.add(new ItemFilterGhostSlot(index, x, y, cb)); + index++; + } + } + } + + @Override + public int getMaxCountThatCanPassFilter(ItemStack item) { + if (item == null || item.getItem() == null) { + return 0; + } + int count = 0; + for (int i = 0; i < items.length; i++) { + ItemStack invStack = items[i]; + if (invStack != null && itemStackMatched(invStack, item, i)) { + count += invStack.stackSize; + } + } + return count; + } + + @Override + public boolean isLimited() { + return true; + } + + public int getInsertLimit(ISidedInventory inv, ItemStack item) { + if (item == null || item.getItem() == null) { + return 0; + } + int count = 0; + for (int i = 0; i < inv.getSizeInventory(); i++) { + ItemStack invStack = inv.getStackInSlot(i); + if (invStack != null && itemStackMatched(invStack, item, i)) { + count += invStack.stackSize; + } + } + return getMaxCountThatCanPassFilter(item) - count; + } + + public int getInsertLimitInv(ISidedInventory inv, ItemStack item) { + return -getInsertLimit(inv, item); + } + + public boolean doesCountPassFilter(int maxCount) { + return maxCount > 0; + } + + @Override + public boolean doesItemPassFilter(NetworkedInventory inv, ItemStack item) { + return isValid() && itemMatched(item) && doesCountPassFilter(getInsertLimit(inv.getInventory(), item)); + + } + + // Filter in extract slot + public boolean doesItemPassFilterInv(NetworkedInventory inv, ItemStack item) { + return isValid() && itemMatched(item) && doesCountPassFilter(getInsertLimitInv(inv.getInventory(), item)); + } + + protected boolean itemStackMatched(ItemStack item, ItemStack filter, int slot) { + if (item == null) { + return false; + } + + boolean checkDamage = fuzzyMode != FuzzyMode.DISABLED; + boolean damageMatched = false; + if (checkDamage && item.getItem().isDamageable()) { + damageMatched = fuzzyMode.compare(item); + } + + if (isItemListEmpty()) { + if (checkDamage) { + return damageMatched; + } else { + return false; + } + } + + boolean matched = false; + + if (filter != null && item.getItem() == filter.getItem()) { + matched = true; + + if (checkDamage && !damageMatched) { + matched = false; + } else if (matchMeta && item.getItemDamage() != filter.getItemDamage()) { + matched = false; + } else if (matchNBT && !isNBTMatch(item, filter)) { + matched = false; + } + } + + if (!matched && useOreDict && isOreDicMatch(filter, item)) { + matched = true; + } + return matched; + } + + public boolean isOreDicMatch(ItemStack filter, ItemStack item) { + int[] id_filter = OreDictionary.getOreIDs(filter); + if (id_filter.length == 0) { + return false; + } + int[] id_item = OreDictionary.getOreIDs(item); + if (id_item.length == 0) { + return false; + } + for (int id1 : id_filter) { + for (int id2 : id_item) { + if (id1 == id2) { + return true; + } + } + } + return false; + } + + @Override + public ItemStack decrStackSize(int fromSlot, int amount) { + if ((fromSlot < 0) || (fromSlot >= items.length)) { + return null; + } + oreIds.set(fromSlot, null); + ItemStack item = items[fromSlot]; + items[fromSlot] = null; + return item.splitStack(amount); + } + + @Override + public String toString() { + return "Limited" + super.toString(); + } + + @Override + public String getUnlocalizedName() { + return "gui.limited_item_filter"; + } + + class ItemFilterGhostSlot extends GhostSlot { + + private final int slot; + private final Runnable cb; + + private final int adjustOnShift; + + ItemFilterGhostSlot(int slot, int x, int y, Runnable cb) { + this.x = x; + this.y = y; + this.slot = slot; + this.cb = cb; + this.displayStdOverlay = true; + this.stackSizeLimit = 64; + this.adjustOnShift = 10; + } + + @Override + public void putStack(ItemStack stack) { + if (stack != null) { + stack = stack.copy(); + if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT)) { + if (Mouse.isButtonDown(0) || Mouse.getEventDWheel() > 0) { + if (stack.stackSize - 1 == 1) { + stack.stackSize += adjustOnShift - 2; + } else { + stack.stackSize = MathHelper + .clamp(stack.stackSize + adjustOnShift - 1, 1, stack.getMaxStackSize()); + } + } else if (Mouse.isButtonDown(1) || Mouse.getEventDWheel() < 0) { + if (stack.stackSize + 1 == 1) { + stack.stackSize++; + } else { + stack.stackSize = MathHelper + .clamp(stack.stackSize - adjustOnShift + 1, 1, stack.getMaxStackSize()); + } + } + } + } + items[slot] = stack; + cb.run(); + } + + @Override + public ItemStack getStack() { + return items[slot]; + } + } +} diff --git a/src/main/java/crazypants/enderio/conduit/item/filter/ItemLimitedItemFilter.java b/src/main/java/crazypants/enderio/conduit/item/filter/ItemLimitedItemFilter.java new file mode 100644 index 00000000..801e5bdf --- /dev/null +++ b/src/main/java/crazypants/enderio/conduit/item/filter/ItemLimitedItemFilter.java @@ -0,0 +1,73 @@ +package crazypants.enderio.conduit.item.filter; + +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; + +import com.enderio.core.api.client.gui.IResourceTooltipProvider; +import com.enderio.core.client.handlers.SpecialTooltipHandler; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import crazypants.enderio.EnderIO; +import crazypants.enderio.EnderIOTab; +import crazypants.enderio.ModObject; +import crazypants.enderio.conduit.item.FilterRegister; + +public class ItemLimitedItemFilter extends Item implements IItemFilterUpgrade, IResourceTooltipProvider { + + public static ItemLimitedItemFilter create() { + ItemLimitedItemFilter result = new ItemLimitedItemFilter(); + result.init(); + return result; + } + + protected ItemLimitedItemFilter() { + setCreativeTab(EnderIOTab.tabEnderIO); + setUnlocalizedName(ModObject.itemLimitedItemFilter.unlocalisedName); + setMaxDamage(0); + setMaxStackSize(64); + } + + protected void init() { + GameRegistry.registerItem(this, ModObject.itemLimitedItemFilter.unlocalisedName); + } + + @Override + public IItemFilter createFilterFromStack(ItemStack stack) { + IItemFilter filter = new ItemFilterLimited(); + if (stack.stackTagCompound != null && stack.stackTagCompound.hasKey("filter")) { + filter.readFromNBT(stack.stackTagCompound.getCompoundTag("filter")); + } + return filter; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister IIconRegister) { + itemIcon = IIconRegister.registerIcon("enderio:limitedItemFilter"); + } + + @Override + public String getUnlocalizedNameForTooltip(ItemStack stack) { + return getUnlocalizedName(); + } + + @Override + @SideOnly(Side.CLIENT) + public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4) { + if (FilterRegister.isFilterSet(par1ItemStack)) { + if (SpecialTooltipHandler.showAdvancedTooltips()) { + par3List.add(EnumChatFormatting.ITALIC + EnderIO.lang.localize("itemConduitFilterUpgrade.configured")); + par3List.add( + EnumChatFormatting.ITALIC + + EnderIO.lang.localize("itemConduitFilterUpgrade.clearConfigMethod")); + } + } + } +} diff --git a/src/main/resources/assets/enderio/lang/en_US.lang b/src/main/resources/assets/enderio/lang/en_US.lang index e55e02d9..f3a456c9 100644 --- a/src/main/resources/assets/enderio/lang/en_US.lang +++ b/src/main/resources/assets/enderio/lang/en_US.lang @@ -93,6 +93,11 @@ item.itemExistingItemFilter.tooltip.detailed.line5=content to the snapshot enderio.item.itemExistingItemFilter.filterUpdated=New items have been added to the snapshot enderio.item.itemExistingItemFilter.filterNotUpdated=The snapshot already covers all items in the inventory +item.itemLimitedItemFilter.name=Limited Item Filter +item.itemLimitedItemFilter.tooltip.basic.line1=Upgrade for item conduits +item.itemLimitedItemFilter.tooltip.detailed.line1=Filters items based on +item.itemLimitedItemFilter.tooltip.detailed.line2=their stack size + item.itemModItemFilter.name=Mod Item Filter item.itemModItemFilter.tooltip.basic.line1=Upgrade for item conduits item.itemModItemFilter.tooltip.detailed.line1=Selects only items for a specified diff --git a/src/main/resources/assets/enderio/textures/items/limitedItemFilter.png b/src/main/resources/assets/enderio/textures/items/limitedItemFilter.png new file mode 100644 index 0000000000000000000000000000000000000000..a726ae79e228d85b76c46c6327a4f9a5c8fd55ec GIT binary patch literal 1506 zcmV<81s(c{P)z@;j|==^1pojAgh@m}RCwC$S6gfpRT%!xnb~W%u@$Nm zC?VLiwvbv9TTzPy(MO|+Z~A7SLem&U!tJ4m;)Pp;($rGx?b&CeFFvAC%FSq(6bhx? zmX@Uzy0`A`%o+drXBWENwJcBYz)7a3=b!m+-}%me{skV52RuX}VS9VKWzVTpiq}dh zo^@T%nX~fj@cDc^ClU#s4a3O!zPr0S&!2p#5NK;_Y<35d#P!TzP+AjCntb-JkHKEmy48i9O^v5 zayKce)GQj-)Wf3ehlYk&K7He+V(_RE3^N+R<-LbXeqAKuIr$dYLD~b25x5g2{crE1&@4#Z1YAk|PBwPp*XKp`+)rNJpEeuNU-}gFtI*t0g@itl#)DA?d{*SFW&pFgQRN zOd$~tL5c|60fot)Ix;HIbnrH=UmwHhu{t2CP}Y8x0$Kv;uRvqdbF9CNw!5y4Q4hvQIzGpN+{_FZP>I4 zHW$A7=@*vk$!TDA5-X~_#PTRkZ!d$T3skoK#qYzr>L70!X#CkAB+3v9rqN)ktp9$nxz%!`lq)6`M* z#T1OhIL13DYs13Q&x2UHY&p(vTZFXVMCE&zkeD`MssP;u#kUy+>p(;2ey#&&-`P$H z8>su1IFOpaZ*37qpy}`oZ2tDY>xbnQXg)!gRnmv6g9N`8Kz02y&`L`YY~9T^Yq~y# z8JWS*o`XekK*1!qGwqbU;}iou(mCFe{us{jQstR?pZ3su55Y?{-$mc3yZUUyzKTuL zv3)NN*cZo!jT`9#apA~!Kd@Y*8xZLk)YMcG;|z?BgjgPrMff%p%66{d>G}q~c!nn? z={79Ezp+{V?zQzV^7)?}3vpmQJv|F>fQXif7U|ngLt(MZfHmvo_eR1&ARTov88vD1 zMBde>X4bY~+?sJjv@Fz`Y)o+VQb5ZmHgU^_2{Uj$D&Y;Oo}Dz;h@xmSZg2 z6IQQW#qF1Lu3)MSDLYCeDUbzQGRK+aWRcmsoFTKHFI?xdZCAFB%p!^cePuyQc3&`e z?RGnm8*_+t2eCOL7K`z`c=2MMvt4smzpJb3;rm_iXgu)oA7q4TKn2C2hX4Qo07*qo IM6N<$f~L6M=l}o! literal 0 HcmV?d00001