Skip to content

Commit

Permalink
add quantum chest support (#29)
Browse files Browse the repository at this point in the history
Co-authored-by: Martin Robertz <[email protected]>
  • Loading branch information
Glease and Dream-Master authored Jan 12, 2024
1 parent e5aa024 commit 1ba7536
Show file tree
Hide file tree
Showing 7 changed files with 286 additions and 266 deletions.
2 changes: 1 addition & 1 deletion .editorconfig
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand Down
1 change: 1 addition & 0 deletions dependencies.gradle
Original file line number Diff line number Diff line change
Expand Up @@ -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 }
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down Expand Up @@ -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());
}
}
}
Original file line number Diff line number Diff line change
@@ -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;
Expand Down Expand Up @@ -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<ItemIdentifier> getItems() {
Set<ItemIdentifier> result = new TreeSet<>();
ItemStack items = _tile.getStoredItemType();
if (items != null && items.stackSize > 0) {
result.add(ItemIdentifier.get(items));
}
return result;
}

@Override
public HashMap<ItemIdentifier, Integer> getItemsAndCount() {
HashMap<ItemIdentifier, Integer> 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();
}
}
Original file line number Diff line number Diff line change
@@ -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<ItemIdentifier> getItems() {
Set<ItemIdentifier> result = new TreeSet<>();
if (!isEmpty()) {
result.add(getTypeIdent());
}
return result;
}

@Override
public HashMap<ItemIdentifier, Integer> getItemsAndCount() {
HashMap<ItemIdentifier, Integer> 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();
}
}
Loading

0 comments on commit 1ba7536

Please sign in to comment.