fix: block nbt population

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/workflows/announce-release-on-discord.yml

@@ -11,7 +11,7 @@ jobs:
           DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
           DISCORD_USERNAME: PlotSquared Release
           DISCORD_AVATAR: https://raw.githubusercontent.com/IntellectualSites/Assets/main/plugins/PlotSquared/PlotSquared.png
-        uses: Ilshidur/action-discord@0.3.2
+        uses: Ilshidur/action-discord@0.4.0
         with:
           args: |
             "<@&525015541815967744> <@&679322738552471574> <@&699293353862496266>"

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BukkitPlotGenerator.java

@@ -90,12 +90,7 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
         this.plotGenerator = generator;
         this.platformGenerator = this;
         this.populators = new ArrayList<>();
-        int minecraftMinorVersion = PlotSquared.platform().serverVersion()[1];
-        if (minecraftMinorVersion >= 17) {
         this.populators.add(new BlockStatePopulator(this.plotGenerator));
-        } else {
-            this.populators.add(new LegacyBlockStatePopulator(this.plotGenerator));
-        }
         this.full = true;
         this.useNewGenerationMethods = PlotSquared.platform().serverVersion()[1] >= 19;
         this.biomeProvider = new BukkitPlotBiomeProvider();

Bukkit/src/main/java/com/plotsquared/bukkit/generator/LegacyBlockStatePopulator.java

@@ -36,6 +36,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.Random;
 
