Added the Regulator Upgrade that can be inserted into a Exporter. This ensures a certain amount of items and fluids is kept in stock in a connected inventory

CHANGELOG.md

@@ -5,6 +5,7 @@
 - Wireless Transmitters can now be placed on any block and in any direction (raoulvdberge)
 - Fixed Exporter not exporting anything when using a Stack Upgrade and there isn't space for 64 items in the inventory (raoulvdberge)
 - Fixed Controller always using the base usage even when turned off (raoulvdberge)
+- Added the Regulator Upgrade that can be inserted into a Exporter. This ensures a certain amount of items and fluids is kept in stock in a connected inventory (raoulvdberge)
 
 ### 1.8.2
 - Add Refined Storage silicon to forge:silicon tag for mod compatibility (jeremiahwinsley)

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java

@@ -3,6 +3,7 @@ package com.raoulvdberge.refinedstorage.apiimpl.network.node;
 import com.raoulvdberge.refinedstorage.RS;
 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.fluid.FluidInventory;
 import com.raoulvdberge.refinedstorage.inventory.item.BaseItemHandler;
 import com.raoulvdberge.refinedstorage.inventory.item.UpgradeItemHandler;
@@ -36,8 +37,35 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
     private BaseItemHandler itemFilters = new BaseItemHandler(9).addListener(new NetworkNodeInventoryListener(this));
     private FluidInventory fluidFilters = new FluidInventory(9).addListener(new NetworkNodeFluidInventoryListener(this));
 
-    private UpgradeItemHandler upgrades = (UpgradeItemHandler) new UpgradeItemHandler(4, UpgradeItem.Type.SPEED, UpgradeItem.Type.CRAFTING, UpgradeItem.Type.STACK)
+    private UpgradeItemHandler upgrades = (UpgradeItemHandler) new UpgradeItemHandler(4, UpgradeItem.Type.SPEED, UpgradeItem.Type.CRAFTING, UpgradeItem.Type.STACK, UpgradeItem.Type.REGULATOR)
-        .addListener(new NetworkNodeInventoryListener(this));
+        .addListener(new NetworkNodeInventoryListener(this))
+        .addListener((handler, slot, reading) -> {
+            if (!getUpgrades().hasUpgrade(UpgradeItem.Type.REGULATOR)) {
+                boolean changed = false;
+
+                for (int i = 0; i < itemFilters.getSlots(); ++i) {
+                    ItemStack filterSlot = itemFilters.getStackInSlot(i);
+
+                    if (filterSlot.getCount() > 1) {
+                        filterSlot.setCount(1);
+                        changed = true;
+                    }
+                }
+
+                for (int i = 0; i < fluidFilters.getSlots(); ++i) {
+                    FluidStack filterSlot = fluidFilters.getFluid(i);
+
+                    if (!filterSlot.isEmpty() && filterSlot.getAmount() != FluidAttributes.BUCKET_VOLUME) {
+                        filterSlot.setAmount(FluidAttributes.BUCKET_VOLUME);
+                        changed = true;
+                    }
+                }
+
+                if (changed) {
+                    markDirty();
+                }
+            }
+        });
 
     private int compare = IComparer.COMPARE_NBT;
     private int type = IType.ITEMS;
@@ -79,6 +107,29 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
                     if (!slot.isEmpty()) {
                         int stackSize = upgrades.getStackInteractCount();
 
+                        if (upgrades.hasUpgrade(UpgradeItem.Type.REGULATOR)) {
+                            int found = 0;
+
+                            for (int i = 0; i < handler.getSlots(); i++) {
+                                ItemStack stackInConnectedHandler = handler.getStackInSlot(i);
+
+                                if (API.instance().getComparer().isEqual(slot, stackInConnectedHandler, compare)) {
+                                    found += stackInConnectedHandler.getCount();
+                                }
+                            }
+
+                            int needed = 0;
+
+                            for (int i = 0; i < itemFilters.getSlots(); ++i) {
+                                if (API.instance().getComparer().isEqualNoQuantity(slot, itemFilters.getStackInSlot(i))) {
+                                    needed += itemFilters.getStackInSlot(i).getCount();
+                                }
+                            }
+
+                            stackSize = Math.min(stackSize, needed - found);
+                        }
+
+                        if (stackSize > 0) {
                             ItemStack took = network.extractItem(slot, Math.min(slot.getMaxStackSize(), stackSize), compare, Action.SIMULATE);
 
                             if (took.isEmpty()) {
@@ -97,6 +148,7 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
                                 }
                             }
                         }
