diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java b/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java index a08aa72a1..e1edfaba2 100644 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java @@ -43,11 +43,13 @@ import com.plotsquared.bukkit.listener.WorldEvents; import com.plotsquared.bukkit.placeholder.PlaceholderFormatter; import com.plotsquared.bukkit.placeholder.Placeholders; import com.plotsquared.bukkit.player.BukkitPlayerManager; -import com.plotsquared.bukkit.util.BukkitTaskManager; +import com.plotsquared.bukkit.util.task.BukkitTaskManager; import com.plotsquared.bukkit.util.BukkitUtil; import com.plotsquared.bukkit.util.BukkitWorld; import com.plotsquared.bukkit.util.SetGenCB; import com.plotsquared.bukkit.util.UpdateUtility; +import com.plotsquared.bukkit.util.task.PaperTimeConverter; +import com.plotsquared.bukkit.util.task.SpigotTimeConverter; import com.plotsquared.bukkit.uuid.BungeePermsUUIDService; import com.plotsquared.bukkit.uuid.EssentialsUUIDService; import com.plotsquared.bukkit.uuid.LuckPermsUUIDService; @@ -102,6 +104,7 @@ import com.plotsquared.core.util.ReflectionUtils; import com.plotsquared.core.util.SetupUtils; import com.plotsquared.core.util.WorldUtil; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.plotsquared.core.uuid.CacheUUIDService; import com.plotsquared.core.uuid.UUIDPipeline; import com.plotsquared.core.uuid.offline.OfflineModeUUIDService; @@ -212,9 +215,16 @@ import static com.plotsquared.core.util.ReflectionUtils.getRefClass; @Override public void onEnable() { this.pluginName = getDescription().getName(); + final TaskTime.TimeConverter timeConverter; + if (PaperLib.isPaper()) { + timeConverter = new PaperTimeConverter(); + } else { + timeConverter = new SpigotTimeConverter(); + } + // Stuff that needs to be created before the PlotSquared instance PlotPlayer.registerConverter(Player.class, BukkitUtil::getPlayer); - TaskManager.setImplementation(new BukkitTaskManager(this)); + TaskManager.setPlatformImplementation(new BukkitTaskManager(this, timeConverter)); final PlotSquared plotSquared = new PlotSquared(this, "Bukkit"); @@ -364,7 +374,7 @@ import static com.plotsquared.core.util.ReflectionUtils.getRefClass; this.setGenerator(world); } } - }, 1); + }, TaskTime.ticks(1L)); } // Services are accessed in order @@ -494,7 +504,7 @@ import static com.plotsquared.core.util.ReflectionUtils.getRefClass; this.startMetrics(); if (Settings.Enabled_Components.WORLDS) { - TaskManager.getImplementation().taskRepeat(this::unload, 20); + TaskManager.getPlatformImplementation().taskRepeat(this::unload, TaskTime.seconds(1L)); try { singleWorldListener = getInjector().getInstance(SingleWorldListener.class); } catch (Exception e) { @@ -954,7 +964,7 @@ import static com.plotsquared.core.util.ReflectionUtils.getRefClass; } catch (Throwable e) { e.printStackTrace(); } - }), 20); + }), TaskTime.seconds(1L)); } @Override @Nullable diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/inject/BukkitModule.java b/Bukkit/src/main/java/com/plotsquared/bukkit/inject/BukkitModule.java index 9c817c8af..c9231110b 100644 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/inject/BukkitModule.java +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/inject/BukkitModule.java @@ -26,6 +26,8 @@ package com.plotsquared.bukkit.inject; import com.google.inject.AbstractModule; +import com.google.inject.Provides; +import com.google.inject.Singleton; import com.google.inject.assistedinject.FactoryModuleBuilder; import com.google.inject.util.Providers; import com.plotsquared.bukkit.BukkitPlatform; @@ -39,6 +41,8 @@ import com.plotsquared.bukkit.util.BukkitPermHandler; import com.plotsquared.bukkit.util.BukkitRegionManager; import com.plotsquared.bukkit.util.BukkitSetupUtils; import com.plotsquared.bukkit.util.BukkitUtil; +import com.plotsquared.bukkit.util.task.PaperTimeConverter; +import com.plotsquared.bukkit.util.task.SpigotTimeConverter; import com.plotsquared.core.PlotPlatform; import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.generator.HybridGen; diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ChunkListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ChunkListener.java index a4b0e3430..bf756fcf0 100644 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ChunkListener.java +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ChunkListener.java @@ -33,7 +33,9 @@ import com.plotsquared.core.plot.world.PlotAreaManager; import com.plotsquared.core.util.ReflectionUtils.RefClass; import com.plotsquared.core.util.ReflectionUtils.RefField; import com.plotsquared.core.util.ReflectionUtils.RefMethod; +import com.plotsquared.core.util.task.PlotSquaredTask; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import io.papermc.lib.PaperLib; import org.bukkit.Bukkit; import org.bukkit.Chunk; @@ -58,6 +60,7 @@ import org.slf4j.LoggerFactory; import javax.annotation.Nonnull; import java.lang.reflect.Method; import java.util.HashSet; +import java.util.Objects; import static com.plotsquared.core.util.ReflectionUtils.getRefClass; @@ -131,7 +134,7 @@ public class ChunkListener implements Listener { } catch (Throwable e) { e.printStackTrace(); } - }, 1); + }, TaskTime.ticks(1L)); } public boolean unloadChunk(String world, Chunk chunk, boolean safe) { @@ -253,17 +256,15 @@ public class ChunkListener implements Listener { private void cleanChunk(final Chunk chunk) { TaskManager.index.incrementAndGet(); final Integer currentIndex = TaskManager.index.get(); - Integer task = TaskManager.runTaskRepeat(() -> { + PlotSquaredTask task = TaskManager.runTaskRepeat(() -> { if (!chunk.isLoaded()) { - Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex)); - TaskManager.tasks.remove(currentIndex); + Objects.requireNonNull(TaskManager.removeTask(currentIndex)).cancel(); chunk.unload(true); return; } BlockState[] tiles = chunk.getTileEntities(); if (tiles.length == 0) { - Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex)); - TaskManager.tasks.remove(currentIndex); + Objects.requireNonNull(TaskManager.removeTask(currentIndex)).cancel(); chunk.unload(true); return; } @@ -271,16 +272,15 @@ public class ChunkListener implements Listener { int i = 0; while (System.currentTimeMillis() - start < 250) { if (i >= tiles.length - Settings.Chunk_Processor.MAX_TILES) { - Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex)); - TaskManager.tasks.remove(currentIndex); + Objects.requireNonNull(TaskManager.removeTask(currentIndex)).cancel(); chunk.unload(true); return; } tiles[i].getBlock().setType(Material.AIR, false); i++; } - }, 5); - TaskManager.tasks.put(currentIndex, task); + }, TaskTime.ticks(5L)); + TaskManager.addTask(task, currentIndex); } public boolean processChunk(Chunk chunk, boolean unload) { diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java index 71d5b9b7c..a3bc9eb5c 100644 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java @@ -111,6 +111,7 @@ import com.plotsquared.core.util.RegExUtil; import com.plotsquared.core.util.WorldUtil; import com.plotsquared.core.util.entity.EntityCategories; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.bukkit.BukkitAdapter; import com.sk89q.worldedit.world.block.BlockType; @@ -281,7 +282,7 @@ import java.util.regex.Pattern; ((BukkitPlayer) player).player.sendBlockChange(bloc, data); } } - }, 3); + }, TaskTime.ticks(3L)); } public static boolean checkEntity(Entity entity, Plot plot) { @@ -701,7 +702,7 @@ import java.util.regex.Pattern; player.saveData(); } this.eventDispatcher.doJoinTask(pp); - }, 20); + }, TaskTime.seconds(1L)); if (pp.hasPermission(Captions.PERMISSION_ADMIN_UPDATE_NOTIFICATION.getTranslated()) && Settings.Enabled_Components.UPDATE_NOTIFICATIONS && PremiumVerification.isPremium() @@ -841,7 +842,7 @@ import java.util.regex.Pattern; Player player = event.getPlayer(); BukkitPlayer pp = BukkitUtil.getPlayer(player); // Cancel teleport - if (TaskManager.TELEPORT_QUEUE.remove(pp.getName())) { + if (TaskManager.removeFromTeleportQueue(pp.getName())) { MainUtil.sendMessage(pp, Captions.TELEPORT_FAILED); } // Set last location @@ -903,7 +904,7 @@ import java.util.regex.Pattern; Player player = event.getPlayer(); BukkitPlayer pp = BukkitUtil.getPlayer(player); // Cancel teleport - if (TaskManager.TELEPORT_QUEUE.remove(pp.getName())) { + if (TaskManager.removeFromTeleportQueue(pp.getName())) { MainUtil.sendMessage(pp, Captions.TELEPORT_FAILED); } // Set last location @@ -2416,7 +2417,7 @@ import java.util.regex.Pattern; } @EventHandler(priority = EventPriority.MONITOR) public void onLeave(PlayerQuitEvent event) { - TaskManager.TELEPORT_QUEUE.remove(event.getPlayer().getName()); + TaskManager.removeFromTeleportQueue(event.getPlayer().getName()); BukkitPlayer pp = BukkitUtil.getPlayer(event.getPlayer()); pp.unregister(); this.logout(pp.getUUID()); diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java index 55dc45512..f9b0eb563 100644 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java @@ -44,6 +44,7 @@ import com.plotsquared.core.util.RegionUtil; import com.plotsquared.core.util.entity.EntityCategories; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.worldedit.bukkit.BukkitAdapter; import com.sk89q.worldedit.bukkit.BukkitWorld; import com.sk89q.worldedit.math.BlockVector2; @@ -399,9 +400,9 @@ import static com.plotsquared.core.util.entity.EntityCategories.CAP_VEHICLE; }); } if (!chunks.isEmpty()) { - TaskManager.runTaskLater(this, 1); + TaskManager.runTaskLater(this, TaskTime.ticks(1L)); } else { - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); } } }); @@ -456,7 +457,7 @@ import static com.plotsquared.core.util.entity.EntityCategories.CAP_VEHICLE; PlotSquared.platform().getGlobalBlockQueue().addEmptyTask(() -> { for (ContentMap map : maps) { map.restoreEntities(world1, 0, 0); - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); } }); } diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitTaskManager.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitTaskManager.java deleted file mode 100644 index c5928c261..000000000 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitTaskManager.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * _____ _ _ _____ _ - * | __ \| | | | / ____| | | - * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | - * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | - * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | - * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| - * | | - * |_| - * PlotSquared plot management system for Minecraft - * Copyright (C) 2020 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 . - */ -package com.plotsquared.bukkit.util; - -import com.google.inject.Inject; -import com.google.inject.Singleton; -import com.plotsquared.bukkit.BukkitPlatform; -import com.plotsquared.core.util.task.TaskManager; -import org.bukkit.Bukkit; - -@Singleton public class BukkitTaskManager extends TaskManager { - - private final BukkitPlatform bukkitMain; - - @Inject public BukkitTaskManager(BukkitPlatform bukkitMain) { - this.bukkitMain = bukkitMain; - } - - @Override public int taskRepeat(Runnable runnable, int interval) { - return this.bukkitMain.getServer().getScheduler() - .scheduleSyncRepeatingTask(this.bukkitMain, runnable, interval, interval); - } - - @SuppressWarnings("deprecation") @Override - public int taskRepeatAsync(Runnable runnable, int interval) { - return this.bukkitMain.getServer().getScheduler() - .scheduleAsyncRepeatingTask(this.bukkitMain, runnable, interval, interval); - } - - @Override public void taskAsync(Runnable runnable) { - if (this.bukkitMain.isEnabled()) { - this.bukkitMain.getServer().getScheduler() - .runTaskAsynchronously(this.bukkitMain, runnable); - } else { - runnable.run(); - } - } - - @Override public void task(Runnable runnable) { - this.bukkitMain.getServer().getScheduler().runTask(this.bukkitMain, runnable).getTaskId(); - } - - @Override public void taskLater(Runnable runnable, int delay) { - this.bukkitMain.getServer().getScheduler().runTaskLater(this.bukkitMain, runnable, delay) - .getTaskId(); - } - - @Override public void taskLaterAsync(Runnable runnable, int delay) { - this.bukkitMain.getServer().getScheduler() - .runTaskLaterAsynchronously(this.bukkitMain, runnable, delay); - } - - @Override public void cancelTask(int task) { - if (task != -1) { - Bukkit.getScheduler().cancelTask(task); - } - } -} diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitUtil.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitUtil.java index c6e3111ca..b17633605 100644 --- a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitUtil.java +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitUtil.java @@ -42,7 +42,6 @@ import com.plotsquared.core.util.PlayerManager; import com.plotsquared.core.util.RegionManager; import com.plotsquared.core.util.StringComparison; import com.plotsquared.core.util.WorldUtil; -import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; import com.sk89q.worldedit.bukkit.BukkitAdapter; import com.sk89q.worldedit.bukkit.BukkitWorld; @@ -409,14 +408,18 @@ import java.util.stream.Stream; @Override @Nullable public String[] getSignSynchronous(@Nonnull final Location location) { Block block = getWorld(location.getWorldName()) .getBlockAt(location.getX(), location.getY(), location.getZ()); - return TaskManager.getImplementation().sync(new RunnableVal() { - @Override public void run(String[] value) { + try { + return TaskManager.getPlatformImplementation().sync(() -> { if (block.getState() instanceof Sign) { Sign sign = (Sign) block.getState(); - this.value = sign.getLines(); + return sign.getLines(); } - } - }); + return new String[0]; + }); + } catch (final Exception e) { + e.printStackTrace(); + } + return new String[0]; } @Override public Location getSpawn(@Nonnull final String world) { diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/BukkitPlotSquaredTask.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/BukkitPlotSquaredTask.java new file mode 100644 index 000000000..d6b2cc7bf --- /dev/null +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/BukkitPlotSquaredTask.java @@ -0,0 +1,46 @@ +/* + * _____ _ _ _____ _ + * | __ \| | | | / ____| | | + * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | + * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | + * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | + * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| + * | | + * |_| + * PlotSquared plot management system for Minecraft + * Copyright (C) 2020 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 . + */ +package com.plotsquared.bukkit.util.task; + +import com.plotsquared.core.util.task.PlotSquaredTask; +import lombok.RequiredArgsConstructor; +import org.bukkit.scheduler.BukkitRunnable; + +import javax.annotation.Nonnull; + +/** + * Bukkit implementation of {@link PlotSquaredTask} + */ +@RequiredArgsConstructor +public final class BukkitPlotSquaredTask extends BukkitRunnable implements PlotSquaredTask { + + @Nonnull private final Runnable runnable; + + @Override public void runTask() { + this.runnable.run(); + } + +} diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/BukkitTaskManager.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/BukkitTaskManager.java new file mode 100644 index 000000000..643c4d8f3 --- /dev/null +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/BukkitTaskManager.java @@ -0,0 +1,111 @@ +/* + * _____ _ _ _____ _ + * | __ \| | | | / ____| | | + * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | + * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | + * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | + * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| + * | | + * |_| + * PlotSquared plot management system for Minecraft + * Copyright (C) 2020 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 . + */ +package com.plotsquared.bukkit.util.task; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import com.plotsquared.bukkit.BukkitPlatform; +import com.plotsquared.core.PlotSquared; +import com.plotsquared.core.util.task.PlotSquaredTask; +import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; +import org.bukkit.Bukkit; +import org.jetbrains.annotations.NotNull; + +import javax.annotation.Nonnull; +import java.util.concurrent.Callable; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; + +/** + * Bukkit implementation of {@link TaskManager} using + * by {@link org.bukkit.scheduler.BukkitScheduler} and {@link BukkitPlotSquaredTask} + */ +@Singleton public class BukkitTaskManager extends TaskManager { + + private final BukkitPlatform bukkitMain; + private final TaskTime.TimeConverter timeConverter; + + @Inject public BukkitTaskManager(@Nonnull final BukkitPlatform bukkitMain, + @Nonnull final TaskTime.TimeConverter timeConverter) { + this.bukkitMain = bukkitMain; + this.timeConverter = timeConverter; + } + + @Override + public PlotSquaredTask taskRepeat(@Nonnull final Runnable runnable, + @Nonnull final TaskTime taskTime) { + final long ticks = this.timeConverter.toTicks(taskTime); + final BukkitPlotSquaredTask bukkitPlotSquaredTask = new BukkitPlotSquaredTask(runnable); + bukkitPlotSquaredTask.runTaskTimer(this.bukkitMain, ticks, ticks); + return bukkitPlotSquaredTask; + } + + @Override + public PlotSquaredTask taskRepeatAsync(@Nonnull final Runnable runnable, + @Nonnull final TaskTime taskTime) { + final long ticks = this.timeConverter.toTicks(taskTime); + final BukkitPlotSquaredTask bukkitPlotSquaredTask = new BukkitPlotSquaredTask(runnable); + bukkitPlotSquaredTask.runTaskTimerAsynchronously(this.bukkitMain, ticks, ticks); + return bukkitPlotSquaredTask; + } + + @Override public void taskAsync(@Nonnull final Runnable runnable) { + if (this.bukkitMain.isEnabled()) { + new BukkitPlotSquaredTask(runnable).runTaskAsynchronously(this.bukkitMain); + } else { + runnable.run(); + } + } + + @Override public T sync(@Nonnull final Callable function, final int timeout) throws Exception { + if (PlotSquared.get().isMainThread(Thread.currentThread())) { + return function.call(); + } + return this.callMethodSync(function).get(timeout, TimeUnit.MILLISECONDS); + } + + @Override public Future callMethodSync(@NotNull final Callable method) { + return Bukkit.getScheduler().callSyncMethod(this.bukkitMain, method); + } + + @Override public void task(@Nonnull final Runnable runnable) { + new BukkitPlotSquaredTask(runnable).runTaskAsynchronously(this.bukkitMain); + } + + @Override public void taskLater(@Nonnull final Runnable runnable, + @Nonnull final TaskTime taskTime) { + final long delay = this.timeConverter.toTicks(taskTime); + new BukkitPlotSquaredTask(runnable).runTaskLater(this.bukkitMain, delay); + } + + @Override public void taskLaterAsync(@Nonnull final Runnable runnable, + @Nonnull final TaskTime taskTime) { + final long delay = this.timeConverter.toTicks(taskTime); + new BukkitPlotSquaredTask(runnable).runTaskLaterAsynchronously(this.bukkitMain, delay); + } + +} diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/PaperTimeConverter.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/PaperTimeConverter.java new file mode 100644 index 000000000..53fd535c2 --- /dev/null +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/PaperTimeConverter.java @@ -0,0 +1,47 @@ +/* + * _____ _ _ _____ _ + * | __ \| | | | / ____| | | + * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | + * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | + * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | + * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| + * | | + * |_| + * PlotSquared plot management system for Minecraft + * Copyright (C) 2020 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 . + */ +package com.plotsquared.bukkit.util.task; + +import com.plotsquared.core.util.task.TaskTime; +import org.bukkit.Bukkit; + +import javax.annotation.Nonnegative; + +/** + * Time converter that uses the server MSPT count to convert between + * different time units + */ +public final class PaperTimeConverter implements TaskTime.TimeConverter { + + @Override public long msToTicks(@Nonnegative final long ms) { + return Math.max(1L, (long) (ms / Bukkit.getAverageTickTime())); + } + + @Override public long ticksToMs(@Nonnegative final long ticks) { + return Math.max(1L, (long) (ticks * Bukkit.getAverageTickTime())); + } + +} diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/SpigotTimeConverter.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/SpigotTimeConverter.java new file mode 100644 index 000000000..1605e7b77 --- /dev/null +++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/task/SpigotTimeConverter.java @@ -0,0 +1,47 @@ +/* + * _____ _ _ _____ _ + * | __ \| | | | / ____| | | + * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | + * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | + * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | + * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| + * | | + * |_| + * PlotSquared plot management system for Minecraft + * Copyright (C) 2020 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 . + */ +package com.plotsquared.bukkit.util.task; + +import com.plotsquared.core.util.task.TaskTime; + +import javax.annotation.Nonnegative; + +/** + * Naive time converter that assumes that all ticks are 50 milliseconds + */ +public final class SpigotTimeConverter implements TaskTime.TimeConverter { + + private static final long MS_PER_TICKS = 50L; + + @Override public long msToTicks(@Nonnegative final long ms) { + return Math.max(1L, ms / MS_PER_TICKS); + } + + @Override public long ticksToMs(@Nonnegative final long ticks) { + return Math.max(1L, ticks * MS_PER_TICKS); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/command/Auto.java b/Core/src/main/java/com/plotsquared/core/command/Auto.java index e1c32e28b..398beccf8 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Auto.java +++ b/Core/src/main/java/com/plotsquared/core/command/Auto.java @@ -150,13 +150,17 @@ public class Auto extends SubCommand { * @param start * @param schematic */ - public static void autoClaimSafe(final PlotPlayer player, final PlotArea area, PlotId start, + public static void autoClaimSafe(final PlotPlayer player, final PlotArea area, PlotId start, final String schematic) { player.setMeta(Auto.class.getName(), true); autoClaimFromDatabase(player, area, start, new RunnableVal() { @Override public void run(final Plot plot) { - TaskManager.getImplementation().sync(new AutoClaimFinishTask(player, plot, area, schematic, - PlotSquared.get().getEventDispatcher())); + try { + TaskManager.getPlatformImplementation().sync(new AutoClaimFinishTask(player, plot, area, schematic, + PlotSquared.get().getEventDispatcher())); + } catch (final Exception e) { + e.printStackTrace(); + } } }); } diff --git a/Core/src/main/java/com/plotsquared/core/command/Claim.java b/Core/src/main/java/com/plotsquared/core/command/Claim.java index e49afd85c..c4b19d018 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Claim.java +++ b/Core/src/main/java/com/plotsquared/core/command/Claim.java @@ -43,30 +43,26 @@ import com.plotsquared.core.util.EconHandler; import com.plotsquared.core.util.EventDispatcher; import com.plotsquared.core.util.Expression; import com.plotsquared.core.util.Permissions; -import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import javax.annotation.Nonnull; import javax.annotation.Nullable; -@CommandDeclaration(command = "claim", - aliases = "c", - description = "Claim the current plot you're standing on", - category = CommandCategory.CLAIMING, - requiredType = RequiredType.PLAYER, - permission = "plots.claim", - usage = "/plot claim") +@CommandDeclaration(command = "claim", aliases = "c", description = "Claim the current plot you're standing on", category = CommandCategory.CLAIMING, requiredType = RequiredType.PLAYER, permission = "plots.claim", usage = "/plot claim") public class Claim extends SubCommand { - private static final Logger logger = LoggerFactory.getLogger("P2/" + Claim.class.getSimpleName()); + private static final Logger logger = + LoggerFactory.getLogger("P2/" + Claim.class.getSimpleName()); private final EventDispatcher eventDispatcher; private final EconHandler econHandler; @Inject public Claim(@Nonnull final EventDispatcher eventDispatcher, - @Nullable final EconHandler econHandler) { + @Nullable final EconHandler econHandler) { this.eventDispatcher = eventDispatcher; this.econHandler = econHandler; } @@ -146,24 +142,29 @@ public class Claim extends SubCommand { } plot.setOwnerAbs(player.getUUID()); final String finalSchematic = schematic; - DBFunc.createPlotSafe(plot, () -> TaskManager.getImplementation().sync(new RunnableVal() { - @Override public void run(Object value) { - if (!plot.claim(player, true, finalSchematic, false)) { - logger.info(Captions.PREFIX.getTranslated() + String - .format("Failed to claim plot %s", plot.getId().toCommaSeparatedString())); - sendMessage(player, Captions.PLOT_NOT_CLAIMED); - plot.setOwnerAbs(null); - } else if (area.isAutoMerge()) { - PlotMergeEvent event = Claim.this.eventDispatcher - .callMerge(plot, Direction.ALL, Integer.MAX_VALUE, player); - if (event.getEventResult() == Result.DENY) { - sendMessage(player, Captions.EVENT_DENIED, "Auto merge on claim"); - } else { - plot.autoMerge(event.getDir(), event.getMax(), player.getUUID(), true); + DBFunc.createPlotSafe(plot, () -> { + try { + TaskManager.getPlatformImplementation().sync(() -> { + if (!plot.claim(player, true, finalSchematic, false)) { + logger.info(Captions.PREFIX.getTranslated() + String + .format("Failed to claim plot %s", plot.getId().toCommaSeparatedString())); + sendMessage(player, Captions.PLOT_NOT_CLAIMED); + plot.setOwnerAbs(null); + } else if (area.isAutoMerge()) { + PlotMergeEvent mergeEvent = Claim.this.eventDispatcher + .callMerge(plot, Direction.ALL, Integer.MAX_VALUE, player); + if (mergeEvent.getEventResult() == Result.DENY) { + sendMessage(player, Captions.EVENT_DENIED, "Auto merge on claim"); + } else { + plot.autoMerge(mergeEvent.getDir(), mergeEvent.getMax(), player.getUUID(), true); + } } - } + return null; + }); + } catch (final Exception e) { + e.printStackTrace(); } - }), () -> { + }, () -> { logger.info(Captions.PREFIX.getTranslated() + String .format("Failed to add plot %s to the database", plot.getId().toCommaSeparatedString())); diff --git a/Core/src/main/java/com/plotsquared/core/command/CmdConfirm.java b/Core/src/main/java/com/plotsquared/core/command/CmdConfirm.java index f7096834b..c8aee497c 100644 --- a/Core/src/main/java/com/plotsquared/core/command/CmdConfirm.java +++ b/Core/src/main/java/com/plotsquared/core/command/CmdConfirm.java @@ -29,6 +29,7 @@ import com.plotsquared.core.configuration.Captions; import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.util.MainUtil; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; public class CmdConfirm { @@ -46,11 +47,9 @@ public class CmdConfirm { if (commandStr != null) { MainUtil.sendMessage(player, Captions.REQUIRES_CONFIRM, commandStr); } - TaskManager.runTaskLater(new Runnable() { - @Override public void run() { - CmdInstance cmd = new CmdInstance(runnable); - player.setMeta("cmdConfirm", cmd); - } - }, 1); + TaskManager.runTaskLater(() -> { + CmdInstance cmd = new CmdInstance(runnable); + player.setMeta("cmdConfirm", cmd); + }, TaskTime.ticks(1L)); } } diff --git a/Core/src/main/java/com/plotsquared/core/command/Condense.java b/Core/src/main/java/com/plotsquared/core/command/Condense.java index bc73a815a..19f70fcd4 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Condense.java +++ b/Core/src/main/java/com/plotsquared/core/command/Condense.java @@ -35,6 +35,7 @@ import com.plotsquared.core.util.MainUtil; import com.plotsquared.core.util.MathMan; import com.plotsquared.core.util.WorldUtil; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import javax.annotation.Nonnull; import java.util.ArrayList; @@ -177,7 +178,7 @@ public class Condense extends SubCommand { if (result.get()) { MainUtil.sendMessage(player, "Moving: " + origin + " -> " + possible); - TaskManager.runTaskLater(task, 1); + TaskManager.runTaskLater(task, TaskTime.ticks(1L)); } }, false).get()); } catch (InterruptedException | ExecutionException e) { diff --git a/Core/src/main/java/com/plotsquared/core/command/DebugExec.java b/Core/src/main/java/com/plotsquared/core/command/DebugExec.java index f48ab43c5..2c2ba2989 100644 --- a/Core/src/main/java/com/plotsquared/core/command/DebugExec.java +++ b/Core/src/main/java/com/plotsquared/core/command/DebugExec.java @@ -182,7 +182,7 @@ public class DebugExec extends SubCommand { if (this.worldEdit != null) { this.scope.put("WEManager", new WEManager()); } - this.scope.put("TaskManager", TaskManager.getImplementation()); + this.scope.put("TaskManager", TaskManager.getPlatformImplementation()); this.scope.put("ConsolePlayer", ConsolePlayer.getConsole()); this.scope.put("SchematicHandler", this.schematicHandler); this.scope.put("ChunkManager", this.chunkManager); diff --git a/Core/src/main/java/com/plotsquared/core/command/PluginCmd.java b/Core/src/main/java/com/plotsquared/core/command/PluginCmd.java index 60925ccbd..f4069bec1 100644 --- a/Core/src/main/java/com/plotsquared/core/command/PluginCmd.java +++ b/Core/src/main/java/com/plotsquared/core/command/PluginCmd.java @@ -40,7 +40,7 @@ import com.plotsquared.core.util.task.TaskManager; public class PluginCmd extends SubCommand { @Override public boolean onCommand(final PlotPlayer player, String[] args) { - TaskManager.getImplementation().taskAsync(() -> { + TaskManager.getPlatformImplementation().taskAsync(() -> { MainUtil.sendMessage(player, String.format( "$2>> $1&l" + PlotSquared.platform().getPluginName() + " $2($1Version$2: $1%s$2)", PlotSquared.get().getVersion())); diff --git a/Core/src/main/java/com/plotsquared/core/command/Trim.java b/Core/src/main/java/com/plotsquared/core/command/Trim.java index a12124ab3..c52d2b996 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Trim.java +++ b/Core/src/main/java/com/plotsquared/core/command/Trim.java @@ -43,6 +43,7 @@ import com.plotsquared.core.util.query.PlotQuery; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.RunnableVal2; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.worldedit.math.BlockVector2; import com.sk89q.worldedit.regions.CuboidRegion; import org.slf4j.Logger; @@ -102,7 +103,7 @@ public class Trim extends SubCommand { MainUtil.sendMessage(null, " - MCA #: " + result.value1.size()); MainUtil.sendMessage(null, " - CHUNKS: " + (result.value1.size() * 1024) + " (max)"); MainUtil.sendMessage(null, " - TIME ESTIMATE: 12 Parsecs"); - TaskManager.objectTask(plots, new RunnableVal() { + TaskManager.getPlatformImplementation().objectTask(plots, new RunnableVal() { @Override public void run(Plot plot) { Location pos1 = plot.getCorners()[0]; Location pos2 = plot.getCorners()[1]; @@ -119,7 +120,8 @@ public class Trim extends SubCommand { } } } - }, result); + }).thenAccept(ignore -> + TaskManager.getPlatformImplementation().taskLater(result, TaskTime.ticks(1L))); return true; } @@ -189,11 +191,12 @@ public class Trim extends SubCommand { } } final LocalBlockQueue queue = blockQueue.getNewQueue(world, false); - TaskManager.objectTask(chunks, new RunnableVal() { + TaskManager.getPlatformImplementation().objectTask(chunks, new RunnableVal() { @Override public void run(BlockVector2 value) { queue.regenChunk(value.getX(), value.getZ()); } - }, this); + }).thenAccept(ignore -> TaskManager.getPlatformImplementation() + .taskLater(this, TaskTime.ticks(1L))); } }; } else { diff --git a/Core/src/main/java/com/plotsquared/core/configuration/Settings.java b/Core/src/main/java/com/plotsquared/core/configuration/Settings.java index 0bc2435a6..3aa084655 100644 --- a/Core/src/main/java/com/plotsquared/core/configuration/Settings.java +++ b/Core/src/main/java/com/plotsquared/core/configuration/Settings.java @@ -482,9 +482,9 @@ public class Settings extends Config { @Comment("Teleport to your plot on death") public static boolean ON_DEATH = false; @Comment("Teleport to your plot on login") public static boolean ON_LOGIN = false; @Comment("Teleport to your plot on claim") public static boolean ON_CLAIM = true; - @Comment({"Add a delay to all teleport commands", - "Assign `plots.teleport.delay.bypass` to bypass the cooldown."}) public static int - DELAY = 0; + @Comment({"Add a delay to all teleport commands (in seconds)", + "Assign `plots.teleport.delay.bypass` to bypass the cooldown"}) + public static int DELAY = 0; @Comment("The visit command is ordered by world instead of globally") public static boolean PER_WORLD_VISIT = false; } diff --git a/Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java b/Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java index 927086cbc..5d4d578a8 100644 --- a/Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java +++ b/Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java @@ -53,6 +53,7 @@ import com.plotsquared.core.util.SchematicHandler; import com.plotsquared.core.util.WorldUtil; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.jnbt.CompoundTag; import com.sk89q.worldedit.math.BlockVector2; import com.sk89q.worldedit.math.BlockVector3; @@ -365,7 +366,7 @@ public class HybridUtils { analyzeRegion(origin.getWorldName(), region, new RunnableVal() { @Override public void run(PlotAnalysis value) { analysis.add(value); - TaskManager.runTaskLater(task, 1); + TaskManager.runTaskLater(task, TaskTime.ticks(1L)); } }); } @@ -477,21 +478,20 @@ public class HybridUtils { } } if (!chunks.isEmpty()) { - TaskManager.getImplementation().sync(new RunnableVal() { - @Override public void run(Object value) { - long start = System.currentTimeMillis(); - Iterator iterator = chunks.iterator(); - while (System.currentTimeMillis() - start < 20 && !chunks - .isEmpty()) { - final BlockVector2 chunk = iterator.next(); - iterator.remove(); - boolean regenedRoads = - regenerateRoad(area, chunk, extend); - if (!regenedRoads && Settings.DEBUG) { - logger.info("[P2] Failed to regenerate road"); - } + TaskManager.getPlatformImplementation().sync(() -> { + long start = System.currentTimeMillis(); + Iterator iterator = chunks.iterator(); + while (System.currentTimeMillis() - start < 20 && !chunks + .isEmpty()) { + final BlockVector2 chunk = iterator.next(); + iterator.remove(); + boolean regenedRoads = + regenerateRoad(area, chunk, extend); + if (!regenedRoads && Settings.DEBUG) { + logger.info("[P2] Failed to regenerate road"); } } + return null; }); } } catch (Exception e) { @@ -510,7 +510,7 @@ public class HybridUtils { } } } - blockQueue.addEmptyTask(() -> TaskManager.runTaskLater(task, 20)); + blockQueue.addEmptyTask(() -> TaskManager.runTaskLater(task, TaskTime.seconds(1L))); }); } } diff --git a/Core/src/main/java/com/plotsquared/core/listener/PlotListener.java b/Core/src/main/java/com/plotsquared/core/listener/PlotListener.java index dc9eb8263..5f9e80f77 100644 --- a/Core/src/main/java/com/plotsquared/core/listener/PlotListener.java +++ b/Core/src/main/java/com/plotsquared/core/listener/PlotListener.java @@ -63,6 +63,7 @@ import com.plotsquared.core.util.Permissions; import com.plotsquared.core.util.StringMan; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.worldedit.world.gamemode.GameMode; import com.sk89q.worldedit.world.gamemode.GameModes; import com.sk89q.worldedit.world.item.ItemType; @@ -127,7 +128,7 @@ public class PlotListener { } } } - }, 20); + }, TaskTime.seconds(1L)); } public boolean plotEntry(final PlotPlayer player, final Plot plot) { @@ -277,7 +278,7 @@ public class PlotListener { Templates.of("owner", plot.getOwner()) ); } - }, 20); + }, TaskTime.seconds(1L)); } } diff --git a/Core/src/main/java/com/plotsquared/core/plot/Plot.java b/Core/src/main/java/com/plotsquared/core/plot/Plot.java index 99e7be7c6..002ea1bea 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/Plot.java +++ b/Core/src/main/java/com/plotsquared/core/plot/Plot.java @@ -66,6 +66,7 @@ import com.plotsquared.core.util.SchematicHandler; import com.plotsquared.core.util.WorldUtil; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.plotsquared.core.uuid.UUIDPipeline; import com.sk89q.jnbt.CompoundTag; import com.sk89q.worldedit.function.pattern.Pattern; @@ -1944,7 +1945,7 @@ public class Plot { this.getId().recalculateHash(); this.area.addPlotAbs(this); DBFunc.movePlot(this, plot); - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); return true; } @@ -2907,7 +2908,7 @@ public class Plot { this.plotListener.plotExit(pp, Plot.this); this.plotListener.plotEntry(pp, Plot.this); } - }, 1); + }, TaskTime.ticks(1L)); } public void debug(@Nonnull final String message) { @@ -2993,16 +2994,16 @@ public class Plot { MainUtil .sendMessage(player, Captions.TELEPORT_IN_SECONDS, Settings.Teleport.DELAY + ""); final String name = player.getName(); - TaskManager.TELEPORT_QUEUE.add(name); + TaskManager.addToTeleportQueue(name); TaskManager.runTaskLater(() -> { - if (!TaskManager.TELEPORT_QUEUE.remove(name)) { + if (!TaskManager.removeFromTeleportQueue(name)) { return; } if (player.isOnline()) { MainUtil.sendMessage(player, Captions.TELEPORTED_TO_PLOT); player.teleport(location, cause); } - }, Settings.Teleport.DELAY * 20); + }, TaskTime.seconds(Settings.Teleport.DELAY)); resultConsumer.accept(true); }; if (this.area.isHomeAllowNonmember() || plot.isAdded(player.getUUID())) { @@ -3152,7 +3153,7 @@ public class Plot { final int offsetX = db.getX() - ob.getX(); final int offsetZ = db.getZ() - ob.getZ(); if (!this.hasOwner()) { - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); return CompletableFuture.completedFuture(false); } AtomicBoolean occupied = new AtomicBoolean(false); @@ -3161,7 +3162,7 @@ public class Plot { Plot other = plot.getRelative(destination.getArea(), offset.x, offset.y); if (other.hasOwner()) { if (!allowSwap) { - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); return CompletableFuture.completedFuture(false); } occupied.set(true); @@ -3268,14 +3269,14 @@ public class Plot { final int offsetX = db.getX() - ob.getX(); final int offsetZ = db.getZ() - ob.getZ(); if (!this.hasOwner()) { - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); return false; } Set plots = this.getConnectedPlots(); for (Plot plot : plots) { Plot other = plot.getRelative(destination.getArea(), offset.x, offset.y); if (other.hasOwner()) { - TaskManager.runTaskLater(whenDone, 1); + TaskManager.runTaskLater(whenDone, TaskTime.ticks(1L)); return false; } } diff --git a/Core/src/main/java/com/plotsquared/core/plot/comment/CommentManager.java b/Core/src/main/java/com/plotsquared/core/plot/comment/CommentManager.java index 7a5e38ded..cabe88b04 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/comment/CommentManager.java +++ b/Core/src/main/java/com/plotsquared/core/plot/comment/CommentManager.java @@ -34,6 +34,7 @@ import com.plotsquared.core.plot.Plot; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; import net.kyori.adventure.text.minimessage.Template; +import com.plotsquared.core.util.task.TaskTime; import java.util.Collection; import java.util.HashMap; @@ -77,7 +78,7 @@ import java.util.concurrent.atomic.AtomicInteger; } }); } - }, 20); + }, TaskTime.seconds(1L)); } public static long getTimestamp(PlotPlayer player, String inbox) { diff --git a/Core/src/main/java/com/plotsquared/core/plot/expiration/ExpireManager.java b/Core/src/main/java/com/plotsquared/core/plot/expiration/ExpireManager.java index b5fbbd385..68f2c4b89 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/expiration/ExpireManager.java +++ b/Core/src/main/java/com/plotsquared/core/plot/expiration/ExpireManager.java @@ -47,6 +47,7 @@ import com.plotsquared.core.util.query.PlotQuery; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.RunnableVal3; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -325,7 +326,8 @@ public class ExpireManager { } for (ExpiryTask expiryTask : expired) { if (!expiryTask.needsAnalysis()) { - expiredTask.run(newPlot, () -> TaskManager.getImplementation().taskLaterAsync(task, 1), + expiredTask.run(newPlot, () -> TaskManager.getPlatformImplementation() + .taskLaterAsync(task, TaskTime.ticks(1L)), expiryTask.requiresConfirmation()); return; } @@ -336,7 +338,7 @@ public class ExpireManager { passesComplexity(changed, expired, new RunnableVal() { @Override public void run(Boolean confirmation) { expiredTask.run(newPlot, - () -> TaskManager.getImplementation().taskLaterAsync(task, 1), + () -> TaskManager.getPlatformImplementation().taskLaterAsync(task, TaskTime.ticks(1L)), confirmation); } }, () -> { @@ -349,7 +351,7 @@ public class ExpireManager { return; } newPlot.setFlag(event.getFlag()); - TaskManager.runTaskLaterAsync(task, 20); + TaskManager.runTaskLaterAsync(task, TaskTime.seconds(1L)); }); } }; @@ -362,7 +364,7 @@ public class ExpireManager { @Override public void run(Boolean value) { doAnalysis.run(); } - }, () -> TaskManager.getImplementation().taskLaterAsync(task, 1)); + }, () -> TaskManager.getPlatformImplementation().taskLaterAsync(task, TaskTime.ticks(1L))); } else { doAnalysis.run(); } @@ -375,9 +377,9 @@ public class ExpireManager { ExpireManager.this.running = 2; runTask(expiredTask); } - }, 86400000); + }, TaskTime.ticks(86400000L)); } else { - TaskManager.runTaskLaterAsync(task, 20 * 10); + TaskManager.runTaskLaterAsync(task, TaskTime.seconds(10L)); } } }); diff --git a/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotArea.java b/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotArea.java index d8c325b72..0d29a8714 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotArea.java +++ b/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotArea.java @@ -47,7 +47,6 @@ import com.plotsquared.core.setup.PlotAreaBuilder; import com.plotsquared.core.setup.SettingsNodesWrapper; import com.plotsquared.core.util.EconHandler; import com.plotsquared.core.util.EventDispatcher; -import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; import javax.annotation.Nonnull; @@ -141,15 +140,18 @@ public class SinglePlotArea extends GridPlotWorld { } } - TaskManager.getImplementation().sync(new RunnableVal() { - @Override public void run(Object value) { - String worldName = id.getX() + "." + id.getY(); - if (PlotSquared.platform().getWorldUtil().isWorld(worldName)) { - return; + try { + TaskManager.getPlatformImplementation().sync(() -> { + final String name = id.getX() + "." + id.getY(); + if (!PlotSquared.platform().getWorldUtil().isWorld(name)) { + PlotSquared.platform().getSetupUtils().setupWorld(builder); } - PlotSquared.platform().getSetupUtils().setupWorld(builder); - } - }); + return null; + }); + } catch (final Exception e) { + e.printStackTrace(); + } + // String worldName = plot.getWorldName(); // World world = Bukkit.getWorld(worldName); // if (world != null) { diff --git a/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotManager.java b/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotManager.java index ed4a29f4b..cd4b932b3 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotManager.java +++ b/Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotManager.java @@ -64,7 +64,7 @@ public class SinglePlotManager extends PlotManager { @Override public boolean clearPlot(Plot plot, final Runnable whenDone) { PlotSquared.platform().getSetupUtils().unload(plot.getWorldName(), false); final File worldFolder = new File(PlotSquared.platform().getWorldContainer(), plot.getWorldName()); - TaskManager.getImplementation().taskAsync(() -> { + TaskManager.getPlatformImplementation().taskAsync(() -> { MainUtil.deleteDirectory(worldFolder); if (whenDone != null) { whenDone.run(); diff --git a/Core/src/main/java/com/plotsquared/core/queue/BasicLocalBlockQueue.java b/Core/src/main/java/com/plotsquared/core/queue/BasicLocalBlockQueue.java index aa2d6d386..03aa8b437 100644 --- a/Core/src/main/java/com/plotsquared/core/queue/BasicLocalBlockQueue.java +++ b/Core/src/main/java/com/plotsquared/core/queue/BasicLocalBlockQueue.java @@ -28,7 +28,6 @@ package com.plotsquared.core.queue; import com.plotsquared.core.util.MainUtil; import com.plotsquared.core.util.MathMan; import com.plotsquared.core.util.PatternUtil; -import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; import com.sk89q.worldedit.function.pattern.Pattern; import com.sk89q.worldedit.world.biome.BiomeType; @@ -185,12 +184,15 @@ public abstract class BasicLocalBlockQueue extends LocalBlockQueue { @Override public void flush() { this.globalBlockQueue.dequeue(this); - TaskManager.getImplementation().sync(new RunnableVal() { - @Override public void run(Object value) { + try { + TaskManager.getPlatformImplementation().sync(() -> { while (next()) { } - } - }); + return null; + }); + } catch (final Exception e) { + e.printStackTrace(); + } } diff --git a/Core/src/main/java/com/plotsquared/core/queue/GlobalBlockQueue.java b/Core/src/main/java/com/plotsquared/core/queue/GlobalBlockQueue.java index 9f79102b0..1ef62a4eb 100644 --- a/Core/src/main/java/com/plotsquared/core/queue/GlobalBlockQueue.java +++ b/Core/src/main/java/com/plotsquared/core/queue/GlobalBlockQueue.java @@ -28,6 +28,7 @@ package com.plotsquared.core.queue; import com.plotsquared.core.PlotSquared; import com.plotsquared.core.util.task.RunnableVal2; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import java.util.ArrayList; import java.util.ConcurrentModificationException; @@ -165,7 +166,7 @@ public class GlobalBlockQueue { SET_TASK.value2.endSet(true); } } - }, 1); + }, TaskTime.ticks(1L)); return true; } diff --git a/Core/src/main/java/com/plotsquared/core/util/ChunkManager.java b/Core/src/main/java/com/plotsquared/core/util/ChunkManager.java index f9809840f..438f60940 100644 --- a/Core/src/main/java/com/plotsquared/core/util/ChunkManager.java +++ b/Core/src/main/java/com/plotsquared/core/util/ChunkManager.java @@ -32,6 +32,7 @@ import com.plotsquared.core.queue.LocalBlockQueue; import com.plotsquared.core.queue.ScopedLocalBlockQueue; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.worldedit.math.BlockVector2; import com.sk89q.worldedit.regions.CuboidRegion; @@ -172,7 +173,7 @@ public abstract class ChunkManager { task.run(); } if (!chunks.isEmpty()) { - TaskManager.runTaskLater(this, 1); + TaskManager.runTaskLater(this, TaskTime.ticks(1L)); } else { TaskManager.runTask(whenDone); } diff --git a/Core/src/main/java/com/plotsquared/core/util/RegionManager.java b/Core/src/main/java/com/plotsquared/core/util/RegionManager.java index 9c02c7f57..40906237d 100644 --- a/Core/src/main/java/com/plotsquared/core/util/RegionManager.java +++ b/Core/src/main/java/com/plotsquared/core/util/RegionManager.java @@ -33,6 +33,7 @@ import com.plotsquared.core.plot.PlotManager; import com.plotsquared.core.queue.LocalBlockQueue; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.worldedit.function.pattern.Pattern; import com.sk89q.worldedit.math.BlockVector2; import com.sk89q.worldedit.regions.CuboidRegion; @@ -94,12 +95,13 @@ public abstract class RegionManager { } } } - TaskManager.objectTask(chunks, new RunnableVal() { + TaskManager.getPlatformImplementation().objectTask(chunks, new RunnableVal() { @Override public void run(BlockVector2 value) { chunkManager.loadChunk(world, value, false) .thenRun(() -> task.run(value)); } - }, whenDone); + }).thenAccept(ignore -> + TaskManager.getPlatformImplementation().taskLater(whenDone, TaskTime.ticks(1L))); }); } diff --git a/Core/src/main/java/com/plotsquared/core/util/SchematicHandler.java b/Core/src/main/java/com/plotsquared/core/util/SchematicHandler.java index c4740ec55..84b7829ee 100644 --- a/Core/src/main/java/com/plotsquared/core/util/SchematicHandler.java +++ b/Core/src/main/java/com/plotsquared/core/util/SchematicHandler.java @@ -35,6 +35,7 @@ import com.plotsquared.core.plot.schematic.Schematic; import com.plotsquared.core.queue.LocalBlockQueue; import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.TaskManager; +import com.plotsquared.core.util.task.TaskTime; import com.sk89q.jnbt.ByteArrayTag; import com.sk89q.jnbt.CompoundTag; import com.sk89q.jnbt.IntArrayTag; @@ -661,7 +662,7 @@ public abstract class SchematicHandler { zTask.run(); } if (yiter.hasNext()) { - TaskManager.runTaskLater(this, 1); + TaskManager.runTaskLater(this, TaskTime.ticks(1L)); } else { regionTask.run(); } diff --git a/Core/src/main/java/com/plotsquared/core/util/task/AutoClaimFinishTask.java b/Core/src/main/java/com/plotsquared/core/util/task/AutoClaimFinishTask.java index c0d2c4b44..725bca79e 100644 --- a/Core/src/main/java/com/plotsquared/core/util/task/AutoClaimFinishTask.java +++ b/Core/src/main/java/com/plotsquared/core/util/task/AutoClaimFinishTask.java @@ -36,7 +36,9 @@ import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.util.EventDispatcher; -public final class AutoClaimFinishTask extends RunnableVal { +import java.util.concurrent.Callable; + +public final class AutoClaimFinishTask implements Callable { private final PlotPlayer player; private final Plot plot; @@ -53,11 +55,11 @@ public final class AutoClaimFinishTask extends RunnableVal { this.eventDispatcher = eventDispatcher; } - @Override public void run(Object value) { + @Override public Boolean call() { player.deleteMeta(Auto.class.getName()); if (plot == null) { player.sendMessage(TranslatableCaption.of("errors.no_free_plots")); - return; + return false; } plot.claim(player, true, schematic, false); if (area.isAutoMerge()) { @@ -69,5 +71,7 @@ public final class AutoClaimFinishTask extends RunnableVal { plot.autoMerge(event.getDir(), event.getMax(), player.getUUID(), true); } } + return true; } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/task/ObjectTaskRunnable.java b/Core/src/main/java/com/plotsquared/core/util/task/ObjectTaskRunnable.java index c56a0b820..467265967 100644 --- a/Core/src/main/java/com/plotsquared/core/util/task/ObjectTaskRunnable.java +++ b/Core/src/main/java/com/plotsquared/core/util/task/ObjectTaskRunnable.java @@ -26,12 +26,14 @@ package com.plotsquared.core.util.task; import java.util.Iterator; +import java.util.concurrent.CompletableFuture; public class ObjectTaskRunnable implements Runnable { + private final CompletableFuture completionFuture = new CompletableFuture<>(); + private final Iterator iterator; private final RunnableVal task; - private final Runnable whenDone; public ObjectTaskRunnable(final Iterator iterator, final RunnableVal task, final Runnable whenDone) { @@ -40,6 +42,10 @@ public class ObjectTaskRunnable implements Runnable { this.whenDone = whenDone; } + public CompletableFuture getCompletionFuture() { + return this.completionFuture; + } + @Override public void run() { long start = System.currentTimeMillis(); boolean hasNext; @@ -48,9 +54,9 @@ public class ObjectTaskRunnable implements Runnable { task.run(); } if (!hasNext) { - TaskManager.runTaskLater(whenDone, 1); + completionFuture.complete(null); } else { - TaskManager.runTaskLater(this, 1); + TaskManager.runTaskLater(this, TaskTime.ticks(1L)); } } diff --git a/Core/src/main/java/com/plotsquared/core/util/task/PlotSquaredTask.java b/Core/src/main/java/com/plotsquared/core/util/task/PlotSquaredTask.java new file mode 100644 index 000000000..3f1f9a16b --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/util/task/PlotSquaredTask.java @@ -0,0 +1,90 @@ +/* + * _____ _ _ _____ _ + * | __ \| | | | / ____| | | + * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | + * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | + * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | + * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| + * | | + * |_| + * PlotSquared plot management system for Minecraft + * Copyright (C) 2020 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 . + */ +package com.plotsquared.core.util.task; + +/** + * A task that can be run and cancelled (if repeating) + */ +public interface PlotSquaredTask extends Runnable { + + /** + * Run the task. Don't override this, instead + * implement {@link #runTask()} + */ + @Override default void run() { + if (isCancelled()) { + return; + } + this.runTask(); + } + + /** + * Run the task + */ + void runTask(); + + /** + * Check if the task has been cancelled + * + * @return {@code true} if the tasks is cancelled, + * {@code false} if not + */ + boolean isCancelled(); + + /** + * Cancel the task + */ + void cancel(); + + /** + * Get a new {@link NullTask} + * + * @return Null task instance + */ + static NullTask nullTask() { + return new NullTask(); + } + + + /** + * Task that does nothing and is always cancelled + */ + class NullTask implements PlotSquaredTask { + + @Override public void runTask() { + } + + @Override public boolean isCancelled() { + return true; + } + + @Override public void cancel() { + } + + } + +} + diff --git a/Core/src/main/java/com/plotsquared/core/util/task/TaskManager.java b/Core/src/main/java/com/plotsquared/core/util/task/TaskManager.java index c140a7e84..a5bbbc77f 100644 --- a/Core/src/main/java/com/plotsquared/core/util/task/TaskManager.java +++ b/Core/src/main/java/com/plotsquared/core/util/task/TaskManager.java @@ -28,147 +28,274 @@ package com.plotsquared.core.util.task; import com.plotsquared.core.PlotSquared; import com.plotsquared.core.util.RuntimeExceptionRunnableVal; +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; -import java.util.concurrent.atomic.AtomicBoolean; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Future; import java.util.concurrent.atomic.AtomicInteger; +/** + * Task manager that handles scheduling of tasks. + * Synchronous methods make no guarantee of being scheduled on the + * server thread, instead they guarantee that no two synchronous + * operations happen at the same time. Implementations of + * the task manager might make other guarantees. All asynchronous + * operations will happen on another thread, no matter where + * they're scheduled from. + */ public abstract class TaskManager { - public static final HashSet TELEPORT_QUEUE = new HashSet<>(); - public static final HashMap tasks = new HashMap<>(); + private static final Set teleportQueue = new HashSet<>(); + private static final Map tasks = new HashMap<>(); public static AtomicInteger index = new AtomicInteger(0); - private static TaskManager implementation; + private static TaskManager platformImplementation; - public static int runTaskRepeat(Runnable runnable, int interval) { - if (runnable != null) { - if (getImplementation() == null) { - throw new IllegalArgumentException("disabled"); - } - return getImplementation().taskRepeat(runnable, interval); - } - return -1; + /** + * Add a string to the teleport queue + * + * @param string String to add + */ + public static void addToTeleportQueue(@Nonnull final String string) { + teleportQueue.add(string); } - public static int runTaskRepeatAsync(Runnable runnable, int interval) { - if (runnable != null) { - if (getImplementation() == null) { - throw new IllegalArgumentException("disabled"); - } - return getImplementation().taskRepeatAsync(runnable, interval); - } - return -1; + /** + * Remove a string from the teleport queue + * + * @param string String to remove + * return {@code true} if the value was stored in the map, or {@code false} + */ + public static boolean removeFromTeleportQueue(@Nonnull final String string) { + return teleportQueue.remove(string); } - public static void runTaskAsync(Runnable runnable) { + /** + * Add a task to the task map + * + * @param task Task + * @param id Task ID + */ + public static void addTask(@Nonnull final PlotSquaredTask task, final int id) { + tasks.put(id, task); + } + + /** + * Remove a task from the task map and return the stored value + * + * @param id Task ID + * @return Task if stored, or {@code null} + */ + @Nullable public static PlotSquaredTask removeTask(final int id) { + return tasks.remove(id); + } + + /** + * Run a repeating synchronous task. If using a platform scheduler, + * this is guaranteed to run on the server thread + * + * @param runnable Task to run + * @param taskTime Task interval + * @return Created task object, can be used to cancel the task + */ + @Nonnull public static PlotSquaredTask runTaskRepeat(@Nullable final Runnable runnable, + @Nonnull final TaskTime taskTime) { if (runnable != null) { - if (getImplementation() == null) { + if (getPlatformImplementation() == null) { + throw new IllegalArgumentException("disabled"); + } + return getPlatformImplementation().taskRepeat(runnable, taskTime); + } + return PlotSquaredTask.nullTask(); + } + + /** + * Run an asynchronous task. This will never run on the server thread + * + * @param runnable Task to run + */ + public static void runTaskAsync(@Nullable final Runnable runnable) { + if (runnable != null) { + if (getPlatformImplementation() == null) { runnable.run(); return; } - getImplementation().taskAsync(runnable); - } - } - - public static void runTask(Runnable runnable) { - if (runnable != null) { - if (getImplementation() == null) { - runnable.run(); - return; - } - getImplementation().task(runnable); + getPlatformImplementation().taskAsync(runnable); } } /** - * Run task later. + * Run a synchronous task. If using a platform scheduler, this is guaranteed + * to run on the server thread * - * @param runnable The task - * @param delay The delay in ticks + * @param runnable Task to run */ - public static void runTaskLater(Runnable runnable, int delay) { + public static void runTask(@Nullable final Runnable runnable) { if (runnable != null) { - if (getImplementation() == null) { + if (getPlatformImplementation() == null) { runnable.run(); return; } - getImplementation().taskLater(runnable, delay); - } - } - - public static void runTaskLaterAsync(Runnable runnable, int delay) { - if (runnable != null) { - if (getImplementation() == null) { - runnable.run(); - return; - } - getImplementation().taskLaterAsync(runnable, delay); + getPlatformImplementation().task(runnable); } } /** - * Break up a series of tasks so that they can run without lagging the server. + * Run a synchronous task after a given delay. + * If using a platform scheduler, this is guaranteed to run on the server thread * - * @param objects - * @param task - * @param whenDone + * @param runnable Task to run + * @param taskTime Task delay */ - public static void objectTask(Collection objects, final RunnableVal task, - final Runnable whenDone) { + public static void runTaskLater(@Nullable final Runnable runnable, + @Nonnull final TaskTime taskTime) { + if (runnable != null) { + if (getPlatformImplementation() == null) { + runnable.run(); + return; + } + getPlatformImplementation().taskLater(runnable, taskTime); + } + } + + /** + * Run an asynchronous task after a given delay. This will never + * run on the server thread + * + * @param runnable Task to run + * @param taskTime Task delay + */ + public static void runTaskLaterAsync(@Nullable final Runnable runnable, + @Nonnull final TaskTime taskTime) { + if (runnable != null) { + if (getPlatformImplementation() == null) { + runnable.run(); + return; + } + getPlatformImplementation().taskLaterAsync(runnable, taskTime); + } + } + + /** + * Break up a series of tasks so that they can run without lagging the server + * + * @param objects Objects to perform the task on + * @param task Task to perform + * @param Object type + * @return Future that completes when the tasks are done + */ + public CompletableFuture objectTask(@Nonnull final Collection objects, + @Nonnull final RunnableVal task) { final Iterator iterator = objects.iterator(); - TaskManager.runTask(new ObjectTaskRunnable<>(iterator, task, whenDone)); + final ObjectTaskRunnable taskRunnable = new ObjectTaskRunnable<>(iterator, task); + TaskManager.runTask(taskRunnable); + return taskRunnable.getCompletionFuture(); } - public static TaskManager getImplementation() { - return TaskManager.implementation; + @Nonnull public static TaskManager getPlatformImplementation() { + return implementation; } - public static void setImplementation(TaskManager implementation) { - TaskManager.implementation = implementation; + @Nonnull public static void setPlatformImplementation(TaskManager implementation) { + implementation = implementation; } public T sync(final RunnableVal function) { + /** + * Make a synchronous method call and return the result + * + * @param function Method to call + * @param Return type + * @return Method result + * @throws Exception If the call fails + */ + public T sync(@Nonnull final Callable function) throws Exception { return sync(function, Integer.MAX_VALUE); } - public T sync(final RunnableVal function, int timeout) { - if (PlotSquared.get().isMainThread(Thread.currentThread())) { - function.run(); - return function.value; - } - final AtomicBoolean running = new AtomicBoolean(true); - final RuntimeExceptionRunnableVal run = - new RuntimeExceptionRunnableVal<>(function, running); - TaskManager.getImplementation().task(run); - try { - synchronized (function) { - while (running.get()) { - function.wait(timeout); - } - } - } catch (InterruptedException e) { - e.printStackTrace(); - } - if (run.value != null) { - throw run.value; - } - return function.value; - } + /** + * Make a synchronous method call and return the result + * + * @param function Method to call + * @param timeout Timeout (ms) + * @param Return type + * @return Method result + * @throws Exception If the call fails + */ + public abstract T sync(@Nonnull final Callable function, final int timeout) + throws Exception; - public abstract int taskRepeat(Runnable runnable, int interval); + /** + * Call a method synchronously and return a future with + * the result of the result + * + * @param method Method to be ran synchronously + * @param Return type + * @return Future completing with the result + */ + public abstract Future callMethodSync(@Nonnegative final Callable method); - public abstract int taskRepeatAsync(Runnable runnable, int interval); + /** + * Run a repeating synchronous task. If using a platform scheduler, + * this is guaranteed to run on the server thread + * + * @param runnable Task to run + * @param taskTime Task interval + * @return Created task object, can be used to cancel the task + */ + public abstract PlotSquaredTask taskRepeat(@Nonnull Runnable runnable, + @Nonnull TaskTime taskTime); - public abstract void taskAsync(Runnable runnable); + /** + * Run a repeating asynchronous task. This will never run on the + * server thread + * + * @param runnable Task to run + * @param taskTime Task interval + * @return Created task object, can be used to cancel the task + */ + public abstract PlotSquaredTask taskRepeatAsync(@Nonnull Runnable runnable, + @Nonnull TaskTime taskTime); - public abstract void task(Runnable runnable); + /** + * Run an asynchronous task. This will never run on the server thread + * + * @param runnable Task to run + */ + public abstract void taskAsync(@Nonnull Runnable runnable); - public abstract void taskLater(Runnable runnable, int delay); + /** + * Run a synchronous task. If using a platform scheduler, this is guaranteed + * to run on the server thread + * + * @param runnable Task to run + */ + public abstract void task(@Nonnull Runnable runnable); - public abstract void taskLaterAsync(Runnable runnable, int delay); + /** + * Run a synchronous task after a given delay. + * If using a platform scheduler, this is guaranteed to run on the server thread + * + * @param runnable Task to run + * @param taskTime Task delay + */ + public abstract void taskLater(@Nonnull Runnable runnable, @Nonnull TaskTime taskTime); + + /** + * Run an asynchronous task after a given delay. This will never + * run on the server thread + * + * @param runnable Task to run + * @param taskTime Task delay + */ + public abstract void taskLaterAsync(@Nonnull Runnable runnable, @Nonnull TaskTime taskTime); - public abstract void cancelTask(int task); } diff --git a/Core/src/main/java/com/plotsquared/core/util/task/TaskTime.java b/Core/src/main/java/com/plotsquared/core/util/task/TaskTime.java new file mode 100644 index 000000000..d11a0b111 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/util/task/TaskTime.java @@ -0,0 +1,150 @@ +/* + * _____ _ _ _____ _ + * | __ \| | | | / ____| | | + * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | + * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | + * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | + * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| + * | | + * |_| + * PlotSquared plot management system for Minecraft + * Copyright (C) 2020 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 . + */ +package com.plotsquared.core.util.task; + +import lombok.EqualsAndHashCode; +import lombok.ToString; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; + +/** + * Task timings + */ +@EqualsAndHashCode @ToString @SuppressWarnings("unused") +public final class TaskTime { + + private final long time; + private final TaskUnit unit; + + private TaskTime(@Nonnegative final long time, @Nonnull final TaskUnit unit) { + this.time = time; + this.unit = unit; + } + + /** + * Create a new task time in seconds + * + * @param seconds Seconds + * @return Created task time instance + */ + @Nonnull public static TaskTime seconds(@Nonnegative final long seconds) { + return new TaskTime(seconds * 1000L, TaskUnit.MILLISECONDS); + } + + /** + * Create a new task time in server ticks + * + * @param ticks Server ticks + * @return Created task time instance + */ + @Nonnull public static TaskTime ticks(@Nonnegative final long ticks) { + return new TaskTime(ticks, TaskUnit.TICKS); + } + + /** + * Create a new task time in milliseconds + * + * @param ms Milliseconds + * @return Created task time instance + */ + @Nonnull public static TaskTime ms(@Nonnegative final long ms) { + return new TaskTime(ms, TaskUnit.MILLISECONDS); + } + + /** + * Get the task time + * + * @return Task time + */ + @Nonnegative public long getTime() { + return this.time; + } + + /** + * Get the time unit + * + * @return Time unit + */ + @Nonnull public TaskUnit getUnit() { + return this.unit; + } + + + public enum TaskUnit { + TICKS, MILLISECONDS + } + + + public interface TimeConverter { + + /** + * Convert from milliseconds to server ticks + * + * @param ms Milliseconds + * @return Server ticks + */ + @Nonnegative long msToTicks(@Nonnegative final long ms); + + /** + * Convert from server ticks to milliseconds + * + * @param ticks Server ticks + * @return Milliseconds + */ + @Nonnegative long ticksToMs(@Nonnegative final long ticks); + + /** + * Convert the task time to server ticks + * + * @param taskTime Task time + * @return Server ticks + */ + @Nonnegative default long toTicks(@Nonnull final TaskTime taskTime) { + if (taskTime.getUnit() == TaskUnit.TICKS) { + return taskTime.getTime(); + } else { + return this.msToTicks(taskTime.getTime()); + } + } + + /** + * Convert the task time to milliseconds + * + * @param taskTime Task time + * @return Milliseconds + */ + @Nonnegative default long toMs(@Nonnull final TaskTime taskTime) { + if (taskTime.getUnit() == TaskUnit.MILLISECONDS) { + return taskTime.getTime(); + } else { + return this.ticksToMs(taskTime.getTime()); + } + } + + } + +}