Switch to Paper (#86)

Some API breakages - Most areas now avoid Material where possible, preferring ItemType or NamespacedKeys.

Author: Jikoo

.github/workflows/auto-merge-dependabot.yml

@@ -6,8 +6,30 @@ on:
 jobs:
   run-ci:
     uses: Jikoo/PlanarActions/.github/workflows/ci_maven.yml@master
-  store-dependabot-pr-data:
-    if: "github.actor == 'dependabot[bot]' && github.event_name == 'pull_request'"
-    uses: Jikoo/PlanarActions/.github/workflows/pr_automerge_prep.yml@master
-    with:
-      pr-number: ${{ github.event.number }}
+  approve-and-merge-dependabot:
+    if: "github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]'"
+    needs: [ "run-ci" ]
+    runs-on: "ubuntu-latest"
+    steps:
+      # Always approve PRs from Dependabot.
+      - name: Approve
+        run: gh pr review --approve "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          GH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+
+      # Fetch Dependabot metadata for finer decisionmaking later.
+      - name: Fetch Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@21025c705c08248db411dc16f3619e6b5f9ea21a
+        with:
+          github-token: "${{ secrets.GITHUB_TOKEN }}"
+
+      # Enable auto-merge for the PR.
+      # Auto-merge is used rather than a direct merge so that any other required checks can pass.
+      - name: Enable auto-merge for minor/patch updates
+        if: steps.metadata.outputs.update-type == 'version-update:semver-patch' || steps.metadata.outputs.update-type == 'version-update:semver-minor'
+        run: gh pr merge --auto --squash "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          GH_TOKEN: ${{secrets.GITHUB_TOKEN}}

.github/workflows/pull_request.yml

@@ -44,8 +44,8 @@
 
   <repositories>
     <repository>
-      <id>spigot-repo</id>
-      <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
+      <id>papermc</id>
+      <url>https://repo.papermc.io/repository/maven-public/</url>
     </repository>
     <repository>
       <id>jitpack.io</id>
@@ -62,9 +62,9 @@
         <scope>provided</scope>
       </dependency>
       <dependency>
-        <groupId>org.spigotmc</groupId>
-        <artifactId>spigot-api</artifactId>
-        <version>1.21.4-R0.1-SNAPSHOT</version>
+        <groupId>io.papermc.paper</groupId>
+        <artifactId>paper-api</artifactId>
+        <version>1.21.11-R0.1-SNAPSHOT</version>
         <scope>provided</scope>
       </dependency>
       <dependency>
@@ -107,8 +107,8 @@
       <artifactId>annotations</artifactId>
     </dependency>
     <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot-api</artifactId>
+      <groupId>io.papermc.paper</groupId>
+      <artifactId>paper-api</artifactId>
     </dependency>
     <dependency>
       <groupId>com.github.jikoo</groupId>

pom.xml

@@ -126,7 +126,7 @@ protected final AnvilResult forge(@NotNull AnvilState state) {
     }
     // Ignore name changes if addition is not empty.
     if (!ItemUtil.isEmpty(state.getAddition().getItem())) {
-      resultMeta.setDisplayName(baseMeta.getDisplayName());
+      resultMeta.customName(baseMeta.customName());
     }
 
     // If reset meta is identical then no operation is occurring.

src/main/java/com/github/jikoo/planarenchanting/anvil/Anvil.java

@@ -1,9 +1,9 @@
 package com.github.jikoo.planarenchanting.anvil;
 
 import com.github.jikoo.planarenchanting.util.MetaCachedStack;
-import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ItemType;
 import org.jetbrains.annotations.NotNull;
 
 public interface AnvilBehavior {
@@ -47,8 +47,8 @@ default int getEnchantMaxLevel(@NotNull Enchantment enchantment) {
    * @return whether items should combine {@code Enchantments}
    */
   default boolean itemsCombineEnchants(@NotNull MetaCachedStack base, @NotNull MetaCachedStack addition) {
-    Material additionType = addition.getItem().getType();
-    return base.getItem().getType() == additionType || additionType == Material.ENCHANTED_BOOK;
+    ItemType additionType = addition.getItem().getType().asItemType();
+    return base.getItem().getType().asItemType() == additionType || additionType == ItemType.ENCHANTED_BOOK;
   }
 
   /**

src/main/java/com/github/jikoo/planarenchanting/anvil/AnvilBehavior.java

@@ -1,16 +1,17 @@
 package com.github.jikoo.planarenchanting.anvil;
 
-import com.github.jikoo.planarenchanting.enchant.EnchantData;
 import com.github.jikoo.planarenchanting.util.ItemUtil;
 import com.github.jikoo.planarenchanting.util.MetaCachedStack;
-import org.bukkit.Material;
+import io.papermc.paper.registry.keys.ItemTypeKeys;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemType;
 import org.bukkit.inventory.meta.Damageable;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.inventory.meta.Repairable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import java.util.Objects;
 
 public enum AnvilFunctions {
   ; // Empty enum to hold constants.
@@ -42,9 +43,17 @@ public int getLevelCostIncrease() {
     public boolean canApply(@NotNull AnvilBehavior behavior, @NotNull AnvilState state) {
       var itemMeta = state.getBase().getMeta();
 
+      if (itemMeta == null) {
+        return false;
+      }
+
       // If names are not the same, can be applied.
-      return itemMeta != null
-          && !Objects.equals(itemMeta.getDisplayName(), state.getAnvil().getRenameText());
+      Component customName = itemMeta.customName();
+      String anvilText = state.getAnvil().getRenameText();
+      if (customName == null) {
+        return anvilText != null;
+      }
+      return !LegacyComponentSerializer.legacySection().serialize(customName).equals(anvilText);
     }
 
     @Override
@@ -64,7 +73,8 @@ public void modifyResult(@Nullable ItemMeta itemMeta) {
             return;
           }
 
-          itemMeta.setDisplayName(state.getAnvil().getRenameText());
+          String anvilText = state.getAnvil().getRenameText();
+          itemMeta.customName(anvilText == null ? null : Component.text(anvilText));
           if (itemMeta instanceof Repairable repairable) {
             int repairCost = Math.max(
                 ItemUtil.getRepairCost(state.getBase().getMeta()),
@@ -172,8 +182,9 @@ public void modifyResult(@Nullable ItemMeta itemMeta) {
   public static final AnvilFunction REPAIR_WITH_COMBINATION = new AnvilFunction() {
     @Override
     public boolean canApply(@NotNull AnvilBehavior behavior, @NotNull AnvilState state) {
-      Material baseType = state.getBase().getItem().getType();
-      return baseType == state.getAddition().getItem().getType()
+      ItemType baseType = state.getBase().getItem().getType().asItemType();
+      return baseType != null
+          && baseType == state.getAddition().getItem().getType().asItemType()
           && baseType.getMaxDurability() > 0
           && state.getBase().getMeta() instanceof Damageable damageable
           && damageable.getDamage() > 0;
@@ -236,12 +247,11 @@ protected int getNonApplicableCost() {
   public static final AnvilFunction COMBINE_ENCHANTMENTS_BEDROCK_EDITION = new CombineEnchantments() {
     @Override
     protected int getAnvilCost(Enchantment enchantment, boolean isFromBook) {
-      EnchantData enchantData = EnchantData.of(enchantment);
-      if (!enchantData.getSecondaryItems().isTagged(Material.TRIDENT)) {
+      if (!enchantment.getSupportedItems().contains(ItemTypeKeys.TRIDENT)) {
         return super.getAnvilCost(enchantment, isFromBook);
       }
 
-      int base = enchantData.getAnvilCost();
+      int base = enchantment.getAnvilCost();
 
       // Bedrock Edition rarity is 1 tier lower for trident enchantments.
       return Math.max(1, isFromBook ? base / 4 : base / 2);

src/main/java/com/github/jikoo/planarenchanting/anvil/AnvilFunctions.java

@@ -1,12 +1,11 @@
 package com.github.jikoo.planarenchanting.anvil;
 
-import com.github.jikoo.planarenchanting.enchant.EnchantData;
 import com.github.jikoo.planarenchanting.enchant.EnchantmentUtil;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
-import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemType;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -32,7 +31,7 @@ public boolean canApply(@NotNull AnvilBehavior behavior, @NotNull AnvilState sta
     }
 
     Map<Enchantment, Integer> newEnchants = new HashMap<>(baseEnchants);
-    boolean isFromBook = state.getAddition().getItem().getType() == Material.ENCHANTED_BOOK;
+    boolean isFromBook = state.getAddition().getItem().getType().asItemType() == ItemType.ENCHANTED_BOOK;
 
     int levelCost = 0;
     for (Entry<Enchantment, Integer> enchantEntry : additionEnchants.entrySet()) {
@@ -77,7 +76,7 @@ public void modifyResult(@Nullable ItemMeta itemMeta) {
   }
 
   protected int getAnvilCost(Enchantment enchantment, boolean isFromBook) {
-    int value = EnchantData.of(enchantment).getAnvilCost();
+    int value = enchantment.getAnvilCost();
     return isFromBook ? Math.max(1, value / 2) : value;
   }
 

src/main/java/com/github/jikoo/planarenchanting/anvil/CombineEnchantments.java

@@ -1,15 +1,18 @@
 package com.github.jikoo.planarenchanting.anvil;
 
+import io.papermc.paper.registry.RegistryAccess;
+import io.papermc.paper.registry.RegistryKey;
+import io.papermc.paper.registry.TypedKey;
+import io.papermc.paper.registry.keys.tags.ItemTypeTagKeys;
+import io.papermc.paper.registry.tag.Tag;
+import io.papermc.paper.registry.tag.TagKey;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import org.bukkit.Material;
-import org.bukkit.Tag;
+import java.util.function.Predicate;
+import org.bukkit.NamespacedKey;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.RecipeChoice;
-import org.bukkit.inventory.RecipeChoice.MaterialChoice;
+import org.bukkit.inventory.ItemType;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.VisibleForTesting;
 
 /**
  * Definitions of materials used in anvil repair operations.
@@ -26,69 +29,69 @@ public final class RepairMaterial {
    * @return whether the addition material can repair the base material
    */
   public static boolean repairs(@NotNull ItemStack base, @NotNull ItemStack addition) {
-    RecipeChoice recipeChoice = MATERIALS_TO_REPAIRABLE.get(base.getType());
-    return recipeChoice != null && recipeChoice.test(addition);
+    Predicate<NamespacedKey> predicate = MATERIALS_TO_REPAIRABLE.get(base.getType().getKey());
+    return predicate != null && predicate.test(addition.getType().getKey());
   }
 
-  private static final Map<Material, RecipeChoice> MATERIALS_TO_REPAIRABLE = new HashMap<>();
+  private static final Map<NamespacedKey, Predicate<NamespacedKey>> MATERIALS_TO_REPAIRABLE = new HashMap<>();
 
   static {
-    String[] armor = new String[] { "_HELMET", "_CHESTPLATE", "_LEGGINGS", "_BOOTS" };
-    String[] tools = new String[] { "_AXE", "_SHOVEL", "_PICKAXE", "_HOE", "_SWORD" };
-    String[] armortools = new String[armor.length + tools.length];
-    System.arraycopy(armor, 0, armortools, 0, armor.length);
-    System.arraycopy(tools, 0, armortools, armor.length, tools.length);
-
-    // Leather armor
-    addGear("LEATHER", armor, Material.LEATHER);
-
-    // Stone tools
-    addGear("STONE", tools, new RecipeChoice.MaterialChoice(Tag.ITEMS_STONE_TOOL_MATERIALS));
-
-    // Wooden tools, shields
-    MaterialChoice choicePlanks = new MaterialChoice(Tag.PLANKS);
-    addGear("WOODEN", tools, choicePlanks);
-    MATERIALS_TO_REPAIRABLE.put(Material.SHIELD, choicePlanks);
-
-    // Chainmail, iron armor and tools
-    RecipeChoice choiceIronIngot = singleChoice(Material.IRON_INGOT);
-    addGear("CHAINMAIL", armor, choiceIronIngot);
-    addGear("IRON", armortools, choiceIronIngot);
-
-    // Gold, diamond, and netherite armor and tools
-    addGear("GOLDEN", armortools, Material.GOLD_INGOT);
-    addGear("DIAMOND", armortools, Material.DIAMOND);
-    addGear("NETHERITE", armortools, Material.NETHERITE_INGOT);
+    // Note that for all choices, we want to use a MaterialChoice.
+    // ExactChoice also does a full meta match.
+
+    // See net.minecraft.world.item.equipment.ArmorMaterials
+    String[] armor = new String[] { "_helmet", "_chestplate", "_leggings", "_boots" };
+    addGear("leather", armor, ItemTypeTagKeys.REPAIRS_LEATHER_ARMOR);
+    addGear("copper", armor, ItemTypeTagKeys.REPAIRS_COPPER_ARMOR);
+    addGear("chainmail", armor, ItemTypeTagKeys.REPAIRS_CHAIN_ARMOR);
+    addGear("iron", armor, ItemTypeTagKeys.REPAIRS_IRON_ARMOR);
+    addGear("golden", armor, ItemTypeTagKeys.REPAIRS_GOLD_ARMOR);
+    addGear("diamond", armor, ItemTypeTagKeys.REPAIRS_DIAMOND_ARMOR);
+    MATERIALS_TO_REPAIRABLE.put(ItemType.TURTLE_HELMET.getKey(), new TagPredicate(ItemTypeTagKeys.REPAIRS_TURTLE_HELMET));
+    addGear("netherite", armor, ItemTypeTagKeys.REPAIRS_NETHERITE_ARMOR);
+    MATERIALS_TO_REPAIRABLE.put(ItemType.WOLF_ARMOR.getKey(), new TagPredicate(ItemTypeTagKeys.REPAIRS_WOLF_ARMOR));
+
+    // See net.minecraft.world.item.ToolMaterial
+    String[] tools = new String[] { "_axe", "_shovel", "_pickaxe", "_hoe", "_sword", "_spear" };
+    addGear("stone", tools, ItemTypeTagKeys.STONE_TOOL_MATERIALS);
+    Predicate<NamespacedKey> woodToolMats = new TagPredicate(ItemTypeTagKeys.WOODEN_TOOL_MATERIALS);
+    addGear("wooden", tools, woodToolMats);
+    MATERIALS_TO_REPAIRABLE.put(ItemType.SHIELD.getKey(), woodToolMats);
+    addGear("iron", tools, ItemTypeTagKeys.IRON_TOOL_MATERIALS);
+    addGear("golden", tools, ItemTypeTagKeys.GOLD_TOOL_MATERIALS);
+    addGear("diamond", tools, ItemTypeTagKeys.DIAMOND_TOOL_MATERIALS);
+    addGear("netherite", tools, ItemTypeTagKeys.NETHERITE_TOOL_MATERIALS);
 
     // Misc. repairable items
-    MATERIALS_TO_REPAIRABLE.put(Material.TURTLE_HELMET, singleChoice(Material.TURTLE_SCUTE));
-    MATERIALS_TO_REPAIRABLE.put(Material.ELYTRA, singleChoice(Material.PHANTOM_MEMBRANE));
-    MATERIALS_TO_REPAIRABLE.put(Material.MACE, singleChoice(Material.BREEZE_ROD));
+    MATERIALS_TO_REPAIRABLE.put(ItemType.ELYTRA.getKey(), key -> ItemType.PHANTOM_MEMBRANE.getKey().equals(key));
+    MATERIALS_TO_REPAIRABLE.put(ItemType.MACE.getKey(), key -> ItemType.BREEZE_ROD.getKey().equals(key));
   }
 
-  private static void addGear(String type, String[] gearType, RecipeChoice repairChoice) {
+  private static void addGear(String type, String[] gearType, Predicate<NamespacedKey> repairChoice) {
     for (String toolType : gearType) {
-      Material material = Material.getMaterial(type + toolType);
-      if (material != null) {
-        MATERIALS_TO_REPAIRABLE.put(material, repairChoice);
-      }
+      MATERIALS_TO_REPAIRABLE.put(NamespacedKey.minecraft(type + toolType), repairChoice);
     }
   }
 
-  private static void addGear(String type, String[] gearType, Material repairMaterial) {
-    addGear(type, gearType, singleChoice(repairMaterial));
+  private static void addGear(String type, String[] gearType, TagKey<ItemType> tag) {
+    addGear(type, gearType, new TagPredicate(tag));
   }
 
-  private static RecipeChoice singleChoice(Material material) {
-    // RecipeChoice.ExactChoice is a full meta match, which isn't what we want.
-    return new RecipeChoice.MaterialChoice(List.of(material));
+  private RepairMaterial() {
+    throw new IllegalStateException("Cannot instantiate static helper method container.");
   }
 
-  @VisibleForTesting
-  static boolean hasEntry(@NotNull Material material) {
-    return MATERIALS_TO_REPAIRABLE.containsKey(material);
-  }
+  private record TagPredicate(Tag<ItemType> tag) implements Predicate<NamespacedKey> {
 
-  private RepairMaterial() {}
+    private TagPredicate(TagKey<ItemType> tag) {
+      this(RegistryAccess.registryAccess().getRegistry(RegistryKey.ITEM).getTag(tag));
+    }
+
+    @Override
+    public boolean test(NamespacedKey key) {
+      return tag.contains(TypedKey.create(RegistryKey.ITEM, key));
+    }
+
+  }
 
 }