@Override public int schedule(long delay, long period, Runnable task) { return Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, task, delay, period); }
/** * Attempts to cancel this task. * * @throws IllegalStateException if task was not scheduled yet */ public synchronized void cancel() throws IllegalStateException { Bukkit.getScheduler().cancelTask(getTaskId()); }
/** * Schedules this in the Bukkit scheduler to run on next tick. * * @param plugin the reference to the plugin scheduling task * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTask(Plugin, Runnable) */ public synchronized BukkitTask runTask(Plugin plugin) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTask(plugin, (Runnable) this)); }
/** * Schedules this to run after the specified number of server ticks. * * @param plugin the reference to the plugin scheduling task * @param delay the ticks to wait before running the task * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskLater(Plugin, Runnable, long) */ public synchronized BukkitTask runTaskLater(Plugin plugin, long delay) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskLater(plugin, (Runnable) this, delay)); }
/** * Schedules this to repeatedly run until cancelled, starting after the * specified number of server ticks. * * @param plugin the reference to the plugin scheduling task * @param delay the ticks to wait before running the task * @param period the ticks to wait between runs * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskTimer(Plugin, Runnable, long, long) */ public synchronized BukkitTask runTaskTimer(Plugin plugin, long delay, long period) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskTimer(plugin, (Runnable) this, delay, period)); }
/** * <b>Asynchronous tasks should never access any API in Bukkit. Great care * should be taken to assure the thread-safety of asynchronous tasks.</b> * <p> * Schedules this in the Bukkit scheduler to run asynchronously. * * @param plugin the reference to the plugin scheduling task * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskAsynchronously(Plugin, Runnable) */ public synchronized BukkitTask runTaskAsynchronously(Plugin plugin) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskAsynchronously(plugin, (Runnable) this)); }
/** * <b>Asynchronous tasks should never access any API in Bukkit. Great care * should be taken to assure the thread-safety of asynchronous tasks.</b> * <p> * Schedules this to run asynchronously after the specified number of * server ticks. * * @param plugin the reference to the plugin scheduling task * @param delay the ticks to wait before running the task * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskLaterAsynchronously(Plugin, Runnable, long) */ public synchronized BukkitTask runTaskLaterAsynchronously(Plugin plugin, long delay) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, (Runnable) this, delay)); }
/** * <b>Asynchronous tasks should never access any API in Bukkit. Great care * should be taken to assure the thread-safety of asynchronous tasks.</b> * <p> * Schedules this to repeatedly run asynchronously until cancelled, * starting after the specified number of server ticks. * * @param plugin the reference to the plugin scheduling task * @param delay the ticks to wait before running the task for the first * time * @param period the ticks to wait between runs * @return a BukkitTask that contains the id number * @throws IllegalArgumentException if plugin is null * @throws IllegalStateException if this was already scheduled * @see BukkitScheduler#runTaskTimerAsynchronously(Plugin, Runnable, long, * long) */ public synchronized BukkitTask runTaskTimerAsynchronously(Plugin plugin, long delay, long period) throws IllegalArgumentException, IllegalStateException { checkState(); return setupId(Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, (Runnable) this, delay, period)); }
/** * Saves the players current location, health, inventory, motion, and other information into the * username.dat file, in the world/player folder. * * @param async if true, save asynchronously; if false, block until saved */ public void saveData(boolean async) { if (async) { Bukkit.getScheduler().runTaskAsynchronously(null, () -> { server.getPlayerDataService().writeData(GlowPlayer.this); server.getPlayerStatisticIoService().writeStatistics(GlowPlayer.this); }); } else { server.getPlayerDataService().writeData(this); server.getPlayerStatisticIoService().writeStatistics(this); } }
&& !knownEntities.contains(entity) && !hiddenEntities.contains(entity.getUniqueId())) .forEach((entity) -> Bukkit.getScheduler() .runTaskAsynchronously(null, () -> { worldLock.readLock().lock();
/** * Cancel. */ public static void cancel() { if (taskId == -1) { return; } Bukkit.getScheduler().cancelTask(taskId); taskId = -1; }
public static void update(final Block b, final String name) { Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunStartup.instance, new Runnable() { @Override public void run() { ArmorStand hologram = getArmorStand(b); hologram.setCustomName(ChatColor.translateAlternateColorCodes('&', name)); } }); }
public static void checkTaskState() { if (flyMap.keySet().size() == 0) { Bukkit.getScheduler().cancelTask(flyid); flyid = - 1; } }
public void unregisterEffect(ClimateEffectType effectType) { ClimateEffect effect = effects.get(effectType); if (effect instanceof Listener) { HandlerList.unregisterAll((ListenerClimateEffect) effect); } if (effect instanceof ScheduleClimateEffect) { Bukkit.getScheduler().cancelTask(((ScheduleClimateEffect) effect).getTaskId()); } effectClasses.remove(effectType); effects.remove(effectType); }
public void start() { if (this.repeater != null) { return; } this.repeater = Bukkit.getScheduler().runTaskTimerAsynchronously(FunnyGuilds.getInstance(), this, 100, 20); }
public void addFirework(Firework firework) { fireworksLaunchedByPlugin.add(firework.getUniqueId()); // Schedule for removal to avoid creating memory leaks. Bukkit.getScheduler().runTaskLaterAsynchronously(advancedAchievements, () -> fireworksLaunchedByPlugin.remove(firework.getUniqueId()), 100); } }
@Override protected void scheduleChangeTask(String oldSkinUrl) { Runnable task = new SkinChanger(plugin, owner, url, oldSkinUrl, invoker); Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, task, 60 * 20L); } }
private void executeDelayedSync(@Nonnull Runnable runnable, long delayTicks) { if (delayTicks <= 0) { executeSync(runnable); } else { Bukkit.getScheduler().runTaskLater(LoaderUtils.getPlugin(), HelperExecutors.wrapRunnable(runnable), delayTicks); } }
@Override public void onDisable() { // Remove all Service Registrations getServer().getServicesManager().unregisterAll(this); Bukkit.getScheduler().cancelTasks(this); }
@EventHandler public void onPlayerJoin(PlayerJoinEvent joinEvent) { Player player = joinEvent.getPlayer(); Bukkit.getScheduler().runTaskLater(plugin, () -> { if (player.isOnline()) { addPlayer(player); } }, PING_INTERVAL); }