Throwing more code at it

- Fixed incorrect re-packager behaviour when ordering multiple recipes from a stock ticker with non-uniform ingredients

Author: simibubi

src/main/java/com/simibubi/create/content/logistics/BigItemStack.java

@@ -1,6 +1,8 @@
 package com.simibubi.create.content.logistics;
 
+import java.util.ArrayList;
 import java.util.Comparator;
+import java.util.List;
 import java.util.Objects;
 
 import net.minecraft.nbt.CompoundTag;
@@ -75,4 +77,11 @@ public String toString() {
 			.getString() + " x" + count + ")";
 	}
 
+	public static List<BigItemStack> duplicateWrappers(List<BigItemStack> list) {
+		List<BigItemStack> copy = new ArrayList<>();
+		for (BigItemStack bigItemStack : list)
+			copy.add(new BigItemStack(bigItemStack.stack, bigItemStack.count));
+		return copy;
+	}
+	
 }

src/main/java/com/simibubi/create/content/logistics/factoryBoard/FactoryPanelScreen.java

@@ -98,14 +98,15 @@ private void updateConfigs() {
 			return;
 		}
 
-		craftingIngredients = convertRecipeToPackageOrderContext(availableCraftingRecipe, inputConfig);
+		craftingIngredients = convertRecipeToPackageOrderContext(availableCraftingRecipe, inputConfig, false);
 	}
 
