Revert API

src/main/java/dev/plex/services/AbstractService.java

@@ -0,0 +1,31 @@
+package dev.plex.services;
+
+import dev.plex.PlexBase;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public abstract class AbstractService extends PlexBase implements IService
+{
+    private boolean asynchronous;
+    private boolean repeating;
+
+    @Setter
+    private int taskId;
+
+    public AbstractService(boolean repeating, boolean async)
+    {
+        this.repeating = repeating;
+        this.asynchronous = async;
+    }
+
+    public void onStart()
+    {
+
+    }
+
+    public void onEnd()
+    {
+
+    }
+}

src/main/java/dev/plex/services/IService.java

@@ -0,0 +1,8 @@
+package dev.plex.services;
+
+public interface IService
+{
+    void run();
+
+    int repeatInSeconds();
+}

src/main/java/dev/plex/services/ServiceManager.java

@@ -0,0 +1,99 @@
+package dev.plex.services;
+
+import com.google.common.collect.Lists;
+import dev.plex.Plex;
+import dev.plex.services.impl.*;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.List;
+
+public class ServiceManager
+{
+    private final List<AbstractService> services = Lists.newArrayList();
+
+    public ServiceManager()
+    {
+        registerService(new BanService());
+        registerService(new GameRuleService());
+        registerService(new UpdateCheckerService());
+        registerService(new AutoWipeService());
+        registerService(new CommandBlockerService());
+    }
+
+    public void startServices()
+    {
+        for (AbstractService service : services)
+        {
+            startService(service);
+        }
+    }
+
+    public void endServices()
+    {
+        services.forEach(this::endService);
+    }
+
+    public AbstractService getService(Class<? extends AbstractService> clazz)
+    {
+        return services.stream().filter(service -> service.getClass().isAssignableFrom(clazz)).findFirst().orElse(null);
+    }
+
+    public void startService(AbstractService service)
+    {
+        if (!service.isRepeating())
+        {
+            int time = service.repeatInSeconds();
+            BukkitTask task;
+            if (time == 0)
+            {
+                task = Bukkit.getScheduler().runTask(Plex.get(), service::run);
+            }
+            else
+            {
+                task = Bukkit.getScheduler().runTaskLater(Plex.get(), service::run, time);
+            }
+            service.setTaskId(task.getTaskId());
+        }
+        else if (service.isRepeating() && service.isAsynchronous())
+        {
+            BukkitTask task = Bukkit.getScheduler().runTaskTimerAsynchronously(Plex.get(), service::run, 0, 20L * service.repeatInSeconds());
+            service.setTaskId(task.getTaskId());
+        }
+        else if (service.isRepeating() && !service.isAsynchronous())
+        {
+            BukkitTask task = Bukkit.getScheduler().runTaskTimer(Plex.get(), service::run, 0, 20L * service.repeatInSeconds());
+            service.setTaskId(task.getTaskId());
+        }
+        if (!services.contains(service))
+        {
+            services.add(service);
+        }
+        service.onStart();
+    }
+
+    public void endService(AbstractService service, boolean remove)
+    {
+        Bukkit.getScheduler().cancelTask(service.getTaskId());
+        service.onEnd();
+        if (remove)
+        {
+            services.remove(service);
+        }
+    }
+
+    public void endService(AbstractService service)
+    {
+        endService(service, false);
+    }
+
+    private void registerService(AbstractService service)
+    {
+        services.add(service);
+    }
+
+    public int serviceCount()
+    {
+        return services.size();
+    }
+}

src/main/java/dev/plex/services/impl/AutoWipeService.java