+@Deprecated(since = "TODO")
 final class LegacyBlockStatePopulator extends BlockPopulator {
 
     private final IndependentPlotGenerator plotGenerator;

Bukkit/src/main/java/com/plotsquared/bukkit/schematic/StateWrapper.java

@@ -21,6 +21,7 @@ package com.plotsquared.bukkit.schematic;
 import com.destroystokyo.paper.profile.PlayerProfile;
 import com.destroystokyo.paper.profile.ProfileProperty;
 import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
 import com.sk89q.jnbt.ByteTag;
 import com.sk89q.jnbt.CompoundTag;
 import com.sk89q.jnbt.ListTag;
@@ -36,6 +37,8 @@ import org.apache.logging.log4j.Logger;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.DyeColor;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
 import org.bukkit.World;
 import org.bukkit.block.Banner;
 import org.bukkit.block.Block;
@@ -44,25 +47,35 @@ import org.bukkit.block.Sign;
 import org.bukkit.block.Skull;
 import org.bukkit.block.banner.Pattern;
 import org.bukkit.block.banner.PatternType;
+import org.bukkit.block.sign.Side;
+import org.bukkit.block.sign.SignSide;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.UUID;
+import java.util.function.BiConsumer;
 
+// TODO: somehow unbreak this class so it doesn't fuck up the whole schematic population system due to MC updates
+@ApiStatus.Internal
 public class StateWrapper {
 
-    public CompoundTag tag;
-
-    private boolean paperErrorTextureSent = false;
     private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + StateWrapper.class.getSimpleName());
+    private static final boolean MODERN_SIGNS = PlotSquared.platform().serverVersion()[1] > 19;
+    private final Registry<PatternType> PATTERN_TYPE_REGISTRY = Objects.requireNonNull(Bukkit.getRegistry(PatternType.class));
+
+    private static boolean paperErrorTextureSent = false;
+
+    public CompoundTag tag;
 
     public StateWrapper(CompoundTag tag) {
         this.tag = tag;
@@ -212,9 +225,9 @@ public class StateWrapper {
                     if (type == null) {
                         continue;
                     }
-                    int count = itemComp.getByte("Count");
+                    int count = itemComp.containsKey("count") ? itemComp.getInt("count") : itemComp.getByte("Count");
                     int slot = itemComp.getByte("Slot");
-                    CompoundTag tag = (CompoundTag) itemComp.getValue().get("tag");
+                    CompoundTag tag = (CompoundTag) itemComp.getValue().get(itemComp.containsKey("tag") ? "tag" : "components");
                     BaseItemStack baseItemStack = new BaseItemStack(type, tag, count);
                     ItemStack itemStack = BukkitAdapter.adapt(baseItemStack);
                     inv.setItem(slot, itemStack);
@@ -223,83 +236,63 @@ public class StateWrapper {
                 return true;
             }
             case "sign" -> {
-                if (state instanceof Sign sign) {
+                if (state instanceof Sign sign && this.restoreSign(sign)) {
-                    sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
+                    state.update(true, false);
-                    sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
-                    sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
-                    sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
-                    state.update(true);
                     return true;
                 }
                 return false;
             }
             case "skull" -> {
-                if (state instanceof Skull skull) {
+                if (state instanceof Skull skull && this.restoreSkull(skull)) {
-                    CompoundTag skullOwner = ((CompoundTag) this.tag.getValue().get("SkullOwner"));
+                    skull.update(true, false);
-                    if (skullOwner == null) {
                     return true;
                 }
-                    String player = skullOwner.getString("Name");
-
-                    if (player != null && !player.isEmpty()) {
-                        try {
-                            skull.setOwningPlayer(Bukkit.getOfflinePlayer(player));
-                            skull.update(true);
-                        } catch (Exception e) {
-                            e.printStackTrace();
-                        }
-                        return true;
-                    }
-
-                    final CompoundTag properties = (CompoundTag) skullOwner.getValue().get("Properties");
-                    if (properties == null) {
-                        return false;
-                    }
-                    final ListTag textures = properties.getListTag("textures");
-                    if (textures.getValue().isEmpty()) {
-                        return false;
-                    }
-                    final CompoundTag textureCompound = (CompoundTag) textures.getValue().get(0);
-                    if (textureCompound == null) {
-                        return false;
-                    }
-                    String textureValue = textureCompound.getString("Value");
-                    if (textureValue == null) {
-                        return false;
-                    }
-                    if (!PaperLib.isPaper()) {
-                        if (!paperErrorTextureSent) {
-                            paperErrorTextureSent = true;
-                            LOGGER.error("Failed to populate skull data in your road schematic - This is a Spigot limitation.");
-                        }
-                        return false;
-                    }
-                    final PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID());
-                    profile.setProperty(new ProfileProperty("textures", textureValue));
-                    skull.setPlayerProfile(profile);
-                    skull.update(true);
-                    return true;
-
-                }
                 return false;
             }
             case "banner" -> {
                 if (state instanceof Banner banner) {
-                    List<Tag> patterns = this.tag.getListTag("Patterns").getValue();
+                    List<CompoundTag> patterns;
-                    if (patterns == null || patterns.isEmpty()) {
+                    // "old" format
-                        return false;
+                    if ((patterns = this.tag.getList("Patterns", CompoundTag.class)) != null && !patterns.isEmpty()) {
-                    }
+                        banner.setPatterns(patterns.stream().map(compoundTag -> {
-                    banner.setPatterns(patterns.stream().map(t -> (CompoundTag) t).map(compoundTag -> {
                             DyeColor color = DyeColor.getByWoolData((byte) compoundTag.getInt("Color"));
-                        PatternType patternType = PatternType.getByIdentifier(compoundTag.getString("Pattern"));
+                            final PatternType patternType = PATTERN_TYPE_REGISTRY.get(Objects.requireNonNull(
+                                    NamespacedKey.fromString(compoundTag.getString("Pattern"))
+                            ));
                             if (color == null || patternType == null) {
                                 return null;
                             }
                             return new Pattern(color, patternType);
                         }).filter(Objects::nonNull).toList());
-                    banner.update(true);
+                        banner.update(true, false);
                         return true;
                     }
+
+                    // "new" format - since 1.21.3-ish
+                    if ((patterns = this.tag.getList("patterns", CompoundTag.class)) != null && !patterns.isEmpty()) {
+                        for (final CompoundTag patternTag : patterns) {
+                            final String color = patternTag.getString("color");
+                            if (color.isEmpty()) {
+                                continue;
+                            }
+                            final Tag pattern = patternTag.getValue().get("pattern");
+                            if (pattern instanceof StringTag patternString && !patternString.getValue().isEmpty()) {
+                                final PatternType patternType = PATTERN_TYPE_REGISTRY.get(Objects.requireNonNull(
+                                        NamespacedKey.fromString(patternString.getValue())
+                                ));
+                                if (patternType == null) {
+                                    continue;
+                                }
+                                banner.addPattern(new Pattern(
+                                        DyeColor.legacyValueOf(color.toUpperCase(Locale.ROOT)),
+                                        patternType
+                                ));
+                            }
+                            // not supporting banner pattern definitions (no API available)
+                        }
+                        banner.update(true, false);
+                    }
+                }
                 return false;
             }
         }
@@ -346,4 +339,150 @@ public class StateWrapper {
         return data;
     }
 
+    private boolean restoreSkull(Skull skull) {
+        boolean updated = false;
+        // can't support custom_name - Spigot does not provide any API for that
+        if (this.tag.containsKey("note_block_sound")) {
+            skull.setNoteBlockSound(NamespacedKey.fromString(this.tag.getString("note_block_sound")));
+            updated = true;
+        }
+        // modern format - MC 1.21.3-ish
+        if (this.tag.containsKey("profile")) {
+            final Tag profile = this.tag.getValue().get("profile");
+            if (profile instanceof StringTag stringTag) {
+                final String name = stringTag.getValue();
+                if (name != null && !name.isEmpty()) {
+                    skull.setOwningPlayer(Bukkit.getOfflinePlayer(name));
+                    return true;
+                }
+                return updated;
+            }
+            if (profile instanceof CompoundTag compoundTag) {
+                final List<Tag> properties = compoundTag.getList("properties");
+                if (properties != null && !properties.isEmpty()) {
+                    if (!PaperLib.isPaper()) {
+                        if (!paperErrorTextureSent) {
+                            paperErrorTextureSent = true;
+                            LOGGER.error("Failed to populate schematic skull data - this is a Spigot limitation.");
+                        }
+                        return updated;
+                    }
+                    for (final Tag propertyTag : properties) {
+                        if (!(propertyTag instanceof CompoundTag property)) {
+                            continue;
+                        }
+                        if (!property.getString("name").equals("textures")) {
+                            continue;
+                        }
+                        final String value = property.getString("value");
+                        final String signature = property.containsKey("signature") ? property.getString("signature") : null;
+                        final PlayerProfile playerProfile = Bukkit.createProfile(UUID.randomUUID());
+                        playerProfile.setProperty(new ProfileProperty("textures", value, signature));
+                        skull.setPlayerProfile(playerProfile);
+                        return true;
+                    }
+                    return updated;
+                }
+                final int[] id = compoundTag.getIntArray("id");
+                if (id != null && id.length == 4) {
+                    skull.setOwningPlayer(Bukkit.getOfflinePlayer(new UUID(
+                            (long) id[0] << 32 | (id[1] & 0xFFFFFFFFL),
+                            (long) id[2] << 32 | (id[3] & 0xFFFFFFFFL)
+                    )));
+                    return true;
+                }
+                final String name = compoundTag.getString("name");
+                if (name != null && !name.isEmpty()) {
+                    skull.setOwningPlayer(Bukkit.getOfflinePlayer(name));
+                    return true;
+                }
+            }
+        }
+
+        // "Old" MC format (idk when it got updated)
+        if (this.tag.getValue().get("SkullOwner") instanceof CompoundTag skullOwner) {
+            if (skullOwner.getValue().get("Name") instanceof StringTag ownerName && !ownerName.getValue().isEmpty()) {
+                skull.setOwningPlayer(Bukkit.getOfflinePlayer(ownerName.getValue()));
+                skull.update(true);
+                return true;
+            }
+            if (skullOwner.getValue().get("Properties") instanceof CompoundTag properties) {
+                if (!paperErrorTextureSent) {
+                    paperErrorTextureSent = true;
+                    LOGGER.error("Failed to populate schematic skull data - this is a Spigot limitation.");
+                    return updated;
+                }
+                final List<CompoundTag> textures = properties.getList("textures", CompoundTag.class);
+                if (textures.isEmpty()) {
+                    return updated;
+                }
+                final String value = textures.get(0).getString("Value");
+                if (!value.isEmpty()) {
+                    final PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID());
+                    profile.setProperty(new ProfileProperty("textures", value));
+                    skull.setPlayerProfile(profile);
+                    return true;
+                }
+            }
+        }
+        return updated;
+    }
+
+    private boolean restoreSign(Sign sign) {
+        // "old" format (pre 1.20)
+        if (this.tag.containsKey("Text1") || this.tag.containsKey("Text2")
+                || this.tag.containsKey("Text3") || this.tag.containsKey("Text4")) {
+            if (!MODERN_SIGNS) {
+                sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
+                sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
+                sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
+                sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
+                sign.setGlowingText(tag.getByte("GlowingText") == 1);
+                if (tag.getValue().get("Color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
+                    sign.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
+                }
+                return true;
+            }
+            SignSide front = sign.getSide(Side.FRONT);
+            front.setLine(0, jsonToColourCode(tag.getString("Text1")));
+            front.setLine(1, jsonToColourCode(tag.getString("Text2")));
+            front.setLine(2, jsonToColourCode(tag.getString("Text3")));
+            front.setLine(3, jsonToColourCode(tag.getString("Text4")));
+            front.setGlowingText(tag.getByte("GlowingText") == 1);
+            if (tag.getValue().get("Color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
+                front.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
+            }
+            return true;
+        }
+
+        // "modern" format
+        if (this.tag.containsKey("front_text") || this.tag.containsKey("back_text") || this.tag.containsKey("is_waxed")) {
+            // the new format on older servers shouldn't be possible, I hope?
+            sign.setWaxed(this.tag.getByte("is_waxed") == 1);
+            BiConsumer<SignSide, CompoundTag> sideSetter = (signSide, compoundTag) -> {
+                signSide.setGlowingText(compoundTag.getByte("has_glowing_text") == 1);
+                if (tag.getValue().get("color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
+                    signSide.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
+                }
+                final List<Tag> lines = compoundTag.getList("messages");
+                for (int i = 0; i < Math.min(lines.size(), 4); i++) {
+                    final Tag line = lines.get(i);
+                    if (line instanceof StringTag stringLine) {
+                        signSide.setLine(i, jsonToColourCode(stringLine.getValue()));
+                        continue;
+                    }
+                    // TODO: how tf support list of components + components - utilize paper + adventure?
+                }
+            };
+            if (this.tag.getValue().get("front_text") instanceof CompoundTag frontText) {
+                sideSetter.accept(sign.getSide(Side.FRONT), frontText);
+            }
+            if (this.tag.getValue().get("back_text") instanceof CompoundTag backText) {
+                sideSetter.accept(sign.getSide(Side.BACK), backText);
+            }
+            return true;
+        }
+        return false;
+    }
+
 }

Core/src/main/java/com/plotsquared/core/command/Grant.java

@@ -177,8 +177,14 @@ public class Grant extends Command {
                 commands.addAll(TabCompletions.completePlayers(player, args[0], Collections.emptyList()));
             }
             return commands;
+        } else if (args.length == 2) {
+            final String subcommand = args[0].toLowerCase();
+            if ((subcommand.equals("add") && player.hasPermission(Permission.PERMISSION_GRANT_ADD)) ||
+                (subcommand.equals("check") && player.hasPermission(Permission.PERMISSION_GRANT_CHECK))) {
+                return TabCompletions.completePlayers(player, args[1], Collections.emptyList());
             }
-        return TabCompletions.completePlayers(player, String.join(",", args).trim(), Collections.emptyList());
+        }
+        return Collections.emptyList();
     }
 
 }

Core/src/main/java/com/plotsquared/core/command/MainCommand.java

@@ -283,24 +283,35 @@ public class MainCommand extends Command {
         }
     }
 
-    private CompletableFuture<Optional<CommandExecutionData>> preparePlotArgument(@Nullable Plot newPlot,
+    private CompletableFuture<Optional<CommandExecutionData>> preparePlotArgument(
+            @Nullable Plot newPlot,
             @Nonnull CommandExecutionData data,
-                                                                                  @Nullable PlotArea area) {
+            @Nullable PlotArea area
-        if (newPlot != null && (data.player() instanceof ConsolePlayer
+    ) {
-                || (area != null && area.equals(newPlot.getArea()))
+        if (newPlot == null) {
-                || data.player().hasPermission(Permission.PERMISSION_ADMIN)
+            return CompletableFuture.completedFuture(Optional.of(data));
-                || data.player().hasPermission(Permission.PERMISSION_ADMIN_AREA_SUDO))
+        }
-                && !newPlot.isDenied(data.player().getUUID())) {
+        final PlotPlayer<?> player = data.player();
+        final boolean isAdmin = player instanceof ConsolePlayer || player.hasPermission(Permission.PERMISSION_ADMIN);
+        final boolean isDenied = newPlot.isDenied(player.getUUID());
+        if (!isAdmin) {
+            if (isDenied) {
+                throw new CommandException(TranslatableCaption.of("deny.cannot_interact"));
+            }
+            if (area != null && area.equals(newPlot.getArea()) && !player.hasPermission(Permission.PERMISSION_ADMIN_AREA_SUDO)) {
+                return CompletableFuture.completedFuture(Optional.of(data));
+            }
+        }
         return fetchPlotCenterLocation(newPlot)
                 .thenApply(newLoc -> {
-                        if (!data.player().canTeleport(newLoc)) {
+                    if (!player.canTeleport(newLoc)) {
-                            data.player().sendMessage(TranslatableCaption.of("border.denied"));
+                        player.sendMessage(TranslatableCaption.of("border.denied"));
                         return Optional.empty();
                     }
                     // Save meta
-                        var originalCommandMeta = setCommandScope(data.player(), new TemporaryCommandMeta(newLoc, newPlot));
+                    var originalCommandMeta = setCommandScope(player, new TemporaryCommandMeta(newLoc, newPlot));
                     return Optional.of(new CommandExecutionData(
-                                data.player(),
+                            player,
                             Arrays.copyOfRange(data.args(), 1, data.args().length), // Trimmed command
                             data.confirm(),
                             data.whenDone(),
@@ -308,8 +319,6 @@ public class MainCommand extends Command {
                     ));
                 });
     }
-        return CompletableFuture.completedFuture(Optional.of(data));
-    }
 
     private Optional<CommandExecutionData> prepareFlagArgument(@Nonnull CommandExecutionData data, @Nonnull PlotArea area) {
         if (data.args().length >= 2 && !data.args()[0].isEmpty() && data.args()[0].charAt(0) == '-') {

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

@@ -352,7 +352,7 @@ public class Plot {
      * @param arg     The search term
      * @param message If a message should be sent to the player if a plot cannot be found
      * @return The plot if only 1 result is found, or null
-     * @since TODO
+     * @since 7.5.5
      */
     public static @Nullable Plot getPlotFromStringUnchecked(
             final @Nullable PlotPlayer<?> player,
@@ -434,7 +434,7 @@ public class Plot {
      * @param string      plot id/area + id
      * @param player      {@link PlotPlayer} player to notify if plot is invalid (outside bounds)
      * @return New or existing plot object
-     * @since TODO
+     * @since 7.5.5
      */
     public static @Nullable Plot fromString(
             final @Nullable PlotArea defaultArea,
@@ -457,7 +457,7 @@ public class Plot {
      * @param defaultArea if no area is specified
      * @param string      plot id/area + id
      * @return New or existing plot object
-     * @since TODO
+     * @since 7.5.5
      */
     public static @Nullable Plot fromStringUnchecked(final @Nullable PlotArea defaultArea, final @NonNull String string) {
         final String[] split = string.split("[;,]");

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

@@ -371,8 +371,7 @@ public final class PlotModificationManager {
                             manager.createRoadSouthEast(current, queue);
                         }
                     }
-                }
+                } else if (current.isMerged(Direction.SOUTH)) {
-                if (current.isMerged(Direction.SOUTH)) {
                     manager.createRoadSouth(current, queue);
                 }
             }

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

@@ -67,7 +67,7 @@ public class PlotTitle {
      * Provides a string representation of this plot title value (used in placeholders).
      *
      * @return the plot title representation in the format {@code "<title>" "<subtitle>"}
-     * @since TODO
+     * @since 7.5.5
      */
     @Override
     public String toString() {

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

@@ -49,10 +49,12 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Set;
 import java.util.TimeZone;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
+import java.util.stream.Collectors;
 
 /**
  * Registry that contains {@link Placeholder placeholders}
@@ -127,6 +129,22 @@ public final class PlaceholderRegistry {
             }
             return legacyComponent(TranslatableCaption.of("info.unknown"), player);
         });
+        this.createPlaceholder("currentplot_owners", (player, plot) -> {
+            if (plot.getFlag(ServerPlotFlag.class)) {
+                return legacyComponent(TranslatableCaption.of("info.server"), player);
+            }
+            final Set<UUID> plotOwners = plot.getOwners();
+            if (plotOwners.isEmpty()) {
+                return legacyComponent(TranslatableCaption.of("generic.generic_unowned"), player);
+            }
+            return plotOwners.stream().map(PlotSquared.platform().playerManager()::getUsernameCaption).map(f -> {
+                try {
+                    return f.get(Settings.UUID.BLOCKING_TIMEOUT, TimeUnit.MILLISECONDS).getComponent(player);
+                } catch (final Exception ignored) {
+                    return legacyComponent(TranslatableCaption.of("info.unknown"), player);
+                }
+            }).collect(Collectors.joining(", "));
+        });
         this.createPlaceholder("currentplot_members", (player, plot) -> {
             if (plot.getMembers().isEmpty() && plot.getTrusted().isEmpty()) {
                 return legacyComponent(TranslatableCaption.of("info.none"), player);

Core/src/main/resources/lang/messages_en.json

@@ -415,6 +415,7 @@
   "deny.denied_added": "<prefix><dark_aqua>You successfully denied the player from this plot.</dark_aqua>",
   "deny.no_enter": "<prefix><red>You are denied from the plot <red><gold><plot></gold><red> and therefore not allowed to enter.</red>",
   "deny.you_got_denied": "<prefix><red>You are denied from the plot you were previously on, and got teleported to spawn.</red>",
+  "deny.cannot_interact": "<prefix><red>You are denied from the plot <red><gold><plot></gold><red> and therefore cannot interact with it.</red>",
   "deny.cant_remove_owner": "<prefix><red>You can't remove the plot owner.</red>",
   "kick.player_not_in_plot": "<prefix><red>The player <gray><player></gray> is not on this plot.</red>",
   "kick.cannot_kick_player": "<prefix><red>You cannot kick the player <gray><player></gray>.</red>",

build.gradle.kts

@@ -20,7 +20,7 @@ plugins {
 }
 
 group = "com.intellectualsites.plotsquared"
-version = "7.5.5-SNAPSHOT"
+version = "7.5.7-SNAPSHOT"
 
 if (!File("$rootDir/.git").exists()) {
     logger.lifecycle("""
@@ -67,8 +67,8 @@ subprojects {
 
     dependencies {
         // Tests
-        testImplementation("org.junit.jupiter:junit-jupiter:5.13.3")
+        testImplementation("org.junit.jupiter:junit-jupiter:5.13.4")
-        testRuntimeOnly("org.junit.platform:junit-platform-launcher:1.13.3")
+        testRuntimeOnly("org.junit.platform:junit-platform-launcher:1.13.4")
     }
 
     plugins.withId("java") {

gradle/libs.versions.toml

@@ -2,21 +2,21 @@
 # Platform expectations
 paper = "1.20.4-R0.1-SNAPSHOT"
 guice = "7.0.0"
-spotbugs = "4.9.3"
+spotbugs = "4.9.4"
 checkerqual = "3.49.5"
 gson = "2.10"
 guava = "31.1-jre"
 snakeyaml = "2.0"
-adventure = "4.23.0"
+adventure = "4.24.0"
-adventure-bukkit = "4.4.0"
+adventure-bukkit = "4.4.1"
 log4j = "2.19.0"
 
 # Plugins
 worldedit = "7.2.20"
-fawe = "2.13.0"
+fawe = "2.13.1"
 placeholderapi = "2.11.6"
 luckperms = "5.5"
-essentialsx = "2.21.1"
+essentialsx = "2.21.2"
 mvdwapi = "3.1.1"
 
 # Third party
@@ -33,9 +33,9 @@ vault = "1.7.1"
 serverlib = "2.3.7"
 
 # Gradle plugins
-shadow = "8.3.8"
+shadow = "8.3.9"
 grgit = "4.1.1"
-spotless = "7.2.0"
+spotless = "7.2.1"
 publish = "0.34.0"
 runPaper = "2.3.1"