-	public static List<BigItemStack> convertRecipeToPackageOrderContext(CraftingRecipe availableCraftingRecipe, List<BigItemStack> inputs) {
+	public static List<BigItemStack> convertRecipeToPackageOrderContext(CraftingRecipe availableCraftingRecipe, List<BigItemStack> inputs, boolean respectAmounts) {
 		List<BigItemStack> craftingIngredients = new ArrayList<>();
 		BigItemStack emptyIngredient = new BigItemStack(ItemStack.EMPTY, 1);
 		NonNullList<Ingredient> ingredients = availableCraftingRecipe.getIngredients();
-
+		List<BigItemStack> mutableInputs = BigItemStack.duplicateWrappers(inputs);
+		
 		int width = Math.min(3, ingredients.size());
 		int height = Math.min(3, ingredients.size() / 3 + 1);
 
@@ -125,9 +126,14 @@ public static List<BigItemStack> convertRecipeToPackageOrderContext(CraftingReci
 			BigItemStack craftingIngredient = emptyIngredient;
 
 			if (!ingredient.isEmpty())
-				for (BigItemStack bigItemStack : inputs)
-					if (ingredient.test(bigItemStack.stack))
+				for (BigItemStack bigItemStack : mutableInputs)
+					if (bigItemStack.count > 0 && ingredient.test(bigItemStack.stack)) {
 						craftingIngredient = new BigItemStack(bigItemStack.stack, 1);
+						if (respectAmounts)
+							bigItemStack.count -= 1;
+						break;
+					}
+			
 			craftingIngredients.add(craftingIngredient);
 
 			if (width < 3 && (i + 1) % width == 0)

src/main/java/com/simibubi/create/content/logistics/stockTicker/StockKeeperRequestScreen.java

@@ -1368,10 +1368,45 @@ private void sendIt() {
 			for (CraftableBigItemStack cbis : recipesToOrder) {
 				if (!(cbis.recipe instanceof CraftingRecipe cr))
 					continue;
-				PackageOrder pattern =
-					new PackageOrder(FactoryPanelScreen.convertRecipeToPackageOrderContext(cr, itemsToOrder));
-				int count = cbis.count / cbis.getOutputCount(blockEntity.getLevel());
-				craftList.add(new CraftingEntry(pattern, count));
+				int craftedCount = 0;
+				int targetCount = cbis.count / cbis.getOutputCount(blockEntity.getLevel());
+				List<BigItemStack> mutableOrder = BigItemStack.duplicateWrappers(itemsToOrder);
+				
+				while (craftedCount < targetCount) {
+					// Carefully split the ordered recipes based on what exactly will be used to craft them
+					PackageOrder pattern = new PackageOrder(FactoryPanelScreen.convertRecipeToPackageOrderContext(cr, mutableOrder, true));
+					int maxCrafts = targetCount - craftedCount;
+					int availableCrafts = 0;
+					
+					boolean itemsExhausted = false;
+					Outer: while (availableCrafts < maxCrafts && !itemsExhausted) {
+						List<BigItemStack> previousSnapshot = BigItemStack.duplicateWrappers(mutableOrder);
+						itemsExhausted = true;
+						Pattern: for (BigItemStack patternStack : pattern.stacks()) {
+							if (patternStack.stack.isEmpty())
+								continue;
+							for (BigItemStack ordered : mutableOrder) {
+								if (!ItemHandlerHelper.canItemStacksStack(ordered.stack, patternStack.stack))
+									continue;
+								if (ordered.count == 0)
+									continue;
+								ordered.count -= 1;
+								itemsExhausted = false;
+								continue Pattern;
+							}
+							mutableOrder = previousSnapshot;
+							break Outer;
+						}
+						availableCrafts++;
+					}
+					
+					if (availableCrafts == 0)
+						break;
+					
+					craftList.add(new CraftingEntry(pattern, availableCrafts));
+					craftedCount += availableCrafts;
+				}
+				
 			}
 			order = new PackageOrderWithCrafts(order.orderedStacks(), craftList);
 		}
@@ -1517,7 +1552,7 @@ private Pair<Integer, List<List<BigItemStack>>> maxCraftable(CraftableBigItemSta
 																 Function<ItemStack, Integer> countModifier, int newTypeLimit) {
 		List<Ingredient> ingredients = cbis.getIngredients();
 		List<List<BigItemStack>> validEntriesByIngredient = new ArrayList<>();
-		List<ItemStack> visited = new ArrayList<>();
+		List<BigItemStack> alreadyCreated = new ArrayList<>();
 
 		for (Ingredient ingredient : ingredients) {
 			if (ingredient.isEmpty())
@@ -1528,17 +1563,18 @@ private Pair<Integer, List<List<BigItemStack>>> maxCraftable(CraftableBigItemSta
 				Entries:for (BigItemStack entry : list) {
 					if (!ingredient.test(entry.stack))
 						continue;
+					for (BigItemStack visitedStack : alreadyCreated) {
+						if (!ItemHandlerHelper.canItemStacksStack(visitedStack.stack, entry.stack))
+							continue;
+						valid.add(visitedStack);
+						continue Entries;
+					}
 					BigItemStack asBis = new BigItemStack(entry.stack,
 						summary.getCountOf(entry.stack) + countModifier.apply(entry.stack));
-					if (asBis.count > 0)
+					if (asBis.count > 0) {
 						valid.add(asBis);
-					for (ItemStack visitedStack : visited) {
-						if (!ItemHandlerHelper.canItemStacksStack(visitedStack, entry.stack))
-							continue;
-						visitedStack.grow(1);
-						continue Entries;
+						alreadyCreated.add(asBis);
 					}
-					visited.add(entry.stack.copyWithCount(1));
 				}
 
 			if (valid.isEmpty())
@@ -1562,15 +1598,7 @@ private Pair<Integer, List<List<BigItemStack>>> maxCraftable(CraftableBigItemSta
 		}
 
 		// Ingredients with shared items must divide counts
-		for (ItemStack visitedItem : visited) {
-			for (List<BigItemStack> list : validEntriesByIngredient) {
-				for (BigItemStack entry : list) {
-					if (!ItemHandlerHelper.canItemStacksStack(entry.stack, visitedItem))
-						continue;
-					entry.count = entry.count / visitedItem.getCount();
-				}
-			}
-		}
+		validEntriesByIngredient = resolveIngredientAmounts(validEntriesByIngredient);
 
 		// Determine the bottlenecking ingredient
 		int minCount = Integer.MAX_VALUE;
@@ -1616,6 +1644,40 @@ private void removeLeastEssentialItemStack(List<List<BigItemStack>> validIngredi
 		for (List<BigItemStack> list : validIngredients)
 			list.remove(chosen);
 	}
+	
+	private List<List<BigItemStack>> resolveIngredientAmounts(List<List<BigItemStack>> validIngredients) {
+		List<List<BigItemStack>> resolvedIngredients = new ArrayList<>();
+		for (int i = 0; i < validIngredients.size(); i++)
+			resolvedIngredients.add(new ArrayList<>());
+		
+		boolean everythingTaken = false;
+		while (!everythingTaken) {
+			everythingTaken = true;
+			Ingredients: for (int i = 0; i < validIngredients.size(); i++) {
+				List<BigItemStack> list = validIngredients.get(i);
+				List<BigItemStack> resolvedList = resolvedIngredients.get(i);
+				for (BigItemStack bigItemStack : list) {
+					if (bigItemStack.count == 0)
+						continue;
+					
+					bigItemStack.count -= 1;
+					everythingTaken = false;
+					
+					for (BigItemStack resolvedItemStack : resolvedList) {
+						if (resolvedItemStack.stack == bigItemStack.stack) {
+							resolvedItemStack.count++;
+							continue Ingredients;
+						}
+					}
+					
+					resolvedList.add(new BigItemStack(bigItemStack.stack, 1));
+					continue Ingredients;
+				}
+			}
+		}
+		
+		return resolvedIngredients;
+	}
 
 	private void syncJEI() {
 		if (Mods.JEI.isLoaded() && AllConfigs.client().syncJeiSearch.get())