diff options
Diffstat (limited to 'patches/server/1071-Improve-exact-choice-recipe-ingredients.patch')
-rw-r--r-- | patches/server/1071-Improve-exact-choice-recipe-ingredients.patch | 453 |
1 files changed, 453 insertions, 0 deletions
diff --git a/patches/server/1071-Improve-exact-choice-recipe-ingredients.patch b/patches/server/1071-Improve-exact-choice-recipe-ingredients.patch new file mode 100644 index 0000000000..88c45348a2 --- /dev/null +++ b/patches/server/1071-Improve-exact-choice-recipe-ingredients.patch @@ -0,0 +1,453 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic <[email protected]> +Date: Sun, 25 Jun 2023 23:10:14 -0700 +Subject: [PATCH] Improve exact choice recipe ingredients + +Fixes exact choices not working with recipe book clicks +and shapeless recipes. + +== AT == +public net.minecraft.world.item.ItemStackLinkedSet TYPE_AND_TAG + +diff --git a/src/main/java/io/papermc/paper/inventory/recipe/ItemOrExact.java b/src/main/java/io/papermc/paper/inventory/recipe/ItemOrExact.java +new file mode 100644 +index 0000000000000000000000000000000000000000..ce745e49cd54fe3ae187785563a1bd311d14b5b2 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/inventory/recipe/ItemOrExact.java +@@ -0,0 +1,63 @@ ++package io.papermc.paper.inventory.recipe; ++ ++import net.minecraft.core.Holder; ++import net.minecraft.world.item.ItemStack; ++ ++public sealed interface ItemOrExact permits ItemOrExact.Item, ItemOrExact.Exact { ++ ++ int getMaxStackSize(); ++ ++ boolean matches(ItemStack stack); ++ ++ record Item(Holder<net.minecraft.world.item.Item> item) implements ItemOrExact { ++ ++ public Item(final ItemStack stack) { ++ this(stack.getItemHolder()); ++ } ++ ++ @Override ++ public int getMaxStackSize() { ++ return this.item.value().getDefaultMaxStackSize(); ++ } ++ ++ @Override ++ public boolean matches(final ItemStack stack) { ++ return stack.is(this.item); ++ } ++ ++ @Override ++ public boolean equals(final Object obj) { ++ if (!(obj instanceof final Item otherItem)) return false; ++ return this.item.equals(otherItem.item()); ++ } ++ ++ @Override ++ public int hashCode() { ++ return this.item.hashCode(); ++ } ++ } ++ ++ record Exact(ItemStack stack) implements ItemOrExact { ++ ++ @Override ++ public int getMaxStackSize() { ++ return this.stack.getMaxStackSize(); ++ } ++ ++ @Override ++ public boolean matches(final ItemStack stack) { ++ return ItemStack.isSameItemSameComponents(this.stack, stack); ++ } ++ ++ @Override ++ public boolean equals(final Object obj) { ++ if (!(obj instanceof final Exact otherExact)) return false; ++ return ItemStack.isSameItemSameComponents(this.stack, otherExact.stack); ++ } ++ ++ @Override ++ public int hashCode() { ++ return ItemStack.hashItemAndComponents(this.stack); ++ } ++ } ++} +diff --git a/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java b/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java +new file mode 100644 +index 0000000000000000000000000000000000000000..f47c12e9dd6cfa857ca07a764edc22de372e25b6 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java +@@ -0,0 +1,68 @@ ++package io.papermc.paper.inventory.recipe; ++ ++import it.unimi.dsi.fastutil.objects.Object2IntMap; ++import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; ++import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet; ++import it.unimi.dsi.fastutil.objects.ObjectSet; ++import net.minecraft.world.entity.player.StackedContents; ++import net.minecraft.world.item.ItemStack; ++import net.minecraft.world.item.ItemStackLinkedSet; ++import net.minecraft.world.item.crafting.CraftingInput; ++import net.minecraft.world.item.crafting.Ingredient; ++import net.minecraft.world.item.crafting.Recipe; ++ ++public final class StackedContentsExtrasMap { ++ ++ private final StackedContents<ItemOrExact> contents; ++ public Object2IntMap<ItemOrExact.Item> regularRemoved = new Object2IntOpenHashMap<>(); // needed for re-using the regular contents (for ShapelessRecipe) ++ public final ObjectSet<ItemStack> exactIngredients = new ObjectOpenCustomHashSet<>(ItemStackLinkedSet.TYPE_AND_TAG); ++ ++ public StackedContentsExtrasMap(final StackedContents<ItemOrExact> contents) { ++ this.contents = contents; ++ } ++ ++ public void initialize(final Recipe<?> recipe) { ++ this.exactIngredients.clear(); ++ for (final Ingredient ingredient : recipe.placementInfo().ingredients()) { ++ if (ingredient.isExact()) { ++ this.exactIngredients.addAll(ingredient.itemStacks()); ++ } ++ } ++ } ++ ++ public void accountInput(final CraftingInput input) { ++ // similar logic to the CraftingInput constructor ++ for (final ItemStack item : input.items()) { ++ if (!item.isEmpty()) { ++ if (this.accountStack(item, 1)) { ++ // if stack was accounted for as an exact ingredient, don't include it in the regular contents ++ final ItemOrExact.Item asItem = new ItemOrExact.Item(item); ++ if (this.contents.amounts.containsKey(asItem)) { ++ final int amount = this.contents.amounts.removeInt(asItem); ++ this.regularRemoved.put(asItem, amount); ++ } ++ } ++ } ++ } ++ } ++ ++ public void resetExtras() { ++ // clear previous extra ids ++ for (final ItemStack extra : this.exactIngredients) { ++ this.contents.amounts.removeInt(new ItemOrExact.Exact(extra)); ++ } ++ for (final Object2IntMap.Entry<ItemOrExact.Item> entry : this.regularRemoved.object2IntEntrySet()) { ++ this.contents.amounts.addTo(entry.getKey(), entry.getIntValue()); ++ } ++ this.exactIngredients.clear(); ++ this.regularRemoved.clear(); ++ } ++ ++ public boolean accountStack(final ItemStack stack, final int count) { ++ if (this.exactIngredients.contains(stack)) { ++ this.contents.account(new ItemOrExact.Exact(stack), count); ++ return true; ++ } ++ return false; ++ } ++} +diff --git a/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java b/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java +index 6d3ccd19baab8f0571b71bd05979efb6b372a6f5..dc9b01db0853964da146ad4ccdc9e0e6f2a279f4 100644 +--- a/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java ++++ b/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java +@@ -40,6 +40,7 @@ public class ServerPlaceRecipe<R extends Recipe<?>> { + return RecipeBookMenu.PostPlaceAction.NOTHING; + } else { + StackedItemContents stackedItemContents = new StackedItemContents(); ++ stackedItemContents.initializeExtras(recipe.value(), null); // Paper - Improve exact choice recipe ingredients + inventory.fillStackedContents(stackedItemContents); + handler.fillCraftSlotsStackedContents(stackedItemContents); + return serverPlaceRecipe.tryPlaceRecipe(recipe, stackedItemContents); +@@ -99,7 +100,7 @@ public class ServerPlaceRecipe<R extends Recipe<?>> { + } + + int j = this.calculateAmountToCraft(i, bl); +- List<Holder<Item>> list = new ArrayList<>(); ++ List<io.papermc.paper.inventory.recipe.ItemOrExact> list = new ArrayList<>(); // Paper - Improve exact choice recipe ingredients + if (finder.canCraft(recipe.value(), j, list::add)) { + int k = clampToMaxStackSize(j, list); + if (k != j) { +@@ -114,7 +115,7 @@ public class ServerPlaceRecipe<R extends Recipe<?>> { + this.gridWidth, this.gridHeight, recipe.value(), recipe.value().placementInfo().slotsToIngredientIndex(), (slotx, index, x, y) -> { + if (slotx != -1) { + Slot slot2 = this.inputGridSlots.get(index); +- Holder<Item> holder = list.get(slotx); ++ io.papermc.paper.inventory.recipe.ItemOrExact holder = list.get(slotx); // Paper - Improve exact choice recipe ingredients + int jx = k; + + while (jx > 0) { +@@ -129,9 +130,11 @@ public class ServerPlaceRecipe<R extends Recipe<?>> { + } + } + +- private static int clampToMaxStackSize(int count, List<Holder<Item>> entries) { +- for (Holder<Item> holder : entries) { +- count = Math.min(count, holder.value().getDefaultMaxStackSize()); ++ // Paper start - Improve exact choice recipe ingredients ++ private static int clampToMaxStackSize(int count, List<io.papermc.paper.inventory.recipe.ItemOrExact> entries) { ++ for (io.papermc.paper.inventory.recipe.ItemOrExact holder : entries) { ++ count = Math.min(count, holder.getMaxStackSize()); ++ // Paper end - Improve exact choice recipe ingredients + } + + return count; +@@ -160,7 +163,7 @@ public class ServerPlaceRecipe<R extends Recipe<?>> { + } + } + +- private int moveItemToGrid(Slot slot, Holder<Item> item, int count) { ++ private int moveItemToGrid(Slot slot, io.papermc.paper.inventory.recipe.ItemOrExact item, int count) { // Paper - Improve exact choice recipe ingredients + ItemStack itemStack = slot.getItem(); + int i = this.inventory.findSlotMatchingCraftingIngredient(item, itemStack); + if (i == -1) { +diff --git a/src/main/java/net/minecraft/world/entity/player/Inventory.java b/src/main/java/net/minecraft/world/entity/player/Inventory.java +index 36ba57e95b84f3d598bf4be624d6c88b05a6f9a6..110456deaa662bc1c0f6ba7878bb3074869a4350 100644 +--- a/src/main/java/net/minecraft/world/entity/player/Inventory.java ++++ b/src/main/java/net/minecraft/world/entity/player/Inventory.java +@@ -188,11 +188,11 @@ public class Inventory implements Container, Nameable { + return !stack.isDamaged() && !stack.isEnchanted() && !stack.has(DataComponents.CUSTOM_NAME); + } + +- public int findSlotMatchingCraftingIngredient(Holder<Item> item, ItemStack stack) { ++ public int findSlotMatchingCraftingIngredient(io.papermc.paper.inventory.recipe.ItemOrExact item, ItemStack stack) { // Paper - Improve exact choice recipe ingredients + for (int i = 0; i < this.items.size(); ++i) { + ItemStack itemstack1 = (ItemStack) this.items.get(i); + +- if (!itemstack1.isEmpty() && itemstack1.is(item) && Inventory.isUsableForCrafting(itemstack1) && (stack.isEmpty() || ItemStack.isSameItemSameComponents(stack, itemstack1))) { ++ if (!itemstack1.isEmpty() && item.matches(itemstack1) && (!(item instanceof io.papermc.paper.inventory.recipe.ItemOrExact.Item) || Inventory.isUsableForCrafting(itemstack1)) && (stack.isEmpty() || ItemStack.isSameItemSameComponents(stack, itemstack1))) { // Paper - Improve exact choice recipe ingredients + return i; + } + } +diff --git a/src/main/java/net/minecraft/world/entity/player/StackedContents.java b/src/main/java/net/minecraft/world/entity/player/StackedContents.java +index b645962fbcebf937a477dc5c94d96be998a84105..f5d737d8a1ad10df8a74c11a6f6394ed0d2ca8be 100644 +--- a/src/main/java/net/minecraft/world/entity/player/StackedContents.java ++++ b/src/main/java/net/minecraft/world/entity/player/StackedContents.java +@@ -13,7 +13,7 @@ import java.util.List; + import javax.annotation.Nullable; + + public class StackedContents<T> { +- public final Reference2IntOpenHashMap<T> amounts = new Reference2IntOpenHashMap<>(); ++ public final it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<T> amounts = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(); // Paper - Improve exact choice recipe ingredients (don't use "reference" map) + + boolean hasAtLeast(T input, int minimum) { + return this.amounts.getInt(input) >= minimum; +@@ -49,7 +49,7 @@ public class StackedContents<T> { + List<T> getUniqueAvailableIngredientItems(Iterable<? extends StackedContents.IngredientInfo<T>> ingredients) { + List<T> list = new ArrayList<>(); + +- for (Entry<T> entry : Reference2IntMaps.fastIterable(this.amounts)) { ++ for (it.unimi.dsi.fastutil.objects.Object2IntMap.Entry<T> entry : it.unimi.dsi.fastutil.objects.Object2IntMaps.fastIterable(this.amounts)) { // Paper - Improve exact choice recipe ingredients (don't use "reference" map) + if (entry.getIntValue() > 0 && anyIngredientMatches(ingredients, entry.getKey())) { + list.add(entry.getKey()); + } +@@ -71,13 +71,13 @@ public class StackedContents<T> { + @VisibleForTesting + public int getResultUpperBound(List<? extends StackedContents.IngredientInfo<T>> ingredients) { + int i = Integer.MAX_VALUE; +- ObjectIterable<Entry<T>> objectIterable = Reference2IntMaps.fastIterable(this.amounts); ++ ObjectIterable<it.unimi.dsi.fastutil.objects.Object2IntMap.Entry<T>> objectIterable = it.unimi.dsi.fastutil.objects.Object2IntMaps.fastIterable(this.amounts); // Paper - Improve exact choice recipe ingredients (don't use "reference" map) + + label31: + for (StackedContents.IngredientInfo<T> ingredientInfo : ingredients) { + int j = 0; + +- for (Entry<T> entry : objectIterable) { ++ for (it.unimi.dsi.fastutil.objects.Object2IntMap.Entry<T> entry : objectIterable) { // Paper - Improve exact choice recipe ingredients (don't use "reference" map) + int k = entry.getIntValue(); + if (k > j) { + if (ingredientInfo.acceptsItem(entry.getKey())) { +diff --git a/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java b/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java +index 9436fb2bfc5f4463bd958c7cbf8d700dbf819890..209ddab9e96169fe4be373b2f6f289cf06f08537 100644 +--- a/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java ++++ b/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java +@@ -9,9 +9,14 @@ import net.minecraft.world.item.crafting.PlacementInfo; + import net.minecraft.world.item.crafting.Recipe; + + public class StackedItemContents { +- private final StackedContents<Holder<Item>> raw = new StackedContents<>(); ++ // Paper start - Improve exact choice recipe ingredients ++ private final StackedContents<io.papermc.paper.inventory.recipe.ItemOrExact> raw = new StackedContents<>(); ++ @Nullable ++ private io.papermc.paper.inventory.recipe.StackedContentsExtrasMap extrasMap = null; ++ // Paper start - Improve exact choice recipe ingredients + + public void accountSimpleStack(ItemStack item) { ++ if (this.extrasMap != null && this.extrasMap.accountStack(item, Math.min(64, item.getCount()))) return; // Paper - Improve exact choice recipe ingredients; max of 64 due to accountStack method below + if (Inventory.isUsableForCrafting(item)) { + this.accountStack(item); + } +@@ -24,36 +29,53 @@ public class StackedItemContents { + public void accountStack(ItemStack item, int maxCount) { + if (!item.isEmpty()) { + int i = Math.min(maxCount, item.getCount()); +- this.raw.account(item.getItemHolder(), i); ++ if (this.extrasMap != null && !item.getComponentsPatch().isEmpty() && this.extrasMap.accountStack(item, i)) return; // Paper - Improve exact choice recipe ingredients; if an exact ingredient, don't include it ++ this.raw.account(new io.papermc.paper.inventory.recipe.ItemOrExact.Item(item.getItemHolder()), i); + } + } + +- public boolean canCraft(Recipe<?> recipe, @Nullable StackedContents.Output<Holder<Item>> itemCallback) { ++ // Paper start - Improve exact choice recipe ingredients ++ public void initializeExtras(final Recipe<?> recipe, @Nullable final net.minecraft.world.item.crafting.CraftingInput input) { ++ if (this.extrasMap == null) { ++ this.extrasMap = new io.papermc.paper.inventory.recipe.StackedContentsExtrasMap(this.raw); ++ } ++ this.extrasMap.initialize(recipe); ++ if (input != null) this.extrasMap.accountInput(input); ++ } ++ ++ public void resetExtras() { ++ if (this.extrasMap != null && !this.raw.amounts.isEmpty()) { ++ this.extrasMap.resetExtras(); ++ } ++ } ++ // Paper end - Improve exact choice recipe ingredients ++ ++ public boolean canCraft(Recipe<?> recipe, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients + return this.canCraft(recipe, 1, itemCallback); + } + +- public boolean canCraft(Recipe<?> recipe, int quantity, @Nullable StackedContents.Output<Holder<Item>> itemCallback) { ++ public boolean canCraft(Recipe<?> recipe, int quantity, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients + PlacementInfo placementInfo = recipe.placementInfo(); + return !placementInfo.isImpossibleToPlace() && this.canCraft(placementInfo.ingredients(), quantity, itemCallback); + } + + public boolean canCraft( +- List<? extends StackedContents.IngredientInfo<Holder<Item>>> rawIngredients, @Nullable StackedContents.Output<Holder<Item>> itemCallback ++ List<? extends StackedContents.IngredientInfo<io.papermc.paper.inventory.recipe.ItemOrExact>> rawIngredients, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback // Paper - Improve exact choice recipe ingredients + ) { + return this.canCraft(rawIngredients, 1, itemCallback); + } + + private boolean canCraft( +- List<? extends StackedContents.IngredientInfo<Holder<Item>>> rawIngredients, int quantity, @Nullable StackedContents.Output<Holder<Item>> itemCallback ++ List<? extends StackedContents.IngredientInfo<io.papermc.paper.inventory.recipe.ItemOrExact>> rawIngredients, int quantity, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback // Paper - Improve exact choice recipe ingredients + ) { + return this.raw.tryPick(rawIngredients, quantity, itemCallback); + } + +- public int getBiggestCraftableStack(Recipe<?> recipe, @Nullable StackedContents.Output<Holder<Item>> itemCallback) { ++ public int getBiggestCraftableStack(Recipe<?> recipe, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients + return this.getBiggestCraftableStack(recipe, Integer.MAX_VALUE, itemCallback); + } + +- public int getBiggestCraftableStack(Recipe<?> recipe, int max, @Nullable StackedContents.Output<Holder<Item>> itemCallback) { ++ public int getBiggestCraftableStack(Recipe<?> recipe, int max, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients + return this.raw.tryPickAll(recipe.placementInfo().ingredients(), max, itemCallback); + } + +diff --git a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java +index 0bd0935e76038e07c063bbfc61fa1a6339c23eed..0b0054b3d5d56ba24e1aee0e3ab56ea5b01a82a8 100644 +--- a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java ++++ b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java +@@ -25,7 +25,7 @@ import java.util.List; + import javax.annotation.Nullable; + // CraftBukkit end + +-public final class Ingredient implements StackedContents.IngredientInfo<Holder<Item>>, Predicate<ItemStack> { ++public final class Ingredient implements StackedContents.IngredientInfo<io.papermc.paper.inventory.recipe.ItemOrExact>, Predicate<ItemStack> { // Paper - Improve exact choice recipe ingredients + + public static final StreamCodec<RegistryFriendlyByteBuf, Ingredient> CONTENTS_STREAM_CODEC = ByteBufCodecs.holderSet(Registries.ITEM).map(Ingredient::new, (recipeitemstack) -> { + return recipeitemstack.values; +@@ -44,19 +44,23 @@ public final class Ingredient implements StackedContents.IngredientInfo<Holder<I + private final HolderSet<Item> values; + // CraftBukkit start + @Nullable +- private List<ItemStack> itemStacks; ++ private java.util.Set<ItemStack> itemStacks; // Paper - Improve exact choice recipe ingredients + + public boolean isExact() { + return this.itemStacks != null; + } + +- public List<ItemStack> itemStacks() { ++ public java.util.Set<ItemStack> itemStacks() { // Paper - Improve exact choice recipe ingredients + return this.itemStacks; + } + + public static Ingredient ofStacks(List<ItemStack> stacks) { + Ingredient recipe = Ingredient.of(stacks.stream().map(ItemStack::getItem)); +- recipe.itemStacks = stacks; ++ // Paper start - Improve exact choice recipe ingredients ++ recipe.itemStacks = net.minecraft.world.item.ItemStackLinkedSet.createTypeAndComponentsSet(); ++ recipe.itemStacks.addAll(stacks); ++ recipe.itemStacks = java.util.Collections.unmodifiableSet(recipe.itemStacks); ++ // Paper end - Improve exact choice recipe ingredients + return recipe; + } + // CraftBukkit end +@@ -94,20 +98,22 @@ public final class Ingredient implements StackedContents.IngredientInfo<Holder<I + public boolean test(ItemStack itemstack) { + // CraftBukkit start + if (this.isExact()) { +- for (ItemStack itemstack1 : this.itemStacks()) { +- if (itemstack1.getItem() == itemstack.getItem() && ItemStack.isSameItemSameComponents(itemstack, itemstack1)) { +- return true; +- } +- } +- +- return false; ++ return this.itemStacks.contains(itemstack); // Paper - Improve exact choice recipe ingredients (hashing FTW!) + } + // CraftBukkit end + return itemstack.is(this.values); + } + +- public boolean acceptsItem(Holder<Item> holder) { +- return this.values.contains(holder); ++ // Paper start - Improve exact choice recipe ingredients ++ @Override ++ public boolean acceptsItem(final io.papermc.paper.inventory.recipe.ItemOrExact holder) { ++ return switch (holder) { ++ case io.papermc.paper.inventory.recipe.ItemOrExact.Item(final Holder<Item> item) -> ++ !this.isExact() && this.values.contains(item); ++ case io.papermc.paper.inventory.recipe.ItemOrExact.Exact(final ItemStack exact) -> ++ this.isExact() && this.itemStacks.contains(exact); ++ }; ++ // Paper end - Improve exact choice recipe ingredients + } + + public boolean equals(Object object) { +@@ -137,6 +143,11 @@ public final class Ingredient implements StackedContents.IngredientInfo<Holder<I + } + + public SlotDisplay display() { ++ // Paper start - show exact ingredients in recipe book ++ if (this.isExact()) { ++ return new SlotDisplay.Composite(this.itemStacks().stream().<SlotDisplay>map(SlotDisplay.ItemStackSlotDisplay::new).toList()); ++ } ++ // Paper end - show exact ingredients in recipe book + return (SlotDisplay) this.values.unwrap().map(SlotDisplay.TagSlotDisplay::new, (list) -> { + return new SlotDisplay.Composite(list.stream().map(Ingredient::displayForSingleItem).toList()); + }); +diff --git a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java +index 6ec7b234b468755835107be40d0080222c0b9263..12f95bee2a69fd5df7c4a165537e01299e60c5f6 100644 +--- a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java ++++ b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java +@@ -80,7 +80,18 @@ public class ShapelessRecipe implements CraftingRecipe { + } + + public boolean matches(CraftingInput input, Level world) { +- return input.ingredientCount() != this.ingredients.size() ? false : (input.size() == 1 && this.ingredients.size() == 1 ? ((Ingredient) this.ingredients.getFirst()).test(input.getItem(0)) : input.stackedContents().canCraft((Recipe) this, (StackedContents.Output) null)); ++ // Paper start - Improve exact choice recipe ingredients & unwrap ternary ++ if (input.ingredientCount() != this.ingredients.size()) { ++ return false; ++ } ++ if (input.size() == 1 && this.ingredients.size() == 1) { ++ return this.ingredients.getFirst().test(input.getItem(0)); ++ } ++ input.stackedContents().initializeExtras(this, input); ++ boolean canCraft = input.stackedContents().canCraft(this, null); ++ input.stackedContents().resetExtras(); ++ return canCraft; ++ // Paper end - Improve exact choice recipe ingredients & unwrap ternary + } + + public ItemStack assemble(CraftingInput input, HolderLookup.Provider registries) { |