Preliminary Folia support (#763)

* Initial work for Folia support

* More Folia work

* Task - add isCancelled and get id

* SecRunTaskLater - add folia options

* EffTaskStop - remove support for all tasks
- Stopping all tasks will also stop internal tasks SkBee is running, OOPS!

* SecWhileRunnable - add folia option

* Config - add setting to allow using Paper schedulers

* FoliaScheduler - prevent 0 delay

* Task sections - update docs, fix a bug, change pattern for run task later

* CondIsOwnedByRegion - add condition to check regions

* SecRunTaskLater - fix expression location

* build.gradle - use Paper's javadocs

* Tasks - update javadocs

* TaskUtils - strip SkBee stuff out and use generic plugin
- this allows other plugins to use these classes easily

* Section pattern cleanup

* Tasks - remove block as its not really needed
- Skript will convert

* RegionUtils - add region utils

* Repackage scheduler

* Util - better Folia check

* TaskUtils - repackage

Author: ShaneBeee

build.gradle

@@ -117,7 +117,7 @@ publishing {
 javadoc {
     destinationDir = file("${projectDir}/build/javadoc")
     options {
-        links('https://hub.spigotmc.org/javadocs/spigot/')
+        links('https://jd.papermc.io/paper/1.21.4/')
         links('https://docs.skriptlang.org/javadocs/')
         links('https://tr7zw.github.io/Item-NBT-API/v2-api/')
         links('https://jd.advntr.dev/api/4.14.0/')

src/main/java/com/shanebeestudios/skbee/AddonLoader.java

@@ -215,6 +215,10 @@ private void loadScoreboardElements() {
             Util.logLoading("&7To use SkBee Scoreboards, please remove the addon which has registered Scoreboard already.");
             return;
         }
+        if (Util.IS_RUNNING_FOLIA) {
+            Util.logLoading("&5Scoreboard Elements &cdisabled &7(&eCurrently not supported on Folia&7)");
+            return;
+        }
         try {
             this.addon.loadClasses("com.shanebeestudios.skbee.elements.scoreboard");
             Util.logLoading("&5Scoreboard Elements &asuccessfully loaded");
@@ -332,6 +336,10 @@ private void loadWorldCreatorElements() {
             Util.logLoading("&5World Creator Elements &cdisabled via config");
             return;
         }
+        if (Util.IS_RUNNING_FOLIA) {
+            Util.logLoading("&5World Creator Elements &cdisabled &7(&eCurrently not supported on Folia&7)");
+            return;
+        }
         try {
             this.plugin.beeWorldConfig = new BeeWorldConfig(this.plugin);
             this.addon.loadClasses("com.shanebeestudios.skbee.elements.worldcreator");
@@ -350,6 +358,10 @@ private void loadChunkGenElements() {
             Util.logLoading("&5Chunk Generator &cdisabled via World Creator config");
             return;
         }
+        if (Util.IS_RUNNING_FOLIA) {
+            Util.logLoading("&5Chunk Generator Elements &cdisabled &7(&eCurrently not supported on Folia&7)");
+            return;
+        }
         try {
             this.addon.loadClasses("com.shanebeestudios.skbee.elements.generator");
             Util.logLoading("&5Chunk Generator Elements &asuccessfully loaded");

src/main/java/com/shanebeestudios/skbee/SkBee.java

@@ -3,19 +3,18 @@
 import ch.njol.skript.Skript;
 import ch.njol.skript.test.runner.TestMode;
 import com.shanebeestudios.skbee.api.bound.Bound;
+import com.shanebeestudios.skbee.api.bound.BoundConfig;
 import com.shanebeestudios.skbee.api.command.SkBeeInfo;
+import com.shanebeestudios.skbee.api.region.TaskUtils;
 import com.shanebeestudios.skbee.api.structure.StructureManager;
 import com.shanebeestudios.skbee.api.util.UpdateChecker;
 import com.shanebeestudios.skbee.api.util.Util;
 import com.shanebeestudios.skbee.api.wrapper.LazyLocation;
-import com.shanebeestudios.skbee.api.bound.BoundConfig;
 import com.shanebeestudios.skbee.config.Config;
-import com.shanebeestudios.skbee.elements.other.sections.SecRunTaskLater;
 import com.shanebeestudios.skbee.elements.worldcreator.objects.BeeWorldConfig;
 import com.shanebeestudios.vf.api.VirtualFurnaceAPI;
 import org.bstats.bukkit.Metrics;
 import org.bstats.charts.SimplePie;
-import org.bukkit.Bukkit;
 import org.bukkit.configuration.serialization.ConfigurationSerialization;
 import org.bukkit.plugin.java.JavaPlugin;
 
@@ -57,6 +56,7 @@ public void onEnable() {
         long start = System.currentTimeMillis();
         instance = this;
         this.config = new Config(this);
+        TaskUtils.initialize(this, Util.IS_RUNNING_FOLIA || this.config.settings_use_paper_schedulers);
         this.addonLoader = new AddonLoader(this);
         // Check if SkriptAddon can actually load
         this.properlyEnabled = addonLoader.canLoadPlugin();
@@ -101,7 +101,7 @@ private void loadMetrics() { //6719
     public void onDisable() {
         if (this.properlyEnabled) {
             // Cancel tasks on stop to prevent async issues
-            Bukkit.getScheduler().cancelTasks(this);
+            TaskUtils.cancelTasks();
         }
         if (this.virtualFurnaceAPI != null) {
             this.virtualFurnaceAPI.disableAPI();

src/main/java/com/shanebeestudios/skbee/api/bound/BoundConfig.java

@@ -3,14 +3,14 @@
 import ch.njol.skript.Skript;
 import ch.njol.skript.test.runner.TestMode;
 import com.shanebeestudios.skbee.SkBee;
-import org.bukkit.Bukkit;
+import com.shanebeestudios.skbee.api.region.scheduler.Scheduler;
+import com.shanebeestudios.skbee.api.region.TaskUtils;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.event.Listener;
-import org.bukkit.scheduler.BukkitScheduler;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -63,13 +63,12 @@ public BoundConfig(SkBee plugin) {
         }
         this.boundPostponing.print();
         // Only start save timer if not in test mode
-        if (!TestMode.ENABLED) startSaveTimer(plugin);
+        if (!TestMode.ENABLED) startSaveTimer();
     }
 
-    private void startSaveTimer(SkBee plugin) {
-        BukkitScheduler scheduler = Bukkit.getScheduler();
-
-        scheduler.runTaskTimer(plugin, () -> {
+    private void startSaveTimer() {
+        Scheduler<?> globalScheduler = TaskUtils.getGlobalScheduler();
+        globalScheduler.runTaskTimer(() -> {
             // Skip saving if maps are empty
             if (this.scheduledToSave.isEmpty() && this.scheduledToRemove.isEmpty()) return;
 
@@ -82,7 +81,7 @@ private void startSaveTimer(SkBee plugin) {
             this.scheduledToSave.clear();
 
             // Async save yaml to file
-            scheduler.runTaskAsynchronously(plugin, this::saveConfig);
+            globalScheduler.runTaskAsync(this::saveConfig);
         }, 6000, 6000); // Every 5 minutes
     }
 

src/main/java/com/shanebeestudios/skbee/api/fastboard/FastBoardBase.java

@@ -1,6 +1,7 @@
 package com.shanebeestudios.skbee.api.fastboard;
 
 import com.shanebeestudios.skbee.SkBee;
+import com.shanebeestudios.skbee.api.util.Util;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.scoreboard.Scoreboard;
@@ -10,7 +11,8 @@
 public abstract class FastBoardBase<T, B> {
 
     protected static final boolean REVERSE = SkBee.getPlugin().getPluginConfig().SETTINGS_FASTBOARD_LINES;
-    private static final Scoreboard DUMMY_BOARD = Bukkit.getScoreboardManager().getNewScoreboard();
+    // Folia has currently removed vanilla scoreboards
+    private static final Scoreboard DUMMY_BOARD = Util.IS_RUNNING_FOLIA ? null : Bukkit.getScoreboardManager().getNewScoreboard();
 
     protected final Player player;
     protected fr.mrmicky.fastboard.FastBoardBase<B> fastBoard;
@@ -49,10 +51,12 @@ public void hide() {
         if (this.fastBoard == null) return;
         this.fastBoard.delete();
         this.fastBoard = null;
-        // This force resends the vanilla scoreboard to the client
-        Scoreboard previous = this.player.getScoreboard();
-        this.player.setScoreboard(DUMMY_BOARD);
-        this.player.setScoreboard(previous);
+        if (DUMMY_BOARD != null) {
+            // This force resends the vanilla scoreboard to the client
+            Scoreboard previous = this.player.getScoreboard();
+            this.player.setScoreboard(DUMMY_BOARD);
+            this.player.setScoreboard(previous);
+        }
     }
 
     public abstract void show();

src/main/java/com/shanebeestudios/skbee/api/fastboard/FastBoardManager.java

@@ -1,6 +1,7 @@
 package com.shanebeestudios.skbee.api.fastboard;
 
 import com.shanebeestudios.skbee.SkBee;
+import com.shanebeestudios.skbee.api.region.TaskUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -17,7 +18,6 @@ public class FastBoardManager implements Listener {
     public static final boolean HAS_ADVENTURE = SkBee.getPlugin().getAddonLoader().isTextComponentEnabled();
 
     private static final Map<UUID, FastBoardBase<?, ?>> BOARDS = new HashMap<>();
-    private static final SkBee PLUGIN = SkBee.getPlugin();
 
     @Nullable
     public static FastBoardBase<?, ?> getBoard(Player player) {
@@ -49,7 +49,7 @@ public FastBoardManager() {
     @EventHandler
     private void onQuit(PlayerQuitEvent event) {
         UUID uuid = event.getPlayer().getUniqueId();
-        Bukkit.getScheduler().runTaskLater(PLUGIN, () -> removeBoard(uuid), 1);
+        TaskUtils.getEntityScheduler(event.getPlayer()).runTaskLater(() -> removeBoard(uuid), 1);
     }
 
 }

src/main/java/com/shanebeestudios/skbee/api/listener/BoundBorderListener.java

@@ -6,6 +6,7 @@
 import com.shanebeestudios.skbee.api.event.bound.BoundEnterEvent;
 import com.shanebeestudios.skbee.api.event.bound.BoundExitEvent;
 import com.shanebeestudios.skbee.api.bound.BoundConfig;
+import com.shanebeestudios.skbee.api.region.TaskUtils;
 import com.shanebeestudios.skbee.config.Config;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -107,7 +108,7 @@ private void onEnterBed(PlayerBedEnterEvent event) {
             private void onExitBed(PlayerBedLeaveEvent event) {
                 Player player = event.getPlayer();
                 Location from = event.getBed().getLocation();
-                Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                TaskUtils.getEntityScheduler(player).runTaskLater(() -> {
                     // Find player's new location after leaving bed
                     // have to add a delay as this isn't determinded in the event
                     Location to = player.getLocation();
@@ -136,7 +137,7 @@ private void onMount(EntityMountEvent event) {
             private void onDismount(EntityDismountEvent event) {
                 if (event.getEntity() instanceof Player player) {
                     Location from = event.getDismounted().getLocation().clone();
-                    Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                    TaskUtils.getEntityScheduler(player).runTaskLater(() -> {
                         Location to = player.getLocation();
                         if (preventBoundMovement(player, from, to)) {
                             from.setYaw(player.getLocation().getYaw());
@@ -166,7 +167,7 @@ private void onVehicleEnter(VehicleEnterEvent event) {
             private void onVehicleExit(VehicleExitEvent event) {
                 Location from = event.getVehicle().getLocation().clone();
                 if (event.getExited() instanceof Player player) {
-                    Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                    TaskUtils.getEntityScheduler(player).runTaskLater(() -> {
                         Location to = player.getLocation();
                         if (preventBoundMovement(player, from, to)) {
                             from.setYaw(player.getLocation().getYaw());
@@ -201,9 +202,10 @@ private void onVehicleMove(VehicleMoveEvent event) {
         if (config.BOUND_EVENTS_VEHICLE_DESTROY) pluginManager.registerEvents(new Listener() {
             @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
             private void onVehicleDestroy(VehicleDestroyEvent event) {
-                Location from = event.getVehicle().getLocation().clone();
-                Bukkit.getScheduler().runTaskLater(plugin, () -> {
-                    for (Entity passenger : event.getVehicle().getPassengers()) {
+                Vehicle vehicle = event.getVehicle();
+                Location from = vehicle.getLocation().clone();
+                TaskUtils.getEntityScheduler(vehicle).runTaskLater(() -> {
+                    for (Entity passenger : vehicle.getPassengers()) {
                         Location to = passenger.getLocation();
                         if (passenger instanceof Player player) {
                             if (preventBoundMovement(player, from, to)) {

src/main/java/com/shanebeestudios/skbee/api/region/RegionUtils.java

@@ -0,0 +1,46 @@
+package com.shanebeestudios.skbee.api.region;
+
+import com.shanebeestudios.skbee.api.util.Util;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+
+/**
+ * Utility methods for Folia's threaded regions
+ */
+public class RegionUtils {
+
+    /**
+     * Check if an object is owned by the curent region
+     * <p>Currently accepts Block/Location/Entity.
+     * If not running Folia this will just return true</p>
+     *
+     * @param object Object to check
+     * @return Whether object is running in the current region
+     */
+    public static boolean isOwnedByCurrentRegion(Object object) {
+        if (!Util.IS_RUNNING_FOLIA) return true;
+
+        if (object instanceof Block block) return Bukkit.isOwnedByCurrentRegion(block);
+        else if (object instanceof Entity entity) return Bukkit.isOwnedByCurrentRegion(entity);
+        else if (object instanceof Location location) return Bukkit.isOwnedByCurrentRegion(location);
+        return true;
+    }
+
+    /**
+     * Check if a chunk location is owned by a current region
+     * <p>If not running Folia this will just return true</p>
+     *
+     * @param world  World of chunk
+     * @param chunkX Chunk X of chunk
+     * @param chunkZ Chunk Z of chunk
+     * @return Whether chunk is running in the current region
+     */
+    public static boolean isOwnedByCurrentRegion(World world, int chunkX, int chunkZ) {
+        if (!Util.IS_RUNNING_FOLIA) return true;
+        return Bukkit.isOwnedByCurrentRegion(world, chunkX, chunkZ);
+    }
+
+}

src/main/java/com/shanebeestudios/skbee/api/region/TaskUtils.java

@@ -0,0 +1,108 @@
+package com.shanebeestudios.skbee.api.region;
+
+import com.shanebeestudios.skbee.api.region.scheduler.FoliaScheduler;
+import com.shanebeestudios.skbee.api.region.scheduler.Scheduler;
+import com.shanebeestudios.skbee.api.region.scheduler.SpigotScheduler;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Utility class for creating {@link Scheduler Schedulers}
+ * <p>Intialize before use, {@link #initialize(Plugin, boolean)}</p>
+ * <p>If initialized with `useFoliaSchedulers=true`, will return a {@link FoliaScheduler}
+ * else will return a {@link SpigotScheduler}</p>
+ */
+public class TaskUtils {
+
+    private static Plugin plugin;
+    private static boolean useFoliaSchedulers;
+
+    /**
+     * Initialize schedulers
+     *
+     * @param plugin             Plugin to reference for tasks
+     * @param useFoliaSchedulers Whether to use Paper/Folia schedulers else Bukkit schedulers
+     */
+    public static void initialize(@NotNull Plugin plugin, boolean useFoliaSchedulers) {
+        if (TaskUtils.plugin != null) {
+            throw new IllegalStateException("TaskUtils already initialized!");
+        }
+        TaskUtils.plugin = plugin;
+        TaskUtils.useFoliaSchedulers = useFoliaSchedulers;
+    }
+
+    /**
+     * Get the plugin that these schedulers will use
+     *
+     * @return Plugin for schedulers
+     */
+    public static Plugin getPlugin() {
+        pluginCheck();
+        return plugin;
+    }
+
+    /**
+     * Get a global scheduler
+     * <p>This is used for global World/Server tasks which don't require regions</p>
+     * <p>If running Spigot or Paper (with Paper schedulers disabled) this will use a normal Bukkit Scheduler</p>
+     *
+     * @return Global scheduler
+     */
+    public static Scheduler<?> getGlobalScheduler() {
+        pluginCheck();
+        if (useFoliaSchedulers) return FoliaScheduler.getGlobalScheduler();
+        return new SpigotScheduler();
+    }
+
+    /**
+     * Get a regional scheduler based on a location
+     * <p>This is used for scheduling tasks at a specific location</p>
+     * <p>If running Spigot or Paper (with Paper schedulers disabled) this will use a normal Bukkit Scheduler</p>
+     *
+     * @param location Location to grab region from
+     * @return Region scheduler
+     */
+    public static Scheduler<?> getRegionalScheduler(Location location) {
+        pluginCheck();
+        if (useFoliaSchedulers) return FoliaScheduler.getRegionalScheduler(location);
+        return new SpigotScheduler();
+    }
+
+    /**
+     * Get an entity scheduler
+     * <p>This is used for scheduling tasks linked to an entity
+     * The tasks will move with the entity to whatever region they're in</p>
+     * <p>If running Spigot or Paper (with Paper schedulers disabled) this will use a normal Bukkit Scheduler</p>
+     *
+     * @param entity Entity to attach scheduler to
+     * @return Entity scheduler
+     */
+    public static Scheduler<?> getEntityScheduler(Entity entity) {
+        pluginCheck();
+        if (useFoliaSchedulers) return FoliaScheduler.getEntityScheduler(entity);
+        return new SpigotScheduler();
+    }
+
+    /**
+     * Cancel all currently running tasks
+     */
+    public static void cancelTasks() {
+        pluginCheck();
+        if (useFoliaSchedulers) {
+            Bukkit.getGlobalRegionScheduler().cancelTasks(plugin);
+            Bukkit.getAsyncScheduler().cancelTasks(plugin);
+        } else {
+            Bukkit.getScheduler().cancelTasks(plugin);
+        }
+    }
+
+    private static void pluginCheck() {
+        if (plugin == null) {
+            throw new IllegalStateException("TaskUtils has not been initialized!");
+        }
+    }
+
+}