+                    }
 
                     filterSlot++;
                 }
@@ -128,6 +180,29 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
                         if (stackInStorage != null) {
                             toExtract = Math.min(toExtract, stackInStorage.getAmount());
 
+                            if (upgrades.hasUpgrade(UpgradeItem.Type.REGULATOR)) {
+                                int found = 0;
+
+                                for (int i = 0; i < handler.getTanks(); i++) {
+                                    FluidStack stackInConnectedHandler = handler.getFluidInTank(i);
+
+                                    if (API.instance().getComparer().isEqual(stack, stackInConnectedHandler, compare)) {
+                                        found += stackInConnectedHandler.getAmount();
+                                    }
+                                }
+
+                                int needed = 0;
+
+                                for (int i = 0; i < fluidFilters.getSlots(); ++i) {
+                                    if (API.instance().getComparer().isEqual(stack, fluidFilters.getFluid(i), IComparer.COMPARE_NBT)) {
+                                        needed += fluidFilters.getFluid(i).getAmount();
+                                    }
+                                }
+
+                                toExtract = Math.min(toExtract, needed - found);
+                            }
+
+                            if (toExtract > 0) {
                                 FluidStack took = network.extractFluid(stack, toExtract, compare, Action.SIMULATE);
 
                                 int filled = handler.fill(took, IFluidHandler.FluidAction.SIMULATE);
@@ -137,6 +212,7 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
 
                                     handler.fill(took, IFluidHandler.FluidAction.EXECUTE);
                                 }
+                            }
                         } else if (upgrades.hasUpgrade(UpgradeItem.Type.CRAFTING)) {
                             network.getCraftingManager().request(this, stack, toExtract);
                         }
@@ -215,7 +291,7 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
         }
     }
 
