More work on bottomless bundles and enchantments

Author: Electro593

src/main/java/de/dafuqs/spectrum/api/block/ImplementedInventory.java

@@ -33,14 +33,18 @@ static ImplementedInventory of(DefaultedList<ItemStack> items) {
 	static ImplementedInventory ofSize(int size) {
 		return of(DefaultedList.ofSize(size, ItemStack.EMPTY));
 	}
-	
+
 	/**
 	 * Returns the inventory size.
 	 */
 	@Override
 	default int size() {
 		return getItems().size();
 	}
+	@Override
+	default int getSize() {
+		return size();
+	}
 
 	/**
 	 * Checks if the inventory is empty.
@@ -65,6 +69,10 @@ default boolean isEmpty() {
 	default ItemStack getStack(int slot) {
 		return getItems().get(slot);
 	}
+	@Override
+	default ItemStack getStackInSlot(int slot) {
+		return getStack(slot);
+	}
 
 	/**
 	 * Removes items from an inventory slot.

src/main/java/de/dafuqs/spectrum/api/item/ExtendedEnchantable.java

@@ -4,10 +4,7 @@
 
 /**
  * Items with that Interface will be able to be enchanted with the given enchants
- * Most notably for items that do not match an existing net.minecraft.enchantment.EnchantmentTarget
- * (since that one is an enum, it cannot be easily extended)
- * <p>
- * Using this interface there is no need to mixin into every individual enchantment to override `isAcceptableItem`
+ * Using this interface there is no need to override every vanilla enchantment to override `supported_items`
  * Note that for an item to be enchanted, it still needs to have `isEnchantable() == true` and `getEnchantability() > 0`
  */
 public interface ExtendedEnchantable {

src/main/java/de/dafuqs/spectrum/blocks/bottomless_bundle/BottomlessBundleBlock.java

@@ -151,7 +151,7 @@ public void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity p
 		if (!world.isClient) {
 			BlockEntity blockEntity = world.getBlockEntity(pos);
 			if (blockEntity instanceof BottomlessBundleBlockEntity bottomlessBundleBlockEntity) {
-				bottomlessBundleBlockEntity.setBundle(itemStack.copy());
+				bottomlessBundleBlockEntity.setBundle(itemStack.copy(), world.getRegistryManager());
 				world.updateComparators(pos, this);
 			}
 		}

src/main/java/de/dafuqs/spectrum/blocks/bottomless_bundle/BottomlessBundleBlockEntity.java

@@ -1,6 +1,5 @@
 package de.dafuqs.spectrum.blocks.bottomless_bundle;
 
-import de.dafuqs.spectrum.helpers.SpectrumEnchantmentHelper;
 import de.dafuqs.spectrum.registries.*;
 import net.fabricmc.fabric.api.transfer.v1.item.*;
 import net.fabricmc.fabric.api.transfer.v1.storage.base.*;
@@ -10,6 +9,7 @@
 import net.minecraft.enchantment.*;
 import net.minecraft.item.*;
 import net.minecraft.nbt.*;
+import net.minecraft.registry.RegistryKeys;
 import net.minecraft.registry.RegistryWrapper;
 import net.minecraft.util.math.*;
 import org.jetbrains.annotations.*;
@@ -67,7 +67,7 @@ public BottomlessBundleBlockEntity(BlockPos pos, BlockState state) {
 	@Override
 	public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
 		super.readNbt(nbt, registryLookup);
-		this.setBundleUnsynced(ItemStack.fromNbt(nbt.getCompound("Bundle")));
+		this.setBundleUnsynced(ItemStack.fromNbt(registryLookup, nbt.getCompound("Bundle")).orElse(SpectrumItems.BOTTOMLESS_BUNDLE.getDefaultStack()), registryLookup);
 
 		// Handle old data by syncing into bundle
 		if (nbt.contains("StorageVariant")) {
@@ -103,19 +103,19 @@ protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryL
 		nbt.put("Bundle", bundleCompound);
 	}
 
-	private boolean setBundleUnsynced(ItemStack itemStack) {
+	private boolean setBundleUnsynced(ItemStack itemStack, RegistryWrapper.WrapperLookup registryLookup) {
 		if (itemStack.getItem() instanceof BottomlessBundleItem) {
 			this.bottomlessBundleStack = itemStack;
 			// cache once, use many times
 			this.isVoiding = EnchantmentHelper.hasAnyEnchantmentsIn(bottomlessBundleStack, SpectrumEnchantmentTags.DELETES_OVERFLOW);
-			this.powerLevel = EnchantmentHelper.getLevel(Enchantments.POWER, itemStack);
+			this.powerLevel = EnchantmentHelper.getLevel(registryLookup.getOptionalWrapper(RegistryKeys.ENCHANTMENT).flatMap(impl -> impl.getOptional(Enchantments.POWER)).orElse(null), itemStack);
 			return true;
 		}
 		return false;
 	}
 
-	public void setBundle(@NotNull ItemStack itemStack) {
-		if (setBundleUnsynced(itemStack)) syncStorageWithBundle();
+	public void setBundle(@NotNull ItemStack itemStack, RegistryWrapper.WrapperLookup registryLookup) {
+		if (setBundleUnsynced(itemStack, registryLookup)) syncStorageWithBundle();
 	}
 
 	public ItemStack retrieveBundle() {

src/main/java/de/dafuqs/spectrum/blocks/bottomless_bundle/BottomlessBundleItem.java

@@ -16,6 +16,7 @@
 import net.minecraft.client.render.model.*;
 import net.minecraft.client.render.model.json.*;
 import net.minecraft.client.util.math.*;
+import net.minecraft.component.DataComponentTypes;
 import net.minecraft.enchantment.*;
 import net.minecraft.entity.*;
 import net.minecraft.entity.player.*;
@@ -115,11 +116,7 @@ private static boolean dropOneBundledStack(ItemStack voidBundleStack, PlayerEnti
 	}
 
 	public static boolean isLocked(ItemStack itemStack) {
-		NbtCompound compound = itemStack.getNbt();
-		if (compound != null) {
-			return compound.getBoolean("Locked");
-		}
-		return false;
+		return itemStack.contains(DataComponentTypes.LOCK);
 	}
 
 	public static ItemStack getFirstBundledStack(ItemStack voidBundleStack) {
@@ -229,14 +226,13 @@ public TypedActionResult<ItemStack> use(World world, PlayerEntity user, Hand han
 		ItemStack itemStack = user.getStackInHand(hand);
 		if (user.isSneaking()) {
 			ItemStack handStack = user.getStackInHand(hand);
-			NbtCompound compound = handStack.getOrCreateNbt();
-			if (compound.contains("Locked")) {
-				compound.remove("Locked");
+			if (handStack.contains(DataComponentTypes.LOCK)) {
+				handStack.remove(DataComponentTypes.LOCK);
 				if (world.isClient) {
 					playZipSound(user, 0.8F);
 				}
 			} else {
-				compound.putBoolean("Locked", true);
+				handStack.set(DataComponentTypes.LOCK, ContainerLock.EMPTY);
 				if (world.isClient) {
 					playZipSound(user, 1.0F);
 				}

src/main/java/de/dafuqs/spectrum/blocks/enchanter/EnchanterBlockEntity.java

@@ -8,7 +8,6 @@
 import de.dafuqs.spectrum.blocks.item_bowl.*;
 import de.dafuqs.spectrum.blocks.upgrade.*;
 import de.dafuqs.spectrum.compat.biome_makeover.*;
-import de.dafuqs.spectrum.enchantments.*;
 import de.dafuqs.spectrum.helpers.*;
 import de.dafuqs.spectrum.items.magic_items.*;
 import de.dafuqs.spectrum.networking.*;
@@ -23,6 +22,7 @@
 import net.minecraft.advancement.criterion.*;
 import net.minecraft.block.*;
 import net.minecraft.block.entity.*;
+import net.minecraft.component.type.ItemEnchantmentsComponent;
 import net.minecraft.enchantment.*;
 import net.minecraft.entity.player.*;
 import net.minecraft.inventory.*;
@@ -31,6 +31,8 @@
 import net.minecraft.network.listener.*;
 import net.minecraft.network.packet.*;
 import net.minecraft.network.packet.s2c.play.*;
+import net.minecraft.registry.entry.RegistryEntry;
+import net.minecraft.registry.tag.EnchantmentTags;
 import net.minecraft.server.network.*;
 import net.minecraft.server.world.*;
 import net.minecraft.sound.*;
@@ -65,14 +67,14 @@ public class EnchanterBlockEntity extends InWorldInteractionBlockEntity implemen
 	// since the item bowls around the enchanter hold some items themselves
 	// they get cached here for faster recipe lookup
 	// virtualInventoryRecipeOrientation is the order the items are ordered for the recipe to match (rotations from 0-3)
-	protected SimpleInventory virtualInventoryIncludingBowlStacks;
+	protected ImplementedInventory virtualInventoryIncludingBowlStacks;
 	protected int virtualInventoryRecipeOrientation;
 	protected boolean virtualInventoryRecipeMirrored;
 
 	protected boolean inventoryChanged;
 	private UpgradeHolder upgrades;
 
-	private GatedSpectrumRecipe currentRecipe;
+	private GatedSpectrumRecipe<?> currentRecipe;
 	private int craftingTime;
 	private int craftingTimeTotal;
 	private int currentItemProcessingTime;
@@ -82,7 +84,7 @@ public class EnchanterBlockEntity extends InWorldInteractionBlockEntity implemen
 
 	public EnchanterBlockEntity(BlockPos pos, BlockState state) {
 		super(SpectrumBlockEntities.ENCHANTER, pos, state, INVENTORY_SIZE);
-		this.virtualInventoryIncludingBowlStacks = new SimpleInventory(INVENTORY_SIZE + 8);
+		this.virtualInventoryIncludingBowlStacks = ImplementedInventory.ofSize(INVENTORY_SIZE + 8);
 		this.currentItemProcessingTime = -1;
 	}
 
@@ -230,23 +232,31 @@ public static void serverTick(World world, BlockPos blockPos, BlockState blockSt
 	public static boolean isValidCenterEnchantingSetup(@NotNull EnchanterBlockEntity enchanterBlockEntity) {
 		ItemStack centerStack = enchanterBlockEntity.virtualInventoryIncludingBowlStacks.getStack(0);
 		boolean isEnchantableBookInCenter = SpectrumEnchantmentHelper.isEnchantableBook(centerStack);
-		if (!centerStack.isEmpty() && (isEnchantableBookInCenter || centerStack.getItem().isEnchantable(centerStack)) && enchanterBlockEntity.virtualInventoryIncludingBowlStacks.getStack(1).getItem() instanceof ExperienceStorageItem) {
+
+		var centerIsEnchantable = (isEnchantableBookInCenter || centerStack.getItem().isEnchantable(centerStack));
+		var hasExpStorage = enchanterBlockEntity.virtualInventoryIncludingBowlStacks.getStack(1).getItem() instanceof ExperienceStorageItem;
+
+		if (!centerStack.isEmpty() && centerIsEnchantable && hasExpStorage) {
 			// gilded books can copy enchantments from any source item
 			boolean centerStackIsGildedBook = centerStack.isOf(SpectrumItems.GILDED_BOOK);
 			boolean enchantedBookWithAdditionalEnchantmentsFound = false;
-			Map<Enchantment, Integer> existingEnchantments = EnchantmentHelper.get(centerStack);
+
+			var existingEnchantments = EnchantmentHelper.getEnchantments(centerStack).getEnchantmentEntries();
 			for (int i = 0; i < 8; i++) {
 				ItemStack virtualSlotStack = enchanterBlockEntity.virtualInventoryIncludingBowlStacks.getStack(2 + i);
+
 				// empty slots do not count
 				if (!virtualSlotStack.isEmpty()) {
 					if (centerStackIsGildedBook || virtualSlotStack.getItem() instanceof EnchantedBookItem) {
-						Map<Enchantment, Integer> currentEnchantedBookEnchantments = EnchantmentHelper.get(virtualSlotStack);
-						for (Enchantment enchantment : currentEnchantedBookEnchantments.keySet()) {
-							if ((isEnchantableBookInCenter || enchantment.isAcceptableItem(centerStack)) && (!existingEnchantments.containsKey(enchantment) || existingEnchantments.get(enchantment) < currentEnchantedBookEnchantments.get(enchantment))) {
+						for (var entry : EnchantmentHelper.getEnchantments(virtualSlotStack).getEnchantmentEntries()) {
+							var enchantment = entry.getKey();
+							var isAcceptable = isEnchantableBookInCenter || enchantment.value().isAcceptableItem(centerStack);
+							var isRedundant = existingEnchantments.stream().anyMatch(existing -> existing.getKey() == enchantment && existing.getIntValue() >= entry.getIntValue());
+							if (isAcceptable && !isRedundant) {
 								if (enchanterBlockEntity.canOwnerApplyConflictingEnchantments) {
 									enchantedBookWithAdditionalEnchantmentsFound = true;
 									break;
-								} else if (SpectrumEnchantmentHelper.canCombineAny(existingEnchantments, currentEnchantedBookEnchantments)) {
+								} else if (SpectrumEnchantmentHelper.canCombineAny(centerStack, virtualSlotStack)) {
 									enchantedBookWithAdditionalEnchantmentsFound = true;
 									break;
 								}
@@ -257,8 +267,10 @@ public static boolean isValidCenterEnchantingSetup(@NotNull EnchanterBlockEntity
 					}
 				}
 			}
+
 			return enchantedBookWithAdditionalEnchantmentsFound;
 		}
+
 		return false;
 	}
 
@@ -300,10 +312,10 @@ private static boolean checkRecipeRequirements(World world, BlockPos blockPos, @
 	public static void enchantCenterItem(@NotNull EnchanterBlockEntity enchanterBlockEntity) {
 		ItemStack centerStack = enchanterBlockEntity.getStack(0);
 		ItemStack centerStackCopy = centerStack.copy();
-		Map<Enchantment, Integer> highestEnchantments = getHighestEnchantmentsInItemBowls(enchanterBlockEntity);
+		var highestEnchantments = getHighestEnchantmentsInItemBowls(enchanterBlockEntity);
 
-		for (Enchantment enchantment : highestEnchantments.keySet()) {
-			centerStackCopy = SpectrumEnchantmentHelper.addOrUpgradeEnchantment(centerStackCopy, enchantment, highestEnchantments.get(enchantment), false, enchanterBlockEntity.canOwnerApplyConflictingEnchantments).getRight();
+		for (var entry : highestEnchantments.getEnchantmentEntries()) {
+			centerStackCopy = SpectrumEnchantmentHelper.addOrUpgradeEnchantment(centerStackCopy, entry.getKey(), entry.getIntValue(), false, enchanterBlockEntity.canOwnerApplyConflictingEnchantments).getRight();
 		}
 
 		int spentExperience = enchanterBlockEntity.currentItemProcessingTime / EnchanterBlockEntity.REQUIRED_TICKS_FOR_EACH_EXPERIENCE_POINT;
@@ -325,27 +337,24 @@ public static void enchantCenterItem(@NotNull EnchanterBlockEntity enchanterBloc
 		}
 	}
 
-	public static Map<Enchantment, Integer> getHighestEnchantmentsInItemBowls(@NotNull EnchanterBlockEntity enchanterBlockEntity) {
-		List<ItemStack> bowlStacks = new ArrayList<>();
-		for (int i = 0; i < 8; i++) {
-			bowlStacks.add(enchanterBlockEntity.virtualInventoryIncludingBowlStacks.getStack(2 + i));
-		}
-		
-		return SpectrumEnchantmentHelper.collectHighestEnchantments(bowlStacks);
+	public static ItemEnchantmentsComponent getHighestEnchantmentsInItemBowls(@NotNull EnchanterBlockEntity enchanterBlockEntity) {
+		return SpectrumEnchantmentHelper.collectHighestEnchantments(
+				enchanterBlockEntity.virtualInventoryIncludingBowlStacks.getItems().subList(2, 10));
 	}
 
 	public static int getRequiredExperienceToEnchantCenterItem(@NotNull EnchanterBlockEntity enchanterBlockEntity) {
 		boolean valid = false;
 		ItemStack centerStack = enchanterBlockEntity.getStack(0);
 		if (!centerStack.isEmpty() && (centerStack.getItem().isEnchantable(centerStack) || SpectrumEnchantmentHelper.isEnchantableBook(centerStack))) {
 			ItemStack centerStackCopy = centerStack.copy();
-			Map<Enchantment, Integer> highestEnchantmentLevels = getHighestEnchantmentsInItemBowls(enchanterBlockEntity);
+			var highestEnchantments = getHighestEnchantmentsInItemBowls(enchanterBlockEntity);
 			int requiredExperience = 0;
-			for (Enchantment enchantment : highestEnchantmentLevels.keySet()) {
-				int enchantmentLevel = highestEnchantmentLevels.get(enchantment);
-				int currentRequired = getRequiredExperienceToEnchantWithEnchantment(centerStackCopy, enchantment, enchantmentLevel, enchanterBlockEntity.canOwnerApplyConflictingEnchantments);
+			for (var entry : highestEnchantments.getEnchantmentEntries()) {
+				var enchantment = entry.getKey();
+				int level = entry.getIntValue();
+				int currentRequired = getRequiredExperienceToEnchantWithEnchantment(centerStackCopy, enchantment, level, enchanterBlockEntity.canOwnerApplyConflictingEnchantments);
 				if (currentRequired > 0) {
-					centerStackCopy = SpectrumEnchantmentHelper.addOrUpgradeEnchantment(centerStackCopy, enchantment, enchantmentLevel, false, enchanterBlockEntity.canOwnerApplyConflictingEnchantments).getRight();
+					centerStackCopy = SpectrumEnchantmentHelper.addOrUpgradeEnchantment(centerStackCopy, enchantment, level, false, enchanterBlockEntity.canOwnerApplyConflictingEnchantments).getRight();
 					requiredExperience += currentRequired;
 					valid = true;
 				} else {
@@ -370,8 +379,8 @@ public static int getRequiredExperienceToEnchantCenterItem(@NotNull EnchanterBlo
 	 * @param level       The enchantments level
 	 * @return The required experience to enchant. -1 if the enchantment is not applicable
 	 */
-	public static int getRequiredExperienceToEnchantWithEnchantment(ItemStack stack, Enchantment enchantment, int level, boolean allowEnchantmentConflicts) {
-		if (!enchantment.isAcceptableItem(stack) && !SpectrumEnchantmentHelper.isEnchantableBook(stack)) {
+	public static int getRequiredExperienceToEnchantWithEnchantment(ItemStack stack, RegistryEntry<Enchantment> enchantment, int level, boolean allowEnchantmentConflicts) {
+		if (!enchantment.value().isAcceptableItem(stack) && !SpectrumEnchantmentHelper.isEnchantableBook(stack)) {
 			return -1;
 		}
 
@@ -380,7 +389,7 @@ public static int getRequiredExperienceToEnchantWithEnchantment(ItemStack stack,
 			return -1;
 		}
 
-		boolean conflicts = SpectrumEnchantmentHelper.hasEnchantmentThatConflictsWith(stack, enchantment);
+		boolean conflicts = !EnchantmentHelper.isCompatible(stack.getEnchantments().getEnchantments(), enchantment);
 		if (conflicts && !allowEnchantmentConflicts) {
 			return -1;
 		}
@@ -392,31 +401,26 @@ public static int getRequiredExperienceToEnchantWithEnchantment(ItemStack stack,
 		return requiredExperience;
 	}
 
-	public static Integer getEnchantingPrice(ItemStack stack, Enchantment enchantment, int level) {
+	public static Integer getEnchantingPrice(ItemStack stack, RegistryEntry<Enchantment> enchantment, int level) {
 		int enchantability = Math.max(1, stack.getItem().getEnchantability()); // items like Elytras have an enchantability of 0, but can get unbreaking
-		if (enchantment.isAcceptableItem(stack) || SpectrumEnchantmentHelper.isEnchantableBook(stack)) {
+		if (enchantment.value().isAcceptableItem(stack) || SpectrumEnchantmentHelper.isEnchantableBook(stack)) {
 			return getRequiredExperienceForEnchantment(enchantability, enchantment, level);
 		}
 		return -1;
 	}
 
-	public static int getRequiredExperienceForEnchantment(int enchantability, Enchantment enchantment, int level) {
+	public static int getRequiredExperienceForEnchantment(int enchantability, RegistryEntry<Enchantment> entry, int level) {
 		if (enchantability > 0) {
-			int rarityCost;
-			Enchantment.Rarity rarity = enchantment.getRarity();
-			switch (rarity) {
-				case COMMON -> rarityCost = 10;
-				case UNCOMMON -> rarityCost = 25;
-				case RARE -> rarityCost = 50;
-				default -> rarityCost = 80;
-			}
-			
+			var enchantment = entry.value();
+
+			// Interpolated version of COMMON -> 10, UNCOMMON -> 25, RARE -> 50, VERY_RARE -> 80
+			var rarityMults = new float[] { 0, 10, 12.5F, 12.67F, 12.5F, 12, 11.33F, 10.71F, 10 };
+			var anvilCost = enchantment.getAnvilCost();
+			var rarityCost = rarityMults[Math.min(anvilCost, rarityMults.length - 1)] * anvilCost;
+
 			float levelCost = level + ((float) level / enchantment.getMaxLevel()); // the higher the level, the pricier. But not as bad for enchantments with high max levels
-			float specialMulti = enchantment.isTreasure() ? 2.0F : enchantment.isCursed() ? 1.5F : 1.0F;
-			float selectionAvailabilityMod = 1.0F;
-			if (!(enchantment instanceof SpectrumEnchantment)) {
-				selectionAvailabilityMod = (enchantment.isAvailableForRandomSelection() ? 0.5F : 0.75F) + (enchantment.isAvailableForEnchantedBookOffer() ? 0.5F : 0.75F);
-			}
+			float specialMulti = entry.isIn(EnchantmentTags.TREASURE) ? 2.0F : entry.isIn(EnchantmentTags.CURSE) ? 1.5F : 1.0F;
+			float selectionAvailabilityMod = (entry.isIn(EnchantmentTags.IN_ENCHANTING_TABLE) ? 0.5F : 0.75F) + (entry.isIn(EnchantmentTags.TRADEABLE) ? 0.5F : 0.75F);
 			float enchantabilityMod = (4.0F / (2 + enchantability)) * 4.0F;
 			return (int) Math.floor(rarityCost * levelCost * specialMulti * selectionAvailabilityMod * enchantabilityMod);
 		}
@@ -548,7 +552,7 @@ private static void calculateCurrentRecipe(@NotNull World world, @NotNull Enchan
 		}
 
 		enchanterBlockEntity.craftingTime = 0;
-		GatedSpectrumRecipe previousRecipe = enchanterBlockEntity.currentRecipe;
+		GatedSpectrumRecipe<?> previousRecipe = enchanterBlockEntity.currentRecipe;
 		enchanterBlockEntity.currentRecipe = null;
 		int previousOrientation = enchanterBlockEntity.virtualInventoryRecipeOrientation;
 		boolean previousMirrored = enchanterBlockEntity.virtualInventoryRecipeMirrored;