Fix a handful of QIO Crafting related bugs:

- Fixed a dupe bug caused by changes mojang made to remainders
- Fixed breaking a QIO Dashboard not persisting crafting window contents
- Fixed the QIO Portable Dashboard's Crafting Windows
- Also fixed some issue with the formulaic assemblicator relating to the changes mojang made crafting input overall size

Author: pupnewfster

README.md

@@ -28,12 +28,12 @@ of things that we haven't finished porting yet.
 
 ## Known Bugs/Things that aren't done being ported yet ##
 - Options in the Module Tweaker that have side effects don't currently have those side effects displayed
-- Fixed (Upcoming 10.6.2): Resistive Heaters do not keep their set Energy Usage when breaking and placing again
-- Fixed (Upcoming 10.6.2): Bins forget if they are locked and what they are locked too if broken and placed
 - When breaking and placing blocks that have fluid item input slots, they do not persist whether the item was actively being drained or whether it was being filled
-- The QIO Dashboard does not persist items stored in crafting windows when broken
-- The Portable QIO Dashboard's Crafting windows do not work at all. DO NOT TRY TO USE THEM
 - The Gravitational Modulation Unit does not currently provide flight
+- Fixed (Upcoming 10.6.2): Resistive Heaters do not keep their set Energy Usage when breaking and placing again
+- Fixed (Upcoming 10.6.2): Bins forget if they are locked and what they are locked too if broken and placed
+- Fixed (Upcoming 10.6.2): The QIO Dashboard does not persist items stored in crafting windows when broken
+- Fixed (Upcoming 10.6.2): The Portable QIO Dashboard's Crafting windows do not work at all. DO NOT TRY TO USE THEM
 - Probably many more things as we have done barely any testing so far
 
 ## Configuration ##

src/datagen/generated/mekanism/.cache/59eb3dbb5f86130e09b3c62d89b9525ee01cf52d

@@ -2,7 +2,6 @@
 
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
@@ -42,30 +41,23 @@ public static Optional<FormulaAttachment> existingFormula(ItemStack stack) {
     }
 
     public static FormulaAttachment create(RecipeFormula formula) {
-        List<ItemStack> stacks = new ArrayList<>(formula.craftingInput.size());
-        for (ItemStack stack : formula.craftingInput.items()) {
-            stacks.add(stack.copy());
-        }
-        return new FormulaAttachment(stacks, false);
+        return new FormulaAttachment(formula.getCopy(true), false);
     }
 
     public FormulaAttachment asInvalid() {
         if (invalid) {
             return this;
         }
-        List<ItemStack> stacks = new ArrayList<>(inventory.size());
-        for (ItemStack stack : inventory) {
-            stacks.add(stack.copy());
-        }
-        return new FormulaAttachment(stacks, true);
+        //Note: We don't have to copy the inventory as FormulaAttachment is immutable, so nothing should be mutating the backing stacks
+        return new FormulaAttachment(inventory, true);
     }
 
     public boolean isEmpty() {
         return inventory.stream().allMatch(ItemStack::isEmpty);
     }
 
     public boolean hasItems() {
-        return inventory.stream().anyMatch(slot -> !slot.isEmpty());
+        return inventory.stream().anyMatch(stack -> !stack.isEmpty());
     }
 
     @Override

src/datagen/generated/mekanism/data/mekanism/loot_table/blocks/qio_dashboard.json

@@ -30,6 +30,7 @@
 import mekanism.common.capabilities.Capabilities;
 import mekanism.common.capabilities.MultiTypeCapability;
 import mekanism.common.content.oredictionificator.OredictionificatorItemFilter;
+import mekanism.common.content.qio.IQIOCraftingWindowHolder;
 import mekanism.common.integration.energy.EnergyCompatUtils;
 import mekanism.common.inventory.slot.BasicInventorySlot;
 import mekanism.common.inventory.slot.EnergyInventorySlot;
