Let's bring back Sponge.

.lift.toml

@@ -1,4 +0,0 @@
-jdkVersion = "17"
-build = "gradle clean build -x test"
-tools = ["findsecbugs", "ErrorProne", "Semgrep", "Detekt", "Infer"]
-ignoreRules = ["CatchAndPrintStackTrace", "ReferenceEquality", "FallThrough", "FutureReturnValueIgnored", "MixedMutabilityReturnType", "EmptyCatch", "MissingCasesInEnumSwitch", "OperatorPrecedence", "StaticAssignmentInConstructor", "ReferenceEquality", "EqualsHashCode", "EqualsGetClass", "TypeParameterUnusedInFormals"]

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

@@ -218,7 +218,6 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
     private PlatformWorldManager<World> worldManager;
     private Locale serverLocale;
 
-    @SuppressWarnings("StringSplitter")
     @Override
     public int @NonNull [] serverVersion() {
         if (this.version == null) {
@@ -971,6 +970,7 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
                                                 }
                                                 iterator.remove();
                                                 entity.remove();
+                                                continue;
                                             }
                                         }
                                     } else {
@@ -982,6 +982,7 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
                                             }
                                             iterator.remove();
                                             entity.remove();
+                                            continue;
                                         }
                                     }
                                 }
@@ -1222,7 +1223,7 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
 
     @Override
     @NonNull
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings("ALL")
     public PlayerManager<? extends PlotPlayer<Player>, ? extends Player> playerManager() {
         return (PlayerManager<BukkitPlayer, Player>) injector().getInstance(PlayerManager.class);
     }

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

@@ -461,7 +461,6 @@ public final class ReplicatingEntityWrapper extends EntityWrapper {
         this.tamed.tamed = tamed.isTamed();
     }
 
