dave/refinedstorage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor the way fluid slots work.

Browse Source
This commit is contained in:
raoulvdberge
2018-07-24 22:03:38 +02:00
parent a4119e533c
commit 5a5d873eba
93 changed files with 1161 additions and 929 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/com/raoulvdberge/refinedstorage/api/autocrafting/ICraftingPatternContainer.java
View File

@@ -29,7 +29,7 @@ public interface ICraftingPatternContainer {
/**
* @return the fluid inventory that this container is connected to, or null if no fluid inventory is present
*
* TODO: remove default.
* TODO: Remove default.
*/
@Nullable
default IFluidHandler getConnectedFluidInventory() {

37
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeConstructor.java
View File

@@ -5,11 +5,11 @@ import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.TileConstructor;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -55,13 +55,14 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
private static final String NBT_TYPE = "Type";
private static final String NBT_DROP = "Drop";
private static final String NBT_COVERS = "Covers";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private static final int BASE_SPEED = 20;
private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(1, new ListenerNetworkNode(this));
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int type = IType.ITEMS;
@@ -105,8 +106,8 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
dropItem();
}
}
} else if (type == IType.FLUIDS && !fluidFilters.getStackInSlot(0).isEmpty()) {
FluidStack stack = fluidFilters.getFluidStackInSlot(0);
} else if (type == IType.FLUIDS && fluidFilters.getFluid(0) != null) {
FluidStack stack = fluidFilters.getFluid(0);
if (stack != null && stack.getFluid().canBePlacedInWorld()) {
BlockPos front = pos.offset(getDirection());
@@ -300,7 +301,8 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
tag.setBoolean(NBT_DROP, drop);
StackUtils.writeItems(itemFilters, 0, tag);
StackUtils.writeItems(fluidFilters, 2, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
return tag;
}
@@ -326,7 +328,10 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
}
StackUtils.readItems(itemFilters, 0, tag);
StackUtils.readItems(fluidFilters, 2, tag);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
}
public boolean isDrop() {
@@ -369,13 +374,13 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
@Override

10
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCrafter.java
View File

@@ -7,9 +7,9 @@ import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPatternProvider
import com.raoulvdberge.refinedstorage.api.network.INetwork;
import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import com.raoulvdberge.refinedstorage.util.WorldUtils;
@@ -37,7 +37,7 @@ public class NetworkNodeCrafter extends NetworkNode implements ICraftingPatternC
private static final String NBT_DISPLAY_NAME = "DisplayName";
private static final String NBT_UUID = "CrafterUuid";
private ItemHandlerBase patterns = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this), s -> isValidPatternInSlot(world, s)) {
private ItemHandlerBase patterns = new ItemHandlerBase(9, new ListenerNetworkNode(this), s -> isValidPatternInSlot(world, s)) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -63,7 +63,7 @@ public class NetworkNodeCrafter extends NetworkNode implements ICraftingPatternC
private List<ICraftingPattern> actualPatterns = new ArrayList<>();
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED);
// Used to prevent infinite recursion on getRootContainer() when there's e.g. two crafters facing each other.
private boolean visited = false;

33
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDestructor.java
View File

@@ -5,10 +5,10 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.TileDestructor;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -60,13 +60,14 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
private static final String NBT_TYPE = "Type";
private static final String NBT_PICKUP = "Pickup";
private static final String NBT_COVERS = "Covers";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private static final int BASE_SPEED = 20;
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_SILK_TOUCH, ItemUpgrade.TYPE_FORTUNE_1, ItemUpgrade.TYPE_FORTUNE_2, ItemUpgrade.TYPE_FORTUNE_3);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_SILK_TOUCH, ItemUpgrade.TYPE_FORTUNE_1, ItemUpgrade.TYPE_FORTUNE_2, ItemUpgrade.TYPE_FORTUNE_3);
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int mode = IFilterable.BLACKLIST;
@@ -251,7 +252,8 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
tag.setBoolean(NBT_PICKUP, pickupItem);
StackUtils.writeItems(itemFilters, 0, tag);
StackUtils.writeItems(fluidFilters, 2, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
return tag;
}
@@ -277,9 +279,12 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
}
StackUtils.readItems(itemFilters, 0, tag);
StackUtils.readItems(fluidFilters, 2, tag);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
}
public IItemHandler getUpgrades() {
@@ -313,13 +318,13 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
@Override

29
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDetector.java
View File

@@ -6,9 +6,9 @@ import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask;
import com.raoulvdberge.refinedstorage.api.network.INetwork;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.TileDetector;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
import com.raoulvdberge.refinedstorage.tile.config.IType;
@@ -36,9 +36,10 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
private static final String NBT_MODE = "Mode";
private static final String NBT_AMOUNT = "Amount";
private static final String NBT_TYPE = "Type";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(1, new ListenerNetworkNode(this));
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int type = IType.ITEMS;
@@ -101,7 +102,7 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
powered = mode == MODE_AUTOCRAFTING ? !network.getCraftingManager().getTasks().isEmpty() : isPowered(network.getItemStorageCache().getList().getStacks().stream().map(ItemStack::getCount).mapToInt(Number::intValue).sum());
}
} else if (type == IType.FLUIDS) {
FluidStack slot = fluidFilters.getFluidStackInSlot(0);
FluidStack slot = fluidFilters.getFluid(0);
if (slot != null) {
FluidStack stack = network.getFluidStorageCache().getList().get(slot, compare);
@@ -197,7 +198,8 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
tag.setInteger(NBT_TYPE, type);
StackUtils.writeItems(itemFilters, 0, tag);
StackUtils.writeItems(fluidFilters, 1, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
return tag;
}
@@ -223,7 +225,10 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
}
StackUtils.readItems(itemFilters, 0, tag);
StackUtils.readItems(fluidFilters, 1, tag);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
}
public IItemHandler getInventory() {
@@ -248,12 +253,12 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
}

31
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java
View File