@@ -80,12 +81,19 @@ public class ItemSlotsBuilder {
     private static final IBasicContainerCreator<ComponentBackedInventorySlot> FORMULA_SLOT_CREATOR = (type, attachedTo, containerIndex) -> new ComponentBackedInventorySlot(attachedTo,
           containerIndex, BasicInventorySlot.alwaysTrueBi, BasicInventorySlot.alwaysTrueBi, TileEntityFormulaicAssemblicator.FORMULA_SLOT_VALIDATOR);
 
-    //QOP drive slot
+    //QIO drive slot
     //Note: As we don't have to update the presence of a drive or remove it from the frequency we can make do with just using a basic slot
     //TODO - 1.20.4: Evaluate if copy the notExternal is correct or do we want this to have some other checks
     private static final IBasicContainerCreator<ComponentBackedInventorySlot> QIO_DRIVE_SLOT_CREATOR = (type, attachedTo, containerIndex) -> new ComponentBackedInventorySlot(attachedTo,
           containerIndex, BasicInventorySlot.notExternal, BasicInventorySlot.notExternal, QIODriveSlot.IS_QIO_ITEM);
 
+    //QIO Dashboard Crafting WINDOW
+    private static final IBasicContainerCreator<ComponentBackedInventorySlot> QIO_DASHBOARD_INPUT_SLOT_CREATOR = (type, attachedTo, containerIndex) -> new ComponentBackedInventorySlot(attachedTo,
+          containerIndex, BasicInventorySlot.notExternal, BasicInventorySlot.alwaysTrueBi, BasicInventorySlot.alwaysTrue);
+    //Note: We don't allow external means to modify this slot as it truthfully only exists to make logic easier
+    private static final IBasicContainerCreator<ComponentBackedInventorySlot> QIO_DASHBOARD_OUTPUT_SLOT_CREATOR = (type, attachedTo, containerIndex) -> new ComponentBackedInventorySlot(attachedTo,
+          containerIndex, BasicInventorySlot.internalOnly, BasicInventorySlot.internalOnly, BasicInventorySlot.alwaysTrue);
+
     //EnergyInventorySlot
     //Note: As energy is untyped we don't have to do extra checks about what is currently stored or not on the attached stack
     private static final BiPredicate<@NotNull ItemStack, @NotNull AutomationType> FILL_CONVERT_ENERGY_SLOT_CAN_EXTRACT = (stack, automationType) ->
@@ -169,8 +177,10 @@ public ItemSlotsBuilder addQIODriveSlots(int count) {
     }
 
     public ItemSlotsBuilder addQIODashboardSlots() {
-        //TODO - 1.21: IMPLEMENT Figure out how to do this
-        //new PortableQIODashboardInventory(null, stack).getSlots()
+        for (byte window = 0; window < IQIOCraftingWindowHolder.MAX_CRAFTING_WINDOWS; window++) {
+            addSlots(9, QIO_DASHBOARD_INPUT_SLOT_CREATOR);
+            addSlot(QIO_DASHBOARD_OUTPUT_SLOT_CREATOR);
+        }
         return this;
     }
 

src/main/java/mekanism/common/attachments/FormulaAttachment.java

@@ -2,10 +2,12 @@
 
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import mekanism.api.SerializationConstants;
 import mekanism.common.content.qio.IQIOCraftingWindowHolder;
+import net.minecraft.core.NonNullList;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.world.item.ItemStack;
@@ -14,6 +16,9 @@ public record PortableDashboardContents(List<ItemStack> contents) {
 
     public static final int TOTAL_SLOTS = (3 * 3) * IQIOCraftingWindowHolder.MAX_CRAFTING_WINDOWS;
 
+    //TODO: Do we want to try and make this an empty list? It not being empty means it is easier to not serialize things when the windows become empty
+    public static final PortableDashboardContents EMPTY = new PortableDashboardContents(NonNullList.withSize(TOTAL_SLOTS, ItemStack.EMPTY));
+
     public static final Codec<PortableDashboardContents> CODEC = RecordCodecBuilder.create(instance -> instance.group(
           ItemStack.OPTIONAL_CODEC.listOf(TOTAL_SLOTS, TOTAL_SLOTS).fieldOf(SerializationConstants.ITEMS).forGetter(PortableDashboardContents::contents)
     ).apply(instance, PortableDashboardContents::new));
@@ -25,6 +30,12 @@ public record PortableDashboardContents(List<ItemStack> contents) {
         contents = Collections.unmodifiableList(contents);
     }
 
+    public PortableDashboardContents with(int window, int index, ItemStack stack) {
+        List<ItemStack> copy = new ArrayList<>(contents);
+        copy.set(9 * window + index, stack);
+        return new PortableDashboardContents(copy);
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) {

src/main/java/mekanism/common/attachments/containers/item/ItemSlotsBuilder.java

@@ -1,6 +1,5 @@
 package mekanism.common.content.assemblicator;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import mekanism.api.inventory.IInventorySlot;
@@ -19,13 +18,15 @@
 
 public class RecipeFormula {
 
-    public final CraftingInput craftingInput;
+    public static final RecipeFormula EMPTY = new RecipeFormula();
+
+    public final CraftingInput.Positioned craftingInput;
     @Nullable
-    public RecipeHolder<CraftingRecipe> recipe;
+    public final RecipeHolder<CraftingRecipe> recipe;
 
-    public RecipeFormula() {
-        //TODO - 1.21: Re-evaluate this
-        craftingInput = CraftingInput.EMPTY;
+    private RecipeFormula() {
+        craftingInput = CraftingInput.Positioned.EMPTY;
+        recipe = null;
     }
 
     public RecipeFormula(Level world, FormulaAttachment attachment) {
@@ -34,7 +35,7 @@ public RecipeFormula(Level world, FormulaAttachment attachment) {
         recipe = getRecipeFromGrid(craftingInput, world);
     }
 
-    public RecipeFormula(Level world, CraftingInput craftingInput) {
+    private RecipeFormula(Level world, CraftingInput.Positioned craftingInput) {
         this.craftingInput = craftingInput;
         recipe = getRecipeFromGrid(this.craftingInput, world);
     }
@@ -46,26 +47,33 @@ public RecipeFormula(Level world, List<IInventorySlot> craftingGridSlots) {
     }
 
     public ItemStack getInputStack(int slot) {
-        return craftingInput.getItem(slot);
+        int row = slot / 3;
+        int column = slot % 3;
+        CraftingInput input = craftingInput.input();
+        if (row < craftingInput.top() || row >= craftingInput.top() + input.height() ||
+            column < craftingInput.left() || column >= craftingInput.left() + input.width()) {
+            return ItemStack.EMPTY;
+        }
+        return input.getItem(column - craftingInput.left(), row - craftingInput.top());
     }
 
     public boolean matches(Level world, List<IInventorySlot> craftingGridSlots) {
         if (recipe == null) {
             return false;
         }
         //Should always be a 3x3 grid for the size
-        return recipe.value().matches(MekanismUtils.getCraftingInputSlots(3, 3, craftingGridSlots, true), world);
+        return recipe.value().matches(MekanismUtils.getCraftingInputSlots(3, 3, craftingGridSlots, true).input(), world);
     }
 
     //Must have matches be called before this and be true as it assumes that the dummy inventory was set by it
     public ItemStack assemble(RegistryAccess registryAccess) {
-        return recipe == null ? ItemStack.EMPTY : recipe.value().assemble(craftingInput, registryAccess);
+        return recipe == null ? ItemStack.EMPTY : recipe.value().assemble(craftingInput.input(), registryAccess);
     }
 
     //Must have matches be called before this and be true as it assumes that the dummy inventory was set by it
     public NonNullList<ItemStack> getRemainingItems() {
         //Should never be null given the assumption matches is called first
-        return recipe == null ? NonNullList.create() : recipe.value().getRemainingItems(craftingInput);
+        return recipe == null ? NonNullList.create() : recipe.value().getRemainingItems(craftingInput.input());
     }
 
     public boolean isIngredientInPos(Level world, ItemStack stack, int i) {
@@ -86,20 +94,20 @@ public boolean isIngredientInPos(Level world, ItemStack stack, int i) {
             return true;
         }
 
-        List<ItemStack> dummy = new ArrayList<>(craftingInput.items());
+        List<ItemStack> dummy = getCopy(false);
         dummy.set(i, stack);
         return recipe.value().matches(CraftingInput.of(3, 3, dummy), world);
     }
 
     public boolean isValidIngredient(Level world, ItemStack stack) {
         if (recipe != null) {
-            for (ItemStack inputItem : craftingInput.items()) {
+            for (ItemStack inputItem : craftingInput.input().items()) {
                 //Short circuit if it is one of the items we already know about
                 if (!inputItem.isEmpty() && ItemStack.isSameItemSameComponents(inputItem, stack)) {
                     return true;
                 }
             }
-            List<ItemStack> dummy = new ArrayList<>(craftingInput.items());
+            List<ItemStack> dummy = getCopy(false);
             for (int i = 0; i < 9; i++) {
                 ItemStack inputItem = dummy.get(i);
                 //Skip slots that aren't expected to be empty
@@ -128,15 +136,31 @@ public boolean isFormulaEqual(RecipeFormula formula) {
         return Objects.equals(formula.getRecipe(), getRecipe());
     }
 
-    //TODO - 1.21: Re-evaluate this entire class, in particular this with stack stuff. Should we be copying stacks when we do dummy based stuff?
     public RecipeFormula withStack(Level world, int index, ItemStack stack) {
-        List<ItemStack> copy = new ArrayList<>(craftingInput.items());
+        if (this == EMPTY && stack.isEmpty()) {
+            return this;
+        }
+        List<ItemStack> copy = getCopy(false);
         copy.set(index, stack);
-        return new RecipeFormula(world, CraftingInput.of(3, 3, copy));
+        return new RecipeFormula(world, CraftingInput.ofPositioned(3, 3, copy));
     }
 
     @Nullable
-    private static RecipeHolder<CraftingRecipe> getRecipeFromGrid(CraftingInput input, Level world) {
-        return MekanismRecipeType.getRecipeFor(RecipeType.CRAFTING, input, world).orElse(null);
+    private static RecipeHolder<CraftingRecipe> getRecipeFromGrid(CraftingInput.Positioned input, Level world) {
+        return MekanismRecipeType.getRecipeFor(RecipeType.CRAFTING, input.input(), world).orElse(null);
+    }
+
+    public List<ItemStack> getCopy(boolean copyStacks) {
+        CraftingInput input = craftingInput.input();
+        List<ItemStack> stacks = NonNullList.withSize(9, ItemStack.EMPTY);
+        for (int row = 0; row < input.height(); row++) {
+            int shiftedRow = 3 * (craftingInput.top() + row);
+            for (int column = 0; column < input.width(); column++) {
+                int index = shiftedRow + craftingInput.left() + column;
+                ItemStack stack = input.getItem(column, row);
+                stacks.set(index, copyStacks ? stack.copy() : stack);
+            }
+        }
+        return stacks;
     }
 }

src/main/java/mekanism/common/attachments/qio/PortableDashboardContents.java

@@ -1,51 +1,52 @@
-package mekanism.common.attachments.qio;
+package mekanism.common.content.qio;
 
 import java.util.ArrayList;
 import java.util.List;
 import mekanism.api.inventory.IInventorySlot;
 import mekanism.common.attachments.FrequencyAware;
-import mekanism.common.content.qio.IQIOCraftingWindowHolder;
-import mekanism.common.content.qio.QIOCraftingWindow;
-import mekanism.common.content.qio.QIOFrequency;
+import mekanism.common.attachments.qio.PortableDashboardContents;
 import mekanism.common.registries.MekanismDataComponents;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.Nullable;
 
-//TODO - 1.21: Move this to a different package?
 public class PortableQIODashboardInventory implements IQIOCraftingWindowHolder {
 
     private final QIOCraftingWindow[] craftingWindows;
     private final List<IInventorySlot> slots;
     private final ItemStack stack;
     @Nullable
     private final Level level;
+    private boolean initializing;
 
     public PortableQIODashboardInventory(@Nullable Level level, ItemStack stack) {
         this.stack = stack;
         this.level = level;
         List<IInventorySlot> slots = new ArrayList<>();
         craftingWindows = new QIOCraftingWindow[MAX_CRAFTING_WINDOWS];
-        PortableDashboardContents contents = stack.get(MekanismDataComponents.QIO_DASHBOARD);
+        List<ItemStack> contents = stack.getOrDefault(MekanismDataComponents.QIO_DASHBOARD, PortableDashboardContents.EMPTY).contents();
+        initializing = true;
         for (int tableIndex = 0; tableIndex < craftingWindows.length; tableIndex++) {
-            QIOCraftingWindow craftingWindow = new QIOCraftingWindow(this, (byte) tableIndex);
+            int finalTableIndex = tableIndex;
+            QIOCraftingWindow craftingWindow = new QIOCraftingWindow(this, (byte) tableIndex, slot -> () -> {
+                //Skip contents change handling until we actually have our crafting window updated
+                if (!initializing) {
+                    ItemStack stored = craftingWindows[finalTableIndex].getInputSlot(slot).getStack().copy();
+                    PortableDashboardContents content = stack.getOrDefault(MekanismDataComponents.QIO_DASHBOARD, PortableDashboardContents.EMPTY);
+                    stack.set(MekanismDataComponents.QIO_DASHBOARD, content.with(finalTableIndex, slot, stored));
+                }
+            });
             craftingWindows[tableIndex] = craftingWindow;
             for (int slot = 0; slot < 9; slot++) {
                 IInventorySlot inputSlot = craftingWindow.getInputSlot(slot);
                 slots.add(inputSlot);
-                if (contents != null) {
-                    //Note: setStack will ensure the stack is copied
-                    inputSlot.setStack(contents.contents().get(tableIndex * 9 + slot));
-                }
+                //Note: setStack will ensure the stack is copied
+                inputSlot.setStack(contents.get(tableIndex * 9 + slot));
             }
             slots.add(craftingWindow.getOutputSlot());
         }
         this.slots = List.copyOf(slots);
-        //TODO - 1.21: Is this still necessary given we are doing it from the constructor?
-        //Force refresh the recipe
-        for (QIOCraftingWindow craftingWindow : craftingWindows) {
-            craftingWindow.invalidateRecipe();
-        }
+        initializing = false;
     }
 
     public List<IInventorySlot> getSlots() {
@@ -77,12 +78,5 @@ public QIOFrequency getFrequency() {
 
     @Override
     public void onContentsChanged() {
-        List<ItemStack> stacks = new ArrayList<>(PortableDashboardContents.TOTAL_SLOTS);
-        for (QIOCraftingWindow craftingWindow : craftingWindows) {
-            for (int slot = 0; slot < 9; slot++) {
-                stacks.add(craftingWindow.getInputSlot(slot).getStack().copy());
-            }
-        }
-        stack.set(MekanismDataComponents.QIO_DASHBOARD, new PortableDashboardContents(stacks));
     }
 }