Cleanup some formula related code:

pupnewfster · pupnewfster · commit e72bd3fee3b2 · 2024-06-16T16:13:20.000-05:00
- Fixed some cases where we were using the wrong set of inputs for calculating the output and remainder in Formulaic Assemblicators
- Made formula related things nonnull to make the code cleaner
- Allow clearing formulas with the configuration reset recipe rather than requiring sneak clicking to clear them
diff --git a/src/main/java/mekanism/client/ClientRegistration.java b/src/main/java/mekanism/client/ClientRegistration.java
@@ -246,16 +246,14 @@ public static void init(FMLClientSetupEvent event) {
             ClientRegistrationUtil.setPropertyOverride(MekanismBlocks.CARDBOARD_BOX, Mekanism.rl("storage"),
                   (stack, world, entity, seed) -> stack.has(MekanismDataComponents.BLOCK_DATA) ? 1 : 0);
 
-            ClientRegistrationUtil.setPropertyOverride(MekanismItems.CRAFTING_FORMULA, Mekanism.rl("invalid"), (stack, world, entity, seed) ->
-                  FormulaAttachment.existingFormula(stack)
-                        .filter(attachment -> attachment.hasItems() && attachment.invalid())
-                        .isPresent() ? 1 : 0
-            );
-            ClientRegistrationUtil.setPropertyOverride(MekanismItems.CRAFTING_FORMULA, Mekanism.rl("encoded"), (stack, world, entity, seed) ->
-                  FormulaAttachment.existingFormula(stack)
-                        .filter(attachment -> attachment.hasItems() && !attachment.invalid())
-                        .isPresent() ? 1 : 0
-            );
+            ClientRegistrationUtil.setPropertyOverride(MekanismItems.CRAFTING_FORMULA, Mekanism.rl("invalid"), (stack, world, entity, seed) -> {
+                FormulaAttachment attachment = stack.getOrDefault(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY);
+                return attachment.hasItems() && attachment.invalid() ? 1 : 0;
+            });
+            ClientRegistrationUtil.setPropertyOverride(MekanismItems.CRAFTING_FORMULA, Mekanism.rl("encoded"), (stack, world, entity, seed) -> {
+                FormulaAttachment attachment = stack.getOrDefault(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY);
+                return attachment.hasItems() && !attachment.invalid() ? 1 : 0;
+            });
             ClientRegistrationUtil.setPropertyOverride(MekanismItems.CONFIGURATION_CARD, Mekanism.rl("encoded"),
                   (stack, world, entity, seed) -> ((ItemConfigurationCard) stack.getItem()).hasData(stack) ? 1 : 0);
 
diff --git a/src/main/java/mekanism/client/gui/machine/GuiFormulaicAssemblicator.java b/src/main/java/mekanism/client/gui/machine/GuiFormulaicAssemblicator.java
@@ -68,9 +68,9 @@ protected void addGuiElements() {
               (element, mouseX, mouseY) -> PacketUtils.sendToServer(new PacketGuiInteract(GuiInteraction.STOCK_CONTROL_BUTTON, ((GuiFormulaicAssemblicator) element.gui()).tile)),
               MekanismLang.STOCK_CONTROL.translate(OnOff.ON), MekanismLang.STOCK_CONTROL.translate(OnOff.OFF)));
         fillEmptyButton = addRenderableWidget(new ToggleButton(this, 44, 75, 16, 16, getButtonLocation("empty"),
-              getButtonLocation("fill"), () -> tile.formula == null, (element, mouseX, mouseY) -> {
+              getButtonLocation("fill"), () -> tile.formula.isEmpty(), (element, mouseX, mouseY) -> {
             TileEntityFormulaicAssemblicator tile = ((GuiFormulaicAssemblicator) element.gui()).tile;
-            GuiInteraction interaction = tile.formula == null ? GuiInteraction.EMPTY_GRID : GuiInteraction.FILL_GRID;
+            GuiInteraction interaction = tile.formula.isEmpty() ? GuiInteraction.EMPTY_GRID : GuiInteraction.FILL_GRID;
             return PacketUtils.sendToServer(new PacketGuiInteract(interaction, tile));
         }, MekanismLang.EMPTY_ASSEMBLICATOR.translate(), MekanismLang.FILL_ASSEMBLICATOR.translate()));
         craftSingleButton = addRenderableWidget(new MekanismImageButton(this, 71, 75, 16, getButtonLocation("craft_single"),
@@ -136,8 +136,7 @@ private boolean canEncode() {
         if (!tile.hasValidFormula()) {
             ItemStack stack = tile.getFormulaSlot().getStack();
             if (!stack.isEmpty() && stack.getItem() instanceof ItemCraftingFormula) {
-                FormulaAttachment existingFormula = stack.get(MekanismDataComponents.FORMULA_HOLDER);
-                return existingFormula == null || !existingFormula.isEmpty();
+                return stack.getOrDefault(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY).isEmpty();
             }
         }
         return false;
diff --git a/src/main/java/mekanism/common/attachments/FormulaAttachment.java b/src/main/java/mekanism/common/attachments/FormulaAttachment.java
@@ -4,19 +4,20 @@
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import java.util.Collections;
 import java.util.List;
-import java.util.Optional;
+import java.util.stream.Stream;
 import mekanism.api.SerializationConstants;
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.common.content.assemblicator.RecipeFormula;
-import mekanism.common.item.ItemCraftingFormula;
-import mekanism.common.registries.MekanismDataComponents;
+import net.minecraft.core.NonNullList;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.ByteBufCodecs;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.world.item.ItemStack;
 
 @NothingNullByDefault
-public record FormulaAttachment(List<ItemStack> inventory, boolean invalid) {//TODO - 1.21: Do we want an empty variant of this?
+public record FormulaAttachment(List<ItemStack> inventory, boolean invalid) {
+
+    public static final FormulaAttachment EMPTY = new FormulaAttachment(NonNullList.withSize(9, ItemStack.EMPTY), false);
 
     public static final Codec<FormulaAttachment> CODEC = RecordCodecBuilder.create(instance -> instance.group(
           ItemStack.OPTIONAL_CODEC.listOf(9, 9).fieldOf(SerializationConstants.ITEMS).forGetter(FormulaAttachment::inventory),
@@ -33,17 +34,11 @@ public record FormulaAttachment(List<ItemStack> inventory, boolean invalid) {//T
         inventory = Collections.unmodifiableList(inventory);
     }
 
-    public static Optional<FormulaAttachment> existingFormula(ItemStack stack) {
-        if (!stack.isEmpty() && stack.getItem() instanceof ItemCraftingFormula) {
-            return Optional.ofNullable(stack.get(MekanismDataComponents.FORMULA_HOLDER));
-        }
-        return Optional.empty();
-    }
-
     public static FormulaAttachment create(RecipeFormula formula) {
         return new FormulaAttachment(formula.getCopy(true), false);
     }
 
+    //TODO - 1.21: I don't think this gets set if in a player's inventory when a reload happens or they rejoin after recipes have changed
     public FormulaAttachment asInvalid() {
         if (invalid) {
             return this;
@@ -53,10 +48,23 @@ public FormulaAttachment asInvalid() {
     }
 
     public boolean isEmpty() {
+        if (this == EMPTY) {
+            return true;
+        }
         return inventory.stream().allMatch(ItemStack::isEmpty);
     }
 
+    public Stream<ItemStack> nonEmptyItems() {
+        if (this == EMPTY) {
+            return Stream.empty();
+        }
+        return inventory.stream().filter(stack -> !stack.isEmpty());
+    }
+
     public boolean hasItems() {
+        if (this == EMPTY) {
+            return false;
+        }
         return inventory.stream().anyMatch(stack -> !stack.isEmpty());
     }
 
diff --git a/src/main/java/mekanism/common/content/assemblicator/RecipeFormula.java b/src/main/java/mekanism/common/content/assemblicator/RecipeFormula.java
@@ -1,13 +1,11 @@
 package mekanism.common.content.assemblicator;
 
 import java.util.List;
-import java.util.Objects;
 import mekanism.api.inventory.IInventorySlot;
 import mekanism.common.attachments.FormulaAttachment;
 import mekanism.common.recipe.MekanismRecipeType;
 import mekanism.common.util.MekanismUtils;
 import net.minecraft.core.NonNullList;
-import net.minecraft.core.RegistryAccess;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.CraftingInput;
 import net.minecraft.world.item.crafting.CraftingRecipe;
@@ -16,37 +14,45 @@
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.Nullable;
 
-public class RecipeFormula {
+public record RecipeFormula(CraftingInput.Positioned craftingInput, @Nullable RecipeHolder<CraftingRecipe> recipe) {
 
-    public static final RecipeFormula EMPTY = new RecipeFormula();
+    public static final RecipeFormula EMPTY = new RecipeFormula(CraftingInput.Positioned.EMPTY, null);
 
-    public final CraftingInput.Positioned craftingInput;
-    @Nullable
-    public final RecipeHolder<CraftingRecipe> recipe;
-
-    private RecipeFormula() {
-        craftingInput = CraftingInput.Positioned.EMPTY;
-        recipe = null;
+    public static RecipeFormula create(Level world, FormulaAttachment attachment) {
+        //Should always be a 3x3 grid for the size
+        return create(world, MekanismUtils.getCraftingInput(3, 3, attachment.inventory(), true));
     }
 
-    public RecipeFormula(Level world, FormulaAttachment attachment) {
+    public static RecipeFormula create(Level world, List<IInventorySlot> craftingGridSlots) {
         //Should always be a 3x3 grid for the size
-        craftingInput = MekanismUtils.getCraftingInput(3, 3, attachment.inventory(), true);
-        recipe = getRecipeFromGrid(craftingInput, world);
+        return create(world, MekanismUtils.getCraftingInputSlots(3, 3, craftingGridSlots, true));
     }
 
-    private RecipeFormula(Level world, CraftingInput.Positioned craftingInput) {
-        this.craftingInput = craftingInput;
-        recipe = getRecipeFromGrid(this.craftingInput, world);
+    public static RecipeFormula create(Level world, CraftingInput.Positioned craftingInput) {
+        if (craftingInput.input().isEmpty()) {
+            return EMPTY;
+        }
+        return new RecipeFormula(craftingInput, MekanismRecipeType.getRecipeFor(RecipeType.CRAFTING, craftingInput.input(), world).orElse(null));
     }
 
-    public RecipeFormula(Level world, List<IInventorySlot> craftingGridSlots) {
-        //Should always be a 3x3 grid for the size
-        craftingInput = MekanismUtils.getCraftingInputSlots(3, 3, craftingGridSlots, true);
-        recipe = getRecipeFromGrid(craftingInput, world);
+    public RecipeFormula withStack(Level world, int index, ItemStack stack) {
+        if (isEmpty() && stack.isEmpty()) {
+            return this;
+        }
+        List<ItemStack> copy = getCopy(false);
+        ItemStack old = copy.set(index, stack);
+        if (old != null && ItemStack.isSameItemSameComponents(old, stack)) {
+            //Nothing changed, don't bother creating new objects
+            //TODO: If there is a performance problem, try to optimize this to being above copying the list
+            return this;
+        }
+        return create(world, CraftingInput.ofPositioned(3, 3, copy));
     }
 
     public ItemStack getInputStack(int slot) {
+        if (isEmpty()) {
+            return ItemStack.EMPTY;
+        }
         int row = slot / 3;
         int column = slot % 3;
         CraftingInput input = craftingInput.input();
@@ -57,6 +63,14 @@ public ItemStack getInputStack(int slot) {
         return input.getItem(column - craftingInput.left(), row - craftingInput.top());
     }
 
+    public boolean isEmpty() {
+        return this == EMPTY;
+    }
+
+    public boolean valid() {
+        return recipe != null;
+    }
+
     public boolean matches(Level world, List<IInventorySlot> craftingGridSlots) {
         if (recipe == null) {
             return false;
@@ -65,17 +79,6 @@ public boolean matches(Level world, List<IInventorySlot> craftingGridSlots) {
         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.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.input());
-    }
-
     public boolean isIngredientInPos(Level world, ItemStack stack, int i) {
         if (recipe == null) {
             return false;
@@ -123,36 +126,12 @@ public boolean isValidIngredient(Level world, ItemStack stack) {
         return false;
     }
 
-    public boolean isValidFormula() {
-        return getRecipe() != null;
-    }
-
-    @Nullable
-    public RecipeHolder<CraftingRecipe> getRecipe() {
-        return recipe;
-    }
-
-    public boolean isFormulaEqual(RecipeFormula formula) {
-        return Objects.equals(formula.getRecipe(), getRecipe());
-    }
-
-    public RecipeFormula withStack(Level world, int index, ItemStack stack) {
-        if (this == EMPTY && stack.isEmpty()) {
-            return this;
-        }
-        List<ItemStack> copy = getCopy(false);
-        copy.set(index, stack);
-        return new RecipeFormula(world, CraftingInput.ofPositioned(3, 3, copy));
-    }
-
-    @Nullable
-    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);
+        if (isEmpty()) {
+            return stacks;
+        }
+        CraftingInput input = craftingInput.input();
         for (int row = 0; row < input.height(); row++) {
             int shiftedRow = 3 * (craftingInput.top() + row);
             for (int column = 0; column < input.width(); column++) {
diff --git a/src/main/java/mekanism/common/item/ItemCraftingFormula.java b/src/main/java/mekanism/common/item/ItemCraftingFormula.java
@@ -4,7 +4,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Optional;
 import java.util.stream.Collectors;
 import mekanism.api.text.EnumColor;
 import mekanism.api.text.TextComponentUtil;
@@ -25,14 +24,12 @@
 public class ItemCraftingFormula extends Item {
 
     public ItemCraftingFormula(Properties properties) {
-        super(properties);
+        super(properties.component(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY));
     }
 
     @Override
     public void appendHoverText(@NotNull ItemStack itemStack, @NotNull Item.TooltipContext context, @NotNull List<Component> tooltip, @NotNull TooltipFlag flag) {
-        Map<HashedItem, Integer> stacks = FormulaAttachment.existingFormula(itemStack)
-              .stream().flatMap(attachment -> attachment.inventory().stream())
-              .filter(stack -> !stack.isEmpty())
+        Map<HashedItem, Integer> stacks = itemStack.getOrDefault(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY).nonEmptyItems()
               .collect(Collectors.toMap(HashedItem::raw, ItemStack::getCount, Integer::sum, LinkedHashMap::new));
         if (!stacks.isEmpty()) {
             tooltip.add(MekanismLang.INGREDIENTS.translateColored(EnumColor.GRAY));
@@ -48,7 +45,7 @@ public InteractionResultHolder<ItemStack> use(@NotNull Level world, Player playe
         ItemStack stack = player.getItemInHand(hand);
         if (player.isShiftKeyDown()) {
             if (!world.isClientSide) {
-                stack.remove(MekanismDataComponents.FORMULA_HOLDER);
+                stack.set(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY);
             }
             return InteractionResultHolder.sidedSuccess(stack, world.isClientSide);
         }
@@ -58,10 +55,8 @@ public InteractionResultHolder<ItemStack> use(@NotNull Level world, Player playe
     @NotNull
     @Override
     public Component getName(@NotNull ItemStack stack) {
-        Optional<FormulaAttachment> formulaAttachment = FormulaAttachment.existingFormula(stack)
-              .filter(FormulaAttachment::hasItems);
-        if (formulaAttachment.isPresent()) {
-            FormulaAttachment attachment = formulaAttachment.get();
+        FormulaAttachment attachment = stack.getOrDefault(MekanismDataComponents.FORMULA_HOLDER, FormulaAttachment.EMPTY);
+        if (attachment.hasItems()) {
             if (attachment.invalid()) {
                 return TextComponentUtil.build(super.getName(stack), " ", EnumColor.DARK_RED, MekanismLang.INVALID);
             }
diff --git a/src/main/java/mekanism/common/recipe/ClearConfigurationRecipe.java b/src/main/java/mekanism/common/recipe/ClearConfigurationRecipe.java
@@ -58,6 +58,7 @@ public class ClearConfigurationRecipe extends CustomRecipe {
         set.add(MekanismDataComponents.STABILIZER_CHUNKS);
         set.add(MekanismDataComponents.FILTER_AWARE);
         set.add(MekanismDataComponents.CONFIGURATION_DATA);
+        set.add(MekanismDataComponents.FORMULA_HOLDER);
 
         set.add(MekanismDataComponents.ATTACHED_HEAT);
         //TODO: Do we want to clear frequencies?
diff --git a/src/main/java/mekanism/common/tile/machine/TileEntityFormulaicAssemblicator.java b/src/main/java/mekanism/common/tile/machine/TileEntityFormulaicAssemblicator.java
