MergeMode

- Implemented strict logic ensuring mode only transitions to higher strictness (Global -> Adjacent -> None).

Author: remakefactory

src/main/java/com/ref/aea/api/modifier/PatternEncodingModifier.java

@@ -24,8 +24,34 @@ ModificationResult apply(
       C customContext);
 
   record ModificationResult(
-      List<List<GenericStack>> inputs, List<GenericStack> outputs, boolean mergeAdjacently) {}
+      List<List<GenericStack>> inputs, List<GenericStack> outputs, MergeMode mergeMode) {}
 
   record ModificationContext(
       Object recipeBase, IRecipeSlotsView slotsView, Player player, boolean maxTransfer) {}
+
+  /**
+   * Defines how identical ingredients are merged during pattern encoding.
+   *
+   * <p>The merge mode is strictly monotonic, meaning it can only transition to a more restrictive
+   * state during the modification chain: {@link #GLOBAL} -> {@link #ADJACENT} -> {@link #NONE}.
+   */
+  enum MergeMode {
+    /**
+     * Standard AE2 behavior. Consolidates all equal items into a single slot, regardless of their
+     * position in the recipe.
+     */
+    GLOBAL,
+
+    /**
+     * Merges items only if they are sequentially adjacent in the list. Useful for recipes where
+     * order matters but consecutive duplicates should be combined.
+     */
+    ADJACENT,
+
+    /**
+     * No merging performed. Every item defined in the list occupies a new slot (until slots run
+     * out), preserving exact count and position.
+     */
+    NONE
+  }
 }

src/main/java/com/ref/aea/config/AEAClientConfig.java

@@ -1,6 +1,7 @@
 package com.ref.aea.config;
 
 import com.ref.aea.AEA;
