From 1ba7536fa716e9ff08991652a2547d595b20420c Mon Sep 17 00:00:00 2001 From: Glease <4586901+Glease@users.noreply.github.com> Date: Sat, 13 Jan 2024 05:22:40 +0800 Subject: [PATCH] add quantum chest support (#29) Co-authored-by: Martin Robertz --- .editorconfig | 2 +- dependencies.gradle | 1 + .../proxy/SpecialInventoryHandlerManager.java | 5 + .../DSUInventoryHandler.java | 138 ++------------- .../DSULikeInventoryHandler.java | 167 ++++++++++++++++++ .../JABBAInventoryHandler.java | 157 ++-------------- .../QuantumChestInventoryHandler.java | 82 +++++++++ 7 files changed, 286 insertions(+), 266 deletions(-) create mode 100644 src/main/java/logisticspipes/proxy/specialinventoryhandler/DSULikeInventoryHandler.java create mode 100644 src/main/java/logisticspipes/proxy/specialinventoryhandler/QuantumChestInventoryHandler.java diff --git a/.editorconfig b/.editorconfig index 958e6ab40..6effbc91a 100644 --- a/.editorconfig +++ b/.editorconfig @@ -8,7 +8,7 @@ root = true charset = utf-8 end_of_line = lf indent_size = 4 -indent_style = tab +indent_style = space insert_final_newline = true trim_trailing_whitespace = true diff --git a/dependencies.gradle b/dependencies.gradle index a288d9e7d..7236b485c 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -16,6 +16,7 @@ dependencies { compileOnly('com.github.GTNewHorizons:EnderStorage:1.4.12:dev') { transitive = false } compileOnly('com.github.GTNewHorizons:ExtraCells2:2.5.34:api') { transitive = false } compileOnly('com.github.GTNewHorizons:Binnie:2.2.4:dev') { transitive = false } + compileOnly('com.github.GTNewHorizons:GT5-Unofficial:5.09.45.15:dev') { transitive = false } compileOnly('net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev') { transitive = false } compileOnly('thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev') { transitive = false } diff --git a/src/main/java/logisticspipes/proxy/SpecialInventoryHandlerManager.java b/src/main/java/logisticspipes/proxy/SpecialInventoryHandlerManager.java index 75cb60ea4..f0c493770 100644 --- a/src/main/java/logisticspipes/proxy/SpecialInventoryHandlerManager.java +++ b/src/main/java/logisticspipes/proxy/SpecialInventoryHandlerManager.java @@ -6,6 +6,7 @@ import logisticspipes.proxy.specialinventoryhandler.CrateInventoryHandler; import logisticspipes.proxy.specialinventoryhandler.DSUInventoryHandler; import logisticspipes.proxy.specialinventoryhandler.JABBAInventoryHandler; +import logisticspipes.proxy.specialinventoryhandler.QuantumChestInventoryHandler; import logisticspipes.proxy.specialinventoryhandler.StorageDrawersInventoryHandler; public class SpecialInventoryHandlerManager { @@ -35,5 +36,9 @@ public static void load() { Class.forName("powercrystals.minefactoryreloaded.api.IDeepStorageUnit"); SimpleServiceLocator.inventoryUtilFactory.registerHandler(new DSUInventoryHandler()); } catch (ClassNotFoundException ignored) {} + + if (Loader.isModLoaded("gregtech")) { + SimpleServiceLocator.inventoryUtilFactory.registerHandler(new QuantumChestInventoryHandler()); + } } } diff --git a/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSUInventoryHandler.java b/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSUInventoryHandler.java index 69e72f2eb..8903fd561 100644 --- a/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSUInventoryHandler.java +++ b/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSUInventoryHandler.java @@ -1,20 +1,14 @@ package logisticspipes.proxy.specialinventoryhandler; -import java.util.HashMap; -import java.util.Set; -import java.util.TreeSet; - import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraftforge.common.util.ForgeDirection; -import logisticspipes.utils.item.ItemIdentifier; import powercrystals.minefactoryreloaded.api.IDeepStorageUnit; -public class DSUInventoryHandler extends SpecialInventoryHandler { +public class DSUInventoryHandler extends DSULikeInventoryHandler { private final IDeepStorageUnit _tile; - private final boolean _hideOnePerStack; private DSUInventoryHandler(TileEntity tile, boolean hideOnePerStack, boolean hideOne, int cropStart, int cropEnd) { _tile = (IDeepStorageUnit) tile; @@ -43,139 +37,37 @@ public SpecialInventoryHandler getUtilForTile(TileEntity tile, ForgeDirection di } @Override - public int itemCount(ItemIdentifier itemIdent) { - ItemStack items = _tile.getStoredItemType(); - if (items != null && ItemIdentifier.get(items).equals(itemIdent)) { - return items.stackSize - (_hideOnePerStack ? 1 : 0); - } - return 0; - } - - @Override - public ItemStack getMultipleItems(ItemIdentifier itemIdent, int count) { - ItemStack items = _tile.getStoredItemType(); - if (items == null || !ItemIdentifier.get(items).equals(itemIdent)) { - return null; - } - if (_hideOnePerStack) { - items.stackSize--; - } - if (count >= items.stackSize) { - _tile.setStoredItemCount((_hideOnePerStack ? 1 : 0)); - return items; - } - ItemStack newItems = items.splitStack(count); - _tile.setStoredItemCount(items.stackSize + (_hideOnePerStack ? 1 : 0)); - return newItems; - } - - @Override - public Set getItems() { - Set result = new TreeSet<>(); - ItemStack items = _tile.getStoredItemType(); - if (items != null && items.stackSize > 0) { - result.add(ItemIdentifier.get(items)); - } - return result; - } - - @Override - public HashMap getItemsAndCount() { - HashMap result = new HashMap<>(); - ItemStack items = _tile.getStoredItemType(); - if (items != null && items.stackSize > 0) { - result.put(ItemIdentifier.get(items), items.stackSize - (_hideOnePerStack ? 1 : 0)); - } - return result; - } - - @Override - public ItemStack getSingleItem(ItemIdentifier itemIdent) { - return getMultipleItems(itemIdent, 1); - } - - @Override - public boolean containsUndamagedItem(ItemIdentifier itemIdent) { - ItemStack items = _tile.getStoredItemType(); - return items != null && ItemIdentifier.get(items).getUndamaged().equals(itemIdent); + boolean isEmpty() { + return _tile.getStoredItemType() != null; } @Override - public int roomForItem(ItemIdentifier item) { - return roomForItem(item, 0); + int getSize() { + return _tile.getMaxStoredCount(); } @Override - public int roomForItem(ItemIdentifier itemIdent, int count) { - if (itemIdent.tag != null) { - return 0; - } - ItemStack items = _tile.getStoredItemType(); - if (items == null) { - return _tile.getMaxStoredCount(); - } - if (ItemIdentifier.get(items).equals(itemIdent)) { - return _tile.getMaxStoredCount() - items.stackSize; - } - return 0; + int getCurrent() { + return isEmpty() ? 0 : _tile.getStoredItemType().stackSize; } @Override - public ItemStack add(ItemStack stack, ForgeDirection from, boolean doAdd) { - ItemStack st = stack.copy(); - st.stackSize = 0; - if (stack.getTagCompound() != null) { - return st; - } - ItemStack items = _tile.getStoredItemType(); - if ((items == null || items.stackSize == 0)) { - if (stack.stackSize <= _tile.getMaxStoredCount()) { - _tile.setStoredItemType(stack, stack.stackSize); - st.stackSize = stack.stackSize; - return st; - } else { - _tile.setStoredItemType(stack, _tile.getMaxStoredCount()); - st.stackSize = _tile.getMaxStoredCount(); - return st; - } - } - if (!items.isItemEqual(stack)) { - return st; - } - if (stack.stackSize <= _tile.getMaxStoredCount() - items.stackSize) { - _tile.setStoredItemCount(items.stackSize + stack.stackSize); - st.stackSize = stack.stackSize; - return st; - } else { - _tile.setStoredItemCount(_tile.getMaxStoredCount()); - st.stackSize = _tile.getMaxStoredCount() - items.stackSize; - return st; - } - } - - @Override - public boolean isSpecialInventory() { - return true; + ItemStack getType() { + return _tile.getStoredItemType(); } @Override - public int getSizeInventory() { - return 1; + void setContent(int count) { + _tile.setStoredItemCount(count); } @Override - public ItemStack getStackInSlot(int i) { - if (i != 0) { - return null; - } - return _tile.getStoredItemType(); + void setContent(ItemStack stack, int size) { + _tile.setStoredItemType(stack, size); } @Override - public ItemStack decrStackSize(int i, int j) { - if (i != 0) { - return null; - } - return getMultipleItems(ItemIdentifier.get(_tile.getStoredItemType()), j); + void markDirty() { + ((TileEntity) _tile).markDirty(); } } diff --git a/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSULikeInventoryHandler.java b/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSULikeInventoryHandler.java new file mode 100644 index 000000000..8d63cc022 --- /dev/null +++ b/src/main/java/logisticspipes/proxy/specialinventoryhandler/DSULikeInventoryHandler.java @@ -0,0 +1,167 @@ +package logisticspipes.proxy.specialinventoryhandler; + +import java.util.HashMap; +import java.util.Set; +import java.util.TreeSet; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; + +import logisticspipes.utils.item.ItemIdentifier; + +abstract class DSULikeInventoryHandler extends SpecialInventoryHandler { + + protected boolean _hideOnePerStack; + + @Override + public int itemCount(ItemIdentifier itemIdent) { + if (isEmpty() || itemIdent.tag != null) return 0; + return getTypeIdent().equals(itemIdent) ? getCurrent() : 0; + } + + @Override + public ItemStack getMultipleItems(ItemIdentifier itemIdent, int count) { + if (isEmpty()) return null; + if (!getTypeIdent().equals(itemIdent)) { + return null; + } + int current = getCurrent(); + int toTake = Math.max(Math.min(_hideOnePerStack ? current - 1 : current, count), 0); + setContent(current - toTake); + markDirty(); + return itemIdent.makeNormalStack(toTake); + } + + @Override + public Set getItems() { + Set result = new TreeSet<>(); + if (!isEmpty()) { + result.add(getTypeIdent()); + } + return result; + } + + @Override + public HashMap getItemsAndCount() { + HashMap result = new HashMap<>(); + if (!isEmpty()) { + result.put(getTypeIdent(), getReportedCount()); + } + return result; + } + + @Override + public ItemStack getSingleItem(ItemIdentifier itemIdent) { + return getMultipleItems(itemIdent, 1); + } + + @Override + public boolean containsUndamagedItem(ItemIdentifier itemIdent) { + return !isEmpty() && getTypeIdent().getUndamaged().equals(itemIdent); + } + + int roomForItemNoTag(ItemStack stack) { + if (stack.stackTagCompound != null) { + return 0; + } + if (isEmpty()) { + return getSize(); + } + if (stack.isItemEqual(getType())) { + return getSize() - getCurrent(); + } + return 0; + } + + @Override + public int roomForItem(ItemIdentifier item) { + return roomForItem(item, 0); + } + + @Override + public int roomForItem(ItemIdentifier itemIdent, int count) { + if (itemIdent.tag != null) { + return 0; + } + if (isEmpty()) { + return getSize(); + } + if (getTypeIdent().equals(itemIdent)) { + return getSize() - getCurrent(); + } + return 0; + } + + @Override + public ItemStack add(ItemStack stack, ForgeDirection from, boolean doAdd) { + ItemStack st = stack.copy(); + st.stackSize = 0; + if (stack.getTagCompound() != null) { + return st; + } + st.stackSize = Math.min(roomForItemNoTag(stack), stack.stackSize); + if (st.stackSize == 0) { + return st; + } + if (doAdd) { + if (isEmpty()) { + setContent(st, st.stackSize); + } else { + setContent(getCurrent() + st.stackSize); + } + markDirty(); + } + return st; + } + + @Override + public boolean isSpecialInventory() { + return true; + } + + @Override + public int getSizeInventory() { + return 1; + } + + @Override + public ItemStack getStackInSlot(int i) { + if (i != 0 || isEmpty()) return null; + ItemStack res = getType(); + res.stackSize = getReportedCount(); + return res; + } + + @Override + public ItemStack decrStackSize(int i, int j) { + if (i != 0 || isEmpty()) return null; + return getMultipleItems(ItemIdentifier.get(getType()), j); + } + + /** + * @return return false if this does not have anything inside, including ghosts with 0 stack size. return true + * otherwise + */ + abstract boolean isEmpty(); + + abstract int getSize(); + + abstract int getCurrent(); + + abstract ItemStack getType(); + + ItemIdentifier getTypeIdent() { + return ItemIdentifier.get(getType()); + } + + abstract void setContent(int count); + + abstract void setContent(ItemStack stack, int size); + + abstract void markDirty(); + + int getReportedCount() { + if (_hideOnePerStack) return Math.max(0, getCurrent() - 1); + return getCurrent(); + } +} diff --git a/src/main/java/logisticspipes/proxy/specialinventoryhandler/JABBAInventoryHandler.java b/src/main/java/logisticspipes/proxy/specialinventoryhandler/JABBAInventoryHandler.java index 20217552f..87f9109ef 100644 --- a/src/main/java/logisticspipes/proxy/specialinventoryhandler/JABBAInventoryHandler.java +++ b/src/main/java/logisticspipes/proxy/specialinventoryhandler/JABBAInventoryHandler.java @@ -1,22 +1,16 @@ package logisticspipes.proxy.specialinventoryhandler; -import java.util.HashMap; -import java.util.Set; -import java.util.TreeSet; - import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraftforge.common.util.ForgeDirection; -import logisticspipes.utils.item.ItemIdentifier; import mcp.mobius.betterbarrels.common.blocks.IBarrelStorage; import mcp.mobius.betterbarrels.common.blocks.TileEntityBarrel; -public class JABBAInventoryHandler extends SpecialInventoryHandler { +public class JABBAInventoryHandler extends DSULikeInventoryHandler { private final TileEntityBarrel _tile; private final IBarrelStorage _storage; - private final boolean _hideOnePerStack; private JABBAInventoryHandler(TileEntity tile, boolean hideOnePerStack, boolean hideOne, int cropStart, int cropEnd) { @@ -48,158 +42,37 @@ public SpecialInventoryHandler getUtilForTile(TileEntity tile, ForgeDirection di } @Override - public int itemCount(ItemIdentifier itemIdent) { - ItemStack items = _storage.getStoredItemType(); - if (items != null && ItemIdentifier.get(items).equals(itemIdent)) { - return (_storage.isCreative() ? (int) (Math.pow(2, 20)) : (items.stackSize - (_hideOnePerStack ? 1 : 0))); - } - return 0; - } - - @Override - public ItemStack getMultipleItems(ItemIdentifier itemIdent, int count) { - ItemStack items = _storage.getStoredItemType(); - if (items == null || !ItemIdentifier.get(items).equals(itemIdent)) { - return null; - } - if (_storage.isCreative()) { - return itemIdent.makeNormalStack(count); - } - if (_hideOnePerStack) { - items.stackSize--; - } - if (count >= items.stackSize) { - _storage.setStoredItemCount((_hideOnePerStack ? 1 : 0)); - _tile.markDirty(); - return items; - } - ItemStack newItems = items.splitStack(count); - _storage.setStoredItemCount(items.stackSize + (_hideOnePerStack ? 1 : 0)); - _tile.markDirty(); - return newItems; - } - - @Override - public Set getItems() { - Set result = new TreeSet<>(); - ItemStack items = _storage.getStoredItemType(); - if (items != null) { - result.add(ItemIdentifier.get(items)); - } - return result; - } - - @Override - public HashMap getItemsAndCount() { - HashMap result = new HashMap<>(); - ItemStack items = _storage.getStoredItemType(); - if (items != null && items.stackSize > 0) { - result.put( - ItemIdentifier.get(items), - _storage.isCreative() ? (int) (Math.pow(2, 20)) : items.stackSize - (_hideOnePerStack ? 1 : 0)); - } - return result; - } - - @Override - public ItemStack getSingleItem(ItemIdentifier itemIdent) { - return getMultipleItems(itemIdent, 1); - } - - @Override - public boolean containsUndamagedItem(ItemIdentifier itemIdent) { - ItemStack items = _storage.getStoredItemType(); - return items != null && ItemIdentifier.get(items).getUndamaged().equals(itemIdent); - } - - @Override - public int roomForItem(ItemIdentifier item) { - return roomForItem(item, 0); + boolean isEmpty() { + return _tile.getStoredItemType() != null; } @Override - public int roomForItem(ItemIdentifier itemIdent, int count) { - if (itemIdent.tag != null) { - return 0; - } - ItemStack items = _storage.getStoredItemType(); - if (items == null) { - return _storage.getMaxStoredCount(); - } - if (_storage.sameItem(itemIdent.makeNormalStack(1))) { - if (_storage.isVoid()) { - return _storage.getMaxStoredCount(); - } else { - return _storage.getMaxStoredCount() - items.stackSize; - } - } - return 0; + int getSize() { + return _storage.getMaxStoredCount(); } @Override - public ItemStack add(ItemStack stack, ForgeDirection from, boolean doAdd) { - ItemStack st = stack.copy(); - st.stackSize = 0; - if (stack.getTagCompound() != null) { - return st; - } - ItemStack items = _storage.getStoredItemType(); - if ((items == null || items.stackSize == 0)) { - if (stack.stackSize <= _storage.getMaxStoredCount()) { - _storage.setStoredItemType(stack, stack.stackSize); - st.stackSize = stack.stackSize; - _tile.markDirty(); - return st; - } else { - _storage.setStoredItemType(stack, _storage.getMaxStoredCount()); - st.stackSize = _storage.getMaxStoredCount(); - _tile.markDirty(); - return st; - } - } - if (!_storage.sameItem(stack)) { - return st; - } - if (stack.stackSize <= _storage.getMaxStoredCount() - items.stackSize) { - _storage.setStoredItemCount(items.stackSize + stack.stackSize); - st.stackSize = stack.stackSize; - _tile.markDirty(); - return st; - } else { - _storage.setStoredItemCount(_storage.getMaxStoredCount()); - if (!_storage.isVoid()) { - st.stackSize = _storage.getMaxStoredCount() - items.stackSize; - } else { - st.stackSize = stack.stackSize; - } - _tile.markDirty(); - return st; - } + int getCurrent() { + return isEmpty() ? 0 : _storage.getStoredItemType().stackSize; } @Override - public boolean isSpecialInventory() { - return true; + ItemStack getType() { + return _storage.getStoredItemType(); } @Override - public int getSizeInventory() { - return 1; + void setContent(int count) { + _storage.setStoredItemCount(count); } @Override - public ItemStack getStackInSlot(int i) { - if (i != 0) { - return null; - } - return _storage.getStoredItemType(); + void setContent(ItemStack stack, int size) { + _storage.setStoredItemType(stack, size); } @Override - public ItemStack decrStackSize(int i, int j) { - if (i != 0) { - return null; - } - return getMultipleItems(ItemIdentifier.get(_storage.getStoredItemType()), j); + void markDirty() { + _tile.markDirty(); } } diff --git a/src/main/java/logisticspipes/proxy/specialinventoryhandler/QuantumChestInventoryHandler.java b/src/main/java/logisticspipes/proxy/specialinventoryhandler/QuantumChestInventoryHandler.java new file mode 100644 index 000000000..d7ff03b60 --- /dev/null +++ b/src/main/java/logisticspipes/proxy/specialinventoryhandler/QuantumChestInventoryHandler.java @@ -0,0 +1,82 @@ +package logisticspipes.proxy.specialinventoryhandler; + +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.common.tileentities.storage.GT_MetaTileEntity_QuantumChest; + +public class QuantumChestInventoryHandler extends DSULikeInventoryHandler { + + private final GT_MetaTileEntity_QuantumChest _mte; + + private QuantumChestInventoryHandler(GT_MetaTileEntity_QuantumChest tile, boolean hideOnePerStack, boolean hideOne, + int cropStart, int cropEnd) { + _mte = tile; + _hideOnePerStack = hideOnePerStack || hideOne; + } + + public QuantumChestInventoryHandler() { + _mte = null; + _hideOnePerStack = false; + } + + @Override + public boolean init() { + return true; + } + + @Override + public boolean isType(TileEntity tile) { + if (!(tile instanceof IGregTechTileEntity)) return false; + return ((IGregTechTileEntity) tile).getMetaTileEntity() instanceof GT_MetaTileEntity_QuantumChest; + } + + @Override + public SpecialInventoryHandler getUtilForTile(TileEntity tile, ForgeDirection dir, boolean hideOnePerStack, + boolean hideOne, int cropStart, int cropEnd) { + return new QuantumChestInventoryHandler( + ((GT_MetaTileEntity_QuantumChest) ((IGregTechTileEntity) tile).getMetaTileEntity()), + hideOnePerStack, + hideOne, + cropStart, + cropEnd); + } + + @Override + boolean isEmpty() { + return _mte.mItemCount == 0 || _mte.mItemStack == null; + } + + @Override + int getSize() { + return _mte.getMaxItemCount(); + } + + @Override + int getCurrent() { + return _mte.mItemCount; + } + + @Override + ItemStack getType() { + return _mte.mItemStack; + } + + @Override + void setContent(int count) { + _mte.mItemCount = count; + } + + @Override + void setContent(ItemStack stack, int size) { + _mte.mItemStack = stack.copy(); + _mte.mItemCount = size; + } + + @Override + void markDirty() { + _mte.markDirty(); + } +}