Add Folia support

Essentials/build.gradle

@@ -25,6 +25,7 @@ dependencies {
     api(project(path: ':providers:PaperProvider', configuration: 'shadow')){
         exclude(module: 'paper-api')
     }
+    api project(':providers:FoliaProvider')
     api(project(':providers:NMSReflectionProvider')) {
         exclude(module: 'bukkit')
     }
@@ -73,6 +74,7 @@ shadowJar {
         include (dependency('net.kyori:adventure-text-minimessage'))
         include (project(':providers:BaseProviders'))
         include (project(path: ':providers:PaperProvider', configuration: 'shadow'))
+        include (project(':providers:FoliaProvider'))
         include (project(':providers:NMSReflectionProvider'))
         include (project(':providers:1_8Provider'))
         include (project(':providers:1_12Provider'))

Essentials/src/main/java/com/earth2me/essentials/AsyncTeleport.java

@@ -139,19 +139,6 @@ public void nowUnsafe(Location loc, TeleportCause cause, CompletableFuture<Boole
         paperFuture.exceptionally(future::completeExceptionally);
     }
 
-    private void runOnMain(final Runnable runnable) throws ExecutionException, InterruptedException {
-        if (Bukkit.isPrimaryThread()) {
-            runnable.run();
-            return;
-        }
-        final CompletableFuture<Object> taskLock = new CompletableFuture<>();
-        Bukkit.getScheduler().runTask(ess, () -> {
-            runnable.run();
-            taskLock.complete(new Object());
-        });
-        taskLock.get();
-    }
-
     protected void nowAsync(final IUser teleportee, final ITarget target, final TeleportCause cause, final CompletableFuture<Boolean> future) {
         cancel(false);
 
@@ -169,8 +156,8 @@ protected void nowAsync(final IUser teleportee, final ITarget target, final Tele
             }
 
             try {
-                runOnMain(() -> teleportee.getBase().eject()); //EntityDismountEvent requires a sync context.
-            } catch (final ExecutionException | InterruptedException e) {
+                ess.ensureEntity(teleportee.getBase(), () -> teleportee.getBase().eject()); //EntityDismountEvent requires a sync context.
+            } catch (final RuntimeException e) {
                 future.completeExceptionally(e);
                 return;
             }
@@ -186,38 +173,38 @@ protected void nowAsync(final IUser teleportee, final ITarget target, final Tele
             targetLoc.setZ(LocationUtil.getZInsideWorldBorder(targetLoc.getWorld(), targetLoc.getBlockZ()));
         }
         PaperLib.getChunkAtAsync(targetLoc.getWorld(), targetLoc.getBlockX() >> 4, targetLoc.getBlockZ() >> 4, true, true).thenAccept(chunk -> {
-            Location loc = targetLoc;
-            if (LocationUtil.isBlockUnsafeForUser(ess, teleportee, chunk.getWorld(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ())) {
-                if (ess.getSettings().isTeleportSafetyEnabled()) {
-                    if (ess.getSettings().isForceDisableTeleportSafety()) {
-                        //The chunk we're teleporting to is 100% going to be loaded here, no need to teleport async.
-                        teleportee.getBase().teleport(loc, cause);
-                    } else {
-                        try {
-                            //There's a chance the safer location is outside the loaded chunk so still teleport async here.
-                            PaperLib.teleportAsync(teleportee.getBase(), LocationUtil.getSafeDestination(ess, teleportee, loc), cause);
-                        } catch (final Exception e) {
-                            future.completeExceptionally(e);
-                            return;
+            ess.scheduleLocationDelayedTask(targetLoc, () -> {
+                Location loc = targetLoc;
+                if (LocationUtil.isBlockUnsafeForUser(ess, teleportee, chunk.getWorld(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ())) {
+                    if (ess.getSettings().isTeleportSafetyEnabled()) {
+                        if (ess.getSettings().isForceDisableTeleportSafety()) {
+                            PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
+                        } else {
+                            try {
+                                //There's a chance the safer location is outside the loaded chunk so still teleport async here.
+                                PaperLib.teleportAsync(teleportee.getBase(), LocationUtil.getSafeDestination(ess, teleportee, loc), cause);
+                            } catch (final Exception e) {
+                                future.completeExceptionally(e);
+                                return;
+                            }
                         }
+                    } else {
+                        future.completeExceptionally(new TranslatableException("unsafeTeleportDestination", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
+                        return;
                     }
                 } else {
-                    future.completeExceptionally(new TranslatableException("unsafeTeleportDestination", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
-                    return;
-                }
-            } else {
-                if (ess.getSettings().isForceDisableTeleportSafety()) {
-                    //The chunk we're teleporting to is 100% going to be loaded here, no need to teleport async.
-                    teleportee.getBase().teleport(loc, cause);
-                } else {
-                    if (ess.getSettings().isTeleportToCenterLocation()) {
-                        loc = LocationUtil.getRoundedDestination(loc);
+                    if (ess.getSettings().isForceDisableTeleportSafety()) {
+                        PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
+                    } else {
+                        if (ess.getSettings().isTeleportToCenterLocation()) {
+                            loc = LocationUtil.getRoundedDestination(loc);
+                        }
+                        //There's a *small* chance the rounded destination produces a location outside the loaded chunk so still teleport async here.
+                        PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
                     }
-                    //There's a *small* chance the rounded destination produces a location outside the loaded chunk so still teleport async here.
-                    PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
                 }
-            }
-            future.complete(true);
+                future.complete(true);
+            });
         }).exceptionally(th -> {
             future.completeExceptionally(th);
             return null;

Essentials/src/main/java/com/earth2me/essentials/AsyncTimedTeleport.java

@@ -1,13 +1,14 @@
 package com.earth2me.essentials;
 
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-
+import net.ess3.api.IEssentials;
+import net.ess3.api.IUser;
+import net.ess3.provider.SchedulingProvider;
 import org.bukkit.Location;
 import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
 
-import net.ess3.api.IEssentials;
-import net.ess3.api.IUser;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
 import net.essentialsx.api.v2.events.TeleportWarmupCancelledEvent;
 import net.essentialsx.api.v2.events.TeleportWarmupCancelledEvent.CancelReason;
 
@@ -31,7 +32,7 @@ public class AsyncTimedTeleport implements Runnable {
     private final boolean timer_canMove;
     private final Trade timer_chargeFor;
     private final TeleportCause timer_cause;
-    private int timer_task;
+    private SchedulingProvider.EssentialsTask timer_task;
     private double timer_health;
 
     AsyncTimedTeleport(final IUser user, final IEssentials ess, final AsyncTeleport teleport, final long delay, final IUser teleportUser, final ITarget target, final Trade chargeFor, final TeleportCause cause, final boolean respawn) {
@@ -55,7 +56,7 @@ public class AsyncTimedTeleport implements Runnable {
         this.timer_respawn = respawn;
         this.timer_canMove = user.isAuthorized("essentials.teleport.timer.move");
 
-        timer_task = ess.runTaskTimerAsynchronously(this, 20, 20).getTaskId();
+        timer_task = ess.runTaskTimerAsynchronously(this, 20, 20);
 
         if (future != null) {
             this.parentFuture = future;
@@ -142,16 +143,16 @@ public void run() {
             }
         }
 
-        ess.scheduleSyncDelayedTask(new DelayedTeleportTask());
+        ess.scheduleEntityDelayedTask(teleportOwner.getBase(), new DelayedTeleportTask());
     }
 
     //If we need to cancelTimer a pending teleportPlayer call this method
     void cancelTimer(final boolean notifyUser) {
-        if (timer_task == -1) {
+        if (timer_task == null) {
             return;
         }
         try {
-            ess.getServer().getScheduler().cancelTask(timer_task);
+            timer_task.cancel();
 
             final IUser teleportUser = ess.getUser(this.timer_teleportee);
             if (teleportUser != null && teleportUser.getBase() != null) {
@@ -167,7 +168,7 @@ void cancelTimer(final boolean notifyUser) {
                 }
             }
         } finally {
-            timer_task = -1;
+            timer_task = null;
         }
     }
 }

Essentials/src/main/java/com/earth2me/essentials/Backup.java

@@ -1,6 +1,7 @@
 package com.earth2me.essentials;
 
 import net.ess3.api.IEssentials;
+import net.ess3.provider.SchedulingProvider;
 import org.bukkit.Server;
 import org.bukkit.command.CommandSender;
 
@@ -17,10 +18,10 @@ public class Backup implements Runnable {
     private transient final Server server;
     private transient final IEssentials ess;
     private final AtomicBoolean pendingShutdown = new AtomicBoolean(false);
-    private transient boolean running = false;
-    private transient int taskId = -1;
-    private transient boolean active = false;
-    private transient CompletableFuture<Object> taskLock = null;
+    private transient volatile boolean running = false;
+    private transient volatile SchedulingProvider.EssentialsTask task = null;
+    private transient volatile boolean active = false;
+    private transient volatile CompletableFuture<Object> taskLock = null;
 
     public Backup(final IEssentials ess) {
         this.ess = ess;
@@ -36,10 +37,10 @@ public void onPlayerJoin() {
 
     public synchronized void stopTask() {
         running = false;
-        if (taskId != -1) {
-            server.getScheduler().cancelTask(taskId);
+        if (task != null) {
+            task.cancel();
         }
-        taskId = -1;
+        task = null;
     }
 
     private synchronized void startTask() {
@@ -48,7 +49,7 @@ private synchronized void startTask() {
             if (interval < 1200) {
                 return;
             }
-            taskId = ess.scheduleSyncRepeatingTask(this, interval, interval);
+            task = ess.scheduleGlobalRepeatingTask(this, interval, interval);
             running = true;
         }
     }
@@ -123,7 +124,7 @@ public void run() {
                 }
 
                 if (!pendingShutdown.get()) {
-                    ess.scheduleSyncDelayedTask(new BackupEnableSaveTask());
+                    ess.scheduleGlobalDelayedTask(new BackupEnableSaveTask());
                 }
             }
         });