+import com.ref.aea.api.modifier.PatternEncodingModifier;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -19,6 +20,17 @@ public class AEAClientConfig {
           .comment("Whether to use Encode Pattern Transfer Modifier")
           .define("useModifier", true);
 
+  private static final ForgeConfigSpec.EnumValue<PatternEncodingModifier.MergeMode>
+      GLOBAL_MERGE_MODE =
+          BUILDER
+              .comment(
+                  "Defines the global merge strategy for pattern encoding.",
+                  "GLOBAL: Standard AE2 behavior. Merges all identical items into one slot.",
+                  "ADJACENT: Merges identical items only if they are next to each other in the list.",
+                  "NONE: No merging. Every item gets its own slot (until full).",
+                  "Note: The merge mode is strictly monotonic (GLOBAL -> ADJACENT -> NONE). A higher strictness level set here or by other modifiers cannot be reverted.")
+              .defineEnum("globalMergeMode", PatternEncodingModifier.MergeMode.GLOBAL);
+
   private static final ForgeConfigSpec.IntValue IO_MULTIPLIER =
       BUILDER.defineInRange("ioMultiplier", 1, 1, Integer.MAX_VALUE);
 
@@ -37,6 +49,7 @@ public class AEAClientConfig {
   public static final ForgeConfigSpec SPEC = BUILDER.build();
 
   public static boolean useModifier;
+  public static PatternEncodingModifier.MergeMode globalMergeMode;
   public static int ioMultiplier;
   public static boolean ioLog;
   public static boolean debugLog;
@@ -47,6 +60,7 @@ public class AEAClientConfig {
   static void onLoad(final ModConfigEvent event) {
     if (event.getConfig().getSpec() != SPEC) return;
     useModifier = USE_MODIFIER.get();
+    globalMergeMode = GLOBAL_MERGE_MODE.get();
     ioMultiplier = IO_MULTIPLIER.get();
     inputsBlackList =
         INPUTS_BLACK_LIST.get().stream().map(ResourceLocation::parse).collect(Collectors.toSet());

src/main/java/com/ref/aea/core/modifier/GlobalModifier.java

@@ -66,7 +66,7 @@ public ModificationResult apply(
             .toList();
 
     return new ModificationResult(
-        processedInputs, processedOutputs, modificationResult.mergeAdjacently());
+        processedInputs, processedOutputs, AEAClientConfig.globalMergeMode);
   }
 
   public GenericStack applyMultiplier(GenericStack stack) {

src/main/java/com/ref/aea/core/modifier/PatternEncodingModifierService.java

@@ -18,6 +18,7 @@
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
 import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.NotNull;
 
 @OnlyIn(Dist.CLIENT)
 public class PatternEncodingModifierService {
@@ -45,50 +46,80 @@ public static void encode(
       boolean maxTransfer) {
     List<List<GenericStack>> inputs = GenericEntryStackHelper.ofInputs(slotsView);
     List<GenericStack> outputs = GenericEntryStackHelper.ofOutputs(slotsView);
+
     PatternEncodingModifier.ModificationResult modificationResult =
-        new PatternEncodingModifier.ModificationResult(inputs, outputs, false);
+        new PatternEncodingModifier.ModificationResult(
+            inputs, outputs, PatternEncodingModifier.MergeMode.GLOBAL);
+
     PatternEncodingModifier.ModificationContext modificationContext =
         new PatternEncodingModifier.ModificationContext(recipeBase, slotsView, player, maxTransfer);
 
     for (var modifier : Modifiers) {
-      modificationResult = modifier.modify(modificationResult, modificationContext);
+      modificationResult = getModificationResult(modificationResult, modificationContext, modifier);
     }
-    modificationResult = GlobalModifier.INSTANCE.modify(modificationResult, modificationContext);
 
-    if (modificationResult.mergeAdjacently()) {
-      PatternEncodingModifierService.encodeProcessingRecipeAdjacentMerge(
-          menu, modificationResult.inputs(), modificationResult.outputs());
-    } else {
+    modificationResult =
+        getModificationResult(modificationResult, modificationContext, GlobalModifier.INSTANCE);
+
+    if (modificationResult.mergeMode() == PatternEncodingModifier.MergeMode.GLOBAL) {
       EncodingHelper.encodeProcessingRecipe(
           menu, modificationResult.inputs(), modificationResult.outputs());
+    } else {
+      PatternEncodingModifierService.encodeProcessingRecipeCustom(
+          menu,
+          modificationResult.inputs(),
+          modificationResult.outputs(),
+          modificationResult.mergeMode());
     }
   }
 
-  public static void encodeProcessingRecipeAdjacentMerge(
+  private static PatternEncodingModifier.@NotNull ModificationResult getModificationResult(
+      PatternEncodingModifier.ModificationResult modificationResult,
+      PatternEncodingModifier.ModificationContext modificationContext,
+      PatternEncodingModifier<?> modifier) {
+    var beforeGlobalMode = modificationResult.mergeMode();
+    var afterGlobalResult = modifier.modify(modificationResult, modificationContext);
+
+    if (afterGlobalResult.mergeMode().ordinal() < beforeGlobalMode.ordinal()) {
+      modificationResult =
+          new PatternEncodingModifier.ModificationResult(
+              afterGlobalResult.inputs(), afterGlobalResult.outputs(), beforeGlobalMode);
+    } else {
+      modificationResult = afterGlobalResult;
+    }
+    return modificationResult;
+  }
+
+  public static void encodeProcessingRecipeCustom(
       PatternEncodingTermMenu menu,
       List<List<GenericStack>> genericIngredients,
-      List<GenericStack> genericResults) {
+      List<GenericStack> genericResults,
+      PatternEncodingModifier.MergeMode mode) {
+
     menu.setMode(EncodingMode.PROCESSING);
     Map<AEKey, Integer> ingredientPriorities =
         EncodingHelper.getIngredientPriorities(menu, ENTRY_COMPARATOR);
-    encodeBestMatchingStacksIntoSlotsAdjacent(
-        genericIngredients, ingredientPriorities, menu.getProcessingInputSlots());
-    encodeBestMatchingStacksIntoSlotsAdjacent(
+
+    encodeBestMatchingStacksIntoSlots(
+        genericIngredients, ingredientPriorities, menu.getProcessingInputSlots(), mode);
+    encodeBestMatchingStacksIntoSlots(
         genericResults.stream().map(List::of).toList(),
         ingredientPriorities,
-        menu.getProcessingOutputSlots());
+        menu.getProcessingOutputSlots(),
+        mode);
   }
 
-  private static void encodeBestMatchingStacksIntoSlotsAdjacent(
+  private static void encodeBestMatchingStacksIntoSlots(
       List<List<GenericStack>> possibleInputsBySlot,
       Map<AEKey, Integer> ingredientPriorities,
-      FakeSlot[] slots) {
+      FakeSlot[] slots,
+      PatternEncodingModifier.MergeMode mode) {
+
     ArrayList<GenericStack> encodedInputs = new ArrayList<>();
 
     for (List<GenericStack> genericIngredient : possibleInputsBySlot) {
       if (!genericIngredient.isEmpty()) {
-        addOrMergeAdjacent(
-            encodedInputs, findBestIngredient(ingredientPriorities, genericIngredient));
+        addStack(encodedInputs, findBestIngredient(ingredientPriorities, genericIngredient), mode);
       }
     }
 
@@ -111,8 +142,9 @@ private static GenericStack findBestIngredient(
         .orElseThrow();
   }
 
-  private static void addOrMergeAdjacent(List<GenericStack> stacks, GenericStack newStack) {
-    if (!stacks.isEmpty()) {
+  private static void addStack(
+      List<GenericStack> stacks, GenericStack newStack, PatternEncodingModifier.MergeMode mode) {
+    if (mode == PatternEncodingModifier.MergeMode.ADJACENT && !stacks.isEmpty()) {
       int lastIndex = stacks.size() - 1;
       GenericStack lastStack = stacks.get(lastIndex);
 

src/main/java/com/ref/aea/integration/create/MechanicalCraftingRecipePatternEncodingModifier.java

@@ -28,6 +28,7 @@ public ModificationResult apply(
       ModificationResult modificationResult,
       ModificationContext modificationContext,
       Boolean customContext) {
-    return new ModificationResult(modificationResult.inputs(), modificationResult.outputs(), true);
+    return new ModificationResult(
+        modificationResult.inputs(), modificationResult.outputs(), MergeMode.ADJACENT);
   }
 }