chore: start work on flexible entity type wrapper

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -27,7 +27,7 @@ body:
       description: Which server version are you using? If your server version is not listed, it is not supported. Update to a supported version first.
       multiple: false
       options:
-        - '1.21.11'
+        - '1.21.4'
         - '1.21.3'
         - '1.21.1'
         - '1.20.6'

.github/stale.yml

@@ -0,0 +1,18 @@
+daysUntilStale: 30
+daysUntilClose: 7
+only: issues
+exemptLabels:
+  - "Bug"
+  - "Enhancement"
+  - "Approved"
+  - "Priority"
+  - "Under investigation"
+staleLabel: "resolution: stale"
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. If the issue is still present and can be reproduced, please let the team know.
+  Thank you for your contributions.
+closeComment: >
+  This issue has been automatically closed because it has not had activity in
+  a long time. If the issue still applies to the most recent supported
+  version, please reply to this issue and the team will reopen it.

.github/workflows/build-pr.yml

@@ -9,7 +9,7 @@ jobs:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
       - name: Validate Gradle Wrapper
         uses: gradle/actions/wrapper-validation@v5
       - name: Setup Java

.github/workflows/build.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
       - name: Validate Gradle Wrapper
         uses: gradle/actions/wrapper-validation@v5
       - name: Setup Java

.github/workflows/codeql.yml

@@ -20,7 +20,7 @@ jobs:
         language: [ 'java' ]
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
       - name: Setup Java
         uses: actions/setup-java@v5
         with:

Bukkit/build.gradle.kts

@@ -110,9 +110,9 @@ tasks {
         val isRelease = if (rootProject.version.toString().endsWith("-SNAPSHOT")) "TODO" else rootProject.version.toString()
         val opt = options as StandardJavadocDocletOptions
         opt.links("https://jd.papermc.io/paper/1.20.4/")
-//        opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-bukkit/" + libs.worldeditBukkit.get().versionConstraint.toString())
+        opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-bukkit/" + libs.worldeditBukkit.get().versionConstraint.toString())
         opt.links("https://intellectualsites.github.io/plotsquared-javadocs/core/")
-//        opt.links("https://jd.advntr.dev/api/" + libs.adventureApi.get().versionConstraint.toString())
+        opt.links("https://jd.advntr.dev/api/" + libs.adventureApi.get().versionConstraint.toString())
         opt.links("https://google.github.io/guice/api-docs/" + libs.guice.get().versionConstraint.toString() + "/javadoc/")
         opt.links("https://checkerframework.org/api/")
         opt.isLinkSource = true

Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java

@@ -24,6 +24,7 @@ import com.google.inject.Injector;
 import com.google.inject.Key;
 import com.google.inject.Singleton;
 import com.google.inject.Stage;
+import com.plotsquared.bukkit.entity.EntityType;
 import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
 import com.plotsquared.bukkit.inject.BackupModule;
 import com.plotsquared.bukkit.inject.BukkitModule;
@@ -794,60 +795,29 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
                     if (entity.getMetadata("ps_custom_spawned").stream().anyMatch(MetadataValue::asBoolean)) {
                         continue;
                     }
-                    // TODO: use (type) pattern matching when targeting java 21
-                    switch (entity.getType().toString()) {
-                        case "EGG":
-                        case "FISHING_HOOK", "FISHING_BOBBER":
-                        case "ENDER_SIGNAL", "EYE_OF_ENDER":
-                        case "AREA_EFFECT_CLOUD":
-                        case "EXPERIENCE_ORB":
-                        case "LEASH_HITCH", "LEASH_KNOT":
-                        case "FIREWORK", "FIREWORK_ROCKET":
-                        case "LIGHTNING", "LIGHTNING_BOLT":
-                        case "WITHER_SKULL":
-                        case "UNKNOWN":
-                        case "PLAYER":
+
+                    switch (EntityType.of(entity.getType())) {
+                        case EGG, FISHING_BOBBER, EYE_OF_ENDER, AREA_EFFECT_CLOUD, EXPERIENCE_ORB, LEASH_KNOT, FIREWORK_ROCKET,
+                             LIGHTNING_BOLT, WITHER_SKULL, UNKNOWN, PLAYER, MANNEQUIN, BLOCK_DISPLAY, INTERACTION, ITEM_DISPLAY,
+                             GLOW_ITEM_FRAME, TEXT_DISPLAY, OMINOUS_ITEM_SPAWNER, MARKER -> {
                             // non moving / unmovable
-                            continue;
-                        case "THROWN_EXP_BOTTLE", "EXPERIENCE_BOTTLE":
-                        case "SPLASH_POTION", "POTION":
-                        case "SNOWBALL":
-                        case "SHULKER_BULLET":
-                        case "SPECTRAL_ARROW":
-                        case "ENDER_PEARL":
-                        case "ARROW":
-                        case "LLAMA_SPIT":
-                        case "TRIDENT":
+                        }
+                        case EXPERIENCE_BOTTLE, SPLASH_POTION, LINGERING_POTION, SNOWBALL, SHULKER_BULLET, SPECTRAL_ARROW,
+                             ENDER_PEARL, ARROW, LLAMA_SPIT, TRIDENT -> {
                             // managed elsewhere | projectile
-                            continue;
-                        case "ITEM_FRAME":
-                        case "PAINTING":
+                        }
+                        case TNT, FALLING_BLOCK -> {
+                            // managed elsewhere
+                        }
+                        case ITEM_FRAME, PAINTING -> {
                             // Not vehicles
-                            continue;
-                        case "ARMOR_STAND":
-                            // Temporarily classify as vehicle
-                        case "MINECART":
-                        case "MINECART_CHEST":
-                        case "CHEST_MINECART":
-                        case "MINECART_COMMAND":
-                        case "COMMAND_BLOCK_MINECART":
-                        case "MINECART_FURNACE":
-                        case "FURNACE_MINECART":
-                        case "MINECART_HOPPER":
-                        case "HOPPER_MINECART":
-                        case "MINECART_MOB_SPAWNER":
-                        case "SPAWNER_MINECART":
-                        case "END_CRYSTAL":
-                        case "ENDER_CRYSTAL": // Backwards compatibility for 1.20.4
-                        case "MINECART_TNT":
-                        case "TNT_MINECART":
-                        case "CHEST_BOAT":
-                        case "BOAT":
-                        case "ACACIA_BOAT", "BIRCH_BOAT", "CHERRY_BOAT", "DARK_OAK_BOAT", "JUNGLE_BOAT", "MANGROVE_BOAT",
-                             "OAK_BOAT", "PALE_OAK_BOAT", "SPRUCE_BOAT", "BAMBOO_RAFT":
-                        case "ACACIA_CHEST_BOAT", "BIRCH_CHEST_BOAT", "CHERRY_CHEST_BOAT", "DARK_OAK_CHEST_BOAT",
-                             "JUNGLE_CHEST_BOAT", "MANGROVE_CHEST_BOAT", "OAK_CHEST_BOAT", "PALE_OAK_CHEST_BOAT",
-                             "SPRUCE_CHEST_BOAT", "BAMBOO_CHEST_RAFT":
+                        }
+                        // ARMOR_STAND temporarily classified as vehicle
+                        case ARMOR_STAND, MINECART, CHEST_MINECART, COMMAND_BLOCK_MINECART, FURNACE_MINECART, HOPPER_MINECART,
+                             SPAWNER_MINECART, END_CRYSTAL, TNT_MINECART, ACACIA_BOAT, BIRCH_BOAT, CHERRY_BOAT, DARK_OAK_BOAT,
+                             JUNGLE_BOAT, MANGROVE_BOAT, OAK_BOAT, PALE_OAK_BOAT, SPRUCE_BOAT, BAMBOO_RAFT, ACACIA_CHEST_BOAT,
+                             BIRCH_CHEST_BOAT, CHERRY_CHEST_BOAT, DARK_OAK_CHEST_BOAT, JUNGLE_CHEST_BOAT, MANGROVE_CHEST_BOAT,
+                             OAK_CHEST_BOAT, PALE_OAK_CHEST_BOAT, SPRUCE_CHEST_BOAT, BAMBOO_CHEST_RAFT -> {
                             if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
                                 com.plotsquared.core.location.Location location = BukkitUtil.adapt(entity.getLocation());
                                 Plot plot = location.getPlot();
@@ -872,22 +842,15 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
                                     this.removeRoadEntity(entity, iterator);
                                 }
                             }
-                            continue;
-                        case "SMALL_FIREBALL":
-                        case "FIREBALL":
-                        case "DRAGON_FIREBALL":
-                        case "DROPPED_ITEM", "ITEM":
+                        }
+                        case SMALL_FIREBALL, FIREBALL, DRAGON_FIREBALL, ITEM, WIND_CHARGE, BREEZE_WIND_CHARGE -> {
                             if (Settings.Enabled_Components.KILL_ROAD_ITEMS
                                     && plotArea.getOwnedPlotAbs(BukkitUtil.adapt(entity.getLocation())) == null) {
                                 this.removeRoadEntity(entity, iterator);
                             }
                             // dropped item
-                            continue;
-                        case "PRIMED_TNT", "TNT":
-                        case "FALLING_BLOCK":
-                            // managed elsewhere
-                            continue;
-                        case "SHULKER":
+                        }
+                        case SHULKER -> {
                             if (Settings.Enabled_Components.KILL_ROAD_MOBS && (Settings.Enabled_Components.KILL_NAMED_ROAD_MOBS || entity.getCustomName() == null)) {
                                 LivingEntity livingEntity = (LivingEntity) entity;
                                 List<MetadataValue> meta = entity.getMetadata("shulkerPlot");
@@ -928,80 +891,16 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
                                     }
                                 }
                             }