-    public IItemHandler getUpgrades() {
+    public UpgradeItemHandler getUpgrades() {
         return upgrades;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/config/ServerConfig.java

@@ -311,6 +311,7 @@ public class ServerConfig {
         private final ForgeConfigSpec.IntValue fortune1UpgradeUsage;
         private final ForgeConfigSpec.IntValue fortune2UpgradeUsage;
         private final ForgeConfigSpec.IntValue fortune3UpgradeUsage;
+        private final ForgeConfigSpec.IntValue regulatorUpgradeUsage;
 
         public Upgrades() {
             builder.push("upgrades");
@@ -323,6 +324,7 @@ public class ServerConfig {
             fortune1UpgradeUsage = builder.comment("The additional energy used by the Fortune 1 Upgrade").defineInRange("fortune1UpgradeUsage", 10, 0, Integer.MAX_VALUE);
             fortune2UpgradeUsage = builder.comment("The additional energy used by the Fortune 2 Upgrade").defineInRange("fortune2UpgradeUsage", 12, 0, Integer.MAX_VALUE);
             fortune3UpgradeUsage = builder.comment("The additional energy used by the Fortune 3 Upgrade").defineInRange("fortune3UpgradeUsage", 14, 0, Integer.MAX_VALUE);
+            regulatorUpgradeUsage = builder.comment("The additional energy used by the Regulator Upgrade").defineInRange("regulatorUpgradeUsage", 15, 0, Integer.MAX_VALUE);
 
             builder.pop();
         }
@@ -358,6 +360,10 @@ public class ServerConfig {
         public int getFortune3UpgradeUsage() {
             return fortune3UpgradeUsage.get();
         }
+
+        public int getRegulatorUpgradeUsage() {
+            return regulatorUpgradeUsage.get();
+        }
     }
 
     public class StorageBlock {

src/main/java/com/raoulvdberge/refinedstorage/container/ExporterContainer.java

@@ -3,30 +3,56 @@ package com.raoulvdberge.refinedstorage.container;
 import com.raoulvdberge.refinedstorage.RSContainers;
 import com.raoulvdberge.refinedstorage.container.slot.filter.FilterSlot;
 import com.raoulvdberge.refinedstorage.container.slot.filter.FluidFilterSlot;
+import com.raoulvdberge.refinedstorage.item.UpgradeItem;
 import com.raoulvdberge.refinedstorage.tile.ExporterTile;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ExporterContainer extends BaseContainer {
+    private final ExporterTile exporter;
+
     public ExporterContainer(ExporterTile exporter, PlayerEntity player, int windowId) {
         super(RSContainers.EXPORTER, exporter, player, windowId);
 
+        this.exporter = exporter;
+
+        initSlots();
+    }
+
+    public void initSlots() {
+        this.inventorySlots.clear();
+        this.inventoryItemStacks.clear();
+
+        this.transferManager.clearTransfers();
+
         for (int i = 0; i < 4; ++i) {
             addSlot(new SlotItemHandler(exporter.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlot(new FilterSlot(exporter.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> exporter.getNode().getType() == IType.ITEMS));
+            addSlot(new FilterSlot(
+                exporter.getNode().getItemFilters(),
+                i,
+                8 + (18 * i),
+                20,
+                exporter.getNode().getUpgrades().hasUpgrade(UpgradeItem.Type.REGULATOR) ? FilterSlot.FILTER_ALLOW_SIZE : 0
+            ).setEnableHandler(() -> exporter.getNode().getType() == IType.ITEMS));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlot(new FluidFilterSlot(exporter.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> exporter.getNode().getType() == IType.FLUIDS));
+            addSlot(new FluidFilterSlot(
+                exporter.getNode().getFluidFilters(),
+                i,
+                8 + (18 * i),
+                20,
+                exporter.getNode().getUpgrades().hasUpgrade(UpgradeItem.Type.REGULATOR) ? FluidFilterSlot.FILTER_ALLOW_SIZE : 0
+            ).setEnableHandler(() -> exporter.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 55);
 
-        transferManager.addBiTransfer(player.inventory, exporter.getNode().getUpgrades());
+        transferManager.addBiTransfer(getPlayer().inventory, exporter.getNode().getUpgrades());
-        transferManager.addFilterTransfer(player.inventory, exporter.getNode().getItemFilters(), exporter.getNode().getFluidFilters(), exporter.getNode()::getType);
+        transferManager.addFilterTransfer(getPlayer().inventory, exporter.getNode().getItemFilters(), exporter.getNode().getFluidFilters(), exporter.getNode()::getType);
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/UpgradeItemHandler.java

@@ -69,24 +69,6 @@ public class UpgradeItemHandler extends BaseItemHandler {
         return usage;
     }
 
-    public int getFortuneLevel() {
-        int maxFortune = 0;
-
-        for (int i = 0; i < getSlots(); ++i) {
-            ItemStack slot = getStackInSlot(i);
-
-            if (slot.getItem() instanceof UpgradeItem) {
-                int fortune = ((UpgradeItem) slot.getItem()).getType().getFortuneLevel();
-
-                if (fortune > maxFortune) {
-                    maxFortune = fortune;
-                }
-            }
-        }
-
-        return maxFortune;
-    }
-
     public int getStackInteractCount() {
         return hasUpgrade(UpgradeItem.Type.STACK) ? 64 : 1;
     }

src/main/java/com/raoulvdberge/refinedstorage/item/UpgradeItem.java

@@ -22,7 +22,8 @@ public class UpgradeItem extends Item {
         SILK_TOUCH("silk_touch"),
         FORTUNE_1("fortune_1"),
         FORTUNE_2("fortune_2"),
-        FORTUNE_3("fortune_3");
+        FORTUNE_3("fortune_3"),
+        REGULATOR("regulator");
 
         private final String name;
 
@@ -54,6 +55,8 @@ public class UpgradeItem extends Item {
                     return RS.SERVER_CONFIG.getUpgrades().getFortune2UpgradeUsage();
                 case FORTUNE_3:
                     return RS.SERVER_CONFIG.getUpgrades().getFortune3UpgradeUsage();
+                case REGULATOR:
+                    return RS.SERVER_CONFIG.getUpgrades().getRegulatorUpgradeUsage();
                 default:
                     throw new IllegalStateException("What even am I?");
             }

src/main/java/com/raoulvdberge/refinedstorage/screen/ExporterScreen.java

@@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.screen;
 
 import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.container.ExporterContainer;
+import com.raoulvdberge.refinedstorage.item.UpgradeItem;
 import com.raoulvdberge.refinedstorage.screen.widget.sidebutton.ExactModeSideButton;
 import com.raoulvdberge.refinedstorage.screen.widget.sidebutton.RedstoneModeSideButton;
 import com.raoulvdberge.refinedstorage.screen.widget.sidebutton.TypeSideButton;
@@ -11,8 +12,16 @@ import net.minecraft.entity.player.PlayerInventory;
 import net.minecraft.util.text.ITextComponent;
 
 public class ExporterScreen extends BaseScreen<ExporterContainer> {
+    private boolean hasRegulatorMode;
+
     public ExporterScreen(ExporterContainer container, PlayerInventory playerInventory, ITextComponent title) {
         super(container, 211, 137, playerInventory, title);
+
+        this.hasRegulatorMode = hasRegulatorMode();
+    }
+
+    private boolean hasRegulatorMode() {
+        return ((ExporterTile) container.getTile()).getNode().getUpgrades().hasUpgrade(UpgradeItem.Type.REGULATOR);
     }
 
     @Override
@@ -26,6 +35,12 @@ public class ExporterScreen extends BaseScreen<ExporterContainer> {
 
     @Override
     public void tick(int x, int y) {
+        boolean updatedHasRegulatorMode = hasRegulatorMode();
+        if (hasRegulatorMode != updatedHasRegulatorMode) {
+            hasRegulatorMode = updatedHasRegulatorMode;
+
+            container.initSlots();
+        }
     }
 
     @Override

src/main/resources/assets/refinedstorage/lang/en_us.json

@@ -273,6 +273,7 @@
   "item.refinedstorage.fortune_1_upgrade": "Fortune Upgrade",
   "item.refinedstorage.fortune_2_upgrade": "Fortune Upgrade",
   "item.refinedstorage.fortune_3_upgrade": "Fortune Upgrade",
+  "item.refinedstorage.regulator_upgrade": "Regulator Upgrade",
   "item.refinedstorage.storage_housing": "Storage Housing",
   "item.refinedstorage.filter": "Filter",
   "item.refinedstorage.network_card": "Network Card",

src/main/resources/assets/refinedstorage/models/item/regulator_upgrade.json

@@ -0,0 +1,6 @@
+{
+  "parent": "item/generated",
+  "textures": {
+    "layer0": "refinedstorage:item/regulator_upgrade"
+  }
+}

src/main/resources/data/refinedstorage/recipes/regulator_upgrade.json

@@ -0,0 +1,25 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "pattern": [
+    "ECE",
+    "RUR",
+    "EEE"
+  ],
+  "key": {
+    "E": {
+      "item": "refinedstorage:quartz_enriched_iron"
+    },
+    "R": {
+      "item": "minecraft:redstone"
+    },
+    "C": {
+      "item": "minecraft:comparator"
+    },
+    "U": {
+      "item": "refinedstorage:upgrade"
+    }
+  },
+  "result": {
+    "item": "refinedstorage:regulator_upgrade"
+  }
+}