@@ -4,10 +4,10 @@ import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.TileExporter;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -35,11 +35,12 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
private static final String NBT_COMPARE = "Compare";
private static final String NBT_TYPE = "Type";
private static final String NBT_COVERS = "Covers";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int type = IType.ITEMS;
@@ -187,7 +188,8 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
tag.setInteger(NBT_TYPE, type);
StackUtils.writeItems(itemFilters, 0, tag);
StackUtils.writeItems(fluidFilters, 2, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
return tag;
}
@@ -216,7 +218,10 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
}
StackUtils.readItems(itemFilters, 0, tag);
StackUtils.readItems(fluidFilters, 2, tag);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
}
public IItemHandler getUpgrades() {
@@ -241,13 +246,13 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
@Override

29
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExternalStorage.java
View File

@@ -15,9 +15,9 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.TileExternalStorage;
import com.raoulvdberge.refinedstorage.tile.config.*;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
@@ -45,9 +45,10 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
private static final String NBT_MODE = "Mode";
private static final String NBT_TYPE = "Type";
private static final String NBT_COVERS = "Covers";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
private int priority = 0;
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
@@ -135,7 +136,8 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
super.writeConfiguration(tag);
StackUtils.writeItems(itemFilters, 0, tag);
StackUtils.writeItems(fluidFilters, 1, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
tag.setInteger(NBT_PRIORITY, priority);
tag.setInteger(NBT_COMPARE, compare);
@@ -152,7 +154,10 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
super.readConfiguration(tag);
StackUtils.readItems(itemFilters, 0, tag);
StackUtils.readItems(fluidFilters, 1, tag);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
if (tag.hasKey(NBT_PRIORITY)) {
priority = tag.getInteger(NBT_PRIORITY);
@@ -172,7 +177,7 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
accessType = AccessTypeUtils.readAccessType(tag);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
}
@Override
@@ -341,13 +346,13 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
public List<IStorageExternal<ItemStack>> getItemStorages() {

56
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java
View File

@@ -6,7 +6,11 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.apiimpl.storage.externalstorage.StorageExternalFluid;
import com.raoulvdberge.refinedstorage.inventory.*;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidHandlerFluidInterface;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.TileFluidInterface;
import com.raoulvdberge.refinedstorage.tile.config.IType;
@@ -26,10 +30,11 @@ import org.apache.commons.lang3.tuple.Pair;
public class NetworkNodeFluidInterface extends NetworkNode {
public static final String ID = "fluid_interface";
public static final int TANK_CAPACITY = 16000;
public static final int TANK_CAPACITY = 16_000;
private static final String NBT_TANK_IN = "TankIn";
private static final String NBT_TANK_OUT = "TankOut";
private static final String NBT_OUT = "Out";
private FluidTank tankIn = new FluidTank(TANK_CAPACITY) {
@Override
@@ -47,10 +52,10 @@ public class NetworkNodeFluidInterface extends NetworkNode {
private FluidHandlerFluidInterface tank = new FluidHandlerFluidInterface(tankIn, tankOut);
private ItemHandlerBase in = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid out = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase in = new ItemHandlerBase(1, new ListenerNetworkNode(this));
private FluidInventory out = new FluidInventory(1, TANK_CAPACITY, new ListenerNetworkNode(this));
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
public NetworkNodeFluidInterface(World world, BlockPos pos) {
super(world, pos);
@@ -66,21 +71,21 @@ public class NetworkNodeFluidInterface extends NetworkNode {
public void update() {
super.update();
ItemStack container = in.getStackInSlot(0);
if (!container.isEmpty()) {
Pair<ItemStack, FluidStack> result = StackUtils.getFluid(container, true);
if (result.getValue() != null && tankIn.fillInternal(result.getValue(), false) == result.getValue().amount) {
result = StackUtils.getFluid(container, false);
tankIn.fillInternal(result.getValue(), true);
in.setStackInSlot(0, result.getLeft());
}
}
if (network != null && canUpdate()) {
ItemStack container = in.getStackInSlot(0);
if (!container.isEmpty()) {
Pair<ItemStack, FluidStack> result = StackUtils.getFluid(container, true);
if (result.getValue() != null && tankIn.fillInternal(result.getValue(), false) == result.getValue().amount) {
result = StackUtils.getFluid(container, false);
tankIn.fillInternal(result.getValue(), true);
in.setStackInSlot(0, result.getLeft());
}
}
if (ticks % upgrades.getSpeed() == 0) {
FluidStack drained = tankIn.drainInternal(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), true);
@@ -94,8 +99,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
}
}
FluidStack wanted = out.getFluidStackInSlot(0);
int wantedAmount = out.getStackInSlot(0).getCount();
FluidStack wanted = out.getFluid(0);
FluidStack got = tankOut.getFluid();
if (wanted == null) {
@@ -109,7 +113,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
onTankOutChanged();
} else {
int delta = got == null ? wantedAmount : (wantedAmount - got.amount);
int delta = got == null ? wanted.amount : (wanted.amount - got.amount);
if (delta > 0) {
final boolean actingAsStorage = isActingAsStorage();
@@ -215,7 +219,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
public NBTTagCompound writeConfiguration(NBTTagCompound tag) {
super.writeConfiguration(tag);
StackUtils.writeItems(out, 2, tag, StackUtils::serializeStackToNbt);
tag.setTag(NBT_OUT, out.writeToNbt());
return tag;
}
@@ -224,7 +228,9 @@ public class NetworkNodeFluidInterface extends NetworkNode {
public void readConfiguration(NBTTagCompound tag) {
super.readConfiguration(tag);
StackUtils.readItems(out, 2, tag, StackUtils::deserializeStackFromNbt);
if (tag.hasKey(NBT_OUT)) {
out.readFromNbt(tag.getCompoundTag(NBT_OUT));
}
}
public ItemHandlerUpgrade getUpgrades() {
@@ -235,7 +241,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
return in;
}
public ItemHandlerFluid getOut() {
public FluidInventory getOut() {
return out;
}

86
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeGrid.java
View File

@@ -22,7 +22,11 @@ import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridFluid;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridItem;
import com.raoulvdberge.refinedstorage.block.BlockGrid;
import com.raoulvdberge.refinedstorage.inventory.*;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemPattern;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import com.raoulvdberge.refinedstorage.tile.data.TileDataManager;
@@ -39,6 +43,7 @@ import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.items.IItemHandler;
@@ -59,12 +64,13 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
public static final String NBT_SORTING_DIRECTION = "SortingDirection";
public static final String NBT_SORTING_TYPE = "SortingType";
public static final String NBT_SEARCH_BOX_MODE = "SearchBoxMode";
public static final String NBT_OREDICT_PATTERN = "OredictPattern";
private static final String NBT_OREDICT_PATTERN = "OredictPattern";
public static final String NBT_TAB_SELECTED = "TabSelected";
public static final String NBT_TAB_PAGE = "TabPage";
public static final String NBT_SIZE = "Size";
public static final String NBT_PROCESSING_PATTERN = "ProcessingPattern";
public static final String NBT_PROCESSING_TYPE = "ProcessingType";
private static final String NBT_PROCESSING_PATTERN = "ProcessingPattern";
private static final String NBT_PROCESSING_TYPE = "ProcessingType";
private static final String NBT_PROCESSING_MATRIX_FLUIDS = "ProcessingMatrixFluids";
private Container craftingContainer = new Container() {
@Override
@@ -80,10 +86,10 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
private IRecipe currentRecipe;
private InventoryCrafting matrix = new InventoryCrafting(craftingContainer, 3, 3);
private InventoryCraftResult result = new InventoryCraftResult();
private ItemHandlerBase matrixProcessing = new ItemHandlerBase(9 * 2, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid matrixProcessingFluids = new ItemHandlerFluid(9 * 2, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase processingMatrix = new ItemHandlerBase(9 * 2, new ListenerNetworkNode(this));
private FluidInventory processingMatrixFluids = new FluidInventory(9 * 2, Fluid.BUCKET_VOLUME, new ListenerNetworkNode(this));
private ItemHandlerBase patterns = new ItemHandlerBase(2, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.PATTERN)) {
private ItemHandlerBase patterns = new ItemHandlerBase(2, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.PATTERN)) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -94,11 +100,11 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
if (isPatternProcessing && isProcessingPattern()) {
for (int i = 0; i < 9; ++i) {
matrixProcessing.setStackInSlot(i, StackUtils.nullToEmpty(ItemPattern.getInputSlot(pattern, i)));
processingMatrix.setStackInSlot(i, StackUtils.nullToEmpty(ItemPattern.getInputSlot(pattern, i)));
}
for (int i = 0; i < 9; ++i) {
matrixProcessing.setStackInSlot(9 + i, StackUtils.nullToEmpty(ItemPattern.getOutputSlot(pattern, i)));
processingMatrix.setStackInSlot(9 + i, StackUtils.nullToEmpty(ItemPattern.getOutputSlot(pattern, i)));
}
} else if (!isPatternProcessing && !isProcessingPattern()) {
for (int i = 0; i < 9; ++i) {
@@ -130,7 +136,7 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
};
private List<IFilter> filters = new ArrayList<>();
private List<IGridTab> tabs = new ArrayList<>();
private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ListenerNetworkNode(this));
private GridType type;
@@ -292,11 +298,11 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
}
public ItemHandlerBase getProcessingMatrix() {
return matrixProcessing;
return processingMatrix;
}
public ItemHandlerFluid getMatrixProcessingFluids() {
return matrixProcessingFluids;
public FluidInventory getProcessingMatrixFluids() {
return processingMatrixFluids;
}
@Override
@@ -405,12 +411,12 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
}
public void clearMatrix() {
for (int i = 0; i < matrixProcessing.getSlots(); ++i) {
matrixProcessing.setStackInSlot(i, ItemStack.EMPTY);
for (int i = 0; i < processingMatrix.getSlots(); ++i) {
processingMatrix.setStackInSlot(i, ItemStack.EMPTY);
}
for (int i = 0; i < matrixProcessingFluids.getSlots(); ++i) {
matrixProcessingFluids.setStackInSlot(i, ItemStack.EMPTY);
for (int i = 0; i < processingMatrixFluids.getSlots(); ++i) {
processingMatrixFluids.setFluid(i, null);
}
for (int i = 0; i < matrix.getSizeInventory(); ++i) {
@@ -524,25 +530,20 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
if (processingPattern) {
for (int i = 0; i < 18; ++i) {
if (!matrixProcessing.getStackInSlot(i).isEmpty()) {
if (!processingMatrix.getStackInSlot(i).isEmpty()) {
if (i >= 9) {
ItemPattern.setOutputSlot(pattern, i - 9, matrixProcessing.getStackInSlot(i));
ItemPattern.setOutputSlot(pattern, i - 9, processingMatrix.getStackInSlot(i));
} else {
ItemPattern.setInputSlot(pattern, i, matrixProcessing.getStackInSlot(i));
ItemPattern.setInputSlot(pattern, i, processingMatrix.getStackInSlot(i));
}
}
if (!matrixProcessingFluids.getStackInSlot(i).isEmpty()) {
FluidStack fluid = processingMatrixFluids.getFluid(i);
if (fluid != null) {
if (i >= 9) {
FluidStack fluid = StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(matrixProcessingFluids.getStackInSlot(i), 1), true).getValue();
if (fluid != null) {
ItemPattern.setFluidOutputSlot(pattern, i - 9, StackUtils.copy(fluid, matrixProcessingFluids.getStackInSlot(i).getCount()));
}
ItemPattern.setFluidOutputSlot(pattern, i - 9, fluid);
} else {
FluidStack fluid = StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(matrixProcessingFluids.getStackInSlot(i), 1), true).getValue();
if (fluid != null) {
ItemPattern.setFluidInputSlot(pattern, i, StackUtils.copy(fluid, matrixProcessingFluids.getStackInSlot(i).getCount()));
}
ItemPattern.setFluidInputSlot(pattern, i, fluid);
}
}
}
@@ -574,21 +575,21 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
int outputsFilled = 0;
for (int i = 0; i < 9; ++i) {
if (!matrixProcessing.getStackInSlot(i).isEmpty()) {
if (!processingMatrix.getStackInSlot(i).isEmpty()) {
inputsFilled++;
}
if (!matrixProcessingFluids.getStackInSlot(i).isEmpty()) {
if (processingMatrixFluids.getFluid(i) != null) {
inputsFilled++;
}
}
for (int i = 9; i < 18; ++i) {
if (!matrixProcessing.getStackInSlot(i).isEmpty()) {
if (!processingMatrix.getStackInSlot(i).isEmpty()) {
outputsFilled++;
}
if (!matrixProcessingFluids.getStackInSlot(i).isEmpty()) {
if (processingMatrixFluids.getFluid(i) != null) {
outputsFilled++;
}
}
@@ -689,13 +690,13 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.FLUIDS ? matrixProcessingFluids : matrixProcessing;
public IItemHandler getItemFilters() {
return processingMatrix;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return processingMatrixFluids;
}
@Override
@@ -710,8 +711,11 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
StackUtils.readItems(matrix, 0, tag);
StackUtils.readItems(patterns, 1, tag);
StackUtils.readItems(filter, 2, tag);
StackUtils.readItems(matrixProcessing, 3, tag);
StackUtils.readItems(matrixProcessingFluids, 4, tag, StackUtils::deserializeStackFromNbt);
StackUtils.readItems(processingMatrix, 3, tag);
if (tag.hasKey(NBT_PROCESSING_MATRIX_FLUIDS)) {
processingMatrixFluids.readFromNbt(tag.getCompoundTag(NBT_PROCESSING_MATRIX_FLUIDS));
}
if (tag.hasKey(NBT_TAB_SELECTED)) {
tabSelected = tag.getInteger(NBT_TAB_SELECTED);
@@ -734,9 +738,9 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
StackUtils.writeItems(matrix, 0, tag);
StackUtils.writeItems(patterns, 1, tag);
StackUtils.writeItems(filter, 2, tag);
StackUtils.writeItems(matrixProcessing, 3, tag);
StackUtils.writeItems(matrixProcessingFluids, 4, tag, StackUtils::serializeStackToNbt);
StackUtils.writeItems(processingMatrix, 3, tag);
tag.setTag(NBT_PROCESSING_MATRIX_FLUIDS, processingMatrixFluids.writeToNbt());
tag.setInteger(NBT_TAB_SELECTED, tabSelected);
tag.setInteger(NBT_TAB_PAGE, tabPage);

33
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java
View File

@@ -5,10 +5,10 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
import com.raoulvdberge.refinedstorage.tile.TileImporter;
@@ -39,11 +39,12 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
private static final String NBT_MODE = "Mode";
private static final String NBT_TYPE = "Type";
private static final String NBT_COVERS = "Covers";
private static final String NBT_FLUID_FILTERS = "FLuidFilters";
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK);
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int mode = IFilterable.BLACKLIST;
@@ -187,7 +188,8 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
tag.setInteger(NBT_TYPE, type);
StackUtils.writeItems(itemFilters, 0, tag);
StackUtils.writeItems(fluidFilters, 2, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
return tag;
}
@@ -209,9 +211,12 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
}
StackUtils.readItems(itemFilters, 0, tag);
StackUtils.readItems(fluidFilters, 2, tag);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
}
public IItemHandler getUpgrades() {
@@ -241,13 +246,13 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
@Override

16
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeInterface.java
View File

@@ -6,10 +6,10 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.apiimpl.storage.externalstorage.StorageExternalItem;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerProxy;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerProxy;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
import com.raoulvdberge.refinedstorage.tile.config.IType;
@@ -27,14 +27,14 @@ public class NetworkNodeInterface extends NetworkNode implements IComparable {
private static final String NBT_COMPARE = "Compare";
private ItemHandlerBase importItems = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase importItems = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private ItemHandlerBase exportFilterItems = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase exportItems = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase exportFilterItems = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private ItemHandlerBase exportItems = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private IItemHandler items = new ItemHandlerProxy(importItems, exportItems);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;

12
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeNetworkTransmitter.java
View File

@@ -2,10 +2,10 @@ package com.raoulvdberge.refinedstorage.apiimpl.network.node;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.RSItems;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemNetworkCard;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.util.StackUtils;
@@ -22,7 +22,7 @@ import javax.annotation.Nullable;
public class NetworkNodeNetworkTransmitter extends NetworkNode {
public static final String ID = "network_transmitter";
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(1, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_INTERDIMENSIONAL) {
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(1, new ListenerNetworkNode(this), ItemUpgrade.TYPE_INTERDIMENSIONAL) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -33,7 +33,7 @@ public class NetworkNodeNetworkTransmitter extends NetworkNode {
}
};
private ItemHandlerBase networkCard = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.NETWORK_CARD)) {
private ItemHandlerBase networkCard = new ItemHandlerBase(1, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.NETWORK_CARD)) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);

10
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSecurityManager.java
View File

@@ -7,9 +7,9 @@ import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCard;
import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCardContainer;
import com.raoulvdberge.refinedstorage.api.network.security.Permission;
import com.raoulvdberge.refinedstorage.apiimpl.network.security.SecurityCard;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemSecurityCard;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.item.ItemStack;
@@ -28,7 +28,7 @@ public class NetworkNodeSecurityManager extends NetworkNode implements ISecurity
private List<ISecurityCard> actualCards = new ArrayList<>();
private ItemHandlerBase cards = new ItemHandlerBase(9 * 2, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD)) {
private ItemHandlerBase cards = new ItemHandlerBase(9 * 2, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD)) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -42,7 +42,7 @@ public class NetworkNodeSecurityManager extends NetworkNode implements ISecurity
}
}
};
private ItemHandlerBase editCard = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD));
private ItemHandlerBase editCard = new ItemHandlerBase(1, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD));
public NetworkNodeSecurityManager(World world, BlockPos pos) {
super(world, pos);

105
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeStorageMonitor.java
View File

@@ -4,12 +4,9 @@ import com.raoulvdberge.refinedstorage.api.network.security.Permission;
import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import com.raoulvdberge.refinedstorage.util.WorldUtils;
@@ -21,31 +18,19 @@ import net.minecraft.server.MinecraftServer;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.IItemHandler;
import org.apache.commons.lang3.tuple.Pair;
import java.util.HashMap;
import java.util.Map;
public class NetworkNodeStorageMonitor extends NetworkNode implements IComparable, IType {
public class NetworkNodeStorageMonitor extends NetworkNode implements IComparable {
public static final int DEPOSIT_ALL_MAX_DELAY = 500;
public static final String ID = "storage_monitor";
private static final String NBT_COMPARE = "Compare";
private static final String NBT_TYPE = "Type";
private ItemHandlerBase itemFilter = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this)) {
@Override
public void onContentsChanged(int slot) {
super.onContentsChanged(slot);
WorldUtils.updateBlock(world, pos);
}
};
private ItemHandlerFluid fluidFilter = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this)) {
private ItemHandlerBase itemFilter = new ItemHandlerBase(1, new ListenerNetworkNode(this)) {
@Override
public void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -57,7 +42,6 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
private Map<String, Pair<ItemStack, Long>> deposits = new HashMap<>();
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int type = IType.ITEMS;
private int oldAmount = -1;
@@ -81,7 +65,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
}
public boolean depositAll(EntityPlayer player) {
if (type != IType.ITEMS || network == null) {
if (network == null) {
return false;
}
@@ -112,7 +96,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
}
public boolean deposit(EntityPlayer player, ItemStack toInsert) {
if (type != IType.ITEMS || network == null) {
if (network == null) {
return false;
}
@@ -132,7 +116,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
}
public void extract(EntityPlayer player, EnumFacing side) {
if (type != IType.ITEMS || network == null || getDirection() != side) {
if (network == null || getDirection() != side) {
return;
}
@@ -179,39 +163,13 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
markDirty();
}
@Override
public int getType() {
return world.isRemote ? TileStorageMonitor.TYPE.getValue() : type;
}
@Override
public void setType(int type) {
this.type = type;
WorldUtils.updateBlock(world, pos);
markDirty();
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilter : fluidFilter;
}
@Override
public boolean isServer() {
return !world.isRemote;
}
@Override
public NBTTagCompound writeConfiguration(NBTTagCompound tag) {
super.writeConfiguration(tag);
tag.setInteger(NBT_COMPARE, compare);
tag.setInteger(NBT_TYPE, type);
StackUtils.writeItems(itemFilter, 0, tag);
StackUtils.writeItems(fluidFilter, 1, tag);
return tag;
}
@@ -224,20 +182,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
compare = tag.getInteger(NBT_COMPARE);
}
if (tag.hasKey(NBT_TYPE)) {
type = tag.getInteger(NBT_TYPE);
}
StackUtils.readItems(itemFilter, 0, tag);
StackUtils.readItems(fluidFilter, 1, tag);
}
public ItemHandlerBase getItemFilter() {
return itemFilter;
}
public ItemHandlerFluid getFluidFilter() {
return fluidFilter;
}
public int getAmount() {
@@ -245,33 +190,19 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
return 0;
}
switch (type) {
case ITEMS: {
ItemStack toCheck = itemFilter.getStackInSlot(0);
ItemStack toCheck = itemFilter.getStackInSlot(0);
if (toCheck.isEmpty()) {
return 0;
}
ItemStack stored = network.getItemStorageCache().getList().get(toCheck, compare);
return stored != null ? stored.getCount() : 0;
}
case FLUIDS: {
FluidStack toCheck = fluidFilter.getFluidStackInSlot(0);
if (toCheck == null) {
return 0;
}
FluidStack stored = network.getFluidStorageCache().getList().get(toCheck, compare);
return stored != null ? stored.amount : 0;
}
default: {
return 0;
}
if (toCheck.isEmpty()) {
return 0;
}
ItemStack stored = network.getItemStorageCache().getList().get(toCheck, compare);
return stored != null ? stored.getCount() : 0;
}
public ItemHandlerBase getItemFilters() {
return itemFilter;
}
@Override

8
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWirelessTransmitter.java
View File

@@ -2,9 +2,9 @@ package com.raoulvdberge.refinedstorage.apiimpl.network.node;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.network.IWirelessTransmitter;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.nbt.NBTTagCompound;
@@ -18,7 +18,7 @@ import javax.annotation.Nullable;
public class NetworkNodeWirelessTransmitter extends NetworkNode implements IWirelessTransmitter {
public static final String ID = "wireless_transmitter";
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_RANGE);
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_RANGE);
public NetworkNodeWirelessTransmitter(World world, BlockPos pos) {
super(world, pos);

36
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/diskdrive/NetworkNodeDiskDrive.java
View File

@@ -15,9 +15,9 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
import com.raoulvdberge.refinedstorage.tile.config.*;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
@@ -45,13 +45,14 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
private static final String NBT_COMPARE = "Compare";
private static final String NBT_MODE = "Mode";
private static final String NBT_TYPE = "Type";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private static final int DISK_STATE_UPDATE_THROTTLE = 30;
private int ticksSinceBlockUpdateRequested;
private boolean blockUpdateRequested;
private ItemHandlerBase disks = new ItemHandlerBase(8, new ItemHandlerListenerNetworkNode(this), VALIDATOR_STORAGE_DISK) {
private ItemHandlerBase disks = new ItemHandlerBase(8, new ListenerNetworkNode(this), VALIDATOR_STORAGE_DISK) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -77,8 +78,8 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
}
};
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
private IStorageDisk[] itemDisks = new IStorageDisk[8];
private IStorageDisk[] fluidDisks = new IStorageDisk[8];
@@ -199,8 +200,8 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
super.writeConfiguration(tag);
StackUtils.writeItems(itemFilters, 1, tag);
StackUtils.writeItems(fluidFilters, 2, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
tag.setInteger(NBT_PRIORITY, priority);
tag.setInteger(NBT_COMPARE, compare);
tag.setInteger(NBT_MODE, mode);
@@ -216,7 +217,10 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
super.readConfiguration(tag);
StackUtils.readItems(itemFilters, 1, tag);
StackUtils.readItems(fluidFilters, 2, tag);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
if (tag.hasKey(NBT_PRIORITY)) {
priority = tag.getInteger(NBT_PRIORITY);
@@ -236,7 +240,7 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
accessType = AccessTypeUtils.readAccessType(tag);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
}
@Override
@@ -359,20 +363,12 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
}
ItemHandlerBase getItemFilters() {
public IItemHandler getItemFilters() {
return itemFilters;
}
ItemHandlerFluid getFluidFilters() {
@Override
public FluidInventory getFluidFilters() {
return fluidFilters;
}

44
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/diskmanipulator/NetworkNodeDiskManipulator.java
View File

@@ -10,7 +10,11 @@ import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.inventory.*;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerProxy;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -42,6 +46,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
private static final String NBT_MODE = "Mode";
private static final String NBT_TYPE = "Type";
private static final String NBT_IO_MODE = "IOMode";
private static final String NBT_FLUID_FILTERS = "FluidFilters";
private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
private int mode = IFilterable.BLACKLIST;
@@ -51,7 +56,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
private IStorageDisk<ItemStack>[] itemDisks = new IStorageDisk[6];
private IStorageDisk<FluidStack>[] fluidDisks = new IStorageDisk[6];
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK) {
private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK) {
@Override
public int getItemInteractCount() {
int count = super.getItemInteractCount();
@@ -64,7 +69,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
}
};
private ItemHandlerBase inputDisks = new ItemHandlerBase(3, new ItemHandlerListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
private ItemHandlerBase inputDisks = new ItemHandlerBase(3, new ListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -85,7 +90,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
}
};
private ItemHandlerBase outputDisks = new ItemHandlerBase(3, new ItemHandlerListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
private ItemHandlerBase outputDisks = new ItemHandlerBase(3, new ListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -112,8 +117,8 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
super(world, pos);
}
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
@Override
public int getEnergyUsage() {
@@ -343,7 +348,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
FluidStack filterStack = null;
while (fluidFilters.getSlots() > i && filterStack == null) {
filterStack = fluidFilters.getFluidStackInSlot(i++);
filterStack = fluidFilters.getFluid(i++);
}
if (filterStack != null) {
@@ -402,13 +407,13 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
}
@Override
public IItemHandler getFilterInventory() {
return getType() == IType.ITEMS ? itemFilters : fluidFilters;
public IItemHandler getItemFilters() {
return itemFilters;
}
@Override
public boolean isServer() {
return !world.isRemote;
public FluidInventory getFluidFilters() {
return fluidFilters;
}
@Override
@@ -441,14 +446,6 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
return disks;
}
public ItemHandlerBase getItemFilters() {
return itemFilters;
}
public ItemHandlerFluid getFluidFilters() {
return fluidFilters;
}
public IItemHandler getUpgrades() {
return upgrades;
}
@@ -499,8 +496,8 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
super.writeConfiguration(tag);
StackUtils.writeItems(itemFilters, 1, tag);
StackUtils.writeItems(fluidFilters, 2, tag);
tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
tag.setInteger(NBT_COMPARE, compare);
tag.setInteger(NBT_MODE, mode);
tag.setInteger(NBT_TYPE, type);
@@ -514,7 +511,10 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
super.readConfiguration(tag);
StackUtils.readItems(itemFilters, 1, tag);
StackUtils.readItems(fluidFilters, 2, tag);
if (tag.hasKey(NBT_FLUID_FILTERS)) {
fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
}
if (tag.hasKey(NBT_COMPARE)) {
compare = tag.getInteger(NBT_COMPARE);
@@ -532,7 +532,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
ioMode = tag.getInteger(NBT_IO_MODE);
}
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
}
@Override

19
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/storage/NetworkNodeFluidStorage.java
View File

@@ -16,8 +16,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.block.BlockFluidStorage;
import com.raoulvdberge.refinedstorage.block.enums.FluidStorageType;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.TileFluidStorage;
import com.raoulvdberge.refinedstorage.tile.config.IAccessType;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -25,7 +25,6 @@ import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
import com.raoulvdberge.refinedstorage.tile.config.IPrioritizable;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
import com.raoulvdberge.refinedstorage.util.AccessTypeUtils;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.block.state.IBlockState;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
@@ -42,9 +41,10 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
private static final String NBT_PRIORITY = "Priority";
private static final String NBT_COMPARE = "Compare";
private static final String NBT_MODE = "Mode";
private static final String NBT_FILTERS = "Filters";
public static final String NBT_ID = "Id";
private ItemHandlerFluid filters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
private FluidInventory filters = new FluidInventory(9, new ListenerNetworkNode(this));
private FluidStorageType type;
@@ -142,8 +142,7 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
public NBTTagCompound writeConfiguration(NBTTagCompound tag) {
super.writeConfiguration(tag);
StackUtils.writeItems(filters, 0, tag);
tag.setTag(NBT_FILTERS, filters.writeToNbt());
tag.setInteger(NBT_PRIORITY, priority);
tag.setInteger(NBT_COMPARE, compare);
tag.setInteger(NBT_MODE, mode);
@@ -157,7 +156,9 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
public void readConfiguration(NBTTagCompound tag) {
super.readConfiguration(tag);
StackUtils.readItems(filters, 0, tag);
if (tag.hasKey(NBT_FILTERS)) {
filters.readFromNbt(tag.getCompoundTag(NBT_FILTERS));
}
if (tag.hasKey(NBT_PRIORITY)) {
priority = tag.getInteger(NBT_PRIORITY);
@@ -173,7 +174,7 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
accessType = AccessTypeUtils.readAccessType(tag);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, null, filters);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, null);
}
public FluidStorageType getType() {
@@ -211,7 +212,7 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
markDirty();
}
public ItemHandlerFluid getFilters() {
public FluidInventory getFilters() {
return filters;
}

8
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/storage/NetworkNodeStorage.java
View File

@@ -16,8 +16,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem;
import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
import com.raoulvdberge.refinedstorage.block.BlockStorage;
import com.raoulvdberge.refinedstorage.block.enums.ItemStorageType;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
import com.raoulvdberge.refinedstorage.tile.TileStorage;
import com.raoulvdberge.refinedstorage.tile.config.IAccessType;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -44,7 +44,7 @@ public class NetworkNodeStorage extends NetworkNode implements IGuiStorage, ISto
private static final String NBT_MODE = "Mode";
public static final String NBT_ID = "Id";
private ItemHandlerBase filters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
private ItemHandlerBase filters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
private ItemStorageType type;
@@ -173,7 +173,7 @@ public class NetworkNodeStorage extends NetworkNode implements IGuiStorage, ISto
accessType = AccessTypeUtils.readAccessType(tag);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, filters, null);
OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, filters);
}
public ItemStorageType getType() {

4
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/util/OneSixMigrationHelper.java
View File

@@ -205,10 +205,10 @@ public class OneSixMigrationHelper implements IOneSixMigrationHelper {
public static void removalHook() {
}
public static void migrateEmptyWhitelistToEmptyBlacklist(String version, IFilterable filterable, @Nullable IItemHandler itemFilterInv, @Nullable IItemHandler fluidFilterInv) {
public static void migrateEmptyWhitelistToEmptyBlacklist(String version, IFilterable filterable, @Nullable IItemHandler itemFilterInv) {
// Only migrate if we come from a version where the RS version tag stuff in NetworkNode wasn't added yet.
// Otherwise, we would constantly migrate empty whitelists to empty blacklists...
if (version == null && filterable.getMode() == IFilterable.WHITELIST && IFilterable.isEmpty(itemFilterInv) && IFilterable.isEmpty(fluidFilterInv)) {
if (version == null && filterable.getMode() == IFilterable.WHITELIST && IFilterable.isEmpty(itemFilterInv)) {
filterable.setMode(IFilter.MODE_BLACKLIST);
}
}

124
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerBase.java
View File

@@ -1,27 +1,30 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.container.slot.*;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.GuiFluidAmount;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyDisabled;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.network.MessageSlotFilterFluidUpdate;
import com.raoulvdberge.refinedstorage.tile.TileBase;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import com.raoulvdberge.refinedstorage.tile.data.TileDataWatcher;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import invtweaks.api.container.InventoryContainer;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.ClickType;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.client.FMLClientHandler;
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.ItemHandlerHelper;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;
@InventoryContainer(showOptions = false)
public abstract class ContainerBase extends Container {
@@ -31,11 +34,16 @@ public abstract class ContainerBase extends Container {
private TileDataWatcher listener;
private EntityPlayer player;
private List<SlotFilterFluid> fluidSlots = new ArrayList<>();
private List<FluidStack> fluids = new ArrayList<>();
public ContainerBase(@Nullable TileBase tile, EntityPlayer player) {
this.tile = tile;
if (tile != null && player instanceof EntityPlayerMP) {
listener = new TileDataWatcher((EntityPlayerMP) player, tile.getDataManager());
}
this.player = player;
}
@@ -56,7 +64,7 @@ public abstract class ContainerBase extends Container {
int y = yInventory + 4 + (3 * 18);
if (isHeldItemDisabled() && i == player.inventory.currentItem) {
addSlotToContainer(new SlotDisabled(player.inventory, id, x, y));
addSlotToContainer(new SlotLegacyDisabled(player.inventory, id, x, y));
} else {
addSlotToContainer(new Slot(player.inventory, id, x, y));
}
@@ -77,8 +85,7 @@ public abstract class ContainerBase extends Container {
public ItemStack slotClick(int id, int dragType, ClickType clickType, EntityPlayer player) {
Slot slot = id >= 0 ? getSlot(id) : null;
// Prevent swapping disabled held item with the number keys
// (dragType is the slot we're swapping with)
// Prevent swapping disabled held item with the number keys (dragType is the slot we're swapping with)
if (isHeldItemDisabled() && clickType == ClickType.SWAP && dragType == player.inventory.currentItem) {
return ItemStack.EMPTY;
}
@@ -88,20 +95,11 @@ public abstract class ContainerBase extends Container {
if (clickType == ClickType.QUICK_MOVE) {
slot.putStack(ItemStack.EMPTY);
} else if (!player.inventory.getItemStack().isEmpty()) {
slot.putStack(ItemHandlerHelper.copyStackWithSize(player.inventory.getItemStack(), ((SlotFilter) slot).getInitialAmount(player.inventory.getItemStack())));
slot.putStack(player.inventory.getItemStack().copy());
} else if (slot.getHasStack()) {
if (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getType().getType() == IType.FLUIDS) {
if (FMLCommonHandler.instance().getSide() == Side.CLIENT) {
Minecraft.getMinecraft().addScheduledTask(() -> {
// Prevent JEI crash - this needs to run on the main thread and not on the packet handler thread
FMLClientHandler.instance().showGuiScreen(new GuiFluidAmount((GuiBase) Minecraft.getMinecraft().currentScreen, player, slot.slotNumber, ((SlotFilterItemOrFluid) slot).getActualStack(), ((SlotFilterItemOrFluid) slot).getMaxFluidAmount()));
});
}
} else {
slot.getStack().setCount(((SlotFilter) slot).getModifiedAmount(dragType));
slot.getStack().setCount(((SlotFilter) slot).getModifiedAmount(dragType));
detectAndSendChanges();
}
detectAndSendChanges();
}
} else if (player.inventory.getItemStack().isEmpty()) {
slot.putStack(ItemStack.EMPTY);
@@ -110,7 +108,21 @@ public abstract class ContainerBase extends Container {
}
return player.inventory.getItemStack();
} else if (slot instanceof SlotFilterLegacy) {
} else if (slot instanceof SlotFilterFluid) {
if (((SlotFilterFluid) slot).isSizeAllowed()) {
if (clickType == ClickType.QUICK_MOVE) {
((SlotFilterFluid) slot).onContainerClicked(ItemStack.EMPTY);
} else if (!player.inventory.getItemStack().isEmpty()) {
((SlotFilterFluid) slot).onContainerClicked(player.inventory.getItemStack());
}
} else if (player.inventory.getItemStack().isEmpty()) {
((SlotFilterFluid) slot).onContainerClicked(ItemStack.EMPTY);
} else {
((SlotFilterFluid) slot).onContainerClicked(player.inventory.getItemStack());
}
return player.inventory.getItemStack();
} else if (slot instanceof SlotLegacyFilter) {
if (player.inventory.getItemStack().isEmpty()) {
slot.putStack(ItemStack.EMPTY);
} else if (slot.isItemValid(player.inventory.getItemStack())) {
@@ -118,7 +130,7 @@ public abstract class ContainerBase extends Container {
}
return player.inventory.getItemStack();
} else if (slot instanceof SlotDisabled) {
} else if (slot instanceof SlotLegacyDisabled) {
return ItemStack.EMPTY;
}
@@ -130,9 +142,9 @@ public abstract class ContainerBase extends Container {
return ItemStack.EMPTY;
}
protected ItemStack mergeItemStackToFilters(ItemStack stack, int begin, int end) {
protected ItemStack transferToFilters(ItemStack stack, int begin, int end) {
for (int i = begin; i < end; ++i) {
if (API.instance().getComparer().isEqualNoQuantity(getStackFromSlot(getSlot(i)), stack)) {
if (API.instance().getComparer().isEqualNoQuantity(getSlot(i).getStack(), stack)) {
return ItemStack.EMPTY;
}
}
@@ -140,7 +152,7 @@ public abstract class ContainerBase extends Container {
for (int i = begin; i < end; ++i) {
Slot slot = getSlot(i);
if (getStackFromSlot(slot).isEmpty() && slot.isItemValid(stack)) {
if (slot.getStack().isEmpty() && slot.isItemValid(stack)) {
slot.putStack(ItemHandlerHelper.copyStackWithSize(stack, 1));
slot.onSlotChanged();
@@ -151,19 +163,30 @@ public abstract class ContainerBase extends Container {
return ItemStack.EMPTY;
}
@Nonnull
private ItemStack getStackFromSlot(Slot slot) {
ItemStack stackInSlot = slot.getStack();
protected ItemStack transferToFluidFilters(ItemStack stack) {
FluidStack fluidInContainer = StackUtils.getFluid(stack, true).getValue();
if (stackInSlot.isEmpty()) {
if (slot instanceof SlotFilterFluid) {
stackInSlot = ((SlotFilterFluid) slot).getActualStack();
} else if (slot instanceof SlotFilterItemOrFluid) {
stackInSlot = ((SlotFilterItemOrFluid) slot).getActualStack();
if (fluidInContainer == null) {
return ItemStack.EMPTY;
}
for (SlotFilterFluid slot : fluidSlots) {
if (API.instance().getComparer().isEqual(fluidInContainer, slot.getFluidInventory().getFluid(slot.getSlotIndex()), IComparer.COMPARE_NBT)) {
return ItemStack.EMPTY;
}
}
return stackInSlot;
for (SlotFilterFluid slot : fluidSlots) {
FluidInventory inventory = slot.getFluidInventory();
if (inventory.getFluid(slot.getSlotIndex()) == null) {
slot.onContainerClicked(stack);
return ItemStack.EMPTY;
}
}
return ItemStack.EMPTY;
}
@Override
@@ -175,6 +198,16 @@ public abstract class ContainerBase extends Container {
return false;
}
@Override
protected Slot addSlotToContainer(Slot slot) {
if (slot instanceof SlotFilterFluid) {
fluids.add(null);
fluidSlots.add((SlotFilterFluid) slot);
}
return super.addSlotToContainer(slot);
}
@Override
public void detectAndSendChanges() {
super.detectAndSendChanges();
@@ -182,6 +215,21 @@ public abstract class ContainerBase extends Container {
if (listener != null) {
listener.detectAndSendChanges();
}
if (this.getPlayer() instanceof EntityPlayerMP) {
for (int i = 0; i < this.fluidSlots.size(); ++i) {
SlotFilterFluid slot = this.fluidSlots.get(i);
FluidStack cached = this.fluids.get(i);
FluidStack actual = slot.getFluidInventory().getFluid(slot.getSlotIndex());
if (!API.instance().getComparer().isEqual(cached, actual, IComparer.COMPARE_QUANTITY | IComparer.COMPARE_NBT)) {
this.fluids.set(i, actual);
RS.INSTANCE.network.sendTo(new MessageSlotFilterFluidUpdate(slot.slotNumber, actual), (EntityPlayerMP) this.getPlayer());
}
}
}
}
@Override

18
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerConstructor.java
View File

@@ -1,21 +1,29 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeConstructor;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileConstructor;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerConstructor extends ContainerBase {
private NetworkNodeConstructor constructor;
public ContainerConstructor(TileConstructor constructor, EntityPlayer player) {
super(constructor, player);
this.constructor = constructor.getNode();
for (int i = 0; i < 4; ++i) {
addSlotToContainer(new SlotItemHandler(constructor.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
}
addSlotToContainer(new SlotFilterItemOrFluid(constructor.getNode(), 0, 80, 20));
addSlotToContainer(new SlotFilter(constructor.getNode().getItemFilters(), 0, 80, 20).setEnableHandler(() -> constructor.getNode().getType() == IType.ITEMS));
addSlotToContainer(new SlotFilterFluid(constructor.getNode().getFluidFilters(), 0, 80, 20, 0).setEnableHandler(() -> constructor.getNode().getType() == IType.FLUIDS));
addPlayerInventory(8, 55);
}
@@ -34,7 +42,11 @@ public class ContainerConstructor extends ContainerBase {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 4, false)) {
return mergeItemStackToFilters(stack, 4, 4 + 1);
if (constructor.getType() == IType.ITEMS) {
return transferToFilters(stack, 4, 4 + 1);
} else {
return transferToFluidFilters(stack);
}
}
if (stack.getCount() == 0) {

2
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCrafterManager.java
View File

@@ -8,7 +8,7 @@ import com.raoulvdberge.refinedstorage.gui.IResizableDisplay;
import com.raoulvdberge.refinedstorage.gui.grid.filtering.GridFilterParser;
import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackItem;
import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.item.ItemPattern;
import com.raoulvdberge.refinedstorage.tile.TileCrafterManager;
import net.minecraft.entity.player.EntityPlayer;

36
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCraftingSettings.java
View File

@@ -1,45 +1,31 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotDisabled;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluidDisabled;
import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackFluid;
import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackItem;
import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.ItemHandlerHelper;
import net.minecraftforge.items.ItemStackHandler;
import net.minecraftforge.items.SlotItemHandler;
import javax.annotation.Nonnull;
public class ContainerCraftingSettings extends ContainerBase {
public ContainerCraftingSettings(EntityPlayer player, IGridStack stack) {
super(null, player);
IItemHandler handler = null;
if (stack instanceof GridStackFluid) {
handler = new ItemHandlerFluid(1, null);
FluidInventory inventory = new FluidInventory(1);
((ItemHandlerFluid) handler).setFluidStack(0, ((GridStackFluid) stack).getStack());
inventory.setFluid(0, ((GridStackFluid) stack).getStack());
addSlotToContainer(new SlotFilterFluidDisabled(inventory, 0, 89, 48));
} else if (stack instanceof GridStackItem) {
handler = new ItemStackHandler(1);
ItemStackHandler handler = new ItemStackHandler(1);
((ItemStackHandler) handler).setStackInSlot(0, ItemHandlerHelper.copyStackWithSize(((GridStackItem) stack).getStack(), 1));
handler.setStackInSlot(0, ItemHandlerHelper.copyStackWithSize(((GridStackItem) stack).getStack(), 1));
addSlotToContainer(new SlotDisabled(handler, 0, 89, 48));
}
addSlotToContainer(new SlotItemHandler(handler, 0, 89, 48) {
@Override
public boolean isItemValid(@Nonnull ItemStack stack) {
return false;
}
@Nonnull
@Override
public ItemStack getStack() {
return stack instanceof GridStackFluid ? ItemStack.EMPTY : super.getStack();
}
});
}
}

23
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDestructor.java
View File

@@ -1,22 +1,33 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDestructor;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileDestructor;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerDestructor extends ContainerBase {
private NetworkNodeDestructor destructor;
public ContainerDestructor(TileDestructor destructor, EntityPlayer player) {
super(destructor, player);
this.destructor = destructor.getNode();
for (int i = 0; i < 4; ++i) {
addSlotToContainer(new SlotItemHandler(destructor.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid(destructor.getNode(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilter(destructor.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> destructor.getNode().getType() == IType.ITEMS));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(destructor.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> destructor.getNode().getType() == IType.FLUIDS));
}
addPlayerInventory(8, 55);
@@ -32,11 +43,15 @@ public class ContainerDestructor extends ContainerBase {
stack = slot.getStack();
if (index < 4) {
if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) {
if (!mergeItemStack(stack, 4 + 9 + 9, inventorySlots.size(), false)) {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 4, false)) {
return mergeItemStackToFilters(stack, 4, 4 + 9);
if (destructor.getType() == IType.ITEMS) {
return transferToFilters(stack, 4, 4 + 9);
} else {
return transferToFluidFilters(stack);
}
}
if (stack.getCount() == 0) {

20
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDetector.java
View File

@@ -1,16 +1,24 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDetector;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileDetector;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
public class ContainerDetector extends ContainerBase {
private NetworkNodeDetector detector;
public ContainerDetector(TileDetector detector, EntityPlayer player) {
super(detector, player);
addSlotToContainer(new SlotFilterItemOrFluid(detector.getNode(), 0, 107, 20));
this.detector = detector.getNode();
addSlotToContainer(new SlotFilter(detector.getNode().getItemFilters(), 0, 107, 20).setEnableHandler(() -> detector.getNode().getType() == IType.ITEMS));
addSlotToContainer(new SlotFilterFluid(detector.getNode().getFluidFilters(), 0, 107, 20).setEnableHandler(() -> detector.getNode().getType() == IType.FLUIDS));
addPlayerInventory(8, 55);
}
@@ -19,8 +27,14 @@ public class ContainerDetector extends ContainerBase {
public ItemStack transferStackInSlot(EntityPlayer player, int index) {
Slot slot = getSlot(index);
ItemStack stack = slot.getStack();
if (slot.getHasStack() && index > 0) {
return mergeItemStackToFilters(slot.getStack(), 0, 1);
if (detector.getType() == IType.ITEMS) {
return transferToFilters(stack, 0, 1);
} else {
return transferToFluidFilters(stack);
}
}
return ItemStack.EMPTY;

29
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskDrive.java
View File

@@ -1,25 +1,36 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerDiskDrive extends ContainerBase {
public ContainerDiskDrive(TileDiskDrive drive, EntityPlayer player) {
super(drive, player);
private NetworkNodeDiskDrive diskDrive;
public ContainerDiskDrive(TileDiskDrive diskDrive, EntityPlayer player) {
super(diskDrive, player);
this.diskDrive = diskDrive.getNode();
int x = 80;
int y = 54;
for (int i = 0; i < 8; ++i) {
addSlotToContainer(new SlotItemHandler(drive.getNode().getDisks(), i, x + ((i % 2) * 18), y + Math.floorDiv(i, 2) * 18));
addSlotToContainer(new SlotItemHandler(diskDrive.getNode().getDisks(), i, x + ((i % 2) * 18), y + Math.floorDiv(i, 2) * 18));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid(drive.getNode(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilter(diskDrive.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskDrive.getNode().getType() == IType.ITEMS));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(diskDrive.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskDrive.getNode().getType() == IType.FLUIDS));
}
addPlayerInventory(8, 141);
@@ -35,11 +46,15 @@ public class ContainerDiskDrive extends ContainerBase {
stack = slot.getStack();
if (index < 8) {
if (!mergeItemStack(stack, 8 + 9, inventorySlots.size(), false)) {
if (!mergeItemStack(stack, 8 + 9 + 9, inventorySlots.size(), false)) {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 8, false)) {
return mergeItemStackToFilters(stack, 8, 8 + 9);
if (diskDrive.getType() == IType.ITEMS) {
return transferToFilters(stack, 8, 8 + 9);
} else {
return transferToFluidFilters(stack);
}
}
if (stack.getCount() == 0) {

35
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskManipulator.java
View File

@@ -1,30 +1,41 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskmanipulator.NetworkNodeDiskManipulator;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerDiskManipulator extends ContainerBase {
public ContainerDiskManipulator(TileDiskManipulator manipulator, EntityPlayer player) {
super(manipulator, player);
private NetworkNodeDiskManipulator diskManipulator;
public ContainerDiskManipulator(TileDiskManipulator diskManipulator, EntityPlayer player) {
super(diskManipulator, player);
this.diskManipulator = diskManipulator.getNode();
for (int i = 0; i < 4; ++i) {
addSlotToContainer(new SlotItemHandler(manipulator.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
addSlotToContainer(new SlotItemHandler(diskManipulator.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
}
for (int i = 0; i < 3; ++i) {
addSlotToContainer(new SlotItemHandler(manipulator.getNode().getInputDisks(), i, 44, 57 + (i * 18)));
addSlotToContainer(new SlotItemHandler(diskManipulator.getNode().getInputDisks(), i, 44, 57 + (i * 18)));
}
for (int i = 0; i < 3; ++i) {
addSlotToContainer(new SlotItemHandler(manipulator.getNode().getOutputDisks(), i, 116, 57 + (i * 18)));
addSlotToContainer(new SlotItemHandler(diskManipulator.getNode().getOutputDisks(), i, 116, 57 + (i * 18)));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid(manipulator.getNode(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilter(diskManipulator.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskManipulator.getNode().getType() == IType.ITEMS));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(diskManipulator.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskManipulator.getNode().getType() == IType.FLUIDS));
}
addPlayerInventory(8, 129);
@@ -39,12 +50,16 @@ public class ContainerDiskManipulator extends ContainerBase {
if (slot.getHasStack()) {
stack = slot.getStack();
if (index < 4 + 6) {
if (!mergeItemStack(stack, 4 + 6 + 9, inventorySlots.size(), false)) {
if (index < 4 + 3 + 3) {
if (!mergeItemStack(stack, 4 + 3 + 3 + 9 + 9, inventorySlots.size(), false)) {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 4 + 3, false)) {
return mergeItemStackToFilters(stack, 4 + 6, 4 + 6 + 9);
if (diskManipulator.getType() == IType.ITEMS) {
return transferToFilters(stack, 4 + 3 + 3, 4 + 3 + 3 + 9);
} else {
return transferToFluidFilters(stack);
}
}
if (stack.getCount() == 0) {

24
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExporter.java
View File

@@ -1,25 +1,33 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeExporter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileExporter;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerExporter extends ContainerBase {
private NetworkNodeExporter exporter;
public ContainerExporter(TileExporter exporter, EntityPlayer player) {
super(exporter, player);
this.inventorySlots.clear();
this.inventoryItemStacks.clear();
this.exporter = exporter.getNode();
for (int i = 0; i < 4; ++i) {
addSlotToContainer(new SlotItemHandler(exporter.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid(exporter.getNode(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilter(exporter.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> exporter.getNode().getType() == IType.ITEMS));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(exporter.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> exporter.getNode().getType() == IType.FLUIDS));
}
addPlayerInventory(8, 55);
@@ -35,11 +43,15 @@ public class ContainerExporter extends ContainerBase {
stack = slot.getStack();
if (index < 4) {
if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) {
if (!mergeItemStack(stack, 4 + 9 + 9, inventorySlots.size(), false)) {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 4, false)) {
return mergeItemStackToFilters(stack, 4, 4 + 9);
if (exporter.getType() == IType.ITEMS) {
return transferToFilters(stack, 4, 4 + 9);
} else {
return transferToFluidFilters(stack);
}
}
if (stack.getCount() == 0) {

23
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExternalStorage.java
View File

@@ -1,17 +1,28 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeExternalStorage;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileExternalStorage;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
public class ContainerExternalStorage extends ContainerBase {
private NetworkNodeExternalStorage externalStorage;
public ContainerExternalStorage(TileExternalStorage externalStorage, EntityPlayer player) {
super(externalStorage, player);
this.externalStorage = externalStorage.getNode();
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid(externalStorage.getNode(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilter(externalStorage.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> externalStorage.getNode().getType() == IType.ITEMS));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(externalStorage.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> externalStorage.getNode().getType() == IType.FLUIDS));
}
addPlayerInventory(8, 141);
@@ -21,8 +32,12 @@ public class ContainerExternalStorage extends ContainerBase {
public ItemStack transferStackInSlot(EntityPlayer player, int index) {
Slot slot = getSlot(index);
if (slot.getHasStack() && index >= 8) {
return mergeItemStackToFilters(slot.getStack(), 0, 9);
if (slot.getHasStack() && index > 8) {
if (externalStorage.getType() == IType.ITEMS) {
return transferToFilters(slot.getStack(), 0, 9);
} else {
return transferToFluidFilters(slot.getStack());
}
}
return ItemStack.EMPTY;

8
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFilter.java
View File

@@ -1,8 +1,8 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilterIcon;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilterItems;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilterIcon;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilterItems;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
@@ -50,7 +50,7 @@ public class ContainerFilter extends ContainerBase {
stack = slot.getStack();
if (index > 27 - 1) {
return mergeItemStackToFilters(stack, 0, 27);
return transferToFilters(stack, 0, 27);
}
return ItemStack.EMPTY;

28
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidAmount.java
View File

@@ -1,32 +1,18 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluidDisabled;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.ItemHandlerHelper;
import net.minecraftforge.items.SlotItemHandler;
import javax.annotation.Nonnull;
import net.minecraftforge.fluids.FluidStack;
public class ContainerFluidAmount extends ContainerBase {
public ContainerFluidAmount(EntityPlayer player, ItemStack fluidContainer) {
public ContainerFluidAmount(EntityPlayer player, FluidStack stack) {
super(null, player);
ItemHandlerFluid handler = new ItemHandlerFluid(1, null);
FluidInventory inventory = new FluidInventory(1);
handler.setStackInSlot(0, ItemHandlerHelper.copyStackWithSize(fluidContainer, 1));
inventory.setFluid(0, stack);
addSlotToContainer(new SlotItemHandler(handler, 0, 89, 48) {
@Override
public boolean isItemValid(@Nonnull ItemStack stack) {
return false;
}
@Nonnull
@Override
public ItemStack getStack() {
return ItemStack.EMPTY;
}
});
addSlotToContainer(new SlotFilterFluidDisabled(inventory, 0, 89, 48, 0));
}
}

39
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidInterface.java
View File

@@ -1,14 +1,11 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidInterface;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileFluidInterface;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerFluidInterface extends ContainerBase {
@@ -20,31 +17,7 @@ public class ContainerFluidInterface extends ContainerBase {
}
addSlotToContainer(new SlotItemHandler(fluidInterface.getNode().getIn(), 0, 44, 32));
addSlotToContainer(new SlotFilterItemOrFluid(new IType() {
@Override
public int getType() {
return IType.FLUIDS;
}
@Override
public void setType(int type) {
// NO OP
}
@Override
public IItemHandler getFilterInventory() {
return fluidInterface.getNode().getOut();
}
@Override
public boolean isServer() {
return !fluidInterface.getNode().getWorld().isRemote;
}
}, 0, 116, 32, SlotFilter.FILTER_ALLOW_SIZE, (slot, amount) -> {
if (amount > 0 && amount <= NetworkNodeFluidInterface.TANK_CAPACITY) {
fluidInterface.getNode().getOut().getStackInSlot(0).setCount(amount);
}
}, NetworkNodeFluidInterface.TANK_CAPACITY));
addSlotToContainer(new SlotFilterFluid(fluidInterface.getNode().getOut(), 0, 116, 32, SlotFilter.FILTER_ALLOW_SIZE));
addPlayerInventory(8, 122);
}
@@ -58,12 +31,12 @@ public class ContainerFluidInterface extends ContainerBase {
if (slot.getHasStack()) {
stack = slot.getStack();
if (index < 4 + 2) {
if (!mergeItemStack(stack, 4 + 2, inventorySlots.size(), false)) {
if (index < 4 + 1 + 1) {
if (!mergeItemStack(stack, 4 + 1 + 1, inventorySlots.size(), false)) {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 4 + 1, false)) {
return mergeItemStackToFilters(stack, 5, 6);
return transferToFluidFilters(stack);
}
if (stack.getCount() == 0) {

8
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidStorage.java
View File

@@ -1,6 +1,6 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileFluidStorage;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
@@ -11,7 +11,7 @@ public class ContainerFluidStorage extends ContainerBase {
super(fluidStorage, player);
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(!fluidStorage.getWorld().isRemote, fluidStorage.getNode().getFilters(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilterFluid(fluidStorage.getNode().getFilters(), i, 8 + (18 * i), 20));
}
addPlayerInventory(8, 141);
@@ -21,8 +21,8 @@ public class ContainerFluidStorage extends ContainerBase {
public ItemStack transferStackInSlot(EntityPlayer player, int index) {
Slot slot = getSlot(index);
if (slot.getHasStack() && index >= 8) {
return mergeItemStackToFilters(slot.getStack(), 0, 9);
if (slot.getHasStack() && index > 8) {
return transferToFluidFilters(slot.getStack());
}
return ItemStack.EMPTY;

25
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java
View File

@@ -10,9 +10,16 @@ import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskFactory;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid;
import com.raoulvdberge.refinedstorage.container.slot.*;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.container.slot.grid.SlotGridCrafting;
import com.raoulvdberge.refinedstorage.container.slot.grid.SlotGridCraftingResult;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyBase;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyDisabled;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
import com.raoulvdberge.refinedstorage.gui.IResizableDisplay;
import com.raoulvdberge.refinedstorage.tile.TileBase;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import com.raoulvdberge.refinedstorage.tile.grid.WirelessGrid;
import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
import com.raoulvdberge.refinedstorage.tile.grid.portable.PortableGrid;
@@ -21,7 +28,6 @@ import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.IContainerListener;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.items.SlotItemHandler;
import javax.annotation.Nullable;
@@ -33,7 +39,7 @@ public class ContainerGrid extends ContainerBase {
private IResizableDisplay display;
private SlotGridCraftingResult craftingResultSlot;
private SlotDisabled patternResultSlot;
private SlotLegacyBase patternResultSlot;
public ContainerGrid(IGrid grid, IResizableDisplay display, @Nullable TileBase gridTile, EntityPlayer player) {
super(gridTile, player);
@@ -96,11 +102,8 @@ public class ContainerGrid extends ContainerBase {
int y = headerAndSlots + 4;
for (int i = 0; i < 9 * 2; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid((NetworkNodeGrid) grid, i, x, y, SlotFilter.FILTER_ALLOW_SIZE, (slot, amount) -> {
if (amount > 0 && amount <= Fluid.BUCKET_VOLUME && slot < ((NetworkNodeGrid) grid).getMatrixProcessingFluids().getSlots()) {
((NetworkNodeGrid) grid).getMatrixProcessingFluids().getStackInSlot(slot).setCount(amount);
}
}, Fluid.BUCKET_VOLUME, () -> ((NetworkNodeGrid) grid).isProcessingPattern()));
addSlotToContainer(new SlotFilter(((NetworkNodeGrid) grid).getProcessingMatrix(), i, x, y, SlotFilter.FILTER_ALLOW_SIZE).setEnableHandler(() -> ((NetworkNodeGrid) grid).isProcessingPattern() && ((NetworkNodeGrid) grid).getType() == IType.ITEMS));
addSlotToContainer(new SlotFilterFluid(((NetworkNodeGrid) grid).getProcessingMatrixFluids(), i, x, y, SlotFilter.FILTER_ALLOW_SIZE).setEnableHandler(() -> ((NetworkNodeGrid) grid).isProcessingPattern() && ((NetworkNodeGrid) grid).getType() == IType.FLUIDS));
x += 18;
@@ -121,7 +124,7 @@ public class ContainerGrid extends ContainerBase {
y = headerAndSlots + 4;
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterLegacy(grid.getCraftingMatrix(), i, x, y, () -> !((NetworkNodeGrid) grid).isProcessingPattern()));
addSlotToContainer(new SlotLegacyFilter(grid.getCraftingMatrix(), i, x, y).setEnableHandler(() -> !((NetworkNodeGrid) grid).isProcessingPattern()));
x += 18;
@@ -131,7 +134,7 @@ public class ContainerGrid extends ContainerBase {
}
}
addSlotToContainer(patternResultSlot = new SlotDisabled(grid.getCraftingResult(), 0, 134, headerAndSlots + 22, () -> !((NetworkNodeGrid) grid).isProcessingPattern()));
addSlotToContainer(patternResultSlot = (new SlotLegacyDisabled(grid.getCraftingResult(), 0, 134, headerAndSlots + 22).setEnableHandler(() -> !((NetworkNodeGrid) grid).isProcessingPattern())));
}
}
@@ -223,7 +226,7 @@ public class ContainerGrid extends ContainerBase {
sendCraftingSlots();
detectAndSendChanges();
} else if (slot != patternResultSlot && !(slot instanceof SlotFilterLegacy)) {
} else if (slot != patternResultSlot && !(slot instanceof SlotLegacyFilter)) {
ItemStack stack = slot.getStack();
if (grid.getGridType() != GridType.FLUID && stack.getItem() == RSItems.FILTER) {

23
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerImporter.java
View File

@@ -1,22 +1,33 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeImporter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.tile.TileImporter;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.SlotItemHandler;
public class ContainerImporter extends ContainerBase {
private NetworkNodeImporter importer;
public ContainerImporter(TileImporter importer, EntityPlayer player) {
super(importer, player);
this.importer = importer.getNode();
for (int i = 0; i < 4; ++i) {
addSlotToContainer(new SlotItemHandler(importer.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterItemOrFluid(importer.getNode(), i, 8 + (18 * i), 20));
addSlotToContainer(new SlotFilter(importer.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> importer.getNode().getType() == IType.ITEMS));
}
for (int i = 0; i < 9; ++i) {
addSlotToContainer(new SlotFilterFluid(importer.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> importer.getNode().getType() == IType.FLUIDS));
}
addPlayerInventory(8, 55);
@@ -32,11 +43,15 @@ public class ContainerImporter extends ContainerBase {
stack = slot.getStack();
if (index < 4) {
if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) {
if (!mergeItemStack(stack, 4 + 9 + 9, inventorySlots.size(), false)) {
return ItemStack.EMPTY;
}
} else if (!mergeItemStack(stack, 0, 4, false)) {
return mergeItemStackToFilters(stack, 4, 4 + 9);
if (importer.getType() == IType.ITEMS) {
return transferToFilters(stack, 4, 4 + 9);
} else {
return transferToFluidFilters(stack);
}
}
if (stack.getCount() == 0) {

2
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerInterface.java
View File

@@ -1,7 +1,7 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.SlotOutput;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.tile.TileInterface;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;

6
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorage.java
View File

@@ -1,6 +1,6 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.tile.TileStorage;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
@@ -21,8 +21,8 @@ public class ContainerStorage extends ContainerBase {
public ItemStack transferStackInSlot(EntityPlayer player, int index) {
Slot slot = getSlot(index);
if (slot.getHasStack() && index >= 8) {
return mergeItemStackToFilters(slot.getStack(), 0, 9);
if (slot.getHasStack() && index > 8) {
return transferToFilters(slot.getStack(), 0, 9);
}
return ItemStack.EMPTY;

6
src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorageMonitor.java
View File

@@ -1,6 +1,6 @@
package com.raoulvdberge.refinedstorage.container;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
@@ -10,7 +10,7 @@ public class ContainerStorageMonitor extends ContainerBase {
public ContainerStorageMonitor(TileStorageMonitor storageMonitor, EntityPlayer player) {
super(storageMonitor, player);
addSlotToContainer(new SlotFilterItemOrFluid(storageMonitor.getNode(), 0, 80, 20));
addSlotToContainer(new SlotFilter(storageMonitor.getNode().getItemFilters(), 0, 80, 20));
addPlayerInventory(8, 55);
}
@@ -22,7 +22,7 @@ public class ContainerStorageMonitor extends ContainerBase {
ItemStack stack = slot.getStack();
if (index > 0 && slot.getHasStack()) {
return mergeItemStackToFilters(stack, 0, 1);
return transferToFilters(stack, 0, 1);
}
return stack;

25
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotBase.java Normal file
View File

@@ -0,0 +1,25 @@
package com.raoulvdberge.refinedstorage.container.slot;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;
import java.util.function.Supplier;
public class SlotBase extends SlotItemHandler {
private Supplier<Boolean> enableHandler = () -> true;
public SlotBase(IItemHandler itemHandler, int inventoryIndex, int x, int y) {
super(itemHandler, inventoryIndex, x, y);
}
public SlotBase setEnableHandler(Supplier<Boolean> enableHandler) {
this.enableHandler = enableHandler;
return this;
}
@Override
public boolean isEnabled() {
return enableHandler.get();
}
}

7
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotCrafterManager.java
View File

@@ -3,15 +3,14 @@ package com.raoulvdberge.refinedstorage.container.slot;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCrafterManager;
import com.raoulvdberge.refinedstorage.gui.IResizableDisplay;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;
public class SlotCrafterManager extends SlotItemHandler {
public class SlotCrafterManager extends SlotBase {
private boolean visible;
private NetworkNodeCrafterManager crafterManager;
private IResizableDisplay display;
public SlotCrafterManager(IItemHandler itemHandler, int index, int xPosition, int yPosition, boolean visible, IResizableDisplay display, NetworkNodeCrafterManager crafterManager) {
super(itemHandler, index, xPosition, yPosition);
public SlotCrafterManager(IItemHandler itemHandler, int inventoryIndex, int x, int y, boolean visible, IResizableDisplay display, NetworkNodeCrafterManager crafterManager) {
super(itemHandler, inventoryIndex, x, y);
this.visible = visible;
this.display = display;

23
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotDisabled.java
View File

@@ -1,32 +1,17 @@
package com.raoulvdberge.refinedstorage.container.slot;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandler;
import javax.annotation.Nonnull;
import java.util.function.Supplier;
public class SlotDisabled extends Slot {
private Supplier<Boolean> enableHandler = () -> true;
public SlotDisabled(IInventory inventory, int id, int x, int y) {
super(inventory, id, x, y);
}
public SlotDisabled(IInventory inventory, int id, int x, int y, Supplier<Boolean> enableHandler) {
this(inventory, id, x, y);
this.enableHandler = enableHandler;
public class SlotDisabled extends SlotBase {
public SlotDisabled(IItemHandler itemHandler, int inventoryIndex, int x, int y) {
super(itemHandler, inventoryIndex, x, y);
}
@Override
public boolean isItemValid(@Nonnull ItemStack stack) {
return false;
}
@Override
public boolean isEnabled() {
return enableHandler.get();
}
}

26
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilterFluid.java
View File

@@ -1,26 +0,0 @@
package com.raoulvdberge.refinedstorage.container.slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandler;
import javax.annotation.Nonnull;
public class SlotFilterFluid extends SlotFilter {
private boolean server;
public SlotFilterFluid(boolean server, IItemHandler handler, int id, int x, int y) {
super(handler, id, x, y);
this.server = server;
}
@Override
@Nonnull
public ItemStack getStack() {
return server ? super.getStack() : ItemStack.EMPTY;
}
public ItemStack getActualStack() {
return super.getStack();
}
}

89
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilterItemOrFluid.java
View File

@@ -1,89 +0,0 @@
package com.raoulvdberge.refinedstorage.container.slot;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.items.IItemHandler;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.function.Supplier;
public class SlotFilterItemOrFluid extends SlotFilter {
public interface IFluidAmountChangeListener {
void onChangeRequested(int slot, int amount);
}
private IType type;
@Nullable
private IFluidAmountChangeListener listener;
private int maxFluidAmount;
private Supplier<Boolean> enableHandler = () -> true;
public SlotFilterItemOrFluid(IType type, int id, int x, int y, int flags, @Nullable IFluidAmountChangeListener listener, int maxFluidAmount) {
super(null, id, x, y, flags);
this.type = type;
this.listener = listener;
this.maxFluidAmount = maxFluidAmount;
}
public SlotFilterItemOrFluid(IType type, int id, int x, int y, int flags, @Nullable IFluidAmountChangeListener listener, int maxFluidAmount, Supplier<Boolean> enableHandler) {
this(type, id, x, y, flags, listener, maxFluidAmount);
this.enableHandler = enableHandler;
}
public SlotFilterItemOrFluid(IType type, int id, int x, int y) {
this(type, id, x, y, 0, null, 0);
}
@Override
public IItemHandler getItemHandler() {
return type.getFilterInventory();
}
@Override
public boolean isBlockAllowed() {
return super.isBlockAllowed() && type.getType() == IType.ITEMS;
}
@Override
@Nonnull
public ItemStack getStack() {
return (type.getType() == IType.ITEMS || type.isServer()) ? super.getStack() : ItemStack.EMPTY;
}
public ItemStack getActualStack() {
return super.getStack();
}
public IType getType() {
return type;
}
@Override
public int getInitialAmount(ItemStack stack) {
if (type.getType() == IType.FLUIDS && isSizeAllowed()) {
return Fluid.BUCKET_VOLUME;
}
return super.getInitialAmount(stack);
}
@Nullable
public IFluidAmountChangeListener getFluidAmountChangeListener() {
return listener;
}
public int getMaxFluidAmount() {
return maxFluidAmount;
}
@Override
public boolean isEnabled() {
return enableHandler.get();
}
}

48
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilterLegacy.java
View File

@@ -1,48 +0,0 @@
package com.raoulvdberge.refinedstorage.container.slot;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import javax.annotation.Nonnull;
import java.util.function.Supplier;
public class SlotFilterLegacy extends Slot {
private Supplier<Boolean> enableHandler = () -> true;
public SlotFilterLegacy(IInventory inventory, int id, int x, int y) {
super(inventory, id, x, y);
}
public SlotFilterLegacy(IInventory inventory, int id, int x, int y, Supplier<Boolean> enableHandler) {
this(inventory, id, x, y);
this.enableHandler = enableHandler;
}
@Override
public boolean canTakeStack(EntityPlayer player) {
return false;
}
@Override
public boolean isItemValid(ItemStack stack) {
return true;
}
@Override
public void putStack(@Nonnull ItemStack stack) {
if (!stack.isEmpty()) {
stack.setCount(1);
}
super.putStack(stack);
}
@Override
public boolean isEnabled() {
return enableHandler.get();
}
}

10
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCrafting.java
View File

@@ -1,10 +0,0 @@
package com.raoulvdberge.refinedstorage.container.slot;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
public class SlotGridCrafting extends Slot {
public SlotGridCrafting(IInventory inventory, int index, int x, int y) {
super(inventory, index, x, y);
}
}

7
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotOutput.java
View File

@@ -2,13 +2,12 @@ package com.raoulvdberge.refinedstorage.container.slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;
import javax.annotation.Nonnull;
public class SlotOutput extends SlotItemHandler {
public SlotOutput(IItemHandler inventory, int id, int x, int y) {
super(inventory, id, x, y);
public class SlotOutput extends SlotBase {
public SlotOutput(IItemHandler inventory, int inventoryIndex, int x, int y) {
super(inventory, inventoryIndex, x, y);
}
@Override

18
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilter.java → src/main/java/com/raoulvdberge/refinedstorage/container/slot/filter/SlotFilter.java Executable file → Normal file
View File

@@ -1,5 +1,6 @@
package com.raoulvdberge.refinedstorage.container.slot;
package com.raoulvdberge.refinedstorage.container.slot.filter;
import com.raoulvdberge.refinedstorage.container.slot.SlotBase;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.item.*;
@@ -7,25 +8,24 @@ import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.IPlantable;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class SlotFilter extends SlotItemHandler {
public class SlotFilter extends SlotBase {
public static final int FILTER_ALLOW_SIZE = 1;
public static final int FILTER_ALLOW_BLOCKS = 2;
private int flags = 0;
public SlotFilter(IItemHandler handler, int id, int x, int y, int flags) {
super(handler, id, x, y);
public SlotFilter(IItemHandler handler, int inventoryIndex, int x, int y, int flags) {
super(handler, inventoryIndex, x, y);
this.flags = flags;
}
public SlotFilter(IItemHandler handler, int id, int x, int y) {
this(handler, id, x, y, 0);
public SlotFilter(IItemHandler handler, int inventoryIndex, int x, int y) {
this(handler, inventoryIndex, x, y, 0);
}
@Override
@@ -70,10 +70,6 @@ public class SlotFilter extends SlotItemHandler {
return amount;
}
public int getInitialAmount(ItemStack stack) {
return stack.getCount();
}
@Nullable
public static IBlockState getBlockState(IBlockAccess world, BlockPos pos, @Nullable ItemStack stack) {
if (stack != null) {

53
src/main/java/com/raoulvdberge/refinedstorage/container/slot/filter/SlotFilterFluid.java Normal file
View File

@@ -0,0 +1,53 @@
package com.raoulvdberge.refinedstorage.container.slot.filter;
import com.raoulvdberge.refinedstorage.container.slot.SlotBase;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.ItemStackHandler;
import javax.annotation.Nonnull;
public class SlotFilterFluid extends SlotBase {
public static final int FILTER_ALLOW_SIZE = 1;
private int flags;
private FluidInventory fluidInventory;
public SlotFilterFluid(FluidInventory inventory, int inventoryIndex, int x, int y, int flags) {
super(new ItemStackHandler(inventory.getSlots()), inventoryIndex, x, y);
this.flags = flags;
this.fluidInventory = inventory;
}
public SlotFilterFluid(FluidInventory inventory, int inventoryIndex, int x, int y) {
this(inventory, inventoryIndex, x, y, 0);
}
@Override
public boolean isItemValid(@Nonnull ItemStack stack) {
return false;
}
public void onContainerClicked(@Nonnull ItemStack stack) {
if (stack.isEmpty()) {
fluidInventory.setFluid(getSlotIndex(), null);
} else {
FluidStack fluid = StackUtils.getFluid(stack, true).getValue();
if (fluid != null) {
fluidInventory.setFluid(getSlotIndex(), fluid);
}
}
}
public boolean isSizeAllowed() {
return (flags & FILTER_ALLOW_SIZE) == FILTER_ALLOW_SIZE;
}
public FluidInventory getFluidInventory() {
return fluidInventory;
}
}

21
src/main/java/com/raoulvdberge/refinedstorage/container/slot/filter/SlotFilterFluidDisabled.java Normal file
View File

@@ -0,0 +1,21 @@
package com.raoulvdberge.refinedstorage.container.slot.filter;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import net.minecraft.item.ItemStack;
import javax.annotation.Nonnull;
public class SlotFilterFluidDisabled extends SlotFilterFluid {
public SlotFilterFluidDisabled(FluidInventory inventory, int inventoryIndex, int x, int y, int flags) {
super(inventory, inventoryIndex, x, y, flags);
}
public SlotFilterFluidDisabled(FluidInventory inventory, int inventoryIndex, int x, int y) {
super(inventory, inventoryIndex, x, y);
}
@Override
public void onContainerClicked(@Nonnull ItemStack stack) {
// NO OP
}
}

10
src/main/java/com/raoulvdberge/refinedstorage/container/slot/grid/SlotGridCrafting.java Normal file
View File

@@ -0,0 +1,10 @@
package com.raoulvdberge.refinedstorage.container.slot.grid;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
public class SlotGridCrafting extends Slot {
public SlotGridCrafting(IInventory inventory, int inventoryIndex, int x, int y) {
super(inventory, inventoryIndex, x, y);
}
}

6
src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCraftingResult.java → src/main/java/com/raoulvdberge/refinedstorage/container/slot/grid/SlotGridCraftingResult.java Executable file → Normal file
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.container.slot;
package com.raoulvdberge.refinedstorage.container.slot.grid;
import com.raoulvdberge.refinedstorage.api.network.grid.IGrid;
import com.raoulvdberge.refinedstorage.container.ContainerGrid;
@@ -12,8 +12,8 @@ public class SlotGridCraftingResult extends SlotCrafting {
private ContainerGrid container;
private IGrid grid;
public SlotGridCraftingResult(ContainerGrid container, EntityPlayer player, IGrid grid, int id, int x, int y) {
super(player, grid.getCraftingMatrix(), grid.getCraftingResult(), id, x, y);
public SlotGridCraftingResult(ContainerGrid container, EntityPlayer player, IGrid grid, int inventoryIndex, int x, int y) {
super(player, grid.getCraftingMatrix(), grid.getCraftingResult(), inventoryIndex, x, y);
this.container = container;
this.grid = grid;

26
src/main/java/com/raoulvdberge/refinedstorage/container/slot/legacy/SlotLegacyBase.java Normal file
View File

@@ -0,0 +1,26 @@
package com.raoulvdberge.refinedstorage.container.slot.legacy;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import java.util.function.Supplier;
public class SlotLegacyBase extends Slot {
private Supplier<Boolean> enableHandler = () -> true;
public SlotLegacyBase(IInventory inventory, int inventoryIndex, int x, int y) {
super(inventory, inventoryIndex, x, y);
}
public SlotLegacyBase setEnableHandler(Supplier<Boolean> enableHandler) {
this.enableHandler = enableHandler;
return this;
}
@Override
public boolean isEnabled() {
return enableHandler.get();
}
}

17
src/main/java/com/raoulvdberge/refinedstorage/container/slot/legacy/SlotLegacyDisabled.java Normal file
View File

@@ -0,0 +1,17 @@
package com.raoulvdberge.refinedstorage.container.slot.legacy;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import javax.annotation.Nonnull;
public class SlotLegacyDisabled extends SlotLegacyBase {
public SlotLegacyDisabled(IInventory inventory, int inventoryIndex, int x, int y) {
super(inventory, inventoryIndex, x, y);
}
@Override
public boolean isItemValid(@Nonnull ItemStack stack) {
return false;
}
}

33
src/main/java/com/raoulvdberge/refinedstorage/container/slot/legacy/SlotLegacyFilter.java Normal file
View File

@@ -0,0 +1,33 @@
package com.raoulvdberge.refinedstorage.container.slot.legacy;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import javax.annotation.Nonnull;
public class SlotLegacyFilter extends SlotLegacyBase {
public SlotLegacyFilter(IInventory inventory, int inventoryIndex, int x, int y) {
super(inventory, inventoryIndex, x, y);
}
@Override
public boolean canTakeStack(EntityPlayer player) {
return false;
}
@Override
public boolean isItemValid(ItemStack stack) {
return true;
}
@Override
public void putStack(@Nonnull ItemStack stack) {
if (!stack.isEmpty()) {
stack.setCount(1);
}
super.putStack(stack);
}
}

58
src/main/java/com/raoulvdberge/refinedstorage/gui/GuiBase.java
View File

@@ -4,26 +4,27 @@ import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.render.IElementDrawer;
import com.raoulvdberge.refinedstorage.api.render.IElementDrawers;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.gui.control.Scrollbar;
import com.raoulvdberge.refinedstorage.gui.control.SideButton;
import com.raoulvdberge.refinedstorage.integration.jei.IntegrationJEI;
import com.raoulvdberge.refinedstorage.integration.jei.RecipeTransferHandlerGrid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.util.RenderUtils;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.resources.I18n;
import net.minecraft.inventory.ClickType;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.client.FMLClientHandler;
import net.minecraftforge.fml.client.config.GuiCheckBox;
import net.minecraftforge.fml.client.config.GuiUtils;
import net.minecraftforge.items.SlotItemHandler;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
@@ -87,6 +88,16 @@ public abstract class GuiBase extends GuiContainer {
private void runRunnables() {
Queue<Consumer> queue = RUNNABLES.get(getClass());
if (queue != null && !queue.isEmpty()) {
Consumer callback;
while ((callback = queue.poll()) != null) {
callback.accept(this);
}
}
queue = RUNNABLES.get(GuiContainer.class);
if (queue != null && !queue.isEmpty()) {
Consumer callback;
while ((callback = queue.poll()) != null) {
@@ -184,23 +195,19 @@ public abstract class GuiBase extends GuiContainer {
for (int i = 0; i < inventorySlots.inventorySlots.size(); ++i) {
Slot slot = inventorySlots.inventorySlots.get(i);
if (slot instanceof SlotItemHandler && ((SlotItemHandler) slot).getItemHandler() instanceof ItemHandlerFluid) {
FluidStack stack = ((ItemHandlerFluid) ((SlotItemHandler) slot).getItemHandler()).getFluidStackInSlot(slot.getSlotIndex());
if (slot.isEnabled() && slot instanceof SlotFilterFluid) {
FluidStack stack = ((SlotFilterFluid) slot).getFluidInventory().getFluid(slot.getSlotIndex());
if (stack != null) {
FLUID_RENDERER.draw(mc, guiLeft + slot.xPos, guiTop + slot.yPos, stack);
if (slot instanceof SlotFilterItemOrFluid) {
int count = ((SlotFilterItemOrFluid) slot).getActualStack().getCount();
if (((SlotFilterFluid) slot).isSizeAllowed()) {
drawQuantity(guiLeft + slot.xPos, guiTop + slot.yPos, API.instance().getQuantityFormatter().formatInBucketForm(stack.amount));
if (count != 1) {
drawQuantity(guiLeft + slot.xPos, guiTop + slot.yPos, API.instance().getQuantityFormatter().formatInBucketForm(count));
GL11.glDisable(GL11.GL_LIGHTING);
}
GL11.glDisable(GL11.GL_LIGHTING);
}
if (inBounds(guiLeft + slot.xPos, guiTop + slot.yPos, 18, 18, mouseX, mouseY)) {
if (inBounds(guiLeft + slot.xPos, guiTop + slot.yPos, 17, 17, mouseX, mouseY)) {
this.hoveringFluid = stack.getLocalizedName();
}
}
@@ -238,6 +245,27 @@ public abstract class GuiBase extends GuiContainer {
}
}
@Override
protected void handleMouseClick(Slot slot, int slotId, int mouseButton, ClickType type) {
if (slot instanceof SlotFilterFluid && slot.isEnabled() && ((SlotFilterFluid) slot).isSizeAllowed() && type != ClickType.QUICK_MOVE && Minecraft.getMinecraft().player.inventory.getItemStack().isEmpty()) {
FluidStack stack = ((SlotFilterFluid) slot).getFluidInventory().getFluid(slot.getSlotIndex());
if (stack != null) {
FMLClientHandler.instance().showGuiScreen(new GuiFluidAmount(
(GuiBase) Minecraft.getMinecraft().currentScreen,
Minecraft.getMinecraft().player,
slot.slotNumber,
stack,
((SlotFilterFluid) slot).getFluidInventory().getMaxAmount()
));
} else {
super.handleMouseClick(slot, slotId, mouseButton, type);
}
} else {
super.handleMouseClick(slot, slotId, mouseButton, type);
}
}
@Override
public void handleMouseInput() throws IOException {
super.handleMouseInput();
@@ -432,4 +460,8 @@ public abstract class GuiBase extends GuiContainer {
queue.add(callback);
}
public static void executeLater(Consumer<GuiContainer> callback) {
executeLater(GuiContainer.class, callback);
}
}

16
src/main/java/com/raoulvdberge/refinedstorage/gui/GuiFluidAmount.java
View File

@@ -3,26 +3,26 @@ package com.raoulvdberge.refinedstorage.gui;
import com.google.common.primitives.Ints;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.container.ContainerFluidAmount;
import com.raoulvdberge.refinedstorage.network.MessageFluidAmount;
import com.raoulvdberge.refinedstorage.network.MessageSlotFilterFluidSetAmount;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
public class GuiFluidAmount extends GuiAmountSpecifying {
private int containerSlot;
private ItemStack fluidContainer;
private FluidStack stack;
private int maxAmount;
public GuiFluidAmount(GuiBase parent, EntityPlayer player, int containerSlot, ItemStack fluidContainer, int maxAmount) {
super(parent, new ContainerFluidAmount(player, fluidContainer), 172, 99);
public GuiFluidAmount(GuiBase parent, EntityPlayer player, int containerSlot, FluidStack stack, int maxAmount) {
super(parent, new ContainerFluidAmount(player, stack), 172, 99);
this.containerSlot = containerSlot;
this.fluidContainer = fluidContainer;
this.stack = stack;
this.maxAmount = maxAmount;
}
@Override
protected int getDefaultAmount() {
return fluidContainer.getCount();
return stack.amount;
}
@Override
@@ -63,7 +63,7 @@ public class GuiFluidAmount extends GuiAmountSpecifying {
Integer amount = Ints.tryParse(amountField.getText());
if (amount != null) {
RS.INSTANCE.network.sendToServer(new MessageFluidAmount(containerSlot, amount));
RS.INSTANCE.network.sendToServer(new MessageSlotFilterFluidSetAmount(containerSlot, amount));
close();
}

3
src/main/java/com/raoulvdberge/refinedstorage/gui/GuiStorageMonitor.java
View File

@@ -3,7 +3,6 @@ package com.raoulvdberge.refinedstorage.gui;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.container.ContainerStorageMonitor;
import com.raoulvdberge.refinedstorage.gui.control.SideButtonCompare;
import com.raoulvdberge.refinedstorage.gui.control.SideButtonType;
import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
public class GuiStorageMonitor extends GuiBase {
@@ -13,8 +12,6 @@ public class GuiStorageMonitor extends GuiBase {
@Override
public void init(int x, int y) {
addSideButton(new SideButtonType(this, TileStorageMonitor.TYPE));
addSideButton(new SideButtonCompare(this, TileStorageMonitor.COMPARE, IComparer.COMPARE_DAMAGE));
addSideButton(new SideButtonCompare(this, TileStorageMonitor.COMPARE, IComparer.COMPARE_NBT));
}

2
src/main/java/com/raoulvdberge/refinedstorage/integration/craftingtweaks/IntegrationCraftingTweaks.java
View File

@@ -4,7 +4,7 @@ import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.raoulvdberge.refinedstorage.api.network.grid.GridType;
import com.raoulvdberge.refinedstorage.container.ContainerGrid;
import com.raoulvdberge.refinedstorage.container.slot.SlotGridCrafting;
import com.raoulvdberge.refinedstorage.container.slot.grid.SlotGridCrafting;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.Loader;
import net.minecraftforge.fml.common.event.FMLInterModComms;

37
src/main/java/com/raoulvdberge/refinedstorage/integration/jei/GhostIngredientHandler.java
View File

@@ -1,22 +1,18 @@
package com.raoulvdberge.refinedstorage.integration.jei;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterLegacy;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.network.MessageFilterSlot;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import com.raoulvdberge.refinedstorage.network.MessageSlotFilterSet;
import com.raoulvdberge.refinedstorage.network.MessageSlotFilterSetFluid;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import mezz.jei.api.gui.IGhostIngredientHandler;
import net.minecraft.init.Items;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
import net.minecraftforge.fluids.capability.IFluidHandlerItem;
import java.awt.*;
import java.util.ArrayList;
@@ -35,11 +31,7 @@ public class GhostIngredientHandler implements IGhostIngredientHandler<GuiBase>
Rectangle bounds = new Rectangle(gui.getGuiLeft() + slot.xPos, gui.getGuiTop() + slot.yPos, 17, 17);
if (ingredient instanceof ItemStack) {
if (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getType().getType() == IType.FLUIDS) {
continue;
}
if (slot instanceof SlotFilterLegacy || (slot instanceof SlotFilter && !(slot instanceof SlotFilterFluid))) {
if (slot instanceof SlotLegacyFilter || slot instanceof SlotFilter) {
targets.add(new Target<I>() {
@Override
public Rectangle getArea() {
@@ -50,12 +42,12 @@ public class GhostIngredientHandler implements IGhostIngredientHandler<GuiBase>
public void accept(I ingredient) {
slot.putStack((ItemStack) ingredient);
RS.INSTANCE.network.sendToServer(new MessageFilterSlot(slot.slotNumber, (ItemStack) ingredient));
RS.INSTANCE.network.sendToServer(new MessageSlotFilterSet(slot.slotNumber, (ItemStack) ingredient));
}
});
}
} else if (ingredient instanceof FluidStack) {
if (slot instanceof SlotFilterFluid || (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getType().getType() == IType.FLUIDS)) {
if (slot instanceof SlotFilterFluid) {
targets.add(new Target<I>() {
@Override
public Rectangle getArea() {
@@ -64,18 +56,7 @@ public class GhostIngredientHandler implements IGhostIngredientHandler<GuiBase>
@Override
public void accept(I ingredient) {
ItemStack filledContainer = new ItemStack(Items.BUCKET);
IFluidHandlerItem fluidHandler = filledContainer.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
fluidHandler.fill(StackUtils.copy((FluidStack) ingredient, Fluid.BUCKET_VOLUME), true);
filledContainer = fluidHandler.getContainer();
filledContainer.setCount(((FluidStack) ingredient).amount);
slot.putStack(filledContainer);
RS.INSTANCE.network.sendToServer(new MessageFilterSlot(slot.slotNumber, filledContainer));
RS.INSTANCE.network.sendToServer(new MessageSlotFilterSetFluid(slot.slotNumber, StackUtils.copy((FluidStack) ingredient, Fluid.BUCKET_VOLUME)));
}
});
}

3
src/main/java/com/raoulvdberge/refinedstorage/integration/jei/RSJEIPlugin.java
View File

@@ -22,7 +22,8 @@ public class RSJEIPlugin implements IModPlugin {
registry.addRecipeRegistryPlugin(new RecipeRegistryPluginCover());
registry.addRecipeRegistryPlugin(new RecipeRegistryPluginHollowCover());
// TODO: #1905 registry.addGhostIngredientHandler(GuiBase.class, new GhostIngredientHandler());
// TODO: #1905
// registry.addGhostIngredientHandler(GuiBase.class, new GhostIngredientHandler());
}
@Override

45
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFluid.java
View File

@@ -1,45 +0,0 @@
package com.raoulvdberge.refinedstorage.inventory;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.ItemHandlerHelper;
import javax.annotation.Nullable;
import java.util.function.Consumer;
public class ItemHandlerFluid extends ItemHandlerBase {
private FluidStack[] fluids;
public ItemHandlerFluid(int size, @Nullable Consumer<Integer> listener) {
super(size, listener, s -> StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(s, 1), true).getValue() != null);
this.fluids = new FluidStack[size];
}
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
ItemStack stack = getStackInSlot(slot);
if (stack.isEmpty()) {
setFluidStack(slot, null);
} else {
setFluidStack(slot, StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(stack, 1), true).getValue());
}
}
public void setFluidStack(int slot, @Nullable FluidStack stack) {
fluids[slot] = stack;
}
@Nullable
public FluidStack getFluidStackInSlot(int slot) {
return fluids[slot];
}
public FluidStack[] getFluids() {
return fluids;
}
}

2
src/main/java/com/raoulvdberge/refinedstorage/inventory/FluidHandlerFluidInterface.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/fluid/FluidHandlerFluidInterface.java
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;

84
src/main/java/com/raoulvdberge/refinedstorage/inventory/fluid/FluidInventory.java Normal file
View File

@@ -0,0 +1,84 @@
package com.raoulvdberge.refinedstorage.inventory.fluid;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.FluidStack;
import javax.annotation.Nullable;
import java.util.function.Consumer;
public class FluidInventory {
private static final String NBT_SLOT = "Slot_%d";
private FluidStack[] fluids;
private int maxAmount;
@Nullable
private Consumer<Integer> listener;
public FluidInventory(int size, int maxAmount, @Nullable Consumer<Integer> listener) {
this.fluids = new FluidStack[size];
this.maxAmount = maxAmount;
this.listener = listener;
}
public FluidInventory(int size, @Nullable Consumer<Integer> listener) {
this(size, Integer.MAX_VALUE, listener);
}
public FluidInventory(int size) {
this(size, Integer.MAX_VALUE, null);
}
public int getSlots() {
return fluids.length;
}
public int getMaxAmount() {
return maxAmount;
}
public FluidStack[] getFluids() {
return fluids;
}
@Nullable
public FluidStack getFluid(int slot) {
return fluids[slot];
}
public void setFluid(int slot, @Nullable FluidStack stack) {
if (stack != null && stack.amount <= 0 && stack.amount > maxAmount) {
throw new IllegalArgumentException("Fluid size is invalid (given: " + stack.amount + ", max size: " + maxAmount + ")");
}
fluids[slot] = stack;
if (listener != null) {
listener.accept(slot);
}
}
public NBTTagCompound writeToNbt() {
NBTTagCompound tag = new NBTTagCompound();
for (int i = 0; i < getSlots(); ++i) {
FluidStack stack = getFluid(i);
if (stack != null) {
tag.setTag(String.format(NBT_SLOT, i), stack.writeToNBT(new NBTTagCompound()));
}
}
return tag;
}
public void readFromNbt(NBTTagCompound tag) {
for (int i = 0; i < getSlots(); ++i) {
String key = String.format(NBT_SLOT, i);
if (tag.hasKey(key)) {
fluids[i] = FluidStack.loadFluidStackFromNBT(tag.getCompoundTag(key));
}
}
}
}

2
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerBase.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerBase.java
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.ItemStackHandler;

3
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFilter.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerFilter.java
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item;
import com.raoulvdberge.refinedstorage.RSItems;
import com.raoulvdberge.refinedstorage.api.network.grid.IGridTab;
@@ -7,6 +7,7 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.grid.GridTab;
import com.raoulvdberge.refinedstorage.apiimpl.util.Filter;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.item.ItemFilter;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.common.FMLCommonHandler;

2
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFilterIcon.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerFilterIcon.java
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item;
import com.raoulvdberge.refinedstorage.item.ItemFilter;
import net.minecraft.item.ItemStack;

2
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFilterItems.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerFilterItems.java
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.item.ItemStack;

2
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerProxy.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerProxy.java
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandler;

3
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerUpgrade.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerUpgrade.java Executable file → Normal file
View File

@@ -1,6 +1,7 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item;
import com.raoulvdberge.refinedstorage.RSItems;
import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
import javax.annotation.Nullable;

2
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemValidatorBasic.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/item/validator/ItemValidatorBasic.java Executable file → Normal file
View File

@@ -1,4 +1,4 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.item.validator;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

6
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerListenerNetworkNode.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/listener/ListenerNetworkNode.java Executable file → Normal file
View File

@@ -1,13 +1,13 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.listener;
import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
import java.util.function.Consumer;
public class ItemHandlerListenerNetworkNode implements Consumer<Integer> {
public class ListenerNetworkNode implements Consumer<Integer> {
private INetworkNode node;
public ItemHandlerListenerNetworkNode(INetworkNode node) {
public ListenerNetworkNode(INetworkNode node) {
this.node = node;
}

6
src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerListenerTile.java → src/main/java/com/raoulvdberge/refinedstorage/inventory/listener/ListenerTile.java Executable file → Normal file
View File

@@ -1,13 +1,13 @@
package com.raoulvdberge.refinedstorage.inventory;
package com.raoulvdberge.refinedstorage.inventory.listener;
import net.minecraft.tileentity.TileEntity;
import java.util.function.Consumer;
public class ItemHandlerListenerTile implements Consumer<Integer> {
public class ListenerTile implements Consumer<Integer> {
private TileEntity tile;
public ItemHandlerListenerTile(TileEntity tile) {
public ListenerTile(TileEntity tile) {
this.tile = tile;
}

2
src/main/java/com/raoulvdberge/refinedstorage/item/ItemFilter.java
View File

@@ -5,7 +5,7 @@ import com.raoulvdberge.refinedstorage.RSGui;
import com.raoulvdberge.refinedstorage.RSItems;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.api.util.IFilter;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilterItems;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilterItems;
import com.raoulvdberge.refinedstorage.item.info.ItemInfo;
import com.raoulvdberge.refinedstorage.render.IModelRegistration;
import com.raoulvdberge.refinedstorage.util.RenderUtils;

7
src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridFluidDelta.java
View File

@@ -13,6 +13,7 @@ import net.minecraftforge.fml.common.network.ByteBufUtils;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import org.apache.commons.lang3.tuple.Pair;
public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageGridFluidDelta, IMessage> {
private INetwork network;
@@ -32,13 +33,15 @@ public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageG
@Override
public void fromBytes(ByteBuf buf) {
gridStack = new GridStackFluid(buf.readInt(), StackUtils.readFluidStack(buf), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), false);
Pair<Integer, FluidStack> hashAndFluidStack = StackUtils.readFluidStackAndHash(buf);
gridStack = new GridStackFluid(hashAndFluidStack.getLeft(), hashAndFluidStack.getRight(), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), false);
delta = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf) {
StackUtils.writeFluidStack(buf, stack);
StackUtils.writeFluidStackAndHash(buf, stack);
IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
buf.writeBoolean(entry != null);

9
src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridFluidUpdate.java
View File

@@ -15,6 +15,7 @@ import net.minecraftforge.fml.common.network.ByteBufUtils;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import org.apache.commons.lang3.tuple.Pair;
import java.util.ArrayList;
import java.util.List;
@@ -39,7 +40,9 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
int items = buf.readInt();
for (int i = 0; i < items; ++i) {
this.stacks.add(new GridStackFluid(buf.readInt(), StackUtils.readFluidStack(buf), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), buf.readBoolean()));
Pair<Integer, FluidStack> hashAndFluidStack = StackUtils.readFluidStackAndHash(buf);
this.stacks.add(new GridStackFluid(hashAndFluidStack.getLeft(), hashAndFluidStack.getRight(), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), buf.readBoolean()));
}
}
@@ -56,7 +59,7 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
buf.writeInt(size);
for (FluidStack stack : network.getFluidStorageCache().getList().getStacks()) {
StackUtils.writeFluidStack(buf, stack);
StackUtils.writeFluidStackAndHash(buf, stack);
IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
buf.writeBoolean(entry != null);
@@ -71,7 +74,7 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
for (ICraftingPattern pattern : network.getCraftingManager().getPatterns()) {
for (FluidStack stack : pattern.getFluidOutputs()) {
StackUtils.writeFluidStack(buf, stack);
StackUtils.writeFluidStackAndHash(buf, stack);
IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
buf.writeBoolean(entry != null);

42
src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridProcessingTransfer.java
View File

@@ -4,17 +4,14 @@ import com.raoulvdberge.refinedstorage.api.network.grid.GridType;
import com.raoulvdberge.refinedstorage.api.network.grid.IGrid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid;
import com.raoulvdberge.refinedstorage.container.ContainerGrid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
import net.minecraftforge.fluids.capability.IFluidHandlerItem;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import java.util.ArrayList;
@@ -60,8 +57,6 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
this.fluidInputs = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
buf.readInt();
this.fluidInputs.add(StackUtils.readFluidStack(buf));
}
@@ -70,8 +65,6 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
this.fluidOutputs = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
buf.readInt();
this.fluidOutputs.add(StackUtils.readFluidStack(buf));
}
}
@@ -110,7 +103,7 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
if (grid.getGridType() == GridType.PATTERN) {
ItemHandlerBase handler = ((NetworkNodeGrid) grid).getProcessingMatrix();
ItemHandlerFluid handlerFluid = ((NetworkNodeGrid) grid).getMatrixProcessingFluids();
FluidInventory handlerFluid = ((NetworkNodeGrid) grid).getProcessingMatrixFluids();
clearInputsAndOutputs(handler);
clearInputsAndOutputs(handlerFluid);
@@ -130,6 +123,12 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
}
}
private void clearInputsAndOutputs(FluidInventory handler) {
for (int i = 0; i < 9 * 2; ++i) {
handler.setFluid(i, null);
}
}
private void setInputs(ItemHandlerBase handler, Collection<ItemStack> stacks) {
setSlots(handler, stacks, 0, 9);
}
@@ -150,30 +149,21 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
}
}
private void setFluidInputs(ItemHandlerBase handler, Collection<FluidStack> stacks) {
setFluidSlots(handler, stacks, 0, 9);
private void setFluidInputs(FluidInventory inventory, Collection<FluidStack> stacks) {
setFluidSlots(inventory, stacks, 0, 9);
}
private void setFluidOutputs(ItemHandlerBase handler, Collection<FluidStack> stacks) {
setFluidSlots(handler, stacks, 9, 18);
private void setFluidOutputs(FluidInventory inventory, Collection<FluidStack> stacks) {
setFluidSlots(inventory, stacks, 9, 18);
}
private void setFluidSlots(ItemHandlerBase handler, Collection<FluidStack> stacks, int begin, int end) {
private void setFluidSlots(FluidInventory inventory, Collection<FluidStack> stacks, int begin, int end) {
for (FluidStack stack : stacks) {
if (!StackUtils.hasFluidBucket(stack) || stack.amount > Fluid.BUCKET_VOLUME) {
if (stack.amount > Fluid.BUCKET_VOLUME) {
continue;
}
ItemStack filledContainer = new ItemStack(Items.BUCKET);
IFluidHandlerItem fluidHandler = filledContainer.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
fluidHandler.fill(StackUtils.copy(stack, Fluid.BUCKET_VOLUME), true);
filledContainer = fluidHandler.getContainer();
filledContainer.setCount(stack.amount);
handler.setStackInSlot(begin, filledContainer);
inventory.setFluid(begin, stack.copy());
begin++;

58
src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterFluidSetAmount.java Normal file
View File

@@ -0,0 +1,58 @@
package com.raoulvdberge.refinedstorage.network;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
public class MessageSlotFilterFluidSetAmount extends MessageHandlerPlayerToServer<MessageSlotFilterFluidSetAmount> implements IMessage {
private int containerSlot;
private int amount;
public MessageSlotFilterFluidSetAmount(int containerSlot, int amount) {
this.containerSlot = containerSlot;
this.amount = amount;
}
public MessageSlotFilterFluidSetAmount() {
// NO OP
}
@Override
protected void handle(MessageSlotFilterFluidSetAmount message, EntityPlayerMP player) {
Container container = player.openContainer;
if (container != null) {
if (message.containerSlot >= 0 && message.containerSlot < container.inventorySlots.size()) {
Slot slot = container.getSlot(message.containerSlot);
if (slot instanceof SlotFilterFluid) {
FluidInventory inventory = ((SlotFilterFluid) slot).getFluidInventory();
FluidStack stack = inventory.getFluid(slot.getSlotIndex());
if (stack != null && message.amount > 0 && message.amount <= inventory.getMaxAmount()) {
inventory.setFluid(slot.getSlotIndex(), StackUtils.copy(stack, message.amount));
}
}
}
}
}
@Override
public void fromBytes(ByteBuf buf) {
containerSlot = buf.readInt();
amount = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf) {
buf.writeInt(containerSlot);
buf.writeInt(amount);
}
}

62
src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterFluidUpdate.java Normal file
View File

@@ -0,0 +1,62 @@
package com.raoulvdberge.refinedstorage.network;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import io.netty.buffer.ByteBuf;
import net.minecraft.inventory.Slot;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
public class MessageSlotFilterFluidUpdate implements IMessage, IMessageHandler<MessageSlotFilterFluidUpdate, IMessage> {
private int containerSlot;
private FluidStack stack;
public MessageSlotFilterFluidUpdate(int containerSlot, FluidStack stack) {
this.containerSlot = containerSlot;
this.stack = stack;
}
public MessageSlotFilterFluidUpdate() {
// NO OP
}
@Override
public void fromBytes(ByteBuf buf) {
containerSlot = buf.readInt();
if (buf.readBoolean()) {
stack = StackUtils.readFluidStack(buf);
}
}
@Override
public void toBytes(ByteBuf buf) {
buf.writeInt(containerSlot);
if (stack == null) {
buf.writeBoolean(false);
} else {
buf.writeBoolean(true);
StackUtils.writeFluidStack(buf, stack);
}
}
@Override
public IMessage onMessage(MessageSlotFilterFluidUpdate message, MessageContext ctx) {
GuiBase.executeLater(gui -> {
if (message.containerSlot >= 0 && message.containerSlot < gui.inventorySlots.inventorySlots.size()) {
Slot slot = gui.inventorySlots.getSlot(message.containerSlot);
if (slot instanceof SlotFilterFluid) {
((SlotFilterFluid) slot).getFluidInventory().setFluid(slot.getSlotIndex(), message.stack);
}
}
});
return null;
}
}

14
src/main/java/com/raoulvdberge/refinedstorage/network/MessageFilterSlot.java → src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterSet.java
View File

@@ -1,7 +1,7 @@
package com.raoulvdberge.refinedstorage.network;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterLegacy;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.Container;
@@ -10,28 +10,28 @@ import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
public class MessageFilterSlot extends MessageHandlerPlayerToServer<MessageFilterSlot> implements IMessage {
public class MessageSlotFilterSet extends MessageHandlerPlayerToServer<MessageSlotFilterSet> implements IMessage {
private int containerSlot;
private ItemStack stack;
public MessageFilterSlot(int containerSlot, ItemStack stack) {
public MessageSlotFilterSet(int containerSlot, ItemStack stack) {
this.containerSlot = containerSlot;
this.stack = stack;
}
public MessageFilterSlot() {
public MessageSlotFilterSet() {
// NO OP
}
@Override
protected void handle(MessageFilterSlot message, EntityPlayerMP player) {
protected void handle(MessageSlotFilterSet message, EntityPlayerMP player) {
Container container = player.openContainer;
if (container != null) {
if (message.containerSlot >= 0 && message.containerSlot < container.inventorySlots.size()) {
Slot slot = container.getSlot(message.containerSlot);
if (slot instanceof SlotFilter || slot instanceof SlotFilterLegacy) {
if (slot instanceof SlotFilter || slot instanceof SlotLegacyFilter) {
slot.putStack(message.stack);
}
}

24
src/main/java/com/raoulvdberge/refinedstorage/network/MessageFluidAmount.java → src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterSetFluid.java
View File

@@ -1,35 +1,37 @@
package com.raoulvdberge.refinedstorage.network;
import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
public class MessageFluidAmount extends MessageHandlerPlayerToServer<MessageFluidAmount> implements IMessage {
public class MessageSlotFilterSetFluid extends MessageHandlerPlayerToServer<MessageSlotFilterSetFluid> implements IMessage {
private int containerSlot;
private int amount;
private FluidStack stack;
public MessageFluidAmount(int containerSlot, int amount) {
public MessageSlotFilterSetFluid(int containerSlot, FluidStack stack) {
this.containerSlot = containerSlot;
this.amount = amount;
this.stack = stack;
}
public MessageFluidAmount() {
public MessageSlotFilterSetFluid() {
// NO OP
}
@Override
protected void handle(MessageFluidAmount message, EntityPlayerMP player) {
protected void handle(MessageSlotFilterSetFluid message, EntityPlayerMP player) {
Container container = player.openContainer;
if (container != null) {
if (message.containerSlot >= 0 && message.containerSlot < container.inventorySlots.size()) {
Slot slot = container.getSlot(message.containerSlot);
if (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getFluidAmountChangeListener() != null) {
((SlotFilterItemOrFluid) slot).getFluidAmountChangeListener().onChangeRequested(slot.getSlotIndex(), message.amount);
if (slot instanceof SlotFilterFluid) {
((SlotFilterFluid) slot).getFluidInventory().setFluid(slot.getSlotIndex(), message.stack);
}
}
}
@@ -38,12 +40,12 @@ public class MessageFluidAmount extends MessageHandlerPlayerToServer<MessageFlui
@Override
public void fromBytes(ByteBuf buf) {
containerSlot = buf.readInt();
amount = buf.readInt();
stack = StackUtils.readFluidStack(buf);
}
@Override
public void toBytes(ByteBuf buf) {
buf.writeInt(containerSlot);
buf.writeInt(amount);
StackUtils.writeFluidStack(buf, stack);
}
}

13
src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java
View File

@@ -95,12 +95,7 @@ public class ProxyCommon {
API.instance().getCraftingTaskRegistry().add(CraftingTaskFactory.ID, new CraftingTaskFactory());
API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementItemRender.ID, buf -> new CraftingMonitorElementItemRender(StackUtils.readItemStack(buf), buf.readInt(), buf.readInt()));
API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementFluidRender.ID, buf -> {
// Consume hash
buf.readInt();
return new CraftingMonitorElementFluidRender(StackUtils.readFluidStack(buf), buf.readInt(), buf.readInt());
});
API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementFluidRender.ID, buf -> new CraftingMonitorElementFluidRender(StackUtils.readFluidStack(buf), buf.readInt(), buf.readInt()));
API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementText.ID, buf -> new CraftingMonitorElementText(ByteBufUtils.readUTF8String(buf), buf.readInt()));
API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementColor.ID, buf -> {
int color = buf.readInt();
@@ -188,8 +183,10 @@ public class ProxyCommon {
RS.INSTANCE.network.registerMessage(MessageStorageDiskSizeRequest.class, MessageStorageDiskSizeRequest.class, id++, Side.SERVER);
RS.INSTANCE.network.registerMessage(MessageStorageDiskSizeResponse.class, MessageStorageDiskSizeResponse.class, id++, Side.CLIENT);
RS.INSTANCE.network.registerMessage(MessageConfigSync.class, MessageConfigSync.class, id++, Side.CLIENT);
RS.INSTANCE.network.registerMessage(MessageFluidAmount.class, MessageFluidAmount.class, id++, Side.SERVER);
RS.INSTANCE.network.registerMessage(MessageFilterSlot.class, MessageFilterSlot.class, id++, Side.SERVER);
RS.INSTANCE.network.registerMessage(MessageSlotFilterFluidSetAmount.class, MessageSlotFilterFluidSetAmount.class, id++, Side.SERVER);
RS.INSTANCE.network.registerMessage(MessageSlotFilterSet.class, MessageSlotFilterSet.class, id++, Side.SERVER);
RS.INSTANCE.network.registerMessage(MessageSlotFilterSetFluid.class, MessageSlotFilterSetFluid.class, id++, Side.SERVER);
RS.INSTANCE.network.registerMessage(MessageSlotFilterFluidUpdate.class, MessageSlotFilterFluidUpdate.class, id++, Side.CLIENT);
NetworkRegistry.INSTANCE.registerGuiHandler(RS.INSTANCE, new GuiHandler());

3
src/main/java/com/raoulvdberge/refinedstorage/render/meshdefinition/ItemMeshDefinitionPortableGrid.java
View File

@@ -4,7 +4,7 @@ import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskProvider;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskSyncData;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.item.itemblock.ItemBlockPortableGrid;
import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
import com.raoulvdberge.refinedstorage.tile.grid.portable.TilePortableGrid;
@@ -17,7 +17,6 @@ import net.minecraftforge.energy.CapabilityEnergy;
import java.util.UUID;
public class ItemMeshDefinitionPortableGrid implements ItemMeshDefinition {
// TODO: Optimize
@Override
public ModelResourceLocation getModelLocation(ItemStack stack) {
ItemHandlerBase disk = new ItemHandlerBase(1);

3
src/main/java/com/raoulvdberge/refinedstorage/render/tesr/TileEntitySpecialRendererStorageMonitor.java
View File

@@ -2,7 +2,6 @@ package com.raoulvdberge.refinedstorage.render.tesr;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.block.model.IBakedModel;
@@ -27,7 +26,7 @@ public class TileEntitySpecialRendererStorageMonitor extends TileEntitySpecialRe
float rotY = 0;
float rotZ = 0;
String amount = tile.getType() == IType.ITEMS ? API.instance().getQuantityFormatter().formatWithUnits(tile.getAmount()) : API.instance().getQuantityFormatter().formatWithUnits((int) ((float) tile.getAmount() / 1000F));
String amount = API.instance().getQuantityFormatter().formatWithUnits(tile.getAmount());
// Very bad, but I don't know how to translate a 2D font width to a 3D font width...
float textWidth = 0;

14
src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorageMonitor.java
View File

@@ -2,7 +2,6 @@ package com.raoulvdberge.refinedstorage.tile;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorageMonitor;
import com.raoulvdberge.refinedstorage.tile.config.IComparable;
import com.raoulvdberge.refinedstorage.tile.config.IType;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
@@ -14,20 +13,16 @@ import javax.annotation.Nullable;
public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
public static final TileDataParameter<Integer, TileStorageMonitor> COMPARE = IComparable.createParameter();
public static final TileDataParameter<Integer, TileStorageMonitor> TYPE = IType.createParameter();
private static final String NBT_TYPE = "Type";
private static final String NBT_STACK = "Stack";
private static final String NBT_AMOUNT = "Amount";
private int type;
private int amount;
@Nullable
private ItemStack itemStack;
public TileStorageMonitor() {
dataManager.addWatchedParameter(COMPARE);
dataManager.addWatchedParameter(TYPE);
}
@Override
@@ -44,9 +39,7 @@ public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
public NBTTagCompound writeUpdate(NBTTagCompound tag) {
super.writeUpdate(tag);
tag.setInteger(NBT_TYPE, getNode().getType());
ItemStack stack = getNode().getType() == IType.ITEMS ? getNode().getItemFilter().getStackInSlot(0) : getNode().getFluidFilter().getStackInSlot(0);
ItemStack stack = getNode().getItemFilters().getStackInSlot(0);
if (!stack.isEmpty()) {
tag.setTag(NBT_STACK, stack.writeToNBT(new NBTTagCompound()));
@@ -61,7 +54,6 @@ public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
public void readUpdate(NBTTagCompound tag) {
super.readUpdate(tag);
type = tag.getInteger(NBT_TYPE);
itemStack = tag.hasKey(NBT_STACK) ? new ItemStack(tag.getCompoundTag(NBT_STACK)) : null;
amount = tag.getInteger(NBT_AMOUNT);
}
@@ -74,10 +66,6 @@ public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
return receivedDirection != getDirection() || receivedActive != getNode().isActive();
}
public int getType() {
return type;
}
public int getAmount() {
return amount;
}

8
src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java
View File

@@ -2,7 +2,7 @@ package com.raoulvdberge.refinedstorage.tile.config;
import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
import net.minecraft.item.ItemStack;
import net.minecraft.network.datasync.DataSerializers;
@@ -50,10 +50,10 @@ public interface IFilterable {
return false;
}
static boolean acceptsFluid(ItemHandlerFluid filters, int mode, int compare, FluidStack stack) {
static boolean acceptsFluid(FluidInventory filters, int mode, int compare, FluidStack stack) {
if (mode == WHITELIST) {
for (int i = 0; i < filters.getSlots(); ++i) {
FluidStack slot = filters.getFluidStackInSlot(i);
FluidStack slot = filters.getFluid(i);
if (slot != null && API.instance().getComparer().isEqual(slot, stack, compare)) {
return true;
@@ -63,7 +63,7 @@ public interface IFilterable {
return false;
} else if (mode == BLACKLIST) {
for (int i = 0; i < filters.getSlots(); ++i) {
FluidStack slot = filters.getFluidStackInSlot(i);
FluidStack slot = filters.getFluid(i);
if (slot != null && API.instance().getComparer().isEqual(slot, stack, compare)) {
return false;

10
src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java
View File

@@ -1,7 +1,7 @@
package com.raoulvdberge.refinedstorage.tile.config;
import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
import com.raoulvdberge.refinedstorage.container.ContainerBase;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
import com.raoulvdberge.refinedstorage.tile.data.TileDataParameterClientListener;
import net.minecraft.network.datasync.DataSerializers;
@@ -18,10 +18,6 @@ public interface IType {
return new TileDataParameter<>(DataSerializers.VARINT, ITEMS, t -> ((IType) t.getNode()).getType(), (t, v) -> {
if (v == IType.ITEMS || v == IType.FLUIDS) {
((IType) t.getNode()).setType(v);
t.getWorld().playerEntities.stream()
.filter(p -> p.openContainer instanceof ContainerBase && ((ContainerBase) p.openContainer).getTile().getPos().equals(t.getPos()))
.forEach(p -> p.openContainer.detectAndSendChanges());
}
}, clientListener);
}
@@ -34,7 +30,7 @@ public interface IType {
void setType(int type);
IItemHandler getFilterInventory();
IItemHandler getItemFilters();
boolean isServer();
FluidInventory getFluidFilters();
}

2
src/main/java/com/raoulvdberge/refinedstorage/tile/grid/WirelessGrid.java
View File

@@ -14,7 +14,7 @@ import com.raoulvdberge.refinedstorage.api.util.IFilter;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridItem;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.item.ItemWirelessGrid;
import com.raoulvdberge.refinedstorage.network.MessageGridSettingsUpdate;
import com.raoulvdberge.refinedstorage.util.StackUtils;

2
src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/IPortableGrid.java
View File

@@ -3,7 +3,7 @@ package com.raoulvdberge.refinedstorage.tile.grid.portable;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import net.minecraft.item.ItemStack;
import net.minecraftforge.items.IItemHandlerModifiable;

4
src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/PortableGrid.java
View File

@@ -21,8 +21,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskItemPortable;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.item.ItemWirelessGrid;
import com.raoulvdberge.refinedstorage.item.itemblock.ItemBlockPortableGrid;
import com.raoulvdberge.refinedstorage.network.MessageGridSettingsUpdate;

10
src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/TilePortableGrid.java
View File

@@ -28,9 +28,9 @@ import com.raoulvdberge.refinedstorage.block.enums.PortableGridDiskState;
import com.raoulvdberge.refinedstorage.block.enums.PortableGridType;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerTile;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
import com.raoulvdberge.refinedstorage.inventory.listener.ListenerTile;
import com.raoulvdberge.refinedstorage.item.ItemWirelessGrid;
import com.raoulvdberge.refinedstorage.item.itemblock.ItemBlockPortableGrid;
import com.raoulvdberge.refinedstorage.render.constants.ConstantsDisk;
@@ -123,8 +123,8 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
private List<IFilter> filters = new ArrayList<>();
private List<IGridTab> tabs = new ArrayList<>();
private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ItemHandlerListenerTile(this));
private ItemHandlerBase disk = new ItemHandlerBase(1, new ItemHandlerListenerTile(this), s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && ((IStorageDiskProvider) s.getItem()).getType() == StorageType.ITEM) {
private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ListenerTile(this));
private ItemHandlerBase disk = new ItemHandlerBase(1, new ListenerTile(this), s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && ((IStorageDiskProvider) s.getItem()).getType() == StorageType.ITEM) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);

17
src/main/java/com/raoulvdberge/refinedstorage/util/StackUtils.java
View File

@@ -21,6 +21,7 @@ import net.minecraftforge.fluids.capability.IFluidHandlerItem;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.IItemHandlerModifiable;
import net.minecraftforge.items.ItemHandlerHelper;
import org.apache.commons.lang3.tuple.Pair;
import javax.annotation.Nonnull;
@@ -60,8 +61,13 @@ public final class StackUtils {
}
}
public static void writeFluidStack(ByteBuf buf, FluidStack stack) {
public static void writeFluidStackAndHash(ByteBuf buf, FluidStack stack) {
buf.writeInt(API.instance().getFluidStackHashCode(stack));
writeFluidStack(buf, stack);
}
public static void writeFluidStack(ByteBuf buf, FluidStack stack) {
ByteBufUtils.writeUTF8String(buf, FluidRegistry.getFluidName(stack.getFluid()));
buf.writeInt(stack.amount);
ByteBufUtils.writeTag(buf, stack.tag);
@@ -71,6 +77,10 @@ public final class StackUtils {
return new FluidStack(FluidRegistry.getFluid(ByteBufUtils.readUTF8String(buf)), buf.readInt(), ByteBufUtils.readTag(buf));
}
public static Pair<Integer, FluidStack> readFluidStackAndHash(ByteBuf buf) {
return Pair.of(buf.readInt(), readFluidStack(buf));
}
public static ItemStack nullToEmpty(@Nullable ItemStack stack) {
return stack == null ? ItemStack.EMPTY : stack;
}
@@ -197,6 +207,11 @@ public final class StackUtils {
}
public static Pair<ItemStack, FluidStack> getFluid(ItemStack stack, boolean simulate) {
// We won't have the capability on stacks with size bigger than 1.
if (stack.getCount() > 1) {
stack = ItemHandlerHelper.copyStackWithSize(stack, 1);
}
if (stack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) {
IFluidHandlerItem fluidHandler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);