-                            continue;
-                        case "ZOMBIFIED_PIGLIN":
-                        case "PIGLIN_BRUTE":
-                        case "LLAMA":
-                        case "DONKEY":
-                        case "MULE":
-                        case "ZOMBIE_HORSE":
-                        case "SKELETON_HORSE":
-                        case "HUSK":
-                        case "ELDER_GUARDIAN":
-                        case "WITHER_SKELETON":
-                        case "STRAY":
-                        case "ZOMBIE_VILLAGER":
-                        case "EVOKER":
-                        case "EVOKER_FANGS":
-                        case "VEX":
-                        case "VINDICATOR":
-                        case "POLAR_BEAR":
-                        case "BAT":
-                        case "BLAZE":
-                        case "CAVE_SPIDER":
-                        case "CHICKEN":
-                        case "COW":
-                        case "CREEPER":
-                        case "ENDERMAN":
-                        case "ENDERMITE":
-                        case "ENDER_DRAGON":
-                        case "GHAST":
-                        case "HAPPY_GHAST": // 1.21.6+
-                        case "GHASTLING": // 1.21.6+
-                        case "GIANT":
-                        case "GUARDIAN":
-                        case "HORSE":
-                        case "IRON_GOLEM":
-                        case "MAGMA_CUBE":
-                        case "MUSHROOM_COW", "MOOSHROOM":
-                        case "OCELOT":
-                        case "PIG":
-                        case "PIG_ZOMBIE":
-                        case "RABBIT":
-                        case "SHEEP":
-                        case "SILVERFISH":
-                        case "SKELETON":
-                        case "SLIME":
-                        case "SNOWMAN", "SNOW_GOLEM":
-                        case "SPIDER":
-                        case "SQUID":
-                        case "VILLAGER":
-                        case "WITCH":
-                        case "WITHER":
-                        case "WOLF":
-                        case "ZOMBIE":
-                        case "PARROT":
-                        case "SALMON":
-                        case "DOLPHIN":
-                        case "TROPICAL_FISH":
-                        case "DROWNED":
-                        case "COD":
-                        case "TURTLE":
-                        case "PUFFERFISH":
-                        case "PHANTOM":
-                        case "ILLUSIONER":
-                        case "CAT":
-                        case "PANDA":
-                        case "FOX":
-                        case "PILLAGER":
-                        case "TRADER_LLAMA":
-                        case "WANDERING_TRADER":
-                        case "RAVAGER":
-                        case "BEE":
-                        case "HOGLIN":
-                        case "PIGLIN":
-                        case "ZOGLIN":
-                        default: {
+                        }
+                        case ZOMBIFIED_PIGLIN, PIGLIN_BRUTE, LLAMA, DONKEY, MULE, ZOMBIE_HORSE, SKELETON_HORSE, HUSK,
+                             ELDER_GUARDIAN, WITHER_SKELETON, STRAY, ZOMBIE_VILLAGER, EVOKER, EVOKER_FANGS, VEX, VINDICATOR,
+                             POLAR_BEAR, BAT, BLAZE, CAVE_SPIDER, CHICKEN, COW, CREEPER, ENDERMAN, ENDERMITE, ENDER_DRAGON, GHAST,
+                             HAPPY_GHAST, GIANT, GUARDIAN, HORSE, IRON_GOLEM, MAGMA_CUBE, MOOSHROOM, OCELOT, PIG, RABBIT, SHEEP,
+                             SILVERFISH, SKELETON, SLIME, SNOW_GOLEM, SPIDER, SQUID, VILLAGER, WITCH, WITHER, WOLF, ZOMBIE,
+                             PARROT, SALMON, DOLPHIN, TROPICAL_FISH, DROWNED, COD, TURTLE, PUFFERFISH, PHANTOM, ILLUSIONER, CAT,
+                             PANDA, FOX, PILLAGER, TRADER_LLAMA, WANDERING_TRADER, RAVAGER, BEE, HOGLIN, PIGLIN, ZOGLIN, FROG,
+                             GOAT, WARDEN, TADPOLE, ALLAY, ARMADILLO, AXOLOTL, STRIDER, SNIFFER, CAMEL, BOGGED, COPPER_GOLEM,
+                             GLOW_SQUID, BREEZE, CREAKING -> {
                             if (Settings.Enabled_Components.KILL_ROAD_MOBS) {
                                 Location location = entity.getLocation();
                                 if (BukkitUtil.adapt(location).isPlotRoad()) {

Bukkit/src/main/java/com/plotsquared/bukkit/entity/EntityType.java

@@ -0,0 +1,261 @@
+package com.plotsquared.bukkit.entity;
+
+import com.sk89q.worldedit.util.Enums;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.EnumMap;
+
+/**
+ * Wrapper Class for Bukkit {@link org.bukkit.entity.EntityType EntityTypes}.
+ * <br>
+ * Intended for a backwards compatible way to interact with entity types. Enum Constants should always be named after the
+ * constants of bukkits EntityType enum in the latest supported versions. Backwards compatible enum constants identifiers
+ * should have a comment assigned to them, so they can be removed in future versions.
+ */
+@ApiStatus.Internal
+public enum EntityType {
+
+    ACACIA_BOAT,
+    ACACIA_CHEST_BOAT,
+    ALLAY,
+    AREA_EFFECT_CLOUD,
+    ARMADILLO,
+    ARMOR_STAND,
+    ARROW,
+    AXOLOTL,
+    BAMBOO_CHEST_RAFT,
+    BAMBOO_RAFT,
+    BAT,
+    BEE,
+    BIRCH_BOAT,
+    BIRCH_CHEST_BOAT,
+    BLAZE,
+    BLOCK_DISPLAY,
+    BOGGED,
+    BREEZE,
+    BREEZE_WIND_CHARGE,
+    CAMEL,
+    CAT,
+    CAVE_SPIDER,
+    CHERRY_BOAT,
+    CHERRY_CHEST_BOAT,
+    // 1.20.5: MINECART_CHEST -> CHEST_MINECART
+    CHEST_MINECART("MINECART_CHEST"),
+    CHICKEN,
+    COD,
+    // 1.20.5: MINECART_COMMAND -> COMMAND_BLOCK_MINECART
+    COMMAND_BLOCK_MINECART("MINECART_COMMAND"),
+    COPPER_GOLEM,
+    COW,
+    CREAKING,
+    CREEPER,
+    DARK_OAK_BOAT,
+    DARK_OAK_CHEST_BOAT,
+    DOLPHIN,
+    DONKEY,
+    DRAGON_FIREBALL,
+    DROWNED,
+    EGG,
+    ELDER_GUARDIAN,
+    // 1.20.5: ENDER_CRYSTAL -> END_CRYSTAL
+    END_CRYSTAL("ENDER_CRYSTAL"),
+    ENDER_DRAGON,
+    ENDER_PEARL,
+    ENDERMAN,
+    ENDERMITE,
+    EVOKER,
+    EVOKER_FANGS,
+    // 1.20.5: THROWN_EXP_BOTTLE -> EXPERIENCE_BOTTLE
+    EXPERIENCE_BOTTLE("THROWN_EXP_BOTTLE"),
+    EXPERIENCE_ORB,
+    // 1.20.5: ENDER_SIGNAL -> EYE_OF_ENDER
+    EYE_OF_ENDER("ENDER_SIGNAL"),
+    FALLING_BLOCK,
+    FIREBALL,
+    // 1.20.5: FIREWORK -> FIREWORK_ROCKET
+    FIREWORK_ROCKET("FIREWORK"),
+    // 1.20.5: FISHING_HOOK -> FISHING_BOBBER
+    FISHING_BOBBER("FISHING_HOOK"),
+    FOX,
+    FROG,
+    // 1.20.5: MINECART_FURNACE -> FURNACE_MINECART
+    FURNACE_MINECART("MINECART_FURNACE"),
+    GHAST,
+    GIANT,
+    GLOW_ITEM_FRAME,
+    GLOW_SQUID,
+    GOAT,
+    GUARDIAN,
+    HAPPY_GHAST,
+    HOGLIN,
+    // 1.20.5: MINECART_HOPPER -> HOPPER_MINECART
+    HOPPER_MINECART("MINECART_HOPPER"),
+    HORSE,
+    HUSK,
+    ILLUSIONER,
+    INTERACTION,
+    IRON_GOLEM,
+    // 1.20.5: DROPPED_ITEM -> ITEM
+    ITEM("DROPPED_ITEM"),
+    ITEM_DISPLAY,
+    ITEM_FRAME,
+    JUNGLE_BOAT,
+    JUNGLE_CHEST_BOAT,
+    // 1.20.5: LEASH_HITCH -> LEASH_KNOT
+    LEASH_KNOT("LEASH_HITCH"),
+    // 1.20.5: LIGHTNING -> LIGHTNING_BOLT
+    LIGHTNING_BOLT("LIGHTNING"),
+    LINGERING_POTION,
+    LLAMA,
+    LLAMA_SPIT,
+    MAGMA_CUBE,
+    MANGROVE_BOAT,
+    MANGROVE_CHEST_BOAT,
+    MANNEQUIN,
+    MARKER,
+    MINECART,
+    // 1.20.5: MUSHROOM_COW -> MOOSHROOM
+    MOOSHROOM("MUSHROOM_COW"),
+    MULE,
+    // 1.21.3: BOAT -> boat subvariants (oak, dark_oak, ...)
+    OAK_BOAT("BOAT"),
+    // 1.21.3: CHEST_BOAT -> chest boat subvariants (oak, dark_oak, ...)
+    OAK_CHEST_BOAT("CHEST_BOAT"),
+    OCELOT,
+    OMINOUS_ITEM_SPAWNER,
+    PAINTING,
+    PALE_OAK_BOAT,
+    PALE_OAK_CHEST_BOAT,
+    PANDA,
+    PARROT,
+    PHANTOM,
+    PIG,
+    PIGLIN,
+    PIGLIN_BRUTE,
+    PILLAGER,
+    PLAYER,
+    POLAR_BEAR,
+    PUFFERFISH,
+    RABBIT,
+    RAVAGER,
+    SALMON,
+    SHEEP,
+    SHULKER,
+    SHULKER_BULLET,
+    SILVERFISH,
+    SKELETON,
+    SKELETON_HORSE,
+    SLIME,
+    SMALL_FIREBALL,
+    SNIFFER,
+    // 1.20.5: SNOWMAN -> SNOW_GOLEM
+    SNOW_GOLEM("SNOWMAN"),
+    SNOWBALL,
+    // 1.20.5: MINECART_MOB_SPAWNER -> SPAWNER_MINECART
+    SPAWNER_MINECART("MINECART_MOB_SPAWNER"),
+    SPECTRAL_ARROW,
+    SPIDER,
+    // 1.21.5: POTION -> SPLASH_POTION + LINGERING_POTION (use SPLASH_POTION FOR compatibility)
+    SPLASH_POTION("POTION"),
+    SPRUCE_BOAT,
+    SPRUCE_CHEST_BOAT,
+    SQUID,
+    STRAY,
+    STRIDER,
+    TADPOLE,
+    TEXT_DISPLAY,
+    // 1.20.5: PRIMED_TNT -> TNT
+    TNT("PRIMED_TNT"),
+    // 1.20.5: MINECART_TNT -> TNT_MINECART
+    TNT_MINECART("MINECART_TNT"),
+    TRADER_LLAMA,
+    TRIDENT,
+    TROPICAL_FISH,
+    TURTLE,
+    UNKNOWN,
+    VEX,
+    VILLAGER,
+    VINDICATOR,
+    WANDERING_TRADER,
+    WARDEN,
+    WIND_CHARGE,
+    WITCH,
+    WITHER,
+    WITHER_SKELETON,
+    WITHER_SKULL,
+    WOLF,
+    ZOGLIN,
+    ZOMBIE,
+    ZOMBIE_HORSE,
+    ZOMBIE_VILLAGER,
+    ZOMBIFIED_PIGLIN;
+
+    private static final Logger LOGGER = LoggerFactory.getLogger("PlotSquared/" + EntityType.class.getSimpleName());
+    private static final EnumMap<org.bukkit.entity.EntityType, EntityType> BUKKIT_TO_INTERNAL =
+            new EnumMap<>(org.bukkit.entity.EntityType.class);
+
+    private final org.bukkit.entity.EntityType bukkitType;
+
+    EntityType(final String... additionalBukkitEnumFields) {
+        org.bukkit.entity.EntityType temp = null;
+        try {
+            temp = org.bukkit.entity.EntityType.valueOf(name());
+        } catch (IllegalArgumentException ignored) {
+            if (additionalBukkitEnumFields.length > 0) {
+                temp = Enums.findByValue(org.bukkit.entity.EntityType.class, additionalBukkitEnumFields);
+            }
+        }
+        bukkitType = temp;
+    }
+
+    public @Nullable org.bukkit.entity.EntityType bukkitType() {
+        return bukkitType;
+    }
+
+    public boolean isAlive() {
+        return this.bukkitType != null && this.bukkitType.isAlive();
+    }
+
+    public boolean isSpawnable() {
+        return this.bukkitType != null && this.bukkitType.isSpawnable();
+    }
+
+    @Override
+    public String toString() {
+        return "EntityType{name=" + name() + "}";
+    }
+
+    public static EntityType of(org.bukkit.entity.EntityType bukkitType) {
+        return BUKKIT_TO_INTERNAL.get(bukkitType);
+    }
+
+    public static EntityType of(Entity entity) {
+        return of(entity.getType());
+    }
+
+    static {
+        // Register all entity types with their aliases
+        for (final EntityType value : values()) {
+            org.bukkit.entity.EntityType bukkitType = value.bukkitType();
+            if (bukkitType != null) {
+                BUKKIT_TO_INTERNAL.put(bukkitType, value);
+            }
+        }
+        // Make sure this wrapper contains EVERY possible entity type available by the server
+        for (final org.bukkit.entity.EntityType bukkitType : org.bukkit.entity.EntityType.values()) {
+            if (!BUKKIT_TO_INTERNAL.containsKey(bukkitType)) {
+                LOGGER.error(
+                        "EntityType {} provided by server has no wrapper equivalent. Is this server version supported? " +
+                                "Falling back to 'UNKNOWN' type.",
+                        bukkitType
+                );
+                BUKKIT_TO_INTERNAL.put(bukkitType, EntityType.UNKNOWN);
+            }
+        }
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/EntityWrapper.java

@@ -21,7 +21,6 @@ package com.plotsquared.bukkit.entity;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
 import org.checkerframework.checker.nullness.qual.NonNull;
 
 public abstract class EntityWrapper {
@@ -36,7 +35,7 @@ public abstract class EntityWrapper {
 
     EntityWrapper(final @NonNull Entity entity) {
         this.entity = entity;
-        this.type = entity.getType();
+        this.type = EntityType.of(entity.getType());
 
         final Location location = entity.getLocation();
         this.x = location.getX();
@@ -49,7 +48,7 @@ public abstract class EntityWrapper {
     @SuppressWarnings("deprecation")
     @Override
     public String toString() {
-        return String.format("[%s, x=%s, y=%s, z=%s]", type.getName(), x, y, z);
+        return String.format("[%s, x=%s, y=%s, z=%s]", type, x, y, z);
     }
 
     public abstract Entity spawn(World world, int xOffset, int zOffset);

Bukkit/src/main/java/com/plotsquared/bukkit/entity/ReplicatingEntityWrapper.java

@@ -37,6 +37,7 @@ import org.bukkit.entity.ChestBoat;
 import org.bukkit.entity.ChestedHorse;
 import org.bukkit.entity.EnderDragon;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.GlowItemFrame;
 import org.bukkit.entity.IronGolem;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.ItemFrame;
@@ -52,6 +53,7 @@ import org.bukkit.util.EulerAngle;
 import org.bukkit.util.Vector;
 
 import java.util.List;
+import java.util.Objects;
 
 public final class ReplicatingEntityWrapper extends EntityWrapper {
 
@@ -85,7 +87,7 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
             return;
         }
         List<Entity> passengers = entity.getPassengers();
-        if (passengers.size() > 0) {
+        if (!passengers.isEmpty()) {
             this.base.passenger = new ReplicatingEntityWrapper(passengers.get(0), depth);
         }
         this.base.fall = entity.getFallDistance();
@@ -101,44 +103,40 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
         if (!entity.hasGravity()) {
             this.noGravity = true;
         }
-        switch (entity.getType().toString()) {
-            case "BOAT", "ACACIA_BOAT", "BIRCH_BOAT", "CHERRY_BOAT", "DARK_OAK_BOAT", "JUNGLE_BOAT", "MANGROVE_BOAT",
-                 "OAK_BOAT", "PALE_OAK_BOAT", "SPRUCE_BOAT", "BAMBOO_RAFT" -> {
+        switch (EntityType.of(entity.getType())) {
+            case ACACIA_BOAT, BIRCH_BOAT, CHERRY_BOAT, DARK_OAK_BOAT, JUNGLE_BOAT, MANGROVE_BOAT,
+                 OAK_BOAT, PALE_OAK_BOAT, SPRUCE_BOAT, BAMBOO_RAFT -> {
                 Boat boat = (Boat) entity;
                 this.dataByte = getOrdinal(Boat.Type.values(), boat.getBoatType());
-                return;
             }
-            case "ACACIA_CHEST_BOAT", "BIRCH_CHEST_BOAT", "CHERRY_CHEST_BOAT", "DARK_OAK_CHEST_BOAT",
-                 "JUNGLE_CHEST_BOAT", "MANGROVE_CHEST_BOAT", "OAK_CHEST_BOAT", "PALE_OAK_CHEST_BOAT",
-                 "SPRUCE_CHEST_BOAT", "BAMBOO_CHEST_RAFT" -> {
+            case ACACIA_CHEST_BOAT, BIRCH_CHEST_BOAT, CHERRY_CHEST_BOAT, DARK_OAK_CHEST_BOAT,
+                 JUNGLE_CHEST_BOAT, MANGROVE_CHEST_BOAT, OAK_CHEST_BOAT, PALE_OAK_CHEST_BOAT,
+                 SPRUCE_CHEST_BOAT, BAMBOO_CHEST_RAFT -> {
                 ChestBoat boat = (ChestBoat) entity;
                 this.dataByte = getOrdinal(Boat.Type.values(), boat.getBoatType());
                 storeInventory(boat);
             }
-            case "ARROW", "EGG", "END_CRYSTAL", "ENDER_CRYSTAL", "ENDER_PEARL", "ENDER_SIGNAL", "EXPERIENCE_ORB", "FALLING_BLOCK", "FIREBALL",
-                    "FIREWORK", "FISHING_HOOK", "LEASH_HITCH", "LIGHTNING", "MINECART", "MINECART_COMMAND", "MINECART_MOB_SPAWNER",
-                    "MINECART_TNT", "PLAYER", "PRIMED_TNT", "SLIME", "SMALL_FIREBALL", "SNOWBALL", "MINECART_FURNACE", "SPLASH_POTION",
-                    "THROWN_EXP_BOTTLE", "WITHER_SKULL", "UNKNOWN", "SPECTRAL_ARROW", "SHULKER_BULLET", "DRAGON_FIREBALL", "AREA_EFFECT_CLOUD",
-                    "TRIDENT", "LLAMA_SPIT" -> {
+            case ARROW, EGG, END_CRYSTAL, ENDER_PEARL, EYE_OF_ENDER, EXPERIENCE_ORB, FALLING_BLOCK, FIREBALL,
+                 FIREWORK_ROCKET, FISHING_BOBBER, LEASH_KNOT, LIGHTNING_BOLT, MINECART, COMMAND_BLOCK_MINECART,
+                 SPAWNER_MINECART, TNT_MINECART, PLAYER, TNT, SLIME, SMALL_FIREBALL, SNOWBALL, FURNACE_MINECART, SPLASH_POTION,
+                 EXPERIENCE_BOTTLE, WITHER_SKULL, UNKNOWN, SPECTRAL_ARROW, SHULKER_BULLET, DRAGON_FIREBALL, AREA_EFFECT_CLOUD,
+                 TRIDENT, LLAMA_SPIT -> {
                 // Do this stuff later
-                return;
             }
             // MISC //
-            case "DROPPED_ITEM", "ITEM" -> {
+            case ITEM -> {
                 Item item = (Item) entity;
                 this.stack = item.getItemStack();
-                return;
             }
-            case "ITEM_FRAME" -> {
+            case ITEM_FRAME, GLOW_ITEM_FRAME -> {
                 this.x = Math.floor(this.getX());
                 this.y = Math.floor(this.getY());
                 this.z = Math.floor(this.getZ());
                 ItemFrame itemFrame = (ItemFrame) entity;
                 this.dataByte = getOrdinal(Rotation.values(), itemFrame.getRotation());
                 this.stack = itemFrame.getItem().clone();
-                return;
             }
-            case "PAINTING" -> {
+            case PAINTING -> {
                 this.x = Math.floor(this.getX());
                 this.y = Math.floor(this.getY());
                 this.z = Math.floor(this.getZ());
@@ -150,18 +148,16 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                     this.y -= 1;
                 }
                 this.dataString = art.name();
-                return;
             }
             // END MISC //
             // INVENTORY HOLDER //
-            case "MINECART_CHEST", "CHEST_MINECART", "MINECART_HOPPER", "HOPPER_MINECART" -> {
+            case CHEST_MINECART, HOPPER_MINECART -> {
                 storeInventory((InventoryHolder) entity);
-                return;
             }
             // START LIVING ENTITY //
             // START AGEABLE //
             // START TAMEABLE //
-            case "CAMEL", "HORSE", "DONKEY", "LLAMA", "TRADER_LLAMA", "MULE", "SKELETON_HORSE", "ZOMBIE_HORSE" -> {
+            case CAMEL, HORSE, DONKEY, LLAMA, TRADER_LLAMA, MULE, SKELETON_HORSE, ZOMBIE_HORSE -> {
                 AbstractHorse horse = (AbstractHorse) entity;
                 this.horse = new HorseStats();
                 this.horse.jump = horse.getJumpStrength();
@@ -176,17 +172,15 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 storeBreedable(horse);
                 storeLiving(horse);
                 storeInventory(horse);
-                return;
             }
             // END INVENTORY HOLDER //
-            case "WOLF", "OCELOT", "CAT", "PARROT" -> {
+            case WOLF, OCELOT, CAT, PARROT -> {
                 storeTameable((Tameable) entity);
                 storeBreedable((Breedable) entity);
                 storeLiving((LivingEntity) entity);
-                return;
             }
             // END TAMEABLE //
-            case "SHEEP" -> {
+            case SHEEP -> {
                 Sheep sheep = (Sheep) entity;
                 if (sheep.isSheared()) {
                     this.dataByte = (byte) 1;
@@ -196,21 +190,18 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 this.dataByte2 = getOrdinal(DyeColor.values(), sheep.getColor());
                 storeBreedable(sheep);
                 storeLiving(sheep);
-                return;
             }
-            case "VILLAGER", "CHICKEN", "COW", "MUSHROOM_COW", "PIG", "TURTLE", "POLAR_BEAR" -> {
+            case VILLAGER, CHICKEN, COW, MOOSHROOM, PIG, TURTLE, POLAR_BEAR -> {
                 storeBreedable((Breedable) entity);
                 storeLiving((LivingEntity) entity);
-                return;
             }
-            case "RABBIT" -> {
+            case RABBIT -> {
                 this.dataByte = getOrdinal(Rabbit.Type.values(), ((Rabbit) entity).getRabbitType());
                 storeBreedable((Breedable) entity);
                 storeLiving((LivingEntity) entity);
-                return;
             }
             // END AGEABLE //
-            case "ARMOR_STAND" -> {
+            case ARMOR_STAND -> {
                 ArmorStand stand = (ArmorStand) entity;
                 this.inventory =
                         new ItemStack[]{stand.getItemInHand().clone(), stand.getHelmet().clone(),
@@ -254,31 +245,26 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 if (stand.isSmall()) {
                     this.stand.small = true;
                 }
-                return;
             }
-            case "ENDERMITE" -> {
-                return;
+            case ENDERMITE -> {
             }
-            case "BAT" -> {
+            case BAT -> {
                 if (((Bat) entity).isAwake()) {
                     this.dataByte = (byte) 1;
                 } else {
                     this.dataByte = (byte) 0;
                 }
-                return;
             }
-            case "ENDER_DRAGON" -> {
+            case ENDER_DRAGON -> {
                 EnderDragon entity1 = (EnderDragon) entity;
                 this.dataByte = (byte) entity1.getPhase().ordinal();
-                return;
             }
-            case "SKELETON", "WITHER_SKELETON", "GUARDIAN", "ELDER_GUARDIAN", "GHAST", "HAPPY_GHAST", "GHASTLING", "MAGMA_CUBE", "SQUID", "PIG_ZOMBIE", "HOGLIN",
-                    "ZOMBIFIED_PIGLIN", "PIGLIN", "PIGLIN_BRUTE", "ZOMBIE", "WITHER", "WITCH", "SPIDER", "CAVE_SPIDER", "SILVERFISH",
-                    "GIANT", "ENDERMAN", "CREEPER", "BLAZE", "SHULKER", "SNOWMAN", "SNOW_GOLEM" -> {
+            case SKELETON, WITHER_SKELETON, GUARDIAN, ELDER_GUARDIAN, GHAST, HAPPY_GHAST, MAGMA_CUBE,
+                 SQUID, HOGLIN, ZOMBIFIED_PIGLIN, PIGLIN, PIGLIN_BRUTE, ZOMBIE, WITHER, WITCH, SPIDER, CAVE_SPIDER, SILVERFISH,
+                 GIANT, ENDERMAN, CREEPER, BLAZE, SHULKER, SNOW_GOLEM -> {
                 storeLiving((LivingEntity) entity);
-                return;
             }
-            case "IRON_GOLEM" -> {
+            case IRON_GOLEM -> {
                 if (((IronGolem) entity).isPlayerCreated()) {
                     this.dataByte = (byte) 1;
                 } else {
@@ -390,8 +376,8 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
     }
 
     /**
-     * @deprecated Use {@link #restoreBreedable(Breedable)} instead
      * @since 7.1.0
+     * @deprecated Use {@link #restoreBreedable(Breedable)} instead
      */
     @Deprecated(forRemoval = true, since = "7.1.0")
     private void restoreAgeable(Ageable entity) {
@@ -405,8 +391,8 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
     }
 
     /**
-     * @deprecated Use {@link #storeBreedable(Breedable)} instead
      * @since 7.1.0
+     * @deprecated Use {@link #storeBreedable(Breedable)} instead
      */
     @Deprecated(forRemoval = true, since = "7.1.0")
     public void storeAgeable(Ageable aged) {
@@ -455,16 +441,17 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
             return null;
         }
         Entity entity;
-        switch (this.getType().toString()) {
-            case "DROPPED_ITEM", "ITEM" -> {
+        switch (this.getType()) {
+            case ITEM -> {
                 return world.dropItem(location, this.stack);
             }
-            case "PLAYER", "LEASH_HITCH" -> {
+            case PLAYER, LEASH_KNOT -> {
                 return null;
             }
-            case "ITEM_FRAME" -> entity = world.spawn(location, ItemFrame.class);
-            case "PAINTING" -> entity = world.spawn(location, Painting.class);
-            default -> entity = world.spawnEntity(location, this.getType());
+            case ITEM_FRAME -> entity = world.spawn(location, ItemFrame.class);
+            case GLOW_ITEM_FRAME -> entity = world.spawn(location, GlowItemFrame.class);
+            case PAINTING -> entity = world.spawn(location, Painting.class);
+            default -> entity = world.spawnEntity(location, Objects.requireNonNull(this.getType().bukkitType()));
         }
         if (this.depth == 0) {
             return entity;
@@ -491,16 +478,16 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
         if (this.noGravity) {
             entity.setGravity(false);
         }
-        switch (entity.getType().toString()) {
-            case "BOAT", "ACACIA_BOAT", "BIRCH_BOAT", "CHERRY_BOAT", "DARK_OAK_BOAT", "JUNGLE_BOAT", "MANGROVE_BOAT",
-                 "OAK_BOAT", "PALE_OAK_BOAT", "SPRUCE_BOAT", "BAMBOO_RAFT" -> {
+        switch (EntityType.of(entity.getType())) {
+            case ACACIA_BOAT, BIRCH_BOAT, CHERRY_BOAT, DARK_OAK_BOAT, JUNGLE_BOAT, MANGROVE_BOAT,
+                 OAK_BOAT, PALE_OAK_BOAT, SPRUCE_BOAT, BAMBOO_RAFT -> {
                 Boat boat = (Boat) entity;
                 boat.setBoatType(Boat.Type.values()[dataByte]);
                 return entity;
             }
-            case "ACACIA_CHEST_BOAT", "BIRCH_CHEST_BOAT", "CHERRY_CHEST_BOAT", "DARK_OAK_CHEST_BOAT",
-                 "JUNGLE_CHEST_BOAT", "MANGROVE_CHEST_BOAT", "OAK_CHEST_BOAT", "PALE_OAK_CHEST_BOAT",
-                 "SPRUCE_CHEST_BOAT", "BAMBOO_CHEST_RAFT" -> {
+            case ACACIA_CHEST_BOAT, BIRCH_CHEST_BOAT, CHERRY_CHEST_BOAT, DARK_OAK_CHEST_BOAT,
+                 JUNGLE_CHEST_BOAT, MANGROVE_CHEST_BOAT, OAK_CHEST_BOAT, PALE_OAK_CHEST_BOAT,
+                 SPRUCE_CHEST_BOAT, BAMBOO_CHEST_RAFT -> {
                 ChestBoat boat = (ChestBoat) entity;
                 boat.setBoatType(Boat.Type.values()[dataByte]);
                 restoreInventory(boat);
@@ -511,22 +498,22 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 ((Slime) entity).setSize(this.dataByte);
                 return entity;
             } */
-            case "ARROW", "EGG", "END_CRYSTAL", "ENDER_CRYSTAL", "ENDER_PEARL", "ENDER_SIGNAL", "DROPPED_ITEM", "EXPERIENCE_ORB", "FALLING_BLOCK",
-                    "FIREBALL", "FIREWORK", "FISHING_HOOK", "LEASH_HITCH", "LIGHTNING", "MINECART", "MINECART_COMMAND",
-                    "MINECART_MOB_SPAWNER", "MINECART_TNT", "PLAYER", "PRIMED_TNT", "SMALL_FIREBALL", "SNOWBALL",
-                    "SPLASH_POTION", "THROWN_EXP_BOTTLE", "SPECTRAL_ARROW", "SHULKER_BULLET", "AREA_EFFECT_CLOUD",
-                    "DRAGON_FIREBALL", "WITHER_SKULL", "MINECART_FURNACE", "LLAMA_SPIT", "TRIDENT", "UNKNOWN" -> {
+            case ARROW, EGG, END_CRYSTAL, ENDER_PEARL, EYE_OF_ENDER, ITEM, EXPERIENCE_ORB, FALLING_BLOCK, FIREBALL, 
+                 FIREWORK_ROCKET, FISHING_BOBBER, LEASH_KNOT, LIGHTNING_BOLT, MINECART, COMMAND_BLOCK_MINECART, SPAWNER_MINECART, 
+                 TNT_MINECART, PLAYER, TNT, SMALL_FIREBALL, SNOWBALL, SPLASH_POTION, EXPERIENCE_BOTTLE, SPECTRAL_ARROW, 
+                 SHULKER_BULLET, AREA_EFFECT_CLOUD, DRAGON_FIREBALL, WITHER_SKULL, FURNACE_MINECART, LLAMA_SPIT, TRIDENT, 
+                 UNKNOWN -> {
                 // Do this stuff later
                 return entity;
             }
             // MISC //
-            case "ITEM_FRAME" -> {
+            case ITEM_FRAME, GLOW_ITEM_FRAME -> {
                 ItemFrame itemframe = (ItemFrame) entity;
                 itemframe.setRotation(Rotation.values()[this.dataByte]);
                 itemframe.setItem(this.stack);
                 return entity;
             }
-            case "PAINTING" -> {
+            case PAINTING -> {
                 Painting painting = (Painting) entity;
                 painting.setFacingDirection(BlockFace.values()[this.dataByte], true);
                 painting.setArt(Art.getByName(this.dataString), true);
@@ -534,14 +521,14 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
             }
             // END MISC //
             // INVENTORY HOLDER //
-            case "MINECART_CHEST", "CHEST_MINECART", "MINECART_HOPPER", "HOPPER_MINECART" -> {
+            case CHEST_MINECART, HOPPER_MINECART -> {
                 restoreInventory((InventoryHolder) entity);
                 return entity;
             }
             // START LIVING ENTITY //
             // START AGEABLE //
             // START TAMEABLE //
-            case "CAMEL", "HORSE", "DONKEY", "LLAMA", "TRADER_LLAMA", "MULE", "SKELETON_HORSE", "ZOMBIE_HORSE" -> {
+            case CAMEL, HORSE, DONKEY, LLAMA, TRADER_LLAMA, MULE, SKELETON_HORSE, ZOMBIE_HORSE -> {
                 AbstractHorse horse = (AbstractHorse) entity;
                 horse.setJumpStrength(this.horse.jump);
                 if (horse instanceof ChestedHorse) {
@@ -558,14 +545,14 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 return entity;
             }
             // END INVENTORY HOLDER //
-            case "WOLF", "OCELOT", "CAT", "PARROT" -> {
+            case WOLF, OCELOT, CAT, PARROT -> {
                 restoreTameable((Tameable) entity);
                 restoreBreedable((Breedable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
             }
             // END AGEABLE //
-            case "SHEEP" -> {
+            case SHEEP -> {
                 Sheep sheep = (Sheep) entity;
                 if (this.dataByte == 1) {
                     sheep.setSheared(true);
@@ -577,13 +564,13 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 restoreLiving(sheep);
                 return sheep;
             }
-            case "VILLAGER", "CHICKEN", "COW", "TURTLE", "POLAR_BEAR", "MUSHROOM_COW", "PIG" -> {
+            case VILLAGER, CHICKEN, COW, TURTLE, POLAR_BEAR, MOOSHROOM, PIG -> {
                 restoreBreedable((Breedable) entity);
                 restoreLiving((LivingEntity) entity);
                 return entity;
             }
             // END AGEABLE //
-            case "RABBIT" -> {
+            case RABBIT -> {
                 if (this.dataByte != 0) {
                     ((Rabbit) entity).setRabbitType(Rabbit.Type.values()[this.dataByte]);
                 }
@@ -591,7 +578,7 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 restoreLiving((LivingEntity) entity);
                 return entity;
             }
-            case "ARMOR_STAND" -> {
+            case ARMOR_STAND -> {
                 // CHECK positions
                 ArmorStand stand = (ArmorStand) entity;
                 if (this.inventory[0] != null) {
@@ -610,41 +597,27 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                     stand.setBoots(this.inventory[4]);
                 }
                 if (this.stand.head[0] != 0 || this.stand.head[1] != 0 || this.stand.head[2] != 0) {
-                    EulerAngle pose =
-                            new EulerAngle(this.stand.head[0], this.stand.head[1], this.stand.head[2]);
+                    EulerAngle pose = new EulerAngle(this.stand.head[0], this.stand.head[1], this.stand.head[2]);
                     stand.setHeadPose(pose);
                 }
                 if (this.stand.body[0] != 0 || this.stand.body[1] != 0 || this.stand.body[2] != 0) {
-                    EulerAngle pose =
-                            new EulerAngle(this.stand.body[0], this.stand.body[1], this.stand.body[2]);
+                    EulerAngle pose = new EulerAngle(this.stand.body[0], this.stand.body[1], this.stand.body[2]);
                     stand.setBodyPose(pose);
                 }
-                if (this.stand.leftLeg[0] != 0 || this.stand.leftLeg[1] != 0
-                        || this.stand.leftLeg[2] != 0) {
-                    EulerAngle pose = new EulerAngle(this.stand.leftLeg[0], this.stand.leftLeg[1],
-                            this.stand.leftLeg[2]
-                    );
+                if (this.stand.leftLeg[0] != 0 || this.stand.leftLeg[1] != 0 || this.stand.leftLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftLeg[0], this.stand.leftLeg[1], this.stand.leftLeg[2]);
                     stand.setLeftLegPose(pose);
                 }
-                if (this.stand.rightLeg[0] != 0 || this.stand.rightLeg[1] != 0
-                        || this.stand.rightLeg[2] != 0) {
-                    EulerAngle pose = new EulerAngle(this.stand.rightLeg[0], this.stand.rightLeg[1],
-                            this.stand.rightLeg[2]
-                    );
+                if (this.stand.rightLeg[0] != 0 || this.stand.rightLeg[1] != 0 || this.stand.rightLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightLeg[0], this.stand.rightLeg[1], this.stand.rightLeg[2]);
                     stand.setRightLegPose(pose);
                 }
-                if (this.stand.leftArm[0] != 0 || this.stand.leftArm[1] != 0
-                        || this.stand.leftArm[2] != 0) {
-                    EulerAngle pose = new EulerAngle(this.stand.leftArm[0], this.stand.leftArm[1],
-                            this.stand.leftArm[2]
-                    );
+                if (this.stand.leftArm[0] != 0 || this.stand.leftArm[1] != 0 || this.stand.leftArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftArm[0], this.stand.leftArm[1], this.stand.leftArm[2]);
                     stand.setLeftArmPose(pose);
                 }
-                if (this.stand.rightArm[0] != 0 || this.stand.rightArm[1] != 0
-                        || this.stand.rightArm[2] != 0) {
-                    EulerAngle pose = new EulerAngle(this.stand.rightArm[0], this.stand.rightArm[1],
-                            this.stand.rightArm[2]
-                    );
+                if (this.stand.rightArm[0] != 0 || this.stand.rightArm[1] != 0 || this.stand.rightArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightArm[0], this.stand.rightArm[1], this.stand.rightArm[2]);
                     stand.setRightArmPose(pose);
                 }
                 if (this.stand.invisible) {
@@ -662,25 +635,28 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
                 restoreLiving(stand);
                 return stand;
             }
-            case "BAT" -> {
+            case BAT -> {
                 if (this.dataByte != 0) {
                     ((Bat) entity).setAwake(true);
                 }
                 restoreLiving((LivingEntity) entity);
                 return entity;
             }
-            case "ENDER_DRAGON" -> {
+            case ENDER_DRAGON -> {
                 if (this.dataByte != 0) {
                     ((EnderDragon) entity).setPhase(EnderDragon.Phase.values()[this.dataByte]);
                 }
                 restoreLiving((LivingEntity) entity);
                 return entity;
             }
-            case "ENDERMITE", "GHAST", "HAPPY_GHAST", "GHASTLING", "MAGMA_CUBE", "SQUID", "PIG_ZOMBIE", "HOGLIN", "PIGLIN", "ZOMBIFIED_PIGLIN", "PIGLIN_BRUTE", "ZOMBIE", "WITHER", "WITCH", "SPIDER", "CAVE_SPIDER", "SILVERFISH", "GIANT", "ENDERMAN", "CREEPER", "BLAZE", "SNOWMAN", "SHULKER", "GUARDIAN", "ELDER_GUARDIAN", "SKELETON", "WITHER_SKELETON" -> {
+            case ENDERMITE, GHAST, HAPPY_GHAST, MAGMA_CUBE, SQUID, HOGLIN, PIGLIN,
+                 ZOMBIFIED_PIGLIN, PIGLIN_BRUTE, ZOMBIE, WITHER, WITCH, SPIDER, CAVE_SPIDER, SILVERFISH, GIANT,
+                 ENDERMAN, CREEPER, BLAZE, SNOW_GOLEM, SHULKER, GUARDIAN, ELDER_GUARDIAN, SKELETON,
+                 WITHER_SKELETON -> {
                 restoreLiving((LivingEntity) entity);
                 return entity;
             }
-            case "IRON_GOLEM" -> {
+            case IRON_GOLEM -> {
                 if (this.dataByte != 0) {
                     ((IronGolem) entity).setPlayerCreated(true);
                 }

Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntityEventListener.java

@@ -20,6 +20,7 @@ package com.plotsquared.bukkit.listener;
 
 import com.google.inject.Inject;
 import com.plotsquared.bukkit.BukkitPlatform;
+import com.plotsquared.bukkit.entity.EntityType;
 import com.plotsquared.bukkit.player.BukkitPlayer;
 import com.plotsquared.bukkit.util.BukkitEntityUtil;
 import com.plotsquared.bukkit.util.BukkitUtil;
@@ -52,7 +53,6 @@ import org.bukkit.block.Block;
 import org.bukkit.entity.Ageable;
 import org.bukkit.entity.Boat;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
 import org.bukkit.entity.FallingBlock;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
@@ -148,8 +148,8 @@ public class EntityEventListener implements Listener {
         if (area == null) {
             return;
         }
-        // Armour-stands are handled elsewhere and should not be handled by area-wide entity-spawn options
-        if (entity.getType() == EntityType.ARMOR_STAND) {
+        // Armor-stands are handled elsewhere and should not be handled by area-wide entity-spawn options
+        if (EntityType.of(event.getEntityType()) == EntityType.ARMOR_STAND) {
             return;
         }
         CreatureSpawnEvent.SpawnReason reason = event.getSpawnReason();
@@ -212,7 +212,7 @@ public class EntityEventListener implements Listener {
 
     @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
     public void onEntityFall(EntityChangeBlockEvent event) {
-        if (event.getEntityType() != EntityType.FALLING_BLOCK) {
+        if (EntityType.of(event.getEntityType()) != EntityType.FALLING_BLOCK) {
             return;
         }
         Block block = event.getBlock();
@@ -278,7 +278,7 @@ public class EntityEventListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onDamage(EntityDamageEvent event) {
-        if (event.getEntityType() != EntityType.PLAYER) {
+        if (EntityType.of(event.getEntityType()) != EntityType.PLAYER) {
             return;
         }
         Location location = BukkitUtil.adapt(event.getEntity().getLocation());

Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntitySpawnListener.java

@@ -18,6 +18,7 @@
  */
 package com.plotsquared.bukkit.listener;
 
+import com.plotsquared.bukkit.entity.EntityType;
 import com.plotsquared.bukkit.util.BukkitEntityUtil;
 import com.plotsquared.bukkit.util.BukkitUtil;
 import com.plotsquared.core.PlotSquared;
@@ -33,7 +34,6 @@ import org.bukkit.block.Block;
 import org.bukkit.entity.ArmorStand;
 import org.bukkit.entity.EnderCrystal;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.Vehicle;
 import org.bukkit.event.EventHandler;
@@ -84,6 +84,7 @@ public class EntitySpawnListener implements Listener {
     public static void test(Entity entity) {
         @NonNull World world = entity.getWorld();
         List<MetadataValue> meta = entity.getMetadata(KEY);
+        final EntityType entityType = EntityType.of(entity);
         if (meta.isEmpty()) {
             if (PlotSquared.get().getPlotAreaManager().hasPlotArea(world.getName())) {
                 entity.setMetadata(KEY, new FixedMetadataValue((Plugin) PlotSquared.platform(), entity.getLocation()));
@@ -94,7 +95,7 @@ public class EntitySpawnListener implements Listener {
             if (!originWorld.equals(world)) {
                 if (!ignoreTP) {
                     if (!world.getName().equalsIgnoreCase(originWorld + "_the_end")) {
-                        if (entity.getType() == EntityType.PLAYER) {
+                        if (entityType == EntityType.PLAYER) {
                             return;
                         }
                         try {
@@ -108,7 +109,7 @@ public class EntitySpawnListener implements Listener {
                         }
                     }
                 } else {
-                    if (entity.getType() == EntityType.PLAYER) {
+                    if (entityType == EntityType.PLAYER) {
                         return;
                     }
                     entity.remove();
@@ -132,7 +133,7 @@ public class EntitySpawnListener implements Listener {
             }
         }
         Plot plot = location.getOwnedPlotAbs();
-        EntityType type = entity.getType();
+        EntityType type = EntityType.of(entity);
         if (plot == null) {
             if (entity instanceof Item) {
                 if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
@@ -201,15 +202,16 @@ public class EntitySpawnListener implements Listener {
         final PlotArea fromArea = fromLocLocation.getPlotArea();
         Location toLocLocation = BukkitUtil.adapt(toLocation.getLocation());
         PlotArea toArea = toLocLocation.getPlotArea();
+        final EntityType entityType = EntityType.of(entity);
 
         if (toArea == null) {
-            if (fromLocation.getType() == EntityType.SHULKER && fromArea != null) {
+            if (entityType == EntityType.SHULKER && fromArea != null) {
                 event.setCancelled(true);
             }
             return;
         }
         Plot toPlot = toArea.getOwnedPlot(toLocLocation);
-        if (fromLocation.getType() == EntityType.SHULKER && fromArea != null) {
+        if (entityType == EntityType.SHULKER && fromArea != null) {
             final Plot fromPlot = fromArea.getOwnedPlot(fromLocLocation);
 
             if (fromPlot != null || toPlot != null) {
@@ -231,7 +233,7 @@ public class EntitySpawnListener implements Listener {
 
     @EventHandler
     public void spawn(CreatureSpawnEvent event) {
-        if (event.getEntityType() == EntityType.ARMOR_STAND) {
+        if (EntityType.of(event.getEntityType()) == EntityType.ARMOR_STAND) {
             testCreate(event.getEntity());
         }
     }

Bukkit/src/main/java/com/plotsquared/bukkit/listener/PaperListener.java

@@ -28,6 +28,7 @@ import com.destroystokyo.paper.event.entity.SlimePathfindEvent;
 import com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent;
 import com.destroystokyo.paper.event.server.AsyncTabCompleteEvent;
 import com.google.inject.Inject;
+import com.plotsquared.bukkit.entity.EntityType;
 import com.plotsquared.bukkit.util.BukkitUtil;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.command.Command;
@@ -55,11 +56,9 @@ import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.tag.Tag;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import org.bukkit.Chunk;
-import org.bukkit.NamespacedKey;
 import org.bukkit.block.Block;
 import org.bukkit.block.TileState;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
 import org.bukkit.entity.Slime;
@@ -84,9 +83,6 @@ import java.util.regex.Pattern;
 @SuppressWarnings("unused")
 public class PaperListener implements Listener {
 
-    private static final NamespacedKey ITEM = NamespacedKey.minecraft("item");
-    private static final NamespacedKey FISHING_BOBBER = NamespacedKey.minecraft("fishing_bobber");
-
     private final PlotAreaManager plotAreaManager;
     private Chunk lastChunk;
 
@@ -104,10 +100,6 @@ public class PaperListener implements Listener {
         }
         Plot plot = area.getPlot(location);
         if (plot != null) {
-            // Prevent dropping blocks which normally would not be dropped.
-            if (!event.willDrop()) {
-                return;
-            }
             event.setWillDrop(plot.getFlag(TileDropFlag.class));
         }
     }
@@ -132,7 +124,7 @@ public class PaperListener implements Listener {
             return;
         }
 
-        handleEntityMovement(event, event.getEntity().getLocation(),  b.getLocation());
+        handleEntityMovement(event, event.getEntity().getLocation(), b.getLocation());
     }
 
     @EventHandler
@@ -186,8 +178,9 @@ public class PaperListener implements Listener {
         if (area == null) {
             return;
         }
-        // Armour-stands are handled elsewhere and should not be handled by area-wide entity-spawn options
-        if (event.getType() == EntityType.ARMOR_STAND) {
+        final EntityType entityType = EntityType.of(event.getType());
+        // Armor-stands are handled elsewhere and should not be handled by area-wide entity-spawn options
+        if (entityType == EntityType.ARMOR_STAND) {
             return;
         }
         // If entities are spawning... the chunk should be loaded?
@@ -206,7 +199,8 @@ public class PaperListener implements Listener {
                     return;
                 }
             }
-            case "REINFORCEMENTS", "NATURAL", "MOUNT", "PATROL", "RAID", "SILVERFISH_BLOCK", "ENDER_PEARL", "TRAP", "VILLAGE_DEFENSE", "VILLAGE_INVASION", "BEEHIVE", "CHUNK_GEN" -> {
+            case "REINFORCEMENTS", "NATURAL", "MOUNT", "PATROL", "RAID", "SILVERFISH_BLOCK", "ENDER_PEARL", "TRAP",
+                 "VILLAGE_DEFENSE", "VILLAGE_INVASION", "BEEHIVE", "CHUNK_GEN" -> {
                 if (!area.isMobSpawning()) {
                     event.setShouldAbortSpawn(true);
                     event.setCancelled(true);
@@ -237,24 +231,23 @@ public class PaperListener implements Listener {
         }
         Plot plot = location.getOwnedPlotAbs();
         if (plot == null) {
-            EntityType type = event.getType();
             // PreCreatureSpawnEvent **should** not be called for DROPPED_ITEM, just for the sake of consistency
-            if (type.getKey().equals(ITEM)) {
+            if (entityType == EntityType.ITEM) {
                 if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
                     event.setCancelled(true);
                 }
                 return;
             }
             if (!area.isMobSpawning()) {
-                if (type == EntityType.PLAYER) {
+                if (entityType == EntityType.PLAYER) {
                     return;
                 }
-                if (type.isAlive()) {
+                if (entityType.isAlive()) {
                     event.setShouldAbortSpawn(true);
                     event.setCancelled(true);
                 }
             }
-            if (!area.isMiscSpawnUnowned() && !type.isAlive()) {
+            if (!area.isMiscSpawnUnowned() && !entityType.isAlive()) {
                 event.setShouldAbortSpawn(true);
                 event.setCancelled(true);
             }
@@ -326,6 +319,7 @@ public class PaperListener implements Listener {
             return;
         }
         Projectile entity = event.getProjectile();
+        EntityType entityType = EntityType.of(entity);
         ProjectileSource shooter = entity.getShooter();
         if (!(shooter instanceof Player)) {
             return;
@@ -365,7 +359,7 @@ public class PaperListener implements Listener {
                 event.setCancelled(true);
             }
         } else if (!plot.isAdded(pp.getUUID())) {
-            if (entity.getType().getKey().equals(FISHING_BOBBER)) {
+            if (entityType == EntityType.FISHING_BOBBER) {
                 if (plot.getFlag(FishingFlag.class)) {
                     return;
                 }

Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEventListener.java

@@ -21,6 +21,7 @@ package com.plotsquared.bukkit.listener;
 import com.destroystokyo.paper.MaterialTags;
 import com.google.common.base.Charsets;
 import com.google.inject.Inject;
+import com.plotsquared.bukkit.entity.EntityType;
 import com.plotsquared.bukkit.player.BukkitPlayer;
 import com.plotsquared.bukkit.util.BukkitEntityUtil;
 import com.plotsquared.bukkit.util.BukkitUtil;
@@ -79,7 +80,6 @@ import com.plotsquared.core.util.task.TaskManager;
 import com.plotsquared.core.util.task.TaskTime;
 import com.sk89q.worldedit.WorldEdit;
 import com.sk89q.worldedit.bukkit.BukkitAdapter;
-import com.sk89q.worldedit.util.Enums;
 import com.sk89q.worldedit.world.block.BlockType;
 import com.sk89q.worldedit.world.block.BlockTypes;
 import io.papermc.lib.PaperLib;
@@ -98,7 +98,6 @@ import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.ArmorStand;
 import org.bukkit.entity.Boat;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.ItemFrame;
 import org.bukkit.entity.LivingEntity;
@@ -160,7 +159,6 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -186,14 +184,6 @@ public class PlayerEventListener implements Listener {
             Material.WRITTEN_BOOK
     );
 
-    /**
-     * The correct EntityType for End Crystal, determined once at class loading time.
-     * Tries END_CRYSTAL first (1.21+), falls back to ENDER_CRYSTAL (1.20.4 and older).
-     */
-    private static final EntityType END_CRYSTAL_ENTITY_TYPE = Objects.requireNonNull(
-            Enums.findByValue(EntityType.class, "END_CRYSTAL", "ENDER_CRYSTAL")
-    );
-
     private static final Set<String> DYES;
 
     static {
@@ -600,7 +590,7 @@ public class PlayerEventListener implements Listener {
                 PlotArea area = location.getPlotArea();
                 if (area == null) {
                     if (lastPlot != null) {
-                        plotListener.plotExit(pp, lastPlot, null, null);
+                        plotListener.plotExit(pp, lastPlot);
                         lastPlotAccess.remove();
                     }
                     try (final MetaDataAccess<Location> lastLocationAccess =
@@ -753,7 +743,7 @@ public class PlayerEventListener implements Listener {
             if (now == null) {
                 try (final MetaDataAccess<Boolean> kickAccess =
                              pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
-                    if (lastPlot != null && !plotListener.plotExit(pp, lastPlot, now, area) && this.tmpTeleport && !kickAccess.get().orElse(
+                    if (lastPlot != null && !plotListener.plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(
                             false)) {
                         pp.sendMessage(
                                 TranslatableCaption.of("permission.no_permission_event"),
@@ -847,7 +837,7 @@ public class PlayerEventListener implements Listener {
             if (plot == null) {
                 try (final MetaDataAccess<Boolean> kickAccess =
                              pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
-                    if (lastPlot != null && !plotListener.plotExit(pp, lastPlot, null, area) && this.tmpTeleport && !kickAccess.get().orElse(
+                    if (lastPlot != null && !plotListener.plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(
                             false)) {
                         pp.sendMessage(
                                 TranslatableCaption.of("permission.no_permission_event"),
@@ -1328,7 +1318,7 @@ public class PlayerEventListener implements Listener {
                 // reset the player's hand item if spawning needs to be cancelled.
                 if (type == Material.ARMOR_STAND || type == Material.END_CRYSTAL) {
                     Plot plot = location.getOwnedPlotAbs();
-                    EntityType entityType = type == Material.ARMOR_STAND ? EntityType.ARMOR_STAND : END_CRYSTAL_ENTITY_TYPE;
+                    EntityType entityType = type == Material.ARMOR_STAND ? EntityType.ARMOR_STAND : EntityType.END_CRYSTAL;
                     if (BukkitEntityUtil.checkEntity(entityType, plot)) {
                         event.setCancelled(true);
                         break;
@@ -1709,7 +1699,7 @@ public class PlayerEventListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
-        if (event.getRightClicked().getType() == EntityType.UNKNOWN) {
+        if (EntityType.of(event.getRightClicked().getType()) == EntityType.UNKNOWN) {
             return;
         }
         Location location = BukkitUtil.adapt(event.getRightClicked().getLocation());

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitEntityUtil.java

@@ -18,6 +18,7 @@
  */
 package com.plotsquared.bukkit.util;
 
+import com.plotsquared.bukkit.entity.EntityType;
 import com.plotsquared.bukkit.player.BukkitPlayer;
 import com.plotsquared.core.configuration.Settings;
 import com.plotsquared.core.configuration.caption.TranslatableCaption;
@@ -48,7 +49,6 @@ import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import org.bukkit.entity.Arrow;
 import org.bukkit.entity.Creature;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Firework;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
@@ -189,7 +189,7 @@ public class BukkitEntityUtil {
                     );
                     return false;
                 }
-            } else if (victim.getType() == EntityType.ARMOR_STAND) {
+            } else if (EntityType.of(victim.getType()) == EntityType.ARMOR_STAND) {
                 if (plot != null && (plot.getFlag(MiscBreakFlag.class) || plot
                         .isAdded(plotPlayer.getUUID()))) {
                     return true;
@@ -354,7 +354,7 @@ public class BukkitEntityUtil {
     }
 
     public static boolean checkEntity(Entity entity, Plot plot) {
-        return checkEntity(entity.getType(), plot);
+        return checkEntity(EntityType.of(entity.getType()), plot);
     }
 
     public static boolean checkEntity(EntityType type, Plot plot) {
@@ -364,7 +364,7 @@ public class BukkitEntityUtil {
         }
 
         final com.sk89q.worldedit.world.entity.EntityType entityType =
-                BukkitAdapter.adapt(type);
+                BukkitAdapter.adapt(type.bukkitType());
 
         if (EntityCategories.PLAYER.contains(entityType)) {
             return false;

Core/build.gradle.kts

@@ -67,8 +67,8 @@ tasks {
     withType<Javadoc> {
         val isRelease = if (rootProject.version.toString().endsWith("-SNAPSHOT")) "TODO" else rootProject.version.toString()
         val opt = options as StandardJavadocDocletOptions
-//        opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-core/" + libs.worldeditCore.get().versionConstraint.toString())
-//        opt.links("https://jd.advntr.dev/api/" + libs.adventureApi.get().versionConstraint.toString())
+        opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-core/" + libs.worldeditCore.get().versionConstraint.toString())
+        opt.links("https://jd.advntr.dev/api/" + libs.adventureApi.get().versionConstraint.toString())
         opt.links("https://jd.advntr.dev/text-minimessage/" + libs.adventureApi.get().versionConstraint.toString())
         opt.links("https://google.github.io/guice/api-docs/" + libs.guice.get().versionConstraint.toString() + "/javadoc/")
         opt.links("https://checkerframework.org/api/")

Core/src/main/java/com/plotsquared/core/listener/PlotListener.java

@@ -164,7 +164,7 @@ public class PlotListener {
         try (final MetaDataAccess<Plot> lastPlot = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
             Plot last = lastPlot.get().orElse(null);
             if ((last != null) && !last.getId().equals(plot.getId())) {
-                plotExit(player, last, plot, plot.getArea());
+                plotExit(player, last);
             }
             if (PlotSquared.platform().expireManager() != null) {
                 PlotSquared.platform().expireManager().handleEntry(player, plot);
@@ -365,12 +365,7 @@ public class PlotListener {
         return true;
     }
 
-    public boolean plotExit(
-            final PlotPlayer<?> player,
-            @NonNull Plot plot,
-            @Nullable Plot nextPlot,
-            @Nullable PlotArea nextArea
-    ) {
+    public boolean plotExit(final PlotPlayer<?> player, Plot plot) {
         try (final MetaDataAccess<Plot> lastPlot = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
             final Plot previous = lastPlot.remove();
 
@@ -387,9 +382,7 @@ public class PlotListener {
             if (plot.hasOwner()) {
                 PlotArea pw = plot.getArea();
                 if (pw == null) {
-                    if (nextPlot == null || nextPlot.getArea() == null) {
-                        return true;
-                    }
+                    return true;
                 }
                 try (final MetaDataAccess<Boolean> kickAccess =
                              player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
@@ -447,23 +440,11 @@ public class PlotListener {
                             player.setFlight(value.get());
                             metaDataAccess.remove();
                         } else {
-                            FlyFlag.FlyStatus flight = FlyFlag.FlyStatus.DEFAULT;
-                            if (nextPlot != null) {
-                                flight = nextPlot.getFlag(FlyFlag.class);
-                            } else if (nextArea != null) {
-                                if (nextArea.isRoadFlags()) {
-                                    flight = nextArea.getRoadFlag(FlyFlag.class);
-                                } else {
-                                    flight = nextArea.getFlag(FlyFlag.class);
-                                }
-                            }
-                            if (flight != FlyFlag.FlyStatus.ENABLED) {
-                                GameMode gameMode = player.getGameMode();
-                                if (gameMode == GameModes.SURVIVAL || gameMode == GameModes.ADVENTURE) {
-                                    player.setFlight(false);
-                                } else if (!player.getFlight()) {
-                                    player.setFlight(true);
-                                }
+                            GameMode gameMode = player.getGameMode();
+                            if (gameMode == GameModes.SURVIVAL || gameMode == GameModes.ADVENTURE) {
+                                player.setFlight(false);
+                            } else if (!player.getFlight()) {
+                                player.setFlight(true);
                             }
                         }
                     }

Core/src/main/java/com/plotsquared/core/player/PlotPlayer.java

@@ -355,7 +355,7 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer,
     /**
      * {@return the world name at the player's contextual position}
      * The contextual position can be affected when using a command with
-     * an explicit plot override, e.g., {@code /plot <id> info}.
+     * an explicit plot override, e.g., `/plot &ltid&gt info`.
      */
     private @NonNull String getContextualWorldName() {
         Plot current = getCurrentPlot();
@@ -368,9 +368,9 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer,
     /**
      * {@return the plot area at the player's contextual position}
      * The contextual position can be affected when using a command with
-     * an explicit plot override, e.g., {@code /plot <id> info}.
+     * an explicit plot override, e.g., `/plot &ltid&gt info`.
      *
-     * @since 7.5.9
+     * @since TODO
      */
     public @Nullable PlotArea getContextualPlotArea() {
         Plot current = getCurrentPlot();

Core/src/main/java/com/plotsquared/core/plot/Plot.java

@@ -1340,7 +1340,7 @@ public class Plot {
         for (Plot current : getConnectedPlots()) {
             List<PlotPlayer<?>> players = current.getPlayersInPlot();
             for (PlotPlayer<?> pp : players) {
-                this.plotListener.plotExit(pp, current, null, area);
+                this.plotListener.plotExit(pp, current);
             }
 
             if (Settings.Backup.DELETE_ON_UNCLAIM) {
@@ -2594,7 +2594,7 @@ public class Plot {
     public void reEnter() {
         TaskManager.runTaskLater(() -> {
             for (PlotPlayer<?> pp : Plot.this.getPlayersInPlot()) {
-                this.plotListener.plotExit(pp, Plot.this, Plot.this, area);
+                this.plotListener.plotExit(pp, Plot.this);
                 this.plotListener.plotEntry(pp, Plot.this);
             }
         }, TaskTime.ticks(1L));

Core/src/main/java/com/plotsquared/core/util/placeholders/PlaceholderRegistry.java

@@ -265,7 +265,7 @@ public final class PlaceholderRegistry {
      * @param key                 Placeholder key
      * @param placeholderFunction Placeholder generator. Cannot return null
      * @param requireAbsolute     If the plot given to the placeholder should be the absolute (not base) plot
-     * @since 7.5.9
+     * @since TODO
      */
     public void createPlaceholder(
             final @NonNull String key,

Core/src/main/java/com/plotsquared/core/util/placeholders/PlotSpecificPlaceholder.java

@@ -38,7 +38,7 @@ public abstract class PlotSpecificPlaceholder extends Placeholder {
      *
      * @param key             Placeholder key
      * @param requireAbsolute If the plot given to the placeholder should be the absolute (not base) plot
-     * @since 7.5.9
+     * @since TODO
      */
     public PlotSpecificPlaceholder(final @NonNull String key, final boolean requireAbsolute) {
         super(key);

build.gradle.kts

@@ -20,7 +20,7 @@ plugins {
 }
 
 group = "com.intellectualsites.plotsquared"
-version = "7.5.11"
+version = "7.5.9-SNAPSHOT"
 
 if (!File("$rootDir/.git").exists()) {
     logger.lifecycle("""
@@ -73,8 +73,8 @@ subprojects {
 
     dependencies {
         // Tests
-        testImplementation("org.junit.jupiter:junit-jupiter:6.0.1")
-        testRuntimeOnly("org.junit.platform:junit-platform-launcher:6.0.1")
+        testImplementation("org.junit.jupiter:junit-jupiter:6.0.0")
+        testRuntimeOnly("org.junit.platform:junit-platform-launcher:6.0.0")
     }
 
     plugins.withId("java") {
@@ -231,10 +231,9 @@ tasks {
         register<RunServer>("runServer-$it") {
             dependsOn(getByName("cacheLatestFaweArtifact"))
             minecraftVersion(it)
-            pluginJars(project.files(
-                project(":plotsquared-bukkit").tasks.named<Jar>("shadowJar")
-                .map { it.archiveFile }
-            ))
+            pluginJars(*project(":plotsquared-bukkit").getTasksByName("shadowJar", false)
+                    .map { task -> (task as Jar).archiveFile }
+                    .toTypedArray())
             jvmArgs("-DPaper.IgnoreJavaVersion=true", "-Dcom.mojang.eula.agree=true")
             downloadPlugins {
                 url("https://ci.athion.net/job/FastAsyncWorldEdit/lastSuccessfulBuild/artifact/artifacts/${project.ext["faweArtifact"]}")

gradle/libs.versions.toml

@@ -3,18 +3,18 @@
 paper = "1.20.4-R0.1-SNAPSHOT"
 guice = "7.0.0"
 spotbugs = "4.9.8"
-checkerqual = "3.52.1"
+checkerqual = "3.51.1"
 gson = "2.10"
 guava = "31.1-jre"
 snakeyaml = "2.0"
-adventure = "4.26.1"
+adventure = "4.25.0"
 adventure-bukkit = "4.4.1"
 log4j = "2.19.0"
 
 # Plugins
 worldedit = "7.2.20"
-fawe = "2.14.3"
-placeholderapi = "2.11.7"
+fawe = "2.14.0"
+placeholderapi = "2.11.6"
 luckperms = "5.5"
 essentialsx = "2.21.2"
 mvdwapi = "3.1.1"
@@ -33,10 +33,10 @@ vault = "1.7.1"
 serverlib = "2.3.7"
 
 # Gradle plugins
-shadow = "9.3.0"
+shadow = "9.2.2"
 grgit = "4.1.1"
-spotless = "8.1.0"
-publish = "0.35.0"
+spotless = "8.0.0"
+publish = "0.34.0"
 runPaper = "3.0.2"
 
 [libraries]

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME