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

The Portable Grid now supports fluid disks. Fixes #1916

Browse Source
This commit is contained in:
raoulvdberge
2018-07-29 19:58:35 +02:00
parent 12bc0a2c41
commit 218c756d5b
22 changed files with 628 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@@ -3,8 +3,8 @@
### 1.6.1
- Added fluid autocrafting (raoulvdberge)
- Added Crafting Upgrade support for fluids on the Exporter, Constructor and Fluid Interface (raoulvdberge)
- Added support for JEI ghost slot dragging (raoulvdberge)
- Added config option to hide covers in the creative mode tabs and JEI (raoulvdberge)
- The Portable Grid now supports fluid disks (raoulvdberge)
- Removed "emit signal when item is being autocrafted" option in the Detector (raoulvdberge)
- The Crafting Card no longer schedules requests when there are items or fluids missing (raoulvdberge)
- You can now keep fluids in stock by attaching a External Storage in fluid mode to a Fluid Interface with a Crafting Upgrade (raoulvdberge)

1
src/main/java/com/raoulvdberge/refinedstorage/api/network/grid/handler/IFluidGridHandler.java
View File

@@ -46,7 +46,6 @@ public interface IFluidGridHandler {
*/
ItemStack onShiftClick(EntityPlayerMP player, ItemStack container);
/**
* Called when a player requests the crafting preview window to be opened.
*

112
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/grid/handler/FluidGridHandlerPortable.java Normal file
View File

@@ -0,0 +1,112 @@
package com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.network.grid.handler.IFluidGridHandler;
import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.api.util.IComparer;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.InventoryHelper;
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 org.apache.commons.lang3.tuple.Pair;
import javax.annotation.Nullable;
public class FluidGridHandlerPortable implements IFluidGridHandler {
private IPortableGrid portableGrid;
public FluidGridHandlerPortable(IPortableGrid portableGrid) {
this.portableGrid = portableGrid;
}
@Override
public void onExtract(EntityPlayerMP player, int hash, boolean shift) {
FluidStack stack = portableGrid.getFluidCache().getList().get(hash);
if (stack == null || stack.amount < Fluid.BUCKET_VOLUME) {
return;
}
if (StackUtils.hasFluidBucket(stack)) {
ItemStack bucket = null;
for (int i = 0; i < player.inventory.getSizeInventory(); ++i) {
ItemStack slot = player.inventory.getStackInSlot(i);
if (API.instance().getComparer().isEqualNoQuantity(StackUtils.EMPTY_BUCKET, slot)) {
bucket = StackUtils.EMPTY_BUCKET.copy();
player.inventory.decrStackSize(i, 1);
break;
}
}
if (bucket != null) {
IFluidHandlerItem fluidHandler = bucket.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
portableGrid.getFluidStorageTracker().changed(player, stack.copy());
fluidHandler.fill(portableGrid.getFluidStorage().extract(stack, Fluid.BUCKET_VOLUME, IComparer.COMPARE_NBT, Action.PERFORM), true);
if (shift) {
if (!player.inventory.addItemStackToInventory(fluidHandler.getContainer().copy())) {
InventoryHelper.spawnItemStack(player.getEntityWorld(), player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ(), fluidHandler.getContainer());
}
} else {
player.inventory.setItemStack(fluidHandler.getContainer());
player.updateHeldItem();
}
portableGrid.drainEnergy(RS.INSTANCE.config.portableGridExtractUsage);
}
}
}
@Nullable
@Override
public ItemStack onInsert(EntityPlayerMP player, ItemStack container) {
Pair<ItemStack, FluidStack> result = StackUtils.getFluid(container, true);
if (result.getValue() != null && portableGrid.getFluidStorage().insert(result.getValue(), result.getValue().amount, Action.SIMULATE) == null) {
portableGrid.getFluidStorageTracker().changed(player, result.getValue().copy());
result = StackUtils.getFluid(container, false);
portableGrid.getFluidStorage().insert(result.getValue(), result.getValue().amount, Action.PERFORM);
portableGrid.drainEnergy(RS.INSTANCE.config.portableGridInsertUsage);
return result.getLeft();
}
return container;
}
@Override
public void onInsertHeldContainer(EntityPlayerMP player) {
player.inventory.setItemStack(StackUtils.nullToEmpty(onInsert(player, player.inventory.getItemStack())));
player.updateHeldItem();
}
@Override
public ItemStack onShiftClick(EntityPlayerMP player, ItemStack container) {
return StackUtils.nullToEmpty(onInsert(player, container));
}
@Override
public void onCraftingPreviewRequested(EntityPlayerMP player, int hash, int quantity, boolean noPreview) {
// NO OP
}
@Override
public void onCraftingRequested(EntityPlayerMP player, int hash, int quantity) {
// NO OP
}
}

22
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/grid/handler/ItemGridHandlerPortable.java
View File

@@ -33,7 +33,7 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
return;
}
ItemStack item = portableGrid.getCache().getList().get(hash);
ItemStack item = portableGrid.getItemCache().getList().get(hash);
if (item == null) {
return;
@@ -76,21 +76,21 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
size = Math.min(size, maxItemSize);
// Do this before actually extracting, since portable grid sends updates as soon as a change happens (so before the storage tracker used to track)
portableGrid.getStorageTracker().changed(player, item.copy());
portableGrid.getItemStorageTracker().changed(player, item.copy());
ItemStack took = portableGrid.getStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.SIMULATE);
ItemStack took = portableGrid.getItemStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.SIMULATE);
if (took != null) {
if ((flags & EXTRACT_SHIFT) == EXTRACT_SHIFT) {
IItemHandler playerInventory = player.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP);
if (ItemHandlerHelper.insertItem(playerInventory, took, true).isEmpty()) {
took = portableGrid.getStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
took = portableGrid.getItemStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
ItemHandlerHelper.insertItem(playerInventory, took, false);
}
} else {
took = portableGrid.getStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
took = portableGrid.getItemStorage().extract(item, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, Action.PERFORM);
if (single && !held.isEmpty()) {
held.grow(1);
@@ -112,9 +112,9 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
return stack;
}
portableGrid.getStorageTracker().changed(player, stack.copy());
portableGrid.getItemStorageTracker().changed(player, stack.copy());
ItemStack remainder = portableGrid.getStorage().insert(stack, stack.getCount(), Action.PERFORM);
ItemStack remainder = portableGrid.getItemStorage().insert(stack, stack.getCount(), Action.PERFORM);
portableGrid.drainEnergy(RS.INSTANCE.config.portableGridInsertUsage);
@@ -130,11 +130,11 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
ItemStack stack = player.inventory.getItemStack();
int size = single ? 1 : stack.getCount();
portableGrid.getStorageTracker().changed(player, stack.copy());
portableGrid.getItemStorageTracker().changed(player, stack.copy());
if (single) {
if (portableGrid.getStorage().insert(stack, size, Action.SIMULATE) == null) {
portableGrid.getStorage().insert(stack, size, Action.PERFORM);
if (portableGrid.getItemStorage().insert(stack, size, Action.SIMULATE) == null) {
portableGrid.getItemStorage().insert(stack, size, Action.PERFORM);
stack.shrink(size);
@@ -143,7 +143,7 @@ public class ItemGridHandlerPortable implements IItemGridHandler {
}
}
} else {
player.inventory.setItemStack(StackUtils.nullToEmpty(portableGrid.getStorage().insert(stack, size, Action.PERFORM)));
player.inventory.setItemStack(StackUtils.nullToEmpty(portableGrid.getItemStorage().insert(stack, size, Action.PERFORM)));
}
player.updateHeldItem();

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

@@ -6,7 +6,7 @@ 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.fluid.FluidHandlerFluidInterface;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidHandlerProxy;
import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
@@ -50,7 +50,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
};
private FluidTank tankOut = new FluidTank(TANK_CAPACITY);
private FluidHandlerFluidInterface tank = new FluidHandlerFluidInterface(tankIn, tankOut);
private FluidHandlerProxy tank = new FluidHandlerProxy(tankIn, tankOut);
private ItemHandlerBase in = new ItemHandlerBase(1, new ListenerNetworkNode(this), stack -> StackUtils.getFluid(stack, true).getRight() != null);
private FluidInventory out = new FluidInventory(1, TANK_CAPACITY, new ListenerNetworkNode(this));
@@ -245,7 +245,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
return out;
}
public FluidHandlerFluidInterface getTank() {
public FluidHandlerProxy getTank() {
return tank;
}

83
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheFluidPortable.java Normal file
View File

@@ -0,0 +1,83 @@
package com.raoulvdberge.refinedstorage.apiimpl.storage;
import com.raoulvdberge.refinedstorage.api.storage.IStorage;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
import com.raoulvdberge.refinedstorage.api.util.IStackList;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
import net.minecraftforge.fluids.FluidStack;
import javax.annotation.Nonnull;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class StorageCacheFluidPortable implements IStorageCache<FluidStack> {
private IPortableGrid portableGrid;
private IStackList<FluidStack> list = API.instance().createFluidStackList();
private List<IStorageCacheListener<FluidStack>> listeners = new LinkedList<>();
public StorageCacheFluidPortable(IPortableGrid portableGrid) {
this.portableGrid = portableGrid;
}
@Override
public void invalidate() {
list.clear();
if (portableGrid.getFluidStorage() != null) {
portableGrid.getFluidStorage().getStacks().forEach(list::add);
}
listeners.forEach(IStorageCacheListener::onInvalidated);
}
@Override
public void add(@Nonnull FluidStack stack, int size, boolean rebuilding, boolean batched) {
list.add(stack, size);
if (!rebuilding) {
listeners.forEach(l -> l.onChanged(stack, size));
}
}
@Override
public void remove(@Nonnull FluidStack stack, int size, boolean batched) {
if (list.remove(stack, size)) {
listeners.forEach(l -> l.onChanged(stack, -size));
}
}
@Override
public void flush() {
throw new UnsupportedOperationException("Cannot flush portable grid storage cache");
}
@Override
public void addListener(IStorageCacheListener<FluidStack> listener) {
listeners.add(listener);
listener.onAttached();
}
@Override
public void removeListener(IStorageCacheListener<FluidStack> listener) {
listeners.remove(listener);
}
@Override
public void sort() {
// NO OP
}
@Override
public IStackList<FluidStack> getList() {
return list;
}
@Override
public List<IStorage<FluidStack>> getStorages() {
return Collections.emptyList();
}
}

4
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheItemPortable.java
View File

@@ -26,8 +26,8 @@ public class StorageCacheItemPortable implements IStorageCache<ItemStack> {
public void invalidate() {
list.clear();
if (portableGrid.getStorage() != null) {
portableGrid.getStorage().getStacks().forEach(list::add);
if (portableGrid.getItemStorage() != null) {
portableGrid.getItemStorage().getStacks().forEach(list::add);
}
listeners.forEach(IStorageCacheListener::onInvalidated);

2
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheListenerGridFluid.java
View File

@@ -32,6 +32,6 @@ public class StorageCacheListenerGridFluid implements IStorageCacheListener<Flui
@Override
public void onChanged(@Nonnull FluidStack stack, int size) {
RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(network, stack, size), player);
RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(network, network.getFluidStorageTracker(), stack, size), player);
}
}

8
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheListenerGridPortable.java
View File

@@ -25,12 +25,12 @@ public class StorageCacheListenerGridPortable implements IStorageCacheListener<I
@Override
public void onAttached() {
RS.INSTANCE.network.sendTo(new MessageGridItemUpdate(buf -> {
buf.writeInt(portableGrid.getCache().getList().getStacks().size());
buf.writeInt(portableGrid.getItemCache().getList().getStacks().size());
for (ItemStack stack : portableGrid.getCache().getList().getStacks()) {
for (ItemStack stack : portableGrid.getItemCache().getList().getStacks()) {
StackUtils.writeItemStack(buf, stack, null, false);
IStorageTracker.IStorageTrackerEntry entry = portableGrid.getStorageTracker().get(stack);
IStorageTracker.IStorageTrackerEntry entry = portableGrid.getItemStorageTracker().get(stack);
buf.writeBoolean(entry != null);
if (entry != null) {
buf.writeLong(entry.getTime());
@@ -47,6 +47,6 @@ public class StorageCacheListenerGridPortable implements IStorageCacheListener<I
@Override
public void onChanged(@Nonnull ItemStack stack, int size) {
RS.INSTANCE.network.sendTo(new MessageGridItemDelta(null, portableGrid.getStorageTracker(), stack, size), player);
RS.INSTANCE.network.sendTo(new MessageGridItemDelta(null, portableGrid.getItemStorageTracker(), stack, size), player);
}
}

57
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/StorageCacheListenerGridPortableFluid.java Normal file
View File

@@ -0,0 +1,57 @@
package com.raoulvdberge.refinedstorage.apiimpl.storage;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
import com.raoulvdberge.refinedstorage.api.storage.IStorageTracker;
import com.raoulvdberge.refinedstorage.network.MessageGridFluidDelta;
import com.raoulvdberge.refinedstorage.network.MessageGridFluidUpdate;
import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import javax.annotation.Nonnull;
public class StorageCacheListenerGridPortableFluid implements IStorageCacheListener<FluidStack> {
private IPortableGrid portableGrid;
private EntityPlayerMP player;
public StorageCacheListenerGridPortableFluid(IPortableGrid portableGrid, EntityPlayerMP player) {
this.portableGrid = portableGrid;
this.player = player;
}
@Override
public void onAttached() {
RS.INSTANCE.network.sendTo(new MessageGridFluidUpdate(buf -> {
int size = portableGrid.getFluidCache().getList().getStacks().size();
buf.writeInt(size);
for (FluidStack stack : portableGrid.getFluidCache().getList().getStacks()) {
StackUtils.writeFluidStackAndHash(buf, stack);
IStorageTracker.IStorageTrackerEntry entry = portableGrid.getFluidStorageTracker().get(stack);
buf.writeBoolean(entry != null);
if (entry != null) {
buf.writeLong(entry.getTime());
ByteBufUtils.writeUTF8String(buf, entry.getName());
}
buf.writeBoolean(false);
buf.writeBoolean(false);
}
}, false), player);
}
@Override
public void onInvalidated() {
// NO OP
}
@Override
public void onChanged(@Nonnull FluidStack stack, int size) {
RS.INSTANCE.network.sendTo(new MessageGridFluidDelta(null, portableGrid.getFluidStorageTracker(), stack, size), player);
}
}

99
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/disk/StorageDiskFluidPortable.java Normal file
View File

@@ -0,0 +1,99 @@
package com.raoulvdberge.refinedstorage.apiimpl.storage.disk;
import com.raoulvdberge.refinedstorage.api.storage.AccessType;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskContainerContext;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskListener;
import com.raoulvdberge.refinedstorage.api.util.Action;
import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.FluidStack;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Collection;
public class StorageDiskFluidPortable implements IStorageDisk<FluidStack> {
private IStorageDisk<FluidStack> parent;
private IPortableGrid portableGrid;
public StorageDiskFluidPortable(IStorageDisk<FluidStack> parent, IPortableGrid portableGrid) {
this.parent = parent;
this.portableGrid = portableGrid;
}
@Override
public int getCapacity() {
return parent.getCapacity();
}
@Override
public void setSettings(@Nullable IStorageDiskListener listener, IStorageDiskContainerContext context) {
parent.setSettings(listener, context);
}
@Override
public NBTTagCompound writeToNbt() {
return parent.writeToNbt();
}
@Override
public Collection<FluidStack> getStacks() {
return parent.getStacks();
}
@Nullable
@Override
public FluidStack insert(@Nonnull FluidStack stack, int size, Action action) {
int storedPre = parent.getStored();
FluidStack remainder = parent.insert(stack, size, action);
if (action == Action.PERFORM) {
int inserted = parent.getCacheDelta(storedPre, size, remainder);
if (inserted > 0) {
portableGrid.getFluidCache().add(stack, inserted, false, false);
}
}
return remainder;
}
@Nullable
@Override
public FluidStack extract(@Nonnull FluidStack stack, int size, int flags, Action action) {
FluidStack extracted = parent.extract(stack, size, flags, action);
if (action == Action.PERFORM && extracted != null) {
portableGrid.getFluidCache().remove(extracted, extracted.amount, false);
}
return extracted;
}
@Override
public int getStored() {
return parent.getStored();
}
@Override
public int getPriority() {
return parent.getPriority();
}
@Override
public AccessType getAccessType() {
return parent.getAccessType();
}
@Override
public int getCacheDelta(int storedPreInsertion, int size, @Nullable FluidStack remainder) {
return parent.getCacheDelta(storedPreInsertion, size, remainder);
}
@Override
public String getId() {
return parent.getId();
}
}

4
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/storage/disk/StorageDiskItemPortable.java
View File

@@ -53,7 +53,7 @@ public class StorageDiskItemPortable implements IStorageDisk<ItemStack> {
int inserted = parent.getCacheDelta(storedPre, size, remainder);
if (inserted > 0) {
portableGrid.getCache().add(stack, inserted, false, false);
portableGrid.getItemCache().add(stack, inserted, false, false);
}
}
@@ -66,7 +66,7 @@ public class StorageDiskItemPortable implements IStorageDisk<ItemStack> {
ItemStack extracted = parent.extract(stack, size, flags, action);
if (action == Action.PERFORM && extracted != null) {
portableGrid.getCache().remove(extracted, extracted.getCount(), false);
portableGrid.getItemCache().remove(extracted, extracted.getCount(), false);
}
return extracted;

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

@@ -54,7 +54,7 @@ public class ContainerGrid extends ContainerBase {
this.transferManager.clearTransfers();
if (grid.getGridType() != GridType.FLUID) {
if (grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) {
addFilterSlots();
}

45
src/main/java/com/raoulvdberge/refinedstorage/gui/grid/GuiGrid.java
View File

@@ -57,19 +57,10 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
private int slotNumber;
public GuiGrid(ContainerGrid container, IGrid grid) {
super(container, grid.getGridType() == GridType.FLUID ? 193 : 227, 0);
IGridSorter defaultSorter;
List<IGridSorter> sorters = new LinkedList<>();
sorters.add(defaultSorter = new GridSorterName());
sorters.add(new GridSorterQuantity());
sorters.add(new GridSorterID());
sorters.add(new GridSorterInventoryTweaks());
sorters.add(new GridSorterLastModified());
super(container, (grid.getGridType() == GridType.FLUID && !(grid instanceof IPortableGrid)) ? 193 : 227, 0);
this.grid = grid;
this.view = grid.getGridType() == GridType.FLUID ? new GridViewFluid(this, defaultSorter, sorters) : new GridViewItem(this, defaultSorter, sorters);
this.view = grid.getGridType() == GridType.FLUID ? new GridViewFluid(this, getDefaultSorter(), getSorters()) : new GridViewItem(this, getDefaultSorter(), getSorters());
this.wasConnected = this.grid.isActive();
this.tabs = new TabList(this, new ElementDrawers(), grid::getTabs, grid::getTotalTabPages, grid::getTabPage, grid::getTabSelected, IGrid.TABS_PER_PAGE);
this.tabs.addListener(new TabList.ITabListListener() {
@@ -151,6 +142,10 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
return grid;
}
public void setView(IGridView view) {
this.view = view;
}
public IGridView getView() {
return view;
}
@@ -271,12 +266,12 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
public void drawBackground(int x, int y, int mouseX, int mouseY) {
tabs.drawBackground(x, y);
if (grid.getGridType() == GridType.CRAFTING) {
if (grid instanceof IPortableGrid) {
bindTexture("gui/portable_grid.png");
} else if (grid.getGridType() == GridType.CRAFTING) {
bindTexture("gui/crafting_grid.png");
} else if (grid.getGridType() == GridType.PATTERN) {
bindTexture("gui/pattern_grid" + (((NetworkNodeGrid) grid).isProcessingPattern() ? "_processing" : "") + ".png");
} else if (grid instanceof IPortableGrid) {
bindTexture("gui/portable_grid.png");
} else {
bindTexture("gui/grid.png");
}
@@ -285,7 +280,8 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
drawTexture(x, yy, 0, 0, screenWidth - (grid.getGridType() != GridType.FLUID ? 34 : 0), getTopHeight());
if (grid.getGridType() != GridType.FLUID) {
// Filters and portable grid disk
if (grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) {
drawTexture(x + screenWidth - 34 + 4, y + tabs.getHeight(), 197, 0, 30, grid instanceof IPortableGrid ? 114 : 82);
}
@@ -294,12 +290,12 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
for (int i = 0; i < rows; ++i) {
yy += 18;
drawTexture(x, yy, 0, getTopHeight() + (i > 0 ? (i == rows - 1 ? 18 * 2 : 18) : 0), screenWidth - (grid.getGridType() != GridType.FLUID ? 34 : 0), 18);
drawTexture(x, yy, 0, getTopHeight() + (i > 0 ? (i == rows - 1 ? 18 * 2 : 18) : 0), screenWidth - ((grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) ? 34 : 0), 18);
}
yy += 18;
drawTexture(x, yy, 0, getTopHeight() + (18 * 3), screenWidth - (grid.getGridType() != GridType.FLUID ? 34 : 0), getBottomHeight());
drawTexture(x, yy, 0, getTopHeight() + (18 * 3), screenWidth - ((grid.getGridType() != GridType.FLUID || grid instanceof IPortableGrid) ? 34 : 0), getBottomHeight());
if (grid.getGridType() == GridType.PATTERN) {
int ty = 0;
@@ -526,4 +522,19 @@ public class GuiGrid extends GuiBase implements IResizableDisplay {
scrollbar.setMaxOffset(getRows() - getVisibleRows());
}
}
public static List<IGridSorter> getSorters() {
List<IGridSorter> sorters = new LinkedList<>();
sorters.add(getDefaultSorter());
sorters.add(new GridSorterQuantity());
sorters.add(new GridSorterID());
sorters.add(new GridSorterInventoryTweaks());
sorters.add(new GridSorterLastModified());
return sorters;
}
public static IGridSorter getDefaultSorter() {
return new GridSorterName();
}
}

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

@@ -22,7 +22,7 @@ public class RSJEIPlugin implements IModPlugin {
registry.addRecipeRegistryPlugin(new RecipeRegistryPluginCover());
registry.addRecipeRegistryPlugin(new RecipeRegistryPluginHollowCover());
// TODO: #1905
// TODO: https://github.com/mezz/JustEnoughItems/issues/1307
// registry.addGhostIngredientHandler(GuiBase.class, new GhostIngredientHandler());
}

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

@@ -8,17 +8,17 @@ import net.minecraftforge.fluids.capability.IFluidTankProperties;
import javax.annotation.Nullable;
public class FluidHandlerFluidInterface implements IFluidHandler {
private FluidTank input;
private FluidTank output;
public class FluidHandlerProxy implements IFluidHandler {
private FluidTank insertHandler;
private FluidTank extractHandler;
private IFluidTankProperties[] properties;
public FluidHandlerFluidInterface(FluidTank input, FluidTank output) {
this.input = input;
this.output = output;
public FluidHandlerProxy(FluidTank insertHandler, FluidTank extractHandler) {
this.insertHandler = insertHandler;
this.extractHandler = extractHandler;
this.properties = new IFluidTankProperties[]{
new FluidTankPropertiesWrapper(input),
new FluidTankPropertiesWrapper(output)
new FluidTankPropertiesWrapper(insertHandler),
new FluidTankPropertiesWrapper(extractHandler)
};
}
@@ -29,18 +29,18 @@ public class FluidHandlerFluidInterface implements IFluidHandler {
@Override
public int fill(FluidStack resource, boolean doFill) {
return input.fill(resource, doFill);
return insertHandler.fill(resource, doFill);
}
@Nullable
@Override
public FluidStack drain(FluidStack resource, boolean doDrain) {
return output.drain(resource, doDrain);
return extractHandler.drain(resource, doDrain);
}
@Nullable
@Override
public FluidStack drain(int maxDrain, boolean doDrain) {
return output.drain(maxDrain, doDrain);
return extractHandler.drain(maxDrain, doDrain);
}
}

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

@@ -15,8 +15,12 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import org.apache.commons.lang3.tuple.Pair;
import javax.annotation.Nullable;
public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageGridFluidDelta, IMessage> {
@Nullable
private INetwork network;
private IStorageTracker<FluidStack> storageTracker;
private FluidStack stack;
private int delta;
@@ -25,8 +29,9 @@ public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageG
public MessageGridFluidDelta() {
}
public MessageGridFluidDelta(INetwork network, FluidStack stack, int delta) {
public MessageGridFluidDelta(@Nullable INetwork network, IStorageTracker<FluidStack> storageTracker, FluidStack stack, int delta) {
this.network = network;
this.storageTracker = storageTracker;
this.stack = stack;
this.delta = delta;
}
@@ -43,14 +48,18 @@ public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageG
public void toBytes(ByteBuf buf) {
StackUtils.writeFluidStackAndHash(buf, stack);
IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
IStorageTracker.IStorageTrackerEntry entry = storageTracker.get(stack);
buf.writeBoolean(entry != null);
if (entry != null) {
buf.writeLong(entry.getTime());
ByteBufUtils.writeUTF8String(buf, entry.getName());
}
if (network != null) {
buf.writeBoolean(network.getCraftingManager().getPattern(stack) != null);
} else {
buf.writeBoolean(false);
}
buf.writeInt(delta);
}

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

@@ -8,6 +8,7 @@ import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackFluid;
import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
import com.raoulvdberge.refinedstorage.gui.grid.view.GridViewFluid;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import io.netty.buffer.ByteBuf;
import net.minecraftforge.fluids.FluidStack;
@@ -19,37 +20,19 @@ import org.apache.commons.lang3.tuple.Pair;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
public class MessageGridFluidUpdate implements IMessage, IMessageHandler<MessageGridFluidUpdate, IMessage> {
private INetwork network;
private boolean canCraft;
private List<IGridStack> stacks = new ArrayList<>();
private Consumer<ByteBuf> sendHandler;
public MessageGridFluidUpdate() {
}
public MessageGridFluidUpdate(INetwork network, boolean canCraft) {
this.network = network;
this.canCraft = canCraft;
}
@Override
public void fromBytes(ByteBuf buf) {
canCraft = buf.readBoolean();
int items = buf.readInt();
for (int i = 0; i < items; ++i) {
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()));
}
}
@Override
public void toBytes(ByteBuf buf) {
buf.writeBoolean(canCraft);
this(buf -> {
int size = network.getFluidStorageCache().getList().getStacks().size();
for (ICraftingPattern pattern : network.getCraftingManager().getPatterns()) {
@@ -87,11 +70,38 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
buf.writeBoolean(true);
}
}
}, canCraft);
}
public MessageGridFluidUpdate(Consumer<ByteBuf> sendHandler, boolean canCraft) {
this.sendHandler = sendHandler;
this.canCraft = canCraft;
}
@Override
public void fromBytes(ByteBuf buf) {
canCraft = buf.readBoolean();
int items = buf.readInt();
for (int i = 0; i < items; ++i) {
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()));
}
}
@Override
public void toBytes(ByteBuf buf) {
buf.writeBoolean(canCraft);
sendHandler.accept(buf);
}
@Override
public IMessage onMessage(MessageGridFluidUpdate message, MessageContext ctx) {
GuiBase.executeLater(GuiGrid.class, grid -> {
grid.setView(new GridViewFluid(grid, GuiGrid.getDefaultSorter(), GuiGrid.getSorters()));
grid.getView().setCanCraft(message.canCraft);
grid.getView().setStacks(message.stacks);
grid.getView().sort();

2
src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridItemUpdate.java
View File

@@ -7,6 +7,7 @@ import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackItem;
import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
import com.raoulvdberge.refinedstorage.gui.grid.view.GridViewItem;
import com.raoulvdberge.refinedstorage.util.StackUtils;
import io.netty.buffer.ByteBuf;
import net.minecraft.item.ItemStack;
@@ -91,6 +92,7 @@ public class MessageGridItemUpdate implements IMessage, IMessageHandler<MessageG
@Override
public IMessage onMessage(MessageGridItemUpdate message, MessageContext ctx) {
GuiBase.executeLater(GuiGrid.class, grid -> {
grid.setView(new GridViewItem(grid, GuiGrid.getDefaultSorter(), GuiGrid.getSorters()));
grid.getView().setCanCraft(message.canCraft);
grid.getView().setStacks(message.stacks);
grid.getView().sort();

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

@@ -1,10 +1,11 @@
package com.raoulvdberge.refinedstorage.tile.grid.portable;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
import com.raoulvdberge.refinedstorage.api.storage.IStorageTracker;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.IItemHandlerModifiable;
import javax.annotation.Nullable;
@@ -20,10 +21,27 @@ public interface IPortableGrid {
boolean isActive();
}
IStorageCache<ItemStack> getCache();
@Nullable
IStorageCache getCache();
default IStorageCache<ItemStack> getItemCache() {
return (IStorageCache<ItemStack>) getCache();
}
default IStorageCache<FluidStack> getFluidCache() {
return (IStorageCache<FluidStack>) getCache();
}
@Nullable
IStorageDisk<ItemStack> getStorage();
IStorageDisk getStorage();
default IStorageDisk<ItemStack> getItemStorage() {
return (IStorageDisk<ItemStack>) getStorage();
}
default IStorageDisk<FluidStack> getFluidStorage() {
return (IStorageDisk<FluidStack>) getStorage();
}
void drainEnergy(int energy);
@@ -33,5 +51,7 @@ public interface IPortableGrid {
IItemHandlerModifiable getFilter();
StorageTrackerItem getStorageTracker();
IStorageTracker<ItemStack> getItemStorageTracker();
IStorageTracker<FluidStack> getFluidStorageTracker();
}

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

@@ -9,15 +9,17 @@ import com.raoulvdberge.refinedstorage.api.network.grid.handler.IItemGridHandler
import com.raoulvdberge.refinedstorage.api.storage.AccessType;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
import com.raoulvdberge.refinedstorage.api.storage.StorageType;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskContainerContext;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskProvider;
import com.raoulvdberge.refinedstorage.api.util.IFilter;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.FluidGridHandlerPortable;
import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.ItemGridHandlerPortable;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItemPortable;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridPortable;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
import com.raoulvdberge.refinedstorage.apiimpl.storage.*;
import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskFluidPortable;
import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskItemPortable;
import com.raoulvdberge.refinedstorage.gui.GuiBase;
import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
@@ -47,12 +49,16 @@ import java.util.List;
public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainerContext {
public static int ID;
public static final String NBT_STORAGE_TRACKER = "StorageTracker";
static final String NBT_STORAGE_TRACKER = "StorageTracker";
static final String NBT_FLUID_STORAGE_TRACKER = "FluidStorageTracker";
@Nullable
private IStorageDisk<ItemStack> storage;
private StorageCacheItemPortable cache = new StorageCacheItemPortable(this);
private ItemGridHandlerPortable handler = new ItemGridHandlerPortable(this, this);
private IStorageDisk storage;
@Nullable
private IStorageCache cache;
private ItemGridHandlerPortable itemHandler = new ItemGridHandlerPortable(this, this);
private FluidGridHandlerPortable fluidHandler = new FluidGridHandlerPortable(this);
private EntityPlayer player;
private ItemStack stack;
@@ -64,7 +70,8 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
private int tabPage;
private int size;
private StorageTrackerItem storageTracker = new StorageTrackerItem(() -> stack.getTagCompound().setTag(NBT_STORAGE_TRACKER, getStorageTracker().serializeNbt()));
private StorageTrackerItem storageTracker = new StorageTrackerItem(() -> stack.getTagCompound().setTag(NBT_STORAGE_TRACKER, getItemStorageTracker().serializeNbt()));
private StorageTrackerFluid fluidStorageTracker = new StorageTrackerFluid(() -> stack.getTagCompound().setTag(NBT_FLUID_STORAGE_TRACKER, getFluidStorageTracker().serializeNbt()));
private List<IFilter> filters = new ArrayList<>();
private List<IGridTab> tabs = new ArrayList<>();
@@ -80,7 +87,7 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
StackUtils.writeItems(this, 0, stack.getTagCompound());
}
};
private ItemHandlerBase disk = new ItemHandlerBase(1, s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && true) {
private ItemHandlerBase disk = new ItemHandlerBase(1, NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -90,18 +97,34 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
if (diskStack.isEmpty()) {
storage = null;
cache = null;
} else {
IStorageDisk disk = API.instance().getStorageDiskManager(player.getEntityWorld()).getByStack(diskStack);
IStorageDisk disk = API.instance().getStorageDiskManager(player.getEntityWorld()).getByStack(getDisk().getStackInSlot(0));
if (disk != null) {
StorageType type = ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType();
switch (type) {
case ITEM:
storage = new StorageDiskItemPortable(disk, PortableGrid.this);
cache = new StorageCacheItemPortable(PortableGrid.this);
break;
case FLUID:
storage = new StorageDiskFluidPortable(disk, PortableGrid.this);
cache = new StorageCacheFluidPortable(PortableGrid.this);
break;
}
storage.setSettings(null, PortableGrid.this);
} else {
storage = null;
cache = null;
}
}
if (cache != null) {
cache.invalidate();
}
StackUtils.writeItems(this, 4, stack.getTagCompound());
}
@@ -129,6 +152,10 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
storageTracker.readFromNbt(stack.getTagCompound().getTagList(NBT_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
}
if (stack.getTagCompound().hasKey(NBT_FLUID_STORAGE_TRACKER)) {
fluidStorageTracker.readFromNbt(stack.getTagCompound().getTagList(NBT_FLUID_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
}
StackUtils.readItems(disk, 4, stack.getTagCompound());
if (!player.getEntityWorld().isRemote) {
@@ -138,11 +165,6 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
StackUtils.readItems(filter, 0, stack.getTagCompound());
drainEnergy(RS.INSTANCE.config.portableGridOpenUsage);
// If there is no disk onContentsChanged isn't called and the update isn't sent, thus items from the previous grid view would remain clientside
if (!player.getEntityWorld().isRemote && disk.getStackInSlot(0).isEmpty()) {
cache.invalidate();
}
}
public ItemStack getStack() {
@@ -150,13 +172,14 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
}
@Override
public StorageCacheItemPortable getCache() {
@Nullable
public IStorageCache getCache() {
return cache;
}
@Override
@Nullable
public IStorageDisk<ItemStack> getStorage() {
public IStorageDisk getStorage() {
return storage;
}
@@ -187,7 +210,7 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
@Override
public GridType getGridType() {
return GridType.NORMAL;
return (getDisk().getStackInSlot(0).isEmpty() || ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType() == StorageType.ITEM) ? GridType.NORMAL : GridType.FLUID;
}
@Nullable
@@ -198,19 +221,19 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
@Override
public IStorageCacheListener createListener(EntityPlayerMP player) {
return new StorageCacheListenerGridPortable(this, player);
return getGridType() == GridType.FLUID ? new StorageCacheListenerGridPortableFluid(this, player) : new StorageCacheListenerGridPortable(this, player);
}
@Nullable
@Override
public IItemGridHandler getItemHandler() {
return handler;
return itemHandler;
}
@Nullable
@Override
public IFluidGridHandler getFluidHandler() {
return null;
return fluidHandler;
}
@Override
@@ -333,10 +356,15 @@ public class PortableGrid implements IGrid, IPortableGrid, IStorageDiskContainer
}
@Override
public StorageTrackerItem getStorageTracker() {
public StorageTrackerItem getItemStorageTracker() {
return storageTracker;
}
@Override
public StorageTrackerFluid getFluidStorageTracker() {
return fluidStorageTracker;
}
@Override
public InventoryCrafting getCraftingMatrix() {
return null;

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

@@ -7,21 +7,18 @@ import com.raoulvdberge.refinedstorage.api.network.grid.IGrid;
import com.raoulvdberge.refinedstorage.api.network.grid.IGridTab;
import com.raoulvdberge.refinedstorage.api.network.grid.handler.IFluidGridHandler;
import com.raoulvdberge.refinedstorage.api.network.grid.handler.IItemGridHandler;
import com.raoulvdberge.refinedstorage.api.storage.AccessType;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
import com.raoulvdberge.refinedstorage.api.storage.StorageType;
import com.raoulvdberge.refinedstorage.api.storage.*;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskContainerContext;
import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskProvider;
import com.raoulvdberge.refinedstorage.api.util.IFilter;
import com.raoulvdberge.refinedstorage.apiimpl.API;
import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.FluidGridHandlerPortable;
import com.raoulvdberge.refinedstorage.apiimpl.network.grid.handler.ItemGridHandlerPortable;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItemPortable;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridPortable;
import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
import com.raoulvdberge.refinedstorage.apiimpl.storage.*;
import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskFluidPortable;
import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskItemPortable;
import com.raoulvdberge.refinedstorage.block.BlockPortableGrid;
import com.raoulvdberge.refinedstorage.block.enums.PortableGridDiskState;
@@ -55,6 +52,7 @@ import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.util.Constants;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.EnergyStorage;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.items.IItemHandlerModifiable;
import javax.annotation.Nonnull;
@@ -64,32 +62,32 @@ import java.util.List;
public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid, IRedstoneConfigurable, IStorageDiskContainerContext, IPortableGrid.IPortableGridRenderInfo {
public static final TileDataParameter<Integer, TilePortableGrid> REDSTONE_MODE = RedstoneMode.createParameter();
public static final TileDataParameter<Integer, TilePortableGrid> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.energyStorage.getEnergyStored());
public static final TileDataParameter<Integer, TilePortableGrid> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingDirection, (t, v) -> {
private static final TileDataParameter<Integer, TilePortableGrid> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.energyStorage.getEnergyStored());
private static final TileDataParameter<Integer, TilePortableGrid> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingDirection, (t, v) -> {
if (IGrid.isValidSortingDirection(v)) {
t.setSortingDirection(v);
t.markDirty();
}
}, (initial, p) -> TileGrid.trySortGrid(initial));
public static final TileDataParameter<Integer, TilePortableGrid> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingType, (t, v) -> {
private static final TileDataParameter<Integer, TilePortableGrid> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSortingType, (t, v) -> {
if (IGrid.isValidSortingType(v)) {
t.setSortingType(v);
t.markDirty();
}
}, (initial, p) -> TileGrid.trySortGrid(initial));
public static final TileDataParameter<Integer, TilePortableGrid> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSearchBoxMode, (t, v) -> {
private static final TileDataParameter<Integer, TilePortableGrid> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSearchBoxMode, (t, v) -> {
if (IGrid.isValidSearchBoxMode(v)) {
t.setSearchBoxMode(v);
t.markDirty();
}
}, (initial, p) -> GuiBase.executeLater(GuiGrid.class, grid -> grid.getSearchField().setMode(p)));
public static final TileDataParameter<Integer, TilePortableGrid> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSize, (t, v) -> {
private static final TileDataParameter<Integer, TilePortableGrid> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getSize, (t, v) -> {
if (IGrid.isValidSize(v)) {
t.setSize(v);
t.markDirty();
}
}, (initial, p) -> GuiBase.executeLater(GuiGrid.class, GuiBase::initGui));
public static final TileDataParameter<Integer, TilePortableGrid> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabSelected, (t, v) -> {
private static final TileDataParameter<Integer, TilePortableGrid> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabSelected, (t, v) -> {
t.setTabSelected(v == t.getTabSelected() ? -1 : v);
t.markDirty();
}, (initial, p) -> {
@@ -97,7 +95,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
GuiBase.executeLater(GuiGrid.class, grid -> grid.getView().sort());
}
});
public static final TileDataParameter<Integer, TilePortableGrid> TAB_PAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabPage, (t, v) -> {
private static final TileDataParameter<Integer, TilePortableGrid> TAB_PAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, TilePortableGrid::getTabPage, (t, v) -> {
if (v >= 0 && v <= t.getTotalTabPages()) {
t.setTabPage(v);
t.markDirty();
@@ -108,6 +106,8 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
private static final String NBT_DISK_STATE = "DiskState";
private static final String NBT_CONNECTED = "Connected";
private static final String NBT_STORAGE_TRACKER = "StorageTracker";
private static final String NBT_FLUID_STORAGE_TRACKER = "FluidStorageTracker";
private static final String NBT_TYPE = "Type";
private EnergyStorage energyStorage = recreateEnergyStorage(0);
private PortableGridType type;
@@ -121,10 +121,12 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
private int tabPage;
private int size;
private GridType clientGridType;
private List<IFilter> filters = new ArrayList<>();
private List<IGridTab> tabs = new ArrayList<>();
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) {
private ItemHandlerBase disk = new ItemHandlerBase(1, new ListenerTile(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
@Override
protected void onContentsChanged(int slot) {
super.onContentsChanged(slot);
@@ -136,14 +138,17 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
};
@Nullable
private IStorageDisk<ItemStack> storage;
private IStorageDisk storage;
@Nullable
private IStorageCache cache;
private StorageCacheItemPortable cache = new StorageCacheItemPortable(this);
private ItemGridHandlerPortable handler = new ItemGridHandlerPortable(this, this);
private ItemGridHandlerPortable itemHandler = new ItemGridHandlerPortable(this, this);
private FluidGridHandlerPortable fluidHandler = new FluidGridHandlerPortable(this);
private PortableGridDiskState diskState = PortableGridDiskState.NONE;
private boolean connected;
private StorageTrackerItem storageTracker = new StorageTrackerItem(this::markDirty);
private StorageTrackerFluid fluidStorageTracker = new StorageTrackerFluid(this::markDirty);
public TilePortableGrid() {
dataManager.addWatchedParameter(REDSTONE_MODE);
@@ -161,20 +166,38 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
if (diskStack.isEmpty()) {
this.storage = null;
this.cache = null;
} else {
IStorageDisk disk = API.instance().getStorageDiskManager(world).getByStack(getDisk().getStackInSlot(0));
if (disk != null) {
StorageType type = ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType();
switch (type) {
case ITEM:
this.storage = new StorageDiskItemPortable(disk, this);
this.cache = new StorageCacheItemPortable(this);
break;
case FLUID:
this.storage = new StorageDiskFluidPortable(disk, this);
this.cache = new StorageCacheFluidPortable(this);
break;
}
this.storage.setSettings(TilePortableGrid.this::checkIfDiskStateChanged, TilePortableGrid.this);
} else {
this.storage = null;
this.cache = null;
}
}
this.cache.invalidate();
if (cache != null) {
cache.invalidate();
}
this.checkIfDiskStateChanged();
checkIfDiskStateChanged();
WorldUtils.updateBlock(world, pos);
}
public PortableGridDiskState getDiskState() {
@@ -188,6 +211,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
public PortableGridType getPortableType() {
if (type == null) {
IBlockState state = world.getBlockState(pos);
if (state.getBlock() == RSBlocks.PORTABLE_GRID) {
this.type = (PortableGridType) state.getValue(BlockPortableGrid.TYPE);
}
@@ -218,6 +242,10 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
if (stack.getTagCompound().hasKey(PortableGrid.NBT_STORAGE_TRACKER)) {
storageTracker.readFromNbt(stack.getTagCompound().getTagList(PortableGrid.NBT_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
}
if (stack.getTagCompound().hasKey(PortableGrid.NBT_FLUID_STORAGE_TRACKER)) {
fluidStorageTracker.readFromNbt(stack.getTagCompound().getTagList(PortableGrid.NBT_FLUID_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
}
}
this.diskState = getDiskState(this);
@@ -242,6 +270,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
stack.getTagCompound().setInteger(NetworkNodeGrid.NBT_TAB_PAGE, tabPage);
stack.getTagCompound().setTag(PortableGrid.NBT_STORAGE_TRACKER, storageTracker.serializeNbt());
stack.getTagCompound().setTag(PortableGrid.NBT_FLUID_STORAGE_TRACKER, fluidStorageTracker.serializeNbt());
stack.getCapability(CapabilityEnergy.ENERGY, null).receiveEnergy(energyStorage.getEnergyStored(), false);
@@ -258,7 +287,11 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
@Override
public GridType getGridType() {
return GridType.NORMAL;
return clientGridType != null ? clientGridType : getServerGridType();
}
private GridType getServerGridType() {
return (getDisk().getStackInSlot(0).isEmpty() || ((IStorageDiskProvider) getDisk().getStackInSlot(0).getItem()).getType() == StorageType.ITEM) ? GridType.NORMAL : GridType.FLUID;
}
@Nullable
@@ -269,19 +302,19 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
@Override
public IStorageCacheListener createListener(EntityPlayerMP player) {
return new StorageCacheListenerGridPortable(this, player);
return getServerGridType() == GridType.FLUID ? new StorageCacheListenerGridPortableFluid(this, player) : new StorageCacheListenerGridPortable(this, player);
}
@Nullable
@Override
public IItemGridHandler getItemHandler() {
return handler;
return itemHandler;
}
@Nullable
@Override
public IFluidGridHandler getFluidHandler() {
return null;
return fluidHandler;
}
@Override
@@ -406,10 +439,15 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
}
@Override
public StorageTrackerItem getStorageTracker() {
public IStorageTracker<ItemStack> getItemStorageTracker() {
return storageTracker;
}
@Override
public IStorageTracker<FluidStack> getFluidStorageTracker() {
return fluidStorageTracker;
}
@Override
public InventoryCrafting getCraftingMatrix() {
return null;
@@ -463,13 +501,14 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
}
@Override
public IStorageCache<ItemStack> getCache() {
@Nullable
public IStorageCache getCache() {
return cache;
}
@Override
@Nullable
public IStorageDisk<ItemStack> getStorage() {
public IStorageDisk getStorage() {
return storage;
}
@@ -552,6 +591,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
redstoneMode.write(tag);
tag.setTag(NBT_STORAGE_TRACKER, storageTracker.serializeNbt());
tag.setTag(NBT_FLUID_STORAGE_TRACKER, fluidStorageTracker.serializeNbt());
return tag;
}
@@ -596,6 +636,10 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
if (tag.hasKey(NBT_STORAGE_TRACKER)) {
storageTracker.readFromNbt(tag.getTagList(NBT_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
}
if (tag.hasKey(NBT_FLUID_STORAGE_TRACKER)) {
fluidStorageTracker.readFromNbt(tag.getTagList(NBT_FLUID_STORAGE_TRACKER, Constants.NBT.TAG_COMPOUND));
}
}
@Override
@@ -612,6 +656,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
public NBTTagCompound writeUpdate(NBTTagCompound tag) {
tag.setInteger(NBT_DISK_STATE, diskState.getId());
tag.setBoolean(NBT_CONNECTED, getEnergy() != 0);
tag.setInteger(NBT_TYPE, getServerGridType().ordinal());
return super.writeUpdate(tag);
}
@@ -622,6 +667,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
diskState = PortableGridDiskState.getById(tag.getInteger(NBT_DISK_STATE));
connected = tag.getBoolean(NBT_CONNECTED);
clientGridType = GridType.values()[tag.getInteger(NBT_TYPE)];
}
@Override