From da9d110d5bf8ffb090d63cd6a443b22ef1ab9d64 Mon Sep 17 00:00:00 2001 From: Spottedleaf Date: Thu, 28 Nov 2024 17:39:40 -0800 Subject: Remove chunk save reattempt patch This patch does not appear to be doing anything useful, and may hide errors. Currently, the save logic does not run through this path either so it did not do anything. Additionally, properly implement support for handling RegionFileSizeException in Moonrise. --- ...0-Improve-exact-choice-recipe-ingredients.patch | 436 +++++++++++++++++++++ 1 file changed, 436 insertions(+) create mode 100644 patches/server/1060-Improve-exact-choice-recipe-ingredients.patch (limited to 'patches/server/1060-Improve-exact-choice-recipe-ingredients.patch') diff --git a/patches/server/1060-Improve-exact-choice-recipe-ingredients.patch b/patches/server/1060-Improve-exact-choice-recipe-ingredients.patch new file mode 100644 index 0000000000..eaed7d5bad --- /dev/null +++ b/patches/server/1060-Improve-exact-choice-recipe-ingredients.patch @@ -0,0 +1,436 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic +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. + +Feature patch + +== 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..caaad8f54fb892dfd6c7d4e02ab9c32997f89a6a +--- /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 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) && stack.getComponentsPatch().isEmpty(); ++ } ++ ++ @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..bdb876a0e687d4b9e885118523e91185a164b27c +--- /dev/null ++++ b/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java +@@ -0,0 +1,67 @@ ++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.Recipe; ++ ++public final class StackedContentsExtrasMap { ++ ++ private final StackedContents contents; ++ public Object2IntMap regularRemoved = new Object2IntOpenHashMap<>(); // needed for re-using the regular contents (for ShapelessRecipe) ++ public final ObjectSet exactIngredients = new ObjectOpenCustomHashSet<>(ItemStackLinkedSet.TYPE_AND_TAG); ++ ++ public StackedContentsExtrasMap(final StackedContents contents) { ++ this.contents = contents; ++ } ++ ++ public void initialize(final Recipe recipe) { ++ this.exactIngredients.clear(); ++ for (final StackedContents.IngredientInfo info : recipe.placementInfo().unpackedIngredients()) { ++ if (info.isExact()) { ++ this.exactIngredients.addAll(info.allowedItems().stream().map(o -> ((ItemOrExact.Exact) o).stack()).toList()); ++ } ++ } ++ } ++ ++ 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 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 462a970ffa610bc1eb3c813dafb768c014d077d1..1afb544fb028b645821063ba1eaa9e3c45cee63f 100644 +--- a/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java ++++ b/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java +@@ -41,6 +41,7 @@ public class ServerPlaceRecipe> { + 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); +@@ -100,9 +101,9 @@ public class ServerPlaceRecipe> { + } + + int j = this.calculateAmountToCraft(i, bl); +- List> list = new ArrayList<>(); ++ List list = new ArrayList<>(); // Paper - Improve exact choice recipe ingredients + if (finder.canCraft(recipe.value(), j, list::add)) { +- OptionalInt optionalInt = list.stream().mapToInt(item -> item.value().getDefaultMaxStackSize()).min(); ++ OptionalInt optionalInt = list.stream().mapToInt(io.papermc.paper.inventory.recipe.ItemOrExact::getMaxStackSize).min(); // Paper - Improve exact choice recipe ingredients + if (optionalInt.isPresent()) { + j = Math.min(j, optionalInt.getAsInt()); + } +@@ -119,7 +120,7 @@ public class ServerPlaceRecipe> { + int kx = k; + + while (kx > 0) { +- Holder holder = list.get(jx); ++ io.papermc.paper.inventory.recipe.ItemOrExact holder = list.get(jx); // Paper - Improve exact choice recipe ingredients + kx = this.moveItemToGrid(slot2, holder, kx); + if (kx == -1) { + return; +@@ -155,7 +156,7 @@ public class ServerPlaceRecipe> { + } + } + +- private int moveItemToGrid(Slot slot, Holder item, int count) { ++ private int moveItemToGrid(Slot slot, io.papermc.paper.inventory.recipe.ItemOrExact item, int count) { // Paper - Improve exact choice recipe ingredients + int i = this.inventory.findSlotMatchingCraftingIngredient(item); + if (i == -1) { + return -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 ad82e5aeb565b23c3ec565fa60e1f31d1710bd4e..0990bcf65f484b9a019c91fcdae1783bac6388da 100644 +--- a/src/main/java/net/minecraft/world/entity/player/Inventory.java ++++ b/src/main/java/net/minecraft/world/entity/player/Inventory.java +@@ -201,11 +201,11 @@ public class Inventory implements Container, Nameable { + return !stack.isDamaged() && !stack.isEnchanted() && !stack.has(DataComponents.CUSTOM_NAME); + } + +- public int findSlotMatchingCraftingIngredient(Holder item) { ++ public int findSlotMatchingCraftingIngredient(io.papermc.paper.inventory.recipe.ItemOrExact item) { // Paper - Improve exact choice recipe ingredients + for (int i = 0; i < this.items.size(); ++i) { + ItemStack itemstack = (ItemStack) this.items.get(i); + +- if (!itemstack.isEmpty() && itemstack.is(item) && Inventory.isUsableForCrafting(itemstack)) { ++ if (!itemstack.isEmpty() && item.matches(itemstack) && (!(item instanceof io.papermc.paper.inventory.recipe.ItemOrExact.Item) || isUsableForCrafting(itemstack))) { // 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 3bc7c9b3df5547c6564696fce67417c96ffdebf9..9ad3c4510f0e0530dfbbc3ba7e6d19b7678e1294 100644 +--- a/src/main/java/net/minecraft/world/entity/player/StackedContents.java ++++ b/src/main/java/net/minecraft/world/entity/player/StackedContents.java +@@ -10,7 +10,7 @@ import java.util.Set; + import javax.annotation.Nullable; + + public class StackedContents { +- public final Reference2IntOpenHashMap amounts = new Reference2IntOpenHashMap<>(); ++ public final it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap amounts = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(); // Paper - Improve exact choice recipe ingredients (don't use "reference" map) + + boolean hasAnyAmount(T input) { + return this.amounts.getInt(input) > 0; +@@ -47,12 +47,13 @@ public class StackedContents { + this.put(input, count); + } + +- public static record IngredientInfo(List allowedItems) { +- public IngredientInfo(List allowedItems) { ++ public static record IngredientInfo(List allowedItems, boolean isExact) { // Paper - Improve exact choice recipe ingredients ++ public IngredientInfo(List allowedItems, boolean isExact) { // Paper - Improve exact choice recipe ingredients + if (allowedItems.isEmpty()) { + throw new IllegalArgumentException("Ingredients can't be empty"); + } else { + this.allowedItems = allowedItems; ++ this.isExact = isExact; // Paper - Improve exact choice recipe ingredients + } + } + } +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 cc6c5cf0d1034ed074b6c354c307a0c2613f85c7..3f075c5c12f7ce331200fddb1b6602380d6f5f3e 100644 +--- a/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java ++++ b/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java +@@ -12,9 +12,14 @@ import net.minecraft.world.item.crafting.PlacementInfo; + import net.minecraft.world.item.crafting.Recipe; + + public class StackedItemContents { +- private final StackedContents> raw = new StackedContents<>(); ++ // Paper start - Improve exact choice recipe ingredients ++ private final StackedContents 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); + } +@@ -27,39 +32,56 @@ 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 static StackedContents.IngredientInfo> convertIngredientContents(Stream> items) { +- List> list = items.sorted(Comparator.comparingInt(item -> BuiltInRegistries.ITEM.getId(item.value()))).toList(); +- return new StackedContents.IngredientInfo<>(list); ++ // 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(); ++ } ++ } ++ ++ public static StackedContents.IngredientInfo convertIngredientContents(Stream items, boolean isExact) { ++ List list = items.sorted(Comparator.comparingInt(item -> isExact ? ItemStack.hashItemAndComponents(((io.papermc.paper.inventory.recipe.ItemOrExact.Exact) item).stack()) : BuiltInRegistries.ITEM.getId(((io.papermc.paper.inventory.recipe.ItemOrExact.Item) item).item().value()))).toList(); ++ return new StackedContents.IngredientInfo<>(list, isExact); ++ // Paper end - Improve exact choice recipe ingredients + } + +- public boolean canCraft(Recipe recipe, @Nullable StackedContents.Output> itemCallback) { ++ public boolean canCraft(Recipe recipe, @Nullable StackedContents.Output itemCallback) { // Paper - Improve exact choice recipe ingredients + return this.canCraft(recipe, 1, itemCallback); + } + +- public boolean canCraft(Recipe recipe, int quantity, @Nullable StackedContents.Output> itemCallback) { ++ public boolean canCraft(Recipe recipe, int quantity, @Nullable StackedContents.Output itemCallback) { // Paper - Improve exact choice recipe ingredients + PlacementInfo placementInfo = recipe.placementInfo(); + return !placementInfo.isImpossibleToPlace() && this.canCraft(placementInfo.unpackedIngredients(), quantity, itemCallback); + } + +- public boolean canCraft(List>> rawIngredients, @Nullable StackedContents.Output> itemCallback) { ++ public boolean canCraft(List> rawIngredients, @Nullable StackedContents.Output itemCallback) { // Paper - Improve exact choice recipe ingredients + return this.canCraft(rawIngredients, 1, itemCallback); + } + + private boolean canCraft( +- List>> rawIngredients, int quantity, @Nullable StackedContents.Output> itemCallback ++ List> rawIngredients, int quantity, @Nullable StackedContents.Output itemCallback // Paper - Improve exact choice recipe ingredients + ) { + return this.raw.tryPick(rawIngredients, quantity, itemCallback); + } + +- public int getBiggestCraftableStack(Recipe recipe, @Nullable StackedContents.Output> itemCallback) { ++ public int getBiggestCraftableStack(Recipe recipe, @Nullable StackedContents.Output 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> itemCallback) { ++ public int getBiggestCraftableStack(Recipe recipe, int max, @Nullable StackedContents.Output itemCallback) { // Paper - Improve exact choice recipe ingredients + return this.raw.tryPickAll(recipe.placementInfo().unpackedIngredients(), 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 2dce801e06687c218be3333ac9f000bae09f0caf..812f919a7a7e309c8513f44104f092496037608f 100644 +--- a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java ++++ b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java +@@ -139,6 +139,11 @@ public final class Ingredient implements Predicate { + } + + public SlotDisplay display() { ++ // Paper start - show exact ingredients in recipe book ++ if (this.isExact()) { ++ return new SlotDisplay.Composite(this.itemStacks().stream().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/PlacementInfo.java b/src/main/java/net/minecraft/world/item/crafting/PlacementInfo.java +index 43124a000f48e243d75df64051fbda816035af25..400fd1cdfd17d4d34552f9bb3d91bc71fd394301 100644 +--- a/src/main/java/net/minecraft/world/item/crafting/PlacementInfo.java ++++ b/src/main/java/net/minecraft/world/item/crafting/PlacementInfo.java +@@ -11,26 +11,28 @@ import net.minecraft.world.item.Item; + public class PlacementInfo { + public static final PlacementInfo NOT_PLACEABLE = new PlacementInfo(List.of(), List.of(), List.of()); + private final List ingredients; +- private final List>> unpackedIngredients; ++ private final List> unpackedIngredients; // Paper - Improve exact choice recipe ingredients + private final List> slotInfo; + + private PlacementInfo( +- List ingredients, List>> rawIngredients, List> placementSlots ++ List ingredients, List> rawIngredients, List> placementSlots // Paper - Improve exact choice recipe ingredients + ) { + this.ingredients = ingredients; + this.unpackedIngredients = rawIngredients; + this.slotInfo = placementSlots; + } + +- public static StackedContents.IngredientInfo> ingredientToContents(Ingredient ingredient) { +- return StackedItemContents.convertIngredientContents(ingredient.items().stream()); ++ // Paper start - Improve exact choice recipe ingredients ++ public static StackedContents.IngredientInfo ingredientToContents(Ingredient ingredient) { ++ return StackedItemContents.convertIngredientContents(ingredient.isExact() ? ingredient.itemStacks().stream().map(io.papermc.paper.inventory.recipe.ItemOrExact.Exact::new) : ingredient.items().stream().map(io.papermc.paper.inventory.recipe.ItemOrExact.Item::new), ingredient.isExact()); ++ // Paper end - Improve exact choice recipe ingredients + } + + public static PlacementInfo create(Ingredient ingredient) { + if (ingredient.items().isEmpty()) { + return NOT_PLACEABLE; + } else { +- StackedContents.IngredientInfo> ingredientInfo = ingredientToContents(ingredient); ++ StackedContents.IngredientInfo ingredientInfo = ingredientToContents(ingredient); // Paper - Improve exact choice recipe ingredients + PlacementInfo.SlotInfo slotInfo = new PlacementInfo.SlotInfo(0); + return new PlacementInfo(List.of(ingredient), List.of(ingredientInfo), List.of(Optional.of(slotInfo))); + } +@@ -39,7 +41,7 @@ public class PlacementInfo { + public static PlacementInfo createFromOptionals(List> ingredients) { + int i = ingredients.size(); + List list = new ArrayList<>(i); +- List>> list2 = new ArrayList<>(i); ++ List> list2 = new ArrayList<>(i); // Paper - Improve exact choice recipe ingredients + List> list3 = new ArrayList<>(i); + int j = 0; + +@@ -63,7 +65,7 @@ public class PlacementInfo { + + public static PlacementInfo create(List ingredients) { + int i = ingredients.size(); +- List>> list = new ArrayList<>(i); ++ List> list = new ArrayList<>(i); // Paper - Improve exact choice recipe ingredients + List> list2 = new ArrayList<>(i); + + for (int j = 0; j < i; j++) { +@@ -87,7 +89,7 @@ public class PlacementInfo { + return this.ingredients; + } + +- public List>> unpackedIngredients() { ++ public List> unpackedIngredients() { // Paper - Improve exact choice recipe ingredients + return this.unpackedIngredients; + } + +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) { -- cgit v1.2.3