Let's bring back Sponge.

* Fix: getName should return something

* Fix caption typo

* Deprecate old getName methods + add new methods for username retrieval

* Remove wildcard import

* Use @since TODO instead of hard coded version

* chore: Update `@since` tags to TODO

Co-authored-by: NotMyFault <mc.cache@web.de>

.github/workflows/release-drafter.yml

@@ -13,6 +13,6 @@ jobs:
   update_release_draft:
     runs-on: ubuntu-latest
     steps:
-      - uses: release-drafter/release-drafter@v5.15.0
+      - uses: release-drafter/release-drafter@v5.17.5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

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

@@ -106,7 +106,7 @@ public class Add extends Command {
                                         .hasPermission(player, Permission.PERMISSION_ADMIN_COMMAND_TRUST))) {
                             player.sendMessage(
                                     TranslatableCaption.of("errors.invalid_player"),
-                                    Template.of("value", PlayerManager.getName(uuid))
+                                    Template.of("value", PlayerManager.resolveName(uuid).getComponent(player))
                             );
                             iterator.remove();
                             continue;
@@ -114,7 +114,7 @@ public class Add extends Command {
                         if (plot.isOwner(uuid)) {
                             player.sendMessage(
                                     TranslatableCaption.of("member.already_added"),
-                                    Template.of("player", PlayerManager.getName(uuid))
+                                    Template.of("player", PlayerManager.resolveName(uuid).getComponent(player))
                             );
                             iterator.remove();
                             continue;
@@ -122,7 +122,7 @@ public class Add extends Command {
                         if (plot.getMembers().contains(uuid)) {
                             player.sendMessage(
                                     TranslatableCaption.of("member.already_added"),
-                                    Template.of("player", PlayerManager.getName(uuid))
+                                    Template.of("player", PlayerManager.resolveName(uuid).getComponent(player))
                             );
                             iterator.remove();
                             continue;

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

@@ -125,7 +125,7 @@ public class Deny extends SubCommand {
                     } else if (plot.getDenied().contains(uuid)) {
                         player.sendMessage(
                                 TranslatableCaption.of("member.already_added"),
-                                Template.of("player", PlayerManager.getName(uuid))
+                                Template.of("player", PlayerManager.resolveName(uuid).getComponent(player))
                         );
                         return;
                     } else {

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

@@ -142,7 +142,7 @@ public class Owner extends SetCommand {
             if (plot.isOwner(uuid)) {
                 player.sendMessage(
                         TranslatableCaption.of("member.already_owner"),
-                        Template.of("player", PlayerManager.getName(uuid, false))
+                        Template.of("player", PlayerManager.resolveName(uuid, false).getComponent(player))
                 );
                 return;
             }
@@ -151,7 +151,7 @@ public class Owner extends SetCommand {
                 if (other == null) {
                     player.sendMessage(
                             TranslatableCaption.of("errors.invalid_player_offline"),
-                            Template.of("player", PlayerManager.getName(uuid))
+                            Template.of("player", PlayerManager.resolveName(uuid).getComponent(player))
                     );
                     return;
                 }

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

@@ -112,7 +112,7 @@ public class Trust extends Command {
                                     .hasPermission(player, Permission.PERMISSION_ADMIN_COMMAND_TRUST))) {
                         player.sendMessage(
                                 TranslatableCaption.of("errors.invalid_player"),
-                                Template.of("value", PlayerManager.getName(uuid))
+                                Template.of("value", PlayerManager.resolveName(uuid).getComponent(player))
                         );
                         iterator.remove();
                         continue;
@@ -120,7 +120,7 @@ public class Trust extends Command {
                     if (currentPlot.isOwner(uuid)) {
                         player.sendMessage(
                                 TranslatableCaption.of("member.already_added"),
-                                Template.of("value", PlayerManager.getName(uuid))
+                                Template.of("value", PlayerManager.resolveName(uuid).getComponent(player))
                         );
                         iterator.remove();
                         continue;
@@ -128,7 +128,7 @@ public class Trust extends Command {
                     if (currentPlot.getTrusted().contains(uuid)) {
                         player.sendMessage(
                                 TranslatableCaption.of("member.already_added"),
-                                Template.of("value", PlayerManager.getName(uuid))
+                                Template.of("value", PlayerManager.resolveName(uuid).getComponent(player))
                         );
                         iterator.remove();
                         continue;

Core/src/main/java/com/plotsquared/core/configuration/caption/Templates.java

@@ -70,7 +70,7 @@ public final class Templates {
      * @return Generated template
      */
     public static @NonNull Template of(final @NonNull String key, final @NonNull UUID uuid) {
-        final String username = PlayerManager.getName(uuid);
+        final String username = PlayerManager.resolveName(uuid).getComponent(LocaleHolder.console());
         return Template.of(key, username);
     }
 

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

@@ -198,13 +198,7 @@ public class PlotListener {
                         final PlotPlayer<?> owner = PlotSquared.platform().playerManager().getPlayerIfExists(uuid);
                         if (owner != null && !owner.getUUID().equals(player.getUUID()) && owner.canSee(player)) {
                             Caption caption = TranslatableCaption.of("notification.notify_enter");
-                            Template playerTemplate = Template.of("player", player.getName());
-                            Template plotTemplate = Template.of("plot", plot.getId().toString());
-                            if (!Settings.Chat.NOTIFICATION_AS_ACTIONBAR) {
-                                owner.sendMessage(caption, playerTemplate, plotTemplate);
-                            } else {
-                                owner.sendActionBar(caption, playerTemplate, plotTemplate);
-                            }
+                            notifyPlotOwner(player, plot, owner, caption);
                         }
                     }
                 }
@@ -327,7 +321,7 @@ public class PlotListener {
                         }
                         if ((lastPlot != null) && plot.getId().equals(lastPlot.getId()) && plot.hasOwner()) {
                             final UUID plotOwner = plot.getOwnerAbs();
-                            String owner = PlayerManager.getName(plotOwner, false);
+                            String owner = PlayerManager.resolveName(plotOwner, false).getComponent(player);
                             Caption header = fromFlag ? StaticCaption.of(title) : TranslatableCaption.of("titles" +
                                     ".title_entered_plot");
                             Caption subHeader = fromFlag ? StaticCaption.of(subtitle) : TranslatableCaption.of("titles" +
@@ -443,13 +437,7 @@ public class PlotListener {
                             final PlotPlayer<?> owner = PlotSquared.platform().playerManager().getPlayerIfExists(uuid);
                             if ((owner != null) && !owner.getUUID().equals(player.getUUID()) && owner.canSee(player)) {
                                 Caption caption = TranslatableCaption.of("notification.notify_leave");
-                                Template playerTemplate = Template.of("player", player.getName());
-                                Template plotTemplate = Template.of("plot", plot.getId().toString());
-                                if (!Settings.Chat.NOTIFICATION_AS_ACTIONBAR) {
-                                    owner.sendMessage(caption, playerTemplate, plotTemplate);
-                                } else {
-                                    owner.sendActionBar(caption, playerTemplate, plotTemplate);
-                                }
+                                notifyPlotOwner(player, plot, owner, caption);
                             }
                         }
                     }
@@ -497,6 +485,17 @@ public class PlotListener {
         return true;
     }
 
+    private void notifyPlotOwner(final PlotPlayer<?> player, final Plot plot, final PlotPlayer<?> owner, final Caption caption) {
+        Template playerTemplate = Template.of("player", player.getName());
+        Template plotTemplate = Template.of("plot", plot.getId().toString());
+        Template areaTemplate = Template.of("area", plot.getArea().toString());
+        if (!Settings.Chat.NOTIFICATION_AS_ACTIONBAR) {
+            owner.sendMessage(caption, playerTemplate, plotTemplate, areaTemplate);
+        } else {
+            owner.sendActionBar(caption, playerTemplate, plotTemplate, areaTemplate);
+        }
+    }
+
     public void logout(UUID uuid) {
         feedRunnable.remove(uuid);
         healRunnable.remove(uuid);

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

@@ -2838,7 +2838,7 @@ public class Plot {
                             if (time != 0) {
                                 seen = TimeUtil.secToTime(time);
                             } else {
-                                seen = TranslatableCaption.of("info.known").getComponent(player);
+                                seen = TranslatableCaption.of("info.unknown").getComponent(player);
                             }
                         }
                     } else {

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

@@ -30,6 +30,7 @@ import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.ConfigurationUtil;
 import com.plotsquared.core.configuration.Settings;
 import com.plotsquared.core.configuration.caption.Caption;
+import com.plotsquared.core.configuration.caption.LocaleHolder;
 import com.plotsquared.core.configuration.caption.TranslatableCaption;
 import com.plotsquared.core.database.DBFunc;
 import com.plotsquared.core.events.PlotComponentSetEvent;
@@ -358,7 +359,8 @@ public final class PlotModificationManager {
         if (createSign) {
             queue.setCompleteTask(() -> TaskManager.runTaskAsync(() -> {
                 for (Plot current : plots) {
-                    current.getPlotModificationManager().setSign(PlayerManager.getName(current.getOwnerAbs()));
+                    current.getPlotModificationManager().setSign(PlayerManager.resolveName(current.getOwnerAbs()).getComponent(
+                            LocaleHolder.console()));
                 }
             }));
         }

Core/src/main/java/com/plotsquared/core/util/PlayerManager.java

@@ -27,7 +27,9 @@ package com.plotsquared.core.util;
 
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.configuration.caption.Caption;
 import com.plotsquared.core.configuration.caption.LocaleHolder;
+import com.plotsquared.core.configuration.caption.StaticCaption;
 import com.plotsquared.core.configuration.caption.TranslatableCaption;
 import com.plotsquared.core.database.DBFunc;
 import com.plotsquared.core.player.ConsolePlayer;
@@ -162,7 +164,9 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
      *
      * @param owner Owner UUID
      * @return The player's name, None, Everyone or Unknown
+     * @deprecated Use {@link #resolveName(UUID)}
      */
+    @Deprecated(forRemoval = true, since = "TODO")
     public static @NonNull String getName(final @Nullable UUID owner) {
         return getName(owner, true);
     }
@@ -173,7 +177,9 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
      * @param owner    Owner UUID
      * @param blocking Whether or not the operation can be blocking
      * @return The player's name, None, Everyone or Unknown
+     * @deprecated Use {@link #resolveName(UUID, boolean)}
      */
+    @Deprecated(forRemoval = true, since = "TODO")
     public static @NonNull String getName(final @Nullable UUID owner, final boolean blocking) {
         if (owner == null) {
             TranslatableCaption.of("info.none");
@@ -203,6 +209,57 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
         return name;
     }
 
+    /**
+     * Attempts to resolve the username by an uuid
+     * <p>
+     * <b>Note:</b> blocks the thread until the name was resolved or failed
+     *
+     * @param owner The UUID of the owner
+     * @return A caption containing either the name, {@code None}, {@code Everyone} or {@code Unknown}
+     * @see #resolveName(UUID, boolean)
+     * @since TODO
+     */
+    public static @NonNull Caption resolveName(final @Nullable UUID owner) {
+        return resolveName(owner, true);
+    }
+
+    /**
+     * Attempts to resolve the username by an uuid
+     *
+     * @param owner    The UUID of the owner
+     * @param blocking If the operation should block the current thread for {@link Settings.UUID#BLOCKING_TIMEOUT} milliseconds
+     * @return A caption containing either the name, {@code None}, {@code Everyone} or {@code Unknown}
+     * @since TODO
+     */
+    public static @NonNull Caption resolveName(final @Nullable UUID owner, final boolean blocking) {
+        if (owner == null) {
+            return TranslatableCaption.of("info.none");
+        }
+        if (owner.equals(DBFunc.EVERYONE)) {
+            return TranslatableCaption.of("info.everyone");
+        }
+        if (owner.equals(DBFunc.SERVER)) {
+            return TranslatableCaption.of("info.server");
+        }
+        final String name;
+        if (blocking) {
+            name = PlotSquared.get().getImpromptuUUIDPipeline()
+                    .getSingle(owner, Settings.UUID.BLOCKING_TIMEOUT);
+        } else {
+            final UUIDMapping uuidMapping =
+                    PlotSquared.get().getImpromptuUUIDPipeline().getImmediately(owner);
+            if (uuidMapping != null) {
+                name = uuidMapping.getUsername();
+            } else {
+                name = null;
+            }
+        }
+        if (name == null) {
+            return TranslatableCaption.of("info.unknown");
+        }
+        return StaticCaption.of(name);
+    }
+
     /**
      * Remove a player from the player map
      *

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

@@ -116,7 +116,7 @@ public final class PlaceholderRegistry {
             }
 
             try {
-                return PlayerManager.getName(plotOwner, false);
+                return PlayerManager.resolveName(plotOwner, false).getComponent(player);
             } catch (final Exception ignored) {
             }
             return legacyComponent(TranslatableCaption.of("info.unknown"), player);

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

@@ -60,8 +60,8 @@
   "worldedit.worldedit_bypassed": "<prefix><gray>Currently bypassing WorldEdit restriction.</gray>",
   "gamemode.gamemode_was_bypassed": "<prefix><gold>You bypassed the gamemode (</gold><gray><gamemode></gray><gold>) <gold>set for </gold><gray><plot>.</gray>",
   "height.height_limit": "<prefix><gold>This plot area has building height limits: Min height: </gold><gray><minHeight></gray><gold>, Max height: </gold><gray><maxHeight></gray>",
-  "notification.notify_enter": "<prefix><gray><player> entered your plot (</gray><gold><plot></gold><gray>).</gray>",
-  "notification.notify_leave": "<prefix><gray><player> left your plot (</gray><gold><plot></gold><gray>).</gray>",
+  "notification.notify_enter": "<prefix><gray><player> entered your plot (</gray><gold><area>;<plot></gold><gray>).</gray>",
+  "notification.notify_leave": "<prefix><gray><player> left your plot (</gray><gold><area>;<plot></gold><gray>).</gray>",
   "swap.swap_overlap": "<prefix><red>The proposed areas are not allowed to overlap.</red>",
   "swap.swap_success": "<prefix><dark_aqua>Successfully swapped plots</dark_aqua> <gold><origin></gold><dark_aqua> -> </dark_aqua><gold><target></gold>",
   "swap.swap_merged": "<prefix><red>Merged plots may not be swapped. Please unmerge the plots before performing the swap.</red>",

Sponge/build.gradle.kts

@@ -0,0 +1,81 @@
+import org.spongepowered.gradle.plugin.config.PluginLoaders
+import org.spongepowered.plugin.metadata.model.PluginDependency
+
+plugins {
+    id("org.spongepowered.gradle.plugin") version "2.0.0"
+}
+
+dependencies {
+    api(projects.plotSquaredCore)
+
+    compileOnly(libs.worldeditSponge)
+}
+
+sponge {
+    apiVersion("8.0.0")
+    license("All Rights Reserved")
+    loader {
+        name(PluginLoaders.JAVA_PLAIN)
+        version("1.0")
+    }
+    plugin("sponge") {
+        displayName("PlotSquared")
+        entrypoint("com.plotsquared.sponge.SpongePlatform")
+        description("Easy, yet powerful Plot World generation and management.")
+        links {
+            // homepage("https://spongepowered.org")
+            // source("https://spongepowered.org/source")
+            // issues("https://spongepowered.org/issues")
+        }
+        contributor("Citymonstret") {
+            description("Author")
+        }
+        contributor("Empire92") {
+            description("Author")
+        }
+        contributor("MattBDev") {
+            description("Author")
+        }
+        contributor("dordsor21") {
+            description("Author")
+        }
+        contributor("NotMyFault") {
+            description("Author")
+        }
+        contributor("SirYwell") {
+            description("Author")
+        }
+        dependency("spongeapi") {
+            loadOrder(PluginDependency.LoadOrder.AFTER)
+            optional(false)
+        }
+//        dependency("${DEPEDENCY}") {
+//            loadOrder(PluginDependency.LoadOrder.AFTER)
+//            optional(false)
+//        }
+    }
+}
+
+val javaTarget = 16
+java {
+    sourceCompatibility = JavaVersion.toVersion(javaTarget)
+    targetCompatibility = JavaVersion.toVersion(javaTarget)
+    if (JavaVersion.current() < JavaVersion.toVersion(javaTarget)) {
+        toolchain.languageVersion.set(JavaLanguageVersion.of(javaTarget))
+    }
+}
+
+tasks.withType(JavaCompile::class).configureEach {
+    options.apply {
+        encoding = "utf-8" // Consistent source file encoding
+        if (JavaVersion.current().isJava10Compatible) {
+            release.set(javaTarget)
+        }
+    }
+}
+
+// Make sure all tasks which produce archives (jar, sources jar, javadoc jar, etc) produce more consistent output
+tasks.withType(AbstractArchiveTask::class).configureEach {
+    isReproducibleFileOrder = true
+    isPreserveFileTimestamps = false
+}

Sponge/src/main/java/com/plotsquared/sponge/SpongePlatform.java

@@ -0,0 +1,174 @@
+package com.plotsquared.sponge;
+
+import com.google.inject.Guice;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Stage;
+import com.plotsquared.core.PlotPlatform;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.inject.modules.PlotSquaredModule;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.util.task.TaskManager;
+import com.plotsquared.core.util.task.TaskTime;
+import com.plotsquared.sponge.inject.SpongeModule;
+import com.plotsquared.sponge.util.task.SpongeTaskManager;
+import com.plotsquared.sponge.util.task.SpongeTimeConverter;
+import net.kyori.adventure.identity.Identity;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.LinearComponents;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.Style;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.apache.logging.log4j.Logger;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.Game;
+import org.spongepowered.api.Server;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.command.Command;
+import org.spongepowered.api.command.CommandResult;
+import org.spongepowered.api.command.parameter.Parameter;
+import org.spongepowered.api.config.ConfigDir;
+import org.spongepowered.api.entity.living.player.Player;
+import org.spongepowered.api.entity.living.player.server.ServerPlayer;
+import org.spongepowered.api.event.Listener;
+import org.spongepowered.api.event.lifecycle.ConstructPluginEvent;
+import org.spongepowered.api.event.lifecycle.RegisterCommandEvent;
+import org.spongepowered.api.event.lifecycle.StartingEngineEvent;
+import org.spongepowered.api.event.lifecycle.StoppingEngineEvent;
+import org.spongepowered.plugin.PluginContainer;
+import org.spongepowered.plugin.builtin.jvm.Plugin;
+
+import java.io.File;
+import java.nio.file.Path;
+
+/**
+ * The main class of your Sponge plugin.
+ *
+ * <p>All methods are optional -- some common event registrations are included as a jumping-off point.</p>
+ */
+@Plugin("sponge")
+public class SpongePlatform implements PlotPlatform<ServerPlayer> {
+
+    public final PluginContainer container;
+    private final Logger logger;
+    private final Game game;
+
+
+    @Inject
+    private PlotAreaManager plotAreaManager;
+
+    @Inject
+    @ConfigDir(sharedRoot = false)
+    private Path configDir;
+
+    private int[] version;
+    private Injector injector;
+
+    @Inject
+    SpongePlatform(final PluginContainer container, final Logger logger, final Game game) {
+        this.container = container;
+        this.logger = logger;
+        this.game = game;
+    }
+
+    @Listener
+    public void onConstructPlugin(final ConstructPluginEvent event) {
+        // Perform any one-time setup
+        this.logger.info("Constructing sponge");
+        final TaskTime.TimeConverter timeConverter = new SpongeTimeConverter();
+        TaskManager.setPlatformImplementation(new SpongeTaskManager(this, timeConverter));
+
+        final PlotSquared plotSquared = new PlotSquared(this, "Sponge");
+
+        if (Settings.FAWE_Components.FAWE_HOOK) {
+            this.logger.info("FAWE Hooks do not work on Sponge. 😞");
+        }
+
+        // We create the injector after PlotSquared has been initialized, so that we have access
+        // to generated instances and settings
+        this.injector = Guice
+                .createInjector(
+                        Stage.PRODUCTION,
+                        new PermissionModule(),
+                        new WorldManagerModule(),
+                        new PlotSquaredModule(),
+                        new SpongeModule(this),
+                        new BackupModule()
+                );
+
+    }
+
+    @Listener
+    public void onServerStarting(final StartingEngineEvent<Server> event) {
+        // Any setup per-game instance. This can run multiple times when
+        // using the integrated (single-player) server.
+    }
+
+    @Listener
+    public void onServerStopping(final StoppingEngineEvent<Server> event) {
+        // Any tear down per-game instance. This can run multiple times when
+        // using the integrated (single-player) server.
+    }
+
+    @Listener
+    public void onRegisterCommands(final RegisterCommandEvent<Command.Parameterized> event) {
+        // Register a simple command
+        // When possible, all commands should be registered within a command register event
+        final Parameter.Value<String> nameParam = Parameter.string().key("name").build();
+        event.register(this.container, Command.builder()
+                .addParameter(nameParam)
+                .permission("sponge.command.greet")
+                .executor(ctx -> {
+                    final String name = ctx.requireOne(nameParam);
+                    ctx.sendMessage(Identity.nil(), LinearComponents.linear(
+                            NamedTextColor.AQUA,
+                            Component.text("Hello "),
+                            Component.text(name, Style.style(TextDecoration.BOLD)),
+                            Component.text("!")
+                    ));
+
+                    return CommandResult.success();
+                })
+                .build(), "greet", "wave");
+    }
+
+    @Override
+    public int[] serverVersion() {
+        if (this.version == null) {
+            try {
+                this.version = new int[3];
+                String[] split = Sponge.platform().minecraftVersion().name().split("\\.");
+                this.version[0] = Integer.parseInt(split[0]);
+                this.version[1] = Integer.parseInt(split[1]);
+                if (split.length == 3) {
+                    this.version[2] = Integer.parseInt(split[2]);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                return new int[]{1, 16, 5};
+            }
+        }
+        return this.version;
+    }
+
+    @Override
+    public @NonNull String serverImplementation() {
+        return "Sponge"; //TODO Possibly revaluate the this method name
+    }
+
+    @Override
+    public @NonNull File getDirectory() {
+        return configDir.toFile();
+    }
+
+    @Override
+    public @NonNull File worldContainer() {
+        return game.gameDirectory().toFile(); //TODO This may be incorrect. Behavior needs verification.
+    }
+
+    public Logger getLogger() {
+        return logger;
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/inject/SpongeModule.java

@@ -0,0 +1,106 @@
+package com.plotsquared.sponge.inject;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.assistedinject.FactoryModuleBuilder;
+import com.plotsquared.core.PlotPlatform;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.generator.HybridGen;
+import com.plotsquared.core.generator.IndependentPlotGenerator;
+import com.plotsquared.core.inject.annotations.ConsoleActor;
+import com.plotsquared.core.inject.annotations.DefaultGenerator;
+import com.plotsquared.core.inject.factory.ChunkCoordinatorBuilderFactory;
+import com.plotsquared.core.inject.factory.ChunkCoordinatorFactory;
+import com.plotsquared.core.inject.factory.HybridPlotWorldFactory;
+import com.plotsquared.core.inject.factory.ProgressSubscriberFactory;
+import com.plotsquared.core.plot.world.DefaultPlotAreaManager;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.plot.world.SinglePlotAreaManager;
+import com.plotsquared.core.queue.ChunkCoordinator;
+import com.plotsquared.core.queue.GlobalBlockQueue;
+import com.plotsquared.core.queue.QueueProvider;
+import com.plotsquared.core.queue.subscriber.DefaultProgressSubscriber;
+import com.plotsquared.core.queue.subscriber.ProgressSubscriber;
+import com.plotsquared.core.util.ChunkManager;
+import com.plotsquared.core.util.EconHandler;
+import com.plotsquared.core.util.InventoryUtil;
+import com.plotsquared.core.util.PlayerManager;
+import com.plotsquared.core.util.RegionManager;
+import com.plotsquared.core.util.SchematicHandler;
+import com.plotsquared.core.util.SetupUtils;
+import com.plotsquared.core.util.WorldUtil;
+import com.plotsquared.sponge.SpongePlatform;
+import com.plotsquared.sponge.player.SpongePlayerManager;
+import com.plotsquared.sponge.util.SpongeEconHandler;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.service.economy.EconomyService;
+
+public class SpongeModule extends AbstractModule {
+
+    private final SpongePlatform spongePlatform;
+
+    public SpongeModule(SpongePlatform spongePlatform) {
+        this.spongePlatform = spongePlatform;
+    }
+
+    @Override
+    protected void configure() {
+        bind(PlayerManager.class).to(SpongePlayerManager.class);
+        bind(PlotPlatform.class).toInstance(spongePlatform);
+        bind(SpongePlatform.class).toInstance(spongePlatform);
+        bind(IndependentPlotGenerator.class).annotatedWith(DefaultGenerator.class).to(HybridGen.class);
+        // Console actor
+        @NonNull ConsoleCommandSender console = Sponge.server().getServer().getConsoleSender();
+        WorldEditPlugin wePlugin = ((WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"));
+        bind(Actor.class).annotatedWith(ConsoleActor.class).toInstance(wePlugin.wrapCommandSender(console));
+        bind(InventoryUtil.class).to(BukkitInventoryUtil.class);
+        bind(SetupUtils.class).to(BukkitSetupUtils.class);
+        bind(WorldUtil.class).to(BukkitUtil.class);
+        install(new FactoryModuleBuilder()
+                .implement(ProgressSubscriber.class, DefaultProgressSubscriber.class)
+                .build(ProgressSubscriberFactory.class));
+        bind(ChunkManager.class).to(BukkitChunkManager.class);
+        if (PlotSquared.platform().isFaweHooking()) {
+            bind(SchematicHandler.class).to(FaweSchematicHandler.class);
+            bind(RegionManager.class).to(FaweRegionManager.class);
+        } else {
+            bind(SchematicHandler.class).to(BukkitSchematicHandler.class);
+            bind(RegionManager.class).to(BukkitRegionManager.class);
+        }
+        bind(GlobalBlockQueue.class).toInstance(new GlobalBlockQueue(QueueProvider.of(BukkitQueueCoordinator.class)));
+        if (Settings.Enabled_Components.WORLDS) {
+            bind(PlotAreaManager.class).to(SinglePlotAreaManager.class);
+            try {
+                bind(SingleWorldListener.class).toInstance(new SingleWorldListener());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            bind(PlotAreaManager.class).to(DefaultPlotAreaManager.class);
+        }
+        install(new FactoryModuleBuilder().build(HybridPlotWorldFactory.class));
+        install(new FactoryModuleBuilder()
+                .implement(ChunkCoordinator.class, BukkitChunkCoordinator.class)
+                .build(ChunkCoordinatorFactory.class));
+        install(new FactoryModuleBuilder().build(ChunkCoordinatorBuilderFactory.class));
+    }
+
+    @Provides
+    @Singleton
+    @NonNull EconHandler provideEconHandler() {
+        if (!Settings.Enabled_Components.ECONOMY) {
+            return EconHandler.nullEconHandler();
+        }
+        SpongeEconHandler economyService = new SpongeEconHandler();
+
+        if (!economyService.isSupported()) {
+            spongePlatform.getLogger().warn("Economy is enabled but no plugin is providing an economy service.");
+        }
+
+        return economyService;
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/player/SpongeOfflinePlayer.java

@@ -0,0 +1,37 @@
+package com.plotsquared.sponge.player;
+
+import com.plotsquared.core.player.OfflinePlotPlayer;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.UUID;
+
+//TODO Implement
+public class SpongeOfflinePlayer implements @Nullable
+        OfflinePlotPlayer {
+
+    @Override
+    public boolean hasPermission(@Nullable final String world, @NonNull final String permission) {
+        return false;
+    }
+
+    @Override
+    public boolean hasKeyedPermission(@Nullable final String world, @NonNull final String permission, @NonNull final String key) {
+        return false;
+    }
+
+    @Override
+    public UUID getUUID() {
+        return null;
+    }
+
+    @Override
+    public long getLastPlayed() {
+        return 0;
+    }
+
+    @Override
+    public String getName() {
+        return null;
+    }
+}

Sponge/src/main/java/com/plotsquared/sponge/player/SpongePlayer.java

@@ -0,0 +1,243 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *               Copyright (C) 2014 - 2022 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.sponge.player;
+
+import com.plotsquared.core.events.TeleportCause;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.permissions.PermissionHandler;
+import com.plotsquared.core.player.ConsolePlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.PlotWeather;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.util.EventDispatcher;
+import com.plotsquared.sponge.util.SpongeUtil;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.world.gamemode.GameModes;
+import com.sk89q.worldedit.world.item.ItemType;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import org.checkerframework.checker.index.qual.NonNegative;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.ResourceKey;
+import org.spongepowered.api.Server;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.entity.living.player.Player;
+import org.spongepowered.api.entity.living.player.server.ServerPlayer;
+import org.spongepowered.api.registry.RegistryTypes;
+import org.spongepowered.api.world.server.ServerLocation;
+import org.spongepowered.math.vector.Vector3d;
+
+import java.util.UUID;
+
+import static com.sk89q.worldedit.world.gamemode.GameModes.SPECTATOR;
+
+public class SpongePlayer extends PlotPlayer<ServerPlayer> {
+
+    private static boolean CHECK_EFFECTIVE = true;
+    public final ServerPlayer player;
+    private String name;
+
+    /**
+     * <p>Please do not use this method. Instead use
+     * BukkitUtil.getPlayer(Player), as it caches player objects.</p>
+     *
+     * @param plotAreaManager   PlotAreaManager instance
+     * @param eventDispatcher   EventDispatcher instance
+     * @param player            Bukkit player instance
+     * @param permissionHandler PermissionHandler instance
+     */
+    public SpongePlayer(
+            final @NonNull PlotAreaManager plotAreaManager,
+            final @NonNull EventDispatcher eventDispatcher,
+            final @NonNull ServerPlayer player,
+            final @NonNull PermissionHandler permissionHandler
+    ) {
+        this(plotAreaManager, eventDispatcher, player, false, permissionHandler);
+    }
+
+    public SpongePlayer(
+            final @NonNull PlotAreaManager plotAreaManager,
+            final @NonNull EventDispatcher eventDispatcher,
+            final @NonNull ServerPlayer player,
+            final boolean realPlayer,
+            final @NonNull PermissionHandler permissionHandler
+    ) {
+        super(plotAreaManager, eventDispatcher, permissionHandler);
+        this.player = player;
+        this.setupPermissionProfile();
+        if (realPlayer) {
+            super.populatePersistentMetaMap();
+        }
+    }
+
+    @Override
+    public Actor toActor() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ServerPlayer getPlatformPlayer() {
+        return this.player;
+    }
+
+    @NonNull
+    @Override
+    public UUID getUUID() {
+/*
+TODO Fix me
+
+        if (Settings.UUID.OFFLINE) {
+            if (Settings.UUID.FORCE_LOWERCASE) {
+                return UUID.nameUUIDFromBytes(("OfflinePlayer:" +
+                        getName().toLowerCase()).getBytes(Charsets.UTF_8));
+            } else {
+                return UUID.nameUUIDFromBytes(("OfflinePlayer:" +
+                        getName()).getBytes(Charsets.UTF_8));
+            }
+        }
+*/
+        return player.uniqueId();
+    }
+
+    @Override
+    @NonNegative
+    public long getLastPlayed() {
+        throw new UnsupportedOperationException("TODO");
+    }
+
+    @Override
+    public boolean canTeleport(final @NonNull Location location) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    @NonNegative
+    public int hasPermissionRange(
+            final @NonNull String stub, @NonNegative final int range
+    ) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void teleport(final @NonNull Location location, final @NonNull TeleportCause cause) {
+        if (Math.abs(location.getX()) >= 30000000 || Math.abs(location.getZ()) >= 30000000) {
+            return;
+        }
+        final ServerLocation spongeLocation = ServerLocation.of(
+                ResourceKey.resolve(location.getWorldName()),
+                location.getX() + 0.5,
+                location.getY(),
+                location.getZ() + 0.5
+        );
+        //TODO has not been tested.
+        player.setLocationAndRotation(spongeLocation, Vector3d.from(location.getPitch(), location.getYaw(), 0));
+    }
+
+    @Override
+    public String getName() {
+        if (this.name == null) {
+            this.name = this.player.name();
+        }
+        return this.player.name();
+    }
+
+    @Override
+    public void setCompassTarget(Location location) {
+        //Setting compass targets changed since the last Sponge API.
+    }
+
+    @Override
+    public Location getLocationFull() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setWeather(final @NonNull PlotWeather weather) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public com.sk89q.worldedit.world.gamemode.GameMode getGameMode() {
+        return GameModes.get(player.gameMode().get().key(RegistryTypes.GAME_MODE).asString());
+    }
+
+    @Override
+    public void setGameMode(final com.sk89q.worldedit.world.gamemode.GameMode gameMode) {
+        player.gameMode().set(Sponge.game().registry(RegistryTypes.GAME_MODE).value(ResourceKey.resolve(gameMode.getId())));
+    }
+
+    @Override
+    public void setTime(final long time) {
+        throw new UnsupportedOperationException("Sponge still doesn't support this after more than 4 years of work on API 8.");
+    }
+
+    @Override
+    public boolean getFlight() {
+        return player.canFly().get();
+    }
+
+    @Override
+    public void setFlight(boolean fly) {
+        this.player.canFly().set(fly);
+    }
+
+    @Override
+    public void playMusic(final @NonNull Location location, final @NonNull ItemType id) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void kick(final String message) {
+        this.player.kick(Component.text(message));
+    }
+
+    @Override
+    public void stopSpectating() {
+        if (getGameMode() == SPECTATOR) {
+            this.player.spectatorTarget().set(null);
+        }
+    }
+
+    @Override
+    public boolean isBanned() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public @NonNull Audience getAudience() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean canSee(final PlotPlayer<?> other) {
+        if (other instanceof ConsolePlayer) {
+            return true;
+        } else {
+            return this.player.canSee(null); //TODO Fix Me?
+        }
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/player/SpongePlayerManager.java

@@ -0,0 +1,86 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *               Copyright (C) 2014 - 2022 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.sponge.player;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import com.plotsquared.core.permissions.PermissionHandler;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.util.EventDispatcher;
+import com.plotsquared.core.util.PlayerManager;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.spongepowered.api.Server;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.entity.living.player.server.ServerPlayer;
+import org.spongepowered.api.user.UserManager;
+
+import java.util.UUID;
+
+@Singleton
+public class SpongePlayerManager extends PlayerManager<SpongePlayer, ServerPlayer> {
+
+    private final PlotAreaManager plotAreaManager;
+    private final EventDispatcher eventDispatcher;
+    private final PermissionHandler permissionHandler;
+    private final UserManager userManager;
+
+    @Inject
+    public SpongePlayerManager(
+            final @NonNull PlotAreaManager plotAreaManager,
+            final @NonNull EventDispatcher eventDispatcher,
+            final @NonNull PermissionHandler permissionHandler
+    ) {
+        this.plotAreaManager = plotAreaManager;
+        this.eventDispatcher = eventDispatcher;
+        this.permissionHandler = permissionHandler;
+        userManager = Sponge.game().server().userManager();
+    }
+
+    @NonNull
+    @Override
+    public SpongePlayer getPlayer(final @NonNull ServerPlayer object) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public @NonNull SpongePlayer createPlayer(final @NonNull UUID uuid) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public SpongeOfflinePlayer getOfflinePlayer(final @Nullable UUID uuid) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    @Override
+    public SpongeOfflinePlayer getOfflinePlayer(final @NonNull String username) {
+        throw new UnsupportedOperationException();
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/util/SpongeEconHandler.java

@@ -0,0 +1,71 @@
+package com.plotsquared.sponge.util;
+
+import com.google.inject.Singleton;
+import com.plotsquared.core.player.OfflinePlotPlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.util.EconHandler;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.service.economy.Currency;
+import org.spongepowered.api.service.economy.EconomyService;
+import org.spongepowered.api.service.economy.account.UniqueAccount;
+
+import java.util.Optional;
+
+
+@Singleton
+public class SpongeEconHandler extends EconHandler {
+
+    private final Optional<EconomyService> economyService; //TODO maybe don't store an optional?
+
+    public SpongeEconHandler() {
+        economyService = Sponge.serviceProvider().provide(EconomyService.class);
+    }
+
+    @Override
+    public boolean init() {
+        return Sponge.serviceProvider().provide(EconomyService.class).isPresent();
+    }
+
+    @Override
+    public double getBalance(final PlotPlayer<?> player) {
+        if(economyService.isPresent()) {
+            final Optional<UniqueAccount> account = economyService.get().findOrCreateAccount(player.getUUID());
+            return account
+                    .map(uniqueAccount -> uniqueAccount.balance(economyService.get().defaultCurrency()).doubleValue())
+                    .orElse(0.0);
+        }
+        return 0;
+    }
+
+    @Override
+    public void withdrawMoney(final PlotPlayer<?> player, final double amount) {
+
+    }
+
+    @Override
+    public void depositMoney(final PlotPlayer<?> player, final double amount) {
+
+    }
+
+    @Override
+    public void depositMoney(final OfflinePlotPlayer player, final double amount) {
+    }
+
+    @Override
+    public boolean isEnabled(final PlotArea plotArea) {
+        return false;
+    }
+
+    @Override
+    public @NonNull String format(final double balance) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isSupported() {
+        return Sponge.serviceProvider().provide(EconomyService.class).isPresent();
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/util/SpongeUtil.java

@@ -0,0 +1,7 @@
+package com.plotsquared.sponge.util;
+
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.util.WorldUtil;
+
+public class SpongeUtil extends WorldUtil {
+}

Sponge/src/main/java/com/plotsquared/sponge/util/SpongeWorld.java

@@ -0,0 +1,25 @@
+package com.plotsquared.sponge.util;
+
+import com.plotsquared.core.location.World;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.world.server.ServerWorld;
+
+public class SpongeWorld implements World<ServerWorld> {
+
+    private final ServerWorld world;
+
+    private SpongeWorld(final ServerWorld world) {
+        this.world = world;
+    }
+
+    @Override
+    public @NonNull ServerWorld getPlatformWorld() {
+        return this.world;
+    }
+
+    @Override
+    public @NonNull String getName() {
+        return this.world.key().asString();
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/util/task/SpongeTaskManager.java

@@ -0,0 +1,69 @@
+package com.plotsquared.sponge.util.task;
+
+import com.plotsquared.core.util.task.PlotSquaredTask;
+import com.plotsquared.core.util.task.TaskManager;
+import com.plotsquared.core.util.task.TaskTime;
+import com.plotsquared.sponge.SpongePlatform;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.scheduler.Task;
+import org.spongepowered.api.util.Ticks;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+
+public class SpongeTaskManager extends TaskManager {
+
+    private final SpongePlatform spongeMain;
+    private final TaskTime.TimeConverter timeConverter;
+
+    public SpongeTaskManager(SpongePlatform spongeMain, TaskTime.TimeConverter timeConverter) {
+        this.spongeMain = spongeMain;
+        this.timeConverter = timeConverter;
+    }
+
+    @Override
+    public <T> T sync(final @NonNull Callable<T> function, final int timeout) throws Exception {
+        return null; //TODO
+    }
+
+    @Override
+    public <T> Future<T> callMethodSync(final @NonNull Callable<T> method) {
+        return null; //TODO
+    }
+
+    @Override
+    public PlotSquaredTask taskRepeat(@NonNull final Runnable runnable, @NonNull final TaskTime taskTime) {
+        return null; //TODO
+    }
+
+    @Override
+    public PlotSquaredTask taskRepeatAsync(@NonNull final Runnable runnable, @NonNull final TaskTime taskTime) {
+        //TODO input the current tick delay and interval using the Sponge Tick API.
+        Task task =
+                Task.builder().delay(Ticks.zero()).interval(Ticks.zero()).plugin(spongeMain.container).execute(runnable).build();
+        Sponge.asyncScheduler().submit(task);
+        return null;
+    }
+
+    @Override
+    public void taskAsync(@NonNull final Runnable runnable) {
+        //TODO
+    }
+
+    @Override
+    public void task(@NonNull final Runnable runnable) {
+        Task.builder().execute(runnable).plugin(spongeMain.container);
+    }
+
+    @Override
+    public void taskLater(@NonNull final Runnable runnable, @NonNull final TaskTime taskTime) {
+        //TODO
+    }
+
+    @Override
+    public void taskLaterAsync(@NonNull final Runnable runnable, @NonNull final TaskTime taskTime) {
+        //TODO
+    }
+
+}

Sponge/src/main/java/com/plotsquared/sponge/util/task/SpongeTimeConverter.java

@@ -0,0 +1,20 @@
+package com.plotsquared.sponge.util.task;
+
+import com.plotsquared.core.util.task.TaskTime;
+import org.checkerframework.checker.index.qual.NonNegative;
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.util.Ticks;
+
+public class SpongeTimeConverter implements TaskTime.TimeConverter {
+
+    @Override
+    public @NonNegative long msToTicks(@NonNegative final long ms) {
+        return 0; // TODO
+    }
+
+    @Override
+    public @NonNegative long ticksToMs(@NonNegative final long ticks) {
+        return 0; // TODO
+    }
+
+}

build.gradle.kts

@@ -26,6 +26,7 @@ allprojects {
 
     repositories {
         mavenCentral()
+        mavenLocal()
 
         maven {
             name = "Sonatype OSS"

gradle/libs.versions.toml

@@ -17,8 +17,8 @@ adventure-text-minimessage = "4.1.0-SNAPSHOT"
 adventure-platform-bukkit = "4.0.1"
 
 # Plugins
-worldedit = "7.2.8"
-fawe = "2.0.0-SNAPSHOT"
+worldedit = "7.2.9-SNAPSHOT"
+fawe = "2.0.0"
 vault = "1.7.1"
 placeholderapi = "2.11.1"
 luckperms = "5.3"
@@ -66,6 +66,7 @@ adventurePlatformBukkit = { group = "net.kyori", name = "adventure-platform-bukk
 # Plugins
 worldeditCore = { group = "com.sk89q.worldedit", name = "worldedit-core", version.ref = "worldedit" }
 worldeditBukkit = { group = "com.sk89q.worldedit", name = "worldedit-bukkit", version.ref = "worldedit" }
+worldeditSponge = { group = "com.sk89q.worldedit", name = "worldedit-sponge", version.ref = "worldedit" }
 fastasyncworldeditBukkit = { group = "com.fastasyncworldedit", name = "FastAsyncWorldEdit-Bukkit", version.ref = "fawe" }
 fastasyncworldeditCore = { group = "com.fastasyncworldedit", name = "FastAsyncWorldEdit-Core", version.ref = "fawe" }
 vault = { group = "com.github.MilkBowl", name = "VaultAPI", version.ref = "vault" }

settings.gradle.kts

@@ -1,9 +1,10 @@
 rootProject.name = "PlotSquared"
 
-include("Core", "Bukkit")
+include("Core", "Bukkit", "Sponge")
 
 project(":Core").name = "PlotSquared-Core"
 project(":Bukkit").name = "PlotSquared-Bukkit"
+project(":Sponge").name = "PlotSquared-Sponge"
 
 enableFeaturePreview("VERSION_CATALOGS")
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")