@@ -0,0 +1,43 @@
+package dev.plex.services.impl;
+
+import dev.plex.Plex;
+import dev.plex.services.AbstractService;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+import java.util.List;
+
+public class AutoWipeService extends AbstractService
+{
+    public AutoWipeService()
+    {
+        super(true, false);
+    }
+
+    @Override
+    public void run()
+    {
+        if (Plex.get().config.getBoolean("autowipe.enabled"))
+        {
+            List<String> entities = plugin.config.getStringList("autowipe.entities");
+
+            for (World world : Bukkit.getWorlds())
+            {
+                for (Entity entity : world.getEntities())
+                {
+                    if (entities.stream().anyMatch(entityName -> entityName.equalsIgnoreCase(entity.getType().name())))
+                    {
+                        entity.remove();
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public int repeatInSeconds()
+    {
+        return Math.max(1, plugin.config.getInt("autowipe.interval"));
+    }
+}

src/main/java/dev/plex/services/impl/BanService.java

@@ -0,0 +1,38 @@
+package dev.plex.services.impl;
+
+import dev.plex.Plex;
+import dev.plex.services.AbstractService;
+import java.time.LocalDateTime;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+
+public class BanService extends AbstractService
+{
+    public BanService()
+    {
+        super(true, true);
+    }
+
+    @Override
+    public void run()
+    {
+        Plex.get().getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
+        {
+            punishments.forEach(punishment ->
+            {
+                if (LocalDateTime.now().isAfter(punishment.getEndDate()))
+                {
+                    Plex.get().getPunishmentManager().unban(punishment);
+                    Bukkit.broadcast(Component.text("Plex - Unbanned " + Bukkit.getOfflinePlayer(punishment.getPunished()).getName()));
+                }
+            });
+        });
+    }
+
+    @Override
+    public int repeatInSeconds()
+    {
+        // Every 5 minutes
+        return 300;
+    }
+}

src/main/java/dev/plex/services/impl/CommandBlockerService.java

@@ -0,0 +1,25 @@
+package dev.plex.services.impl;
+
+import dev.plex.services.AbstractService;
+import dev.plex.util.PlexLog;
+
+public class CommandBlockerService extends AbstractService
+{
+    public CommandBlockerService()
+    {
+        super(false, true);
+    }
+
+    @Override
+    public void run()
+    {
+        plugin.getCommandBlockerManager().syncCommands();
+        PlexLog.log("Command Blocker commands loaded");
+    }
+
+    @Override
+    public int repeatInSeconds()
+    {
+        return 0;
+    }
+}

src/main/java/dev/plex/services/impl/GameRuleService.java

@@ -0,0 +1,41 @@
+package dev.plex.services.impl;
+
+import dev.plex.services.AbstractService;
+import dev.plex.util.PlexLog;
+import dev.plex.util.PlexUtils;
+import java.util.Locale;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+public class GameRuleService extends AbstractService
+{
+    public GameRuleService()
+    {
+        super(false, true);
+    }
+
+    @Override
+    public void run()
+    {
+        for (World world : Bukkit.getWorlds())
+        {
+            PlexUtils.commitGlobalGameRules(world);
+            PlexLog.log("Set global gamerules for world: " + world.getName());
+        }
+        for (String world : plugin.config.getConfigurationSection("worlds").getKeys(false))
+        {
+            World bukkitWorld = Bukkit.getWorld(world);
+            if (bukkitWorld != null)
+            {
+                PlexUtils.commitSpecificGameRules(bukkitWorld);
+                PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
+            }
+        }
+    }
+
+    @Override
+    public int repeatInSeconds()
+    {
+        return 0;
+    }
+}

src/main/java/dev/plex/services/impl/UpdateCheckerService.java

@@ -0,0 +1,33 @@
+package dev.plex.services.impl;
+
+import dev.plex.services.AbstractService;
+import org.bukkit.Bukkit;
+
+public class UpdateCheckerService extends AbstractService
+{
+    private boolean newVersion = false;
+
+    public UpdateCheckerService()
+    {
+        super(true, true);
+    }
+
+    @Override
+    public void run()
+    {
+        if (!newVersion)
+        {
+            if (plugin.getUpdateChecker().getUpdateStatusMessage(Bukkit.getConsoleSender(), false, 1))
+            {
+                newVersion = true;
+            }
+        }
+    }
+
+    @Override
+    public int repeatInSeconds()
+    {
+        // Every 30 minutes
+        return 1800;
+    }
+}