-    @SuppressWarnings("deprecation") // Paper deprecation
     @Override
     public Entity spawn(World world, int xOffset, int zOffset) {
         Location location = new Location(world, this.getX() + xOffset, this.getY(), this.z + zOffset);

Bukkit/src/main/java/com/plotsquared/bukkit/inject/WorldManagerModule.java

@@ -36,7 +36,6 @@ import org.bukkit.World;
 
 public class WorldManagerModule extends AbstractModule {
 
-    @SuppressWarnings("removal") // Internal use only
     @Provides
     @Singleton
     PlatformWorldManager<World> provideWorldManager() {

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

@@ -36,6 +36,7 @@ import com.plotsquared.core.plot.world.PlotAreaManager;
 import net.kyori.adventure.text.minimessage.Template;
 import org.bukkit.block.Banner;
 import org.bukkit.block.Beacon;
+import org.bukkit.block.Bed;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.CommandBlock;
 import org.bukkit.block.Comparator;
@@ -50,7 +51,6 @@ import org.bukkit.block.Jukebox;
 import org.bukkit.block.Sign;
 import org.bukkit.block.Skull;
 import org.bukkit.block.Structure;
-import org.bukkit.block.data.type.Bed;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.checkerframework.checker.nullness.qual.NonNull;

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

@@ -154,6 +154,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
@@ -223,7 +224,6 @@ public class PlayerEventListener extends PlotListener implements Listener {
         }
     }
 
-    @SuppressWarnings("StringSplitter")
     @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
     public void playerCommand(PlayerCommandPreprocessEvent event) {
         String msg = event.getMessage().toLowerCase().replaceAll("/", "").trim();
@@ -379,7 +379,6 @@ public class PlayerEventListener extends PlotListener implements Listener {
         this.eventDispatcher.doRespawnTask(pp);
     }
 
-    @SuppressWarnings("deprecation") // We explicitly want #getHomeSynchronous here
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onTeleport(PlayerTeleportEvent event) {
         Player player = event.getPlayer();
@@ -1064,13 +1063,9 @@ public class PlayerEventListener extends PlotListener implements Listener {
         if (area == null) {
             return;
         }
-        PlayerBlockEventType eventType;
+        PlayerBlockEventType eventType = null;
         BlockType blocktype1;
         Block block = event.getClickedBlock();
-        if (block == null) {
-            // We do not care in this case, the player is likely interacting with air ("nothing").
-            return;
-        }
         Location location = BukkitUtil.adapt(block.getLocation());
         Action action = event.getAction();
         switch (action) {
@@ -1672,7 +1667,6 @@ public class PlayerEventListener extends PlotListener implements Listener {
         }
     }
 
-    @SuppressWarnings("deprecation") // #getLocate is needed for Spigot compatibility
     @EventHandler
     public void onLocaleChange(final PlayerLocaleChangeEvent event) {
         // The event is fired before the player is deemed online upon login

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

@@ -43,6 +43,7 @@ import java.lang.reflect.Method;
 
 import static com.plotsquared.core.util.ReflectionUtils.getRefClass;
 
+@SuppressWarnings("unused")
 public class SingleWorldListener implements Listener {
 
     private final Method methodGetHandleChunk;

Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitPlayer.java

@@ -162,7 +162,6 @@ public class BukkitPlayer extends PlotPlayer<Player> {
         }
     }
 
-    @SuppressWarnings("StringSplitter")
     @Override
     @NonNegative
     public int hasPermissionRange(
@@ -320,7 +319,7 @@ public class BukkitPlayer extends PlotPlayer<Player> {
         if (id == ItemTypes.AIR) {
             // Let's just stop all the discs because why not?
             for (final Sound sound : Arrays.stream(Sound.values())
-                    .filter(sound -> sound.name().contains("DISC")).toList()) {
+                    .filter(sound -> sound.name().contains("DISC")).collect(Collectors.toList())) {
                 player.stopSound(sound);
             }
             // this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, Material.AIR);
@@ -332,7 +331,6 @@ public class BukkitPlayer extends PlotPlayer<Player> {
         }
     }
 
-    @SuppressWarnings("deprecation") // Needed for Spigot compatibility
     @Override
     public void kick(final String message) {
         this.player.kickPlayer(message);

Bukkit/src/main/java/com/plotsquared/bukkit/queue/BukkitQueueCoordinator.java

@@ -199,7 +199,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
                     }
                 }
                 if (localChunk.getTiles().size() > 0) {
-                    localChunk.getTiles().forEach((blockVector3, tag) -> {
+                    localChunk.getTiles().forEach(((blockVector3, tag) -> {
                         try {
                             BaseBlock block = getWorld().getBlock(blockVector3).toBaseBlock(tag);
                             getWorld().setBlock(blockVector3, block, noSideEffectSet);
@@ -207,7 +207,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
                             StateWrapper sw = new StateWrapper(tag);
                             sw.restoreTag(getWorld().getName(), blockVector3.getX(), blockVector3.getY(), blockVector3.getZ());
                         }
-                    });
+                    }));
                 }
                 if (localChunk.getEntities().size() > 0) {
                     localChunk.getEntities().forEach((location, entity) -> getWorld().createEntity(location, entity));

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

@@ -166,7 +166,6 @@ public class StateWrapper {
         return str;
     }
 
-    @SuppressWarnings("deprecation") // #setLine is needed for Spigot compatibility
     public boolean restoreTag(String worldName, int x, int y, int z) {
         if (this.tag == null) {
             return false;

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

@@ -77,7 +77,6 @@ public class BukkitInventoryUtil extends InventoryUtil {
         return stack;
     }
 
-    @SuppressWarnings("deprecation") // Paper deprecation
     @Override
     public void open(PlotInventory inv) {
         BukkitPlayer bp = (BukkitPlayer) inv.getPlayer();
@@ -114,7 +113,6 @@ public class BukkitInventoryUtil extends InventoryUtil {
         bp.player.updateInventory();
     }
 
-    @SuppressWarnings("deprecation") // Paper deprecation
     public PlotItemStack getItem(ItemStack item) {
         if (item == null) {
             return null;
@@ -147,7 +145,6 @@ public class BukkitInventoryUtil extends InventoryUtil {
                 .toArray(PlotItemStack[]::new);
     }
 
-    @SuppressWarnings("deprecation") // #getTitle is needed for Spigot compatibility
     @Override
     public boolean isOpen(PlotInventory plotInventory) {
         if (!plotInventory.isOpen()) {

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

@@ -61,7 +61,6 @@ public class UpdateUtility implements Listener {
         internalVersion = PlotSquared.get().getVersion();
     }
 
-    @SuppressWarnings({"deprecation", "DefaultCharset"}) // Suppress Json deprecation, we can't use features from gson 2.8.1 and newer yet
     public void updateChecker() {
         task = Bukkit.getScheduler().runTaskTimerAsynchronously(this.javaPlugin, () -> {
             try {
@@ -69,7 +68,7 @@ public class UpdateUtility implements Listener {
                         "https://api.spigotmc.org/simple/0.1/index.php?action=getResource&id=77506")
                         .openConnection();
                 connection.setRequestMethod("GET");
-                JsonObject result = new JsonParser()
+                JsonObject result = (new JsonParser())
                         .parse(new JsonReader(new InputStreamReader(connection.getInputStream())))
                         .getAsJsonObject();
                 spigotVersion = result.get("current_version").getAsString();
@@ -92,7 +91,7 @@ public class UpdateUtility implements Listener {
                 notify = false;
                 LOGGER.info("Congratulations! You are running the latest PlotSquared version");
             }
-        }, 0L, (long) Settings.UpdateChecker.POLL_RATE * 60 * 20);
+        }, 0L, Settings.UpdateChecker.POLL_RATE * 60 * 20);
     }
 
     private void cancelTask() {

Bukkit/src/main/java/com/plotsquared/bukkit/util/fawe/FaweSchematicHandler.java

@@ -75,7 +75,6 @@ public class FaweSchematicHandler extends SchematicHandler {
         return delegate.save(tag, path);
     }
 
-    @SuppressWarnings("removal") // Just the override
     @Override
     public void upload(final CompoundTag tag, final UUID uuid, final String file, final RunnableVal<URL> whenDone) {
         delegate.upload(tag, uuid, file, whenDone);

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

@@ -53,7 +53,7 @@ public abstract class MetaDataAccess<T> implements AutoCloseable {
         this.lockAccess = lockAccess;
     }
 
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings("ALL")
     private static <E extends Throwable> void sneakyThrow(final Throwable e) throws E {
         throw (E) e;
     }

Core/src/main/java/com/plotsquared/core/plot/flag/FlagContainer.java

@@ -96,7 +96,7 @@ public class FlagContainer {
     }
 
     /**
-     * Cast a plot flag with wildcard parameters into a parametrized
+     * Cast a plot flag with wildcard parameters into a parametrisized
      * PlotFlag. This is an unsafe operation, and should only be performed
      * if the generic parameters are known beforehand.
      *
@@ -105,7 +105,7 @@ public class FlagContainer {
      * @param <T>  Flag type
      * @return Casted flag
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings("ALL")
     public static <V, T extends PlotFlag<V, ?>> T castUnsafe(
             final PlotFlag<?, ?> flag
     ) {
@@ -181,7 +181,6 @@ public class FlagContainer {
      * @param <V>  flag value type
      * @return value of flag removed
      */
-    @SuppressWarnings("unchecked")
     public <V, T extends PlotFlag<V, ?>> V removeFlag(final T flag) {
         final Object value = this.flagMap.remove(flag.getClass());
         if (this.plotFlagUpdateHandler != null) {

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

@@ -73,7 +73,6 @@ public class EntityUtil {
         return i;
     }
 
-    @SuppressWarnings("unchecked")
     public static boolean checkEntity(Plot plot, PlotFlag<Integer, ?>... flags) {
         if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
             return true;

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,7 +17,7 @@ adventure-text-minimessage = "4.1.0-SNAPSHOT"
 adventure-platform-bukkit = "4.0.1"
 
 # Plugins
-worldedit = "7.2.8"
+worldedit = "7.2.9-SNAPSHOT"
 fawe = "2.0.0"
 vault = "1.7.1"
 placeholderapi = "2.11.1"
@@ -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")