Plex 1.0.3

likely needs tweaking

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,77 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master, server ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '29 4 * * *'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+      
+    - name: Set up JDK 17
+      uses: actions/setup-java@v2
+      with:
+        distribution: temurin
+        java-version: 17
+        cache: gradle
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    - run: |
+       chmod +x gradlew
+       ./gradlew build --no-daemon
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

CONTRIBUTING.md

@@ -0,0 +1,23 @@
+For those who are wanting to contribute, we fully encourage doing so. There are a few rules we require following when contributing however.
+
+## Steps
+1. Make an isuse and get feedback. It's important to know if your idea will be accepted before writing any code.
+  - If it is a feature request, describe the feature and be extremely specific.
+  - If it is a bug report, ensure you include how to reproduce the bug and the expected outcome
+  - If it is an enhancement, describe your proposed changes. Ensure you are extremely specific.
+2. Fork Plex
+3. Create a new branch that describes the new feature, enhancement, or bug fix. For example, this is good: `feature/add-xyz`. This is bad: `fix-this-lol`.
+4. Write the code that addresses your change.
+  - Keep in mind that it **must** be formatted correctly. If you are using IntelliJ, there is a `codeStyle.xml` file that tells IntelliJ how to format your code. Check this link for information on how to use the file: https://www.jetbrains.com/help/idea/configuring-code-style.html#import-export-schemes
+5. Push your changes to your new branch and make a PR based off of that branch.
+
+## Requirements for a PR
+- The issue must be marked as approved
+- It must only address each specific issue. Don't make one PR for multiple issues.
+- Your PR must compile and work. If it does not compile or work, your PR will most likely be rejected.
+
+## Code requirements
+- Most importantly, your code must be efficient. Your pull request may be rejected if your code is deemed inefficient or sloppy.
+- Do not repeat yourself. Create functions as needed if you're using large blocks of code over and over again.
+- Do not use an excessive amount of commits when making your PR. It makes the master branch look messy.
+- Your code must be consistent with Plex's codebase. If a function already exists, use it.

Jenkinsfile

@@ -23,7 +23,7 @@ pipeline {
     }
     post {
         always {
-            archiveArtifacts artifacts: "build/libs/Plex.jar", fingerprint: true
+            archiveArtifacts artifacts: "build/libs/*.jar", fingerprint: true
             javadoc javadocDir: "build/docs/javadoc", keepAll: false
             discordSend description: "**Build:** ${env.BUILD_NUMBER}\n**Status:** ${currentBuild.currentResult}", enableArtifactsList: true, footer: "Built with Jenkins", link: env.BUILD_URL, result: currentBuild.currentResult, scmWebUrl: "https://github.com/plexusorg/Plex", showChangeset: true, title: env.JOB_NAME, webhookURL: env.PLEX_WEBHOOK_URL
             cleanWs()

build.gradle

@@ -58,29 +58,21 @@ dependencies {
 }
 
 group = "dev.plex"
-version = "1.0.1"
+version = "1.0.3"
 description = "Plex"
 
 shadowJar {
-    archiveBaseName.set("Plex")
     archiveClassifier.set("")
-    archiveVersion.set("")
     relocate "org.bstats", "dev.plex"
 }
 
-tasks.jar {
-    archiveBaseName.set("Plex")
-    archiveClassifier.set("notshaded")
-    archiveVersion.set("")
-}
-
 bukkit {
     name = "Plex"
     version = rootProject.version
     description = "Plex provides a new experience for freedom servers."
     main = "dev.plex.Plex"
     website = "https://plex.us.org"
-    authors = ["Telesphoreo", "taahanis", "super"]
+    authors = ["Telesphoreo", "taahanis", "supernt"]
     softDepend = ["Vault"]
     apiVersion = "1.18"
 }

src/main/java/dev/plex/Plex.java

@@ -21,13 +21,12 @@ import dev.plex.storage.player.MongoPlayerData;
 import dev.plex.storage.player.SQLPlayerData;
 import dev.plex.storage.punishment.SQLNotes;
 import dev.plex.storage.punishment.SQLPunishment;
+import dev.plex.util.BuildInfo;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.UpdateChecker;
 import dev.plex.world.CustomWorld;
 import java.io.File;
-import java.io.InputStream;
-import java.util.Properties;
 import lombok.Getter;
 import lombok.Setter;
 import net.milkbowl.vault.permission.Permission;
@@ -40,7 +39,6 @@ import org.bukkit.plugin.java.JavaPlugin;
 @Setter
 public class Plex extends JavaPlugin
 {
-    public static final BuildProperties build = new BuildProperties();
     private static Plex plugin;
 
     public Config config;
@@ -51,6 +49,8 @@ public class Plex extends JavaPlugin
     public File modulesFolder;
     private StorageType storageType = StorageType.SQLITE;
 
+    public static final BuildInfo build = new BuildInfo();
+
     private SQLConnection sqlConnection;
     private MongoConnection mongoConnection;
     private RedisConnection redisConnection;
@@ -241,37 +241,6 @@ public class Plex extends JavaPlugin
         });
     }
 
-    public static class BuildProperties
-    {
-        public String number;
-        public String author;
-        public String date;
-        public String head;
-
-        public void load(Plex plugin)
-        {
-            try
-            {
-                final Properties props;
-
-                try (InputStream in = plugin.getResource("build.properties"))
-                {
-                    props = new Properties();
-                    props.load(in);
-                }
-
-                number = props.getProperty("buildNumber", "unknown");
-                author = props.getProperty("buildAuthor", "unknown");
-                date = props.getProperty("buildDate", "unknown");
-                head = props.getProperty("buildHead", "unknown");
-            }
-            catch (Exception ex)
-            {
-                PlexLog.error("Could not load build properties! Did you compile with NetBeans/Maven?");
-            }
-        }
-    }
-
     public boolean setupPermissions()
     {
         RegisteredServiceProvider<Permission> rsp = Bukkit.getServicesManager().getRegistration(Permission.class);

src/main/java/dev/plex/PlexBase.java

@@ -1,6 +1,6 @@
 package dev.plex;
 
-public class PlexBase
+public interface PlexBase
 {
-    protected final static Plex plugin = Plex.get();
+    Plex plugin = Plex.get();
 }

src/main/java/dev/plex/admin/AdminList.java

@@ -25,7 +25,7 @@ import java.util.stream.Collectors;
  * @see Admin
  */
 
-public class AdminList extends PlexBase
+public class AdminList implements PlexBase
 {
     /**
      * Key / Value storage, where the key is the unique ID of the admin

src/main/java/dev/plex/command/PlexCommand.java

@@ -201,7 +201,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
             }
         }
         catch (PlayerNotFoundException | CommandFailException | ConsoleOnlyException |
-               ConsoleMustDefinePlayerException | PlayerNotBannedException ex)
+               ConsoleMustDefinePlayerException | PlayerNotBannedException | NumberFormatException ex)
         {
             send(sender, PlexUtils.mmDeserialize(ex.getMessage()));
         }

src/main/java/dev/plex/command/impl/BanCMD.java

@@ -14,7 +14,11 @@ import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.TimeUtils;
+import dev.plex.util.WebUtils;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.UUID;
 import net.kyori.adventure.text.Component;
@@ -38,7 +42,7 @@ public class BanCMD extends PlexCommand
             return usage();
         }
 
-        UUID targetUUID = PlexUtils.getFromName(args[0]);
+        UUID targetUUID = WebUtils.getFromName(args[0]);
 
         if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
         {
@@ -83,7 +87,7 @@ public class BanCMD extends PlexCommand
                 punishment.setReason("No reason provided.");
             }
             punishment.setPunishedUsername(plexPlayer.getName());
-            LocalDateTime date = LocalDateTime.now();
+            ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
             punishment.setEndDate(date.plusDays(1));
             punishment.setCustomTime(false);
             punishment.setActive(!isAdmin(plexPlayer));

src/main/java/dev/plex/command/impl/ConsoleSayCMD.java

@@ -15,7 +15,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandPermissions(level = Rank.ADMIN, permission = "plex.consolesay", source = RequiredCommandSource.CONSOLE)
 @CommandParameters(name = "consolesay", usage = "/<command> <message>", description = "Displays a message to everyone", aliases = "csay")
-public class ConsoleSayCommand extends PlexCommand
+public class ConsoleSayCMD extends PlexCommand
 {
     @Override
     protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)

src/main/java/dev/plex/command/impl/DebugCMD.java

@@ -6,6 +6,7 @@ import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.annotation.System;
 import dev.plex.rank.enums.Rank;
+import dev.plex.util.GameRuleUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import java.util.Arrays;
@@ -47,7 +48,7 @@ public class DebugCMD extends PlexCommand
         {
             for (World world : Bukkit.getWorlds())
             {
-                PlexUtils.commitGlobalGameRules(world);
+                GameRuleUtil.commitGlobalGameRules(world);
                 PlexLog.log("Set global gamerules for world: " + world.getName());
             }
             for (String world : plugin.config.getConfigurationSection("worlds").getKeys(false))
@@ -55,7 +56,7 @@ public class DebugCMD extends PlexCommand
                 World bukkitWorld = Bukkit.getWorld(world);
                 if (bukkitWorld != null)
                 {
-                    PlexUtils.commitSpecificGameRules(bukkitWorld);
+                    GameRuleUtil.commitSpecificGameRules(bukkitWorld);
                     PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
                 }
             }

src/main/java/dev/plex/command/impl/EntityWipeCMD.java

@@ -82,10 +82,6 @@ public class EntityWipeCMD extends PlexCommand
             list = list.replaceAll("(, )(?!.*\1)", (list.indexOf(", ") == list.lastIndexOf(", ") ? "" : ",") + " and ");
             PlexUtils.broadcast(messageComponent("removedEntitiesOfTypes", sender.getName(), entityCount, list));
         }
-
-        /*entityCounts.forEach((entityName, numRemoved) -> {
-            sender.sendMessage(messageComponent("removedEntitiesOfType", sender.getName(), numRemoved, entityName));
-        });*/
         return null;
     }
 

src/main/java/dev/plex/command/impl/FreezeCMD.java

@@ -10,7 +10,11 @@ import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.List;
+
+import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -51,7 +55,7 @@ public class FreezeCMD extends PlexCommand
 
         Punishment punishment = new Punishment(punishedPlayer.getUuid(), getUUID(sender));
         punishment.setCustomTime(false);
-        LocalDateTime date = LocalDateTime.now();
+        ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
         punishment.setEndDate(date.plusMinutes(5));
         punishment.setType(PunishmentType.FREEZE);
         punishment.setPunishedUsername(player.getName());

src/main/java/dev/plex/command/impl/KickCMD.java

@@ -11,7 +11,11 @@ import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.TimeUtils;
+import dev.plex.util.WebUtils;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.UUID;
 import net.kyori.adventure.text.Component;
 import org.apache.commons.lang.StringUtils;
@@ -33,7 +37,7 @@ public class KickCMD extends PlexCommand
             return usage();
         }
 
-        UUID targetUUID = PlexUtils.getFromName(args[0]);
+        UUID targetUUID = WebUtils.getFromName(args[0]);
         String reason = "No reason provided";
 
         if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
@@ -56,7 +60,7 @@ public class KickCMD extends PlexCommand
         }
 
         punishment.setPunishedUsername(plexPlayer.getName());
-        punishment.setEndDate(LocalDateTime.now());
+        punishment.setEndDate(ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)));
         punishment.setCustomTime(false);
         punishment.setActive(false);
         punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());

src/main/java/dev/plex/command/impl/MuteCMD.java

@@ -10,7 +10,11 @@ import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.List;
+
+import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -51,7 +55,7 @@ public class MuteCMD extends PlexCommand
 
         Punishment punishment = new Punishment(punishedPlayer.getUuid(), getUUID(sender));
         punishment.setCustomTime(false);
-        LocalDateTime date = LocalDateTime.now();
+        ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
         punishment.setEndDate(date.plusMinutes(5));
         punishment.setType(PunishmentType.MUTE);
         punishment.setPunishedUsername(player.getName());

src/main/java/dev/plex/command/impl/NameHistoryCMD.java

@@ -10,6 +10,7 @@ import dev.plex.util.AshconInfo;
 import dev.plex.util.MojangUtils;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.TimeUtils;
 import java.util.Arrays;
 import java.util.List;
 import net.kyori.adventure.text.Component;
@@ -42,12 +43,12 @@ public class NameHistoryCMD extends PlexCommand
         List<Component> historyList = Lists.newArrayList();
         Arrays.stream(info.getUsernameHistories()).forEach(history ->
         {
-            if (history.getLocalDateTime() != null)
+            if (history.getZonedDateTime() != null)
             {
                 historyList.add(
                         messageComponent("nameHistoryBody",
                                 history.getUsername(),
-                                PlexUtils.useTimezone(history.getLocalDateTime())));
+                                TimeUtils.useTimezone(history.getZonedDateTime())));
             }
             else
             {

src/main/java/dev/plex/command/impl/NotesCMD.java

@@ -9,7 +9,10 @@ import dev.plex.punishment.extra.Note;
 import dev.plex.rank.enums.Rank;
 import dev.plex.storage.StorageType;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.TimeUtils;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -74,7 +77,7 @@ public class NotesCMD extends PlexCommand
                 String content = StringUtils.join(ArrayUtils.subarray(args, 2, args.length), " ");
                 if (playerSender != null)
                 {
-                    Note note = new Note(plexPlayer.getUuid(), content, playerSender.getUniqueId(), LocalDateTime.now());
+                    Note note = new Note(plexPlayer.getUuid(), content, playerSender.getUniqueId(), ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)));
                     plexPlayer.getNotes().add(note);
                     if (plugin.getStorageType() != StorageType.MONGODB)
                     {
@@ -168,7 +171,7 @@ public class NotesCMD extends PlexCommand
         AtomicReference<Component> noteList = new AtomicReference<>(Component.text("Player notes for: " + plexPlayer.getName()).color(NamedTextColor.GREEN));
         for (Note note : notes)
         {
-            Component noteLine = mmString("<gold><!italic>" + note.getId() + " - Written by: " + DataUtils.getPlayer(note.getWrittenBy()).getName() + " on " + PlexUtils.useTimezone(note.getTimestamp()));
+            Component noteLine = mmString("<gold><!italic>" + note.getId() + " - Written by: " + DataUtils.getPlayer(note.getWrittenBy()).getName() + " on " + TimeUtils.useTimezone(note.getTimestamp()));
             noteLine = noteLine.append(mmString("<newline><yellow># " + note.getNote()));
             noteList.set(noteList.get().append(Component.newline()));
             noteList.set(noteList.get().append(noteLine));

src/main/java/dev/plex/command/impl/PlexCMD.java

@@ -9,13 +9,17 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.module.PlexModule;
 import dev.plex.module.PlexModuleFile;
 import dev.plex.rank.enums.Rank;
+import dev.plex.util.BuildInfo;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
+
+import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.apache.commons.lang.StringUtils;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -33,9 +37,9 @@ public class PlexCMD extends PlexCommand
         if (args.length == 0)
         {
             send(sender, mmString("<light_purple>Plex - A new freedom plugin."));
-            send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion() + " #" + Plex.build.number + " <light_purple>Git: <gold>" + Plex.build.head));
+            send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion() + " #" + BuildInfo.getNumber() + " <light_purple>Git: <gold>" + BuildInfo.getHead()));
             send(sender, mmString("<light_purple>Authors: <gold>Telesphoreo, Taahh"));
-            send(sender, mmString("<light_purple>Built by: <gold>" + Plex.build.author + " <light_purple>on <gold>" + Plex.build.date));
+            send(sender, mmString("<light_purple>Built by: <gold>" + BuildInfo.getAuthor() + " <light_purple>on <gold>" + BuildInfo.getDate()));
             send(sender, mmString("<light_purple>Run <gold>/plex modules <light_purple>to see a list of modules."));
             plugin.getUpdateChecker().getUpdateStatusMessage(sender, true, 2);
             return null;
@@ -62,6 +66,8 @@ public class PlexCMD extends PlexCommand
             plugin.getServiceManager().endServices();
             plugin.getServiceManager().startServices();
             PlexLog.debug("Restarted services");
+            TimeUtils.TIMEZONE = plugin.config.getString("server.timezone");
+            send(sender, "Set timezone to: " + TimeUtils.TIMEZONE);
             send(sender, "Plex successfully reloaded.");
             return null;
         }

src/main/java/dev/plex/command/impl/SmiteCMD.java

@@ -10,8 +10,12 @@ import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.Collections;
 import java.util.List;
+
+import dev.plex.util.TimeUtils;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.title.Title;
@@ -125,7 +129,7 @@ public class SmiteCMD extends PlexCommand
 
         Punishment punishment = new Punishment(plexPlayer.getUuid(), getUUID(sender));
         punishment.setCustomTime(false);
-        punishment.setEndDate(LocalDateTime.now());
+        punishment.setEndDate(ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)));
         punishment.setType(PunishmentType.SMITE);
         punishment.setPunishedUsername(player.getName());
         punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());

src/main/java/dev/plex/command/impl/TempbanCMD.java

@@ -12,6 +12,8 @@ import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.TimeUtils;
+import dev.plex.util.WebUtils;
 import java.util.List;
 import java.util.UUID;
 import net.kyori.adventure.text.Component;
@@ -35,7 +37,7 @@ public class TempbanCMD extends PlexCommand
             return usage();
         }
 
-        UUID targetUUID = PlexUtils.getFromName(args[0]);
+        UUID targetUUID = WebUtils.getFromName(args[0]);
         String reason;
 
         if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
@@ -64,7 +66,7 @@ public class TempbanCMD extends PlexCommand
             return messageComponent("playerBanned");
         }
         Punishment punishment = new Punishment(targetUUID, getUUID(sender));
-        punishment.setType(PunishmentType.BAN);
+        punishment.setType(PunishmentType.TEMPBAN);
         if (args.length > 2)
         {
             reason = StringUtils.join(args, " ", 2, args.length);
@@ -75,7 +77,7 @@ public class TempbanCMD extends PlexCommand
             punishment.setReason("No reason provided.");
         }
         punishment.setPunishedUsername(plexPlayer.getName());
-        punishment.setEndDate(PlexUtils.parseDateOffset(args[1]));
+        punishment.setEndDate(TimeUtils.createDate(args[1]));
         punishment.setCustomTime(false);
         punishment.setActive(!isAdmin(plexPlayer));
         if (player != null)

src/main/java/dev/plex/command/impl/UnbanCMD.java

@@ -11,6 +11,7 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.WebUtils;
 import java.util.List;
 import java.util.UUID;
 import net.kyori.adventure.text.Component;
@@ -34,7 +35,7 @@ public class UnbanCMD extends PlexCommand
 
         if (args.length == 1)
         {
-            UUID targetUUID = PlexUtils.getFromName(args[0]);
+            UUID targetUUID = WebUtils.getFromName(args[0]);
 
             if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
             {

src/main/java/dev/plex/config/ModuleConfig.java

@@ -23,21 +23,27 @@ public class ModuleConfig extends YamlConfiguration
     private File file;
 
     /**
-     * The file name
+     * Where the file is in the module JAR
      */
-    private String name;
+    private String from;
+
+    /**
+     * Where it should be copied to in the module folder
+     */
+    private String to;
 
     /**
      * Creates a config object
      *
      * @param module The module instance
-     * @param name   The file name
+     * @param to     The file name
      */
-    public ModuleConfig(PlexModule module, String name)
+    public ModuleConfig(PlexModule module, String from, String to)
     {
         this.module = module;
-        this.file = new File(module.getDataFolder(), name);
-        this.name = name;
+        this.file = new File(module.getDataFolder(), to);
+        this.to = to;
+        this.from = from;
 
         if (!file.exists())
         {
@@ -79,45 +85,11 @@ public class ModuleConfig extends YamlConfiguration
     {
         try
         {
-            Files.copy(module.getClass().getResourceAsStream("/" + name), this.file.toPath());
+            Files.copy(module.getClass().getResourceAsStream("/" + from), this.file.toPath());
         }
         catch (IOException e)
         {
             e.printStackTrace();
         }
-        /*if (name == null || name.equals("")) {
-            throw new IllegalArgumentException("ResourcePath cannot be null or empty");
-        }
-
-        name = name.replace('\\', '/');
-        InputStream in = module.getResource("/" + name);
-        if (in == null) {
-            throw new IllegalArgumentException("The embedded resource '" + name + "'");
-        }
-
-        File outFile = new File(module.getDataFolder(), name);
-        int lastIndex = name.lastIndexOf('/');
-        File outDir = new File(module.getDataFolder(), name.substring(0, lastIndex >= 0 ? lastIndex : 0));
-
-        if (!outDir.exists()) {
-            outDir.mkdirs();
-        }
-
-        try {
-            if (!outFile.exists()) {
-                OutputStream out = new FileOutputStream(outFile);
-                byte[] buf = new byte[1024];
-                int len;
-                while ((len = in.read(buf)) > 0) {
-                    out.write(buf, 0, len);
-                }
-                out.close();
-                in.close();
-            } else {
-                module.getLogger().log(org.apache.logging.log4j.Level.INFO, "Could not save " + outFile.getName() + " to " + outFile + " because " + outFile.getName() + " already exists.");
-            }
-        } catch (IOException ex) {
-            module.getLogger().log(Level.ERROR, "Could not save " + outFile.getName() + " to " + outFile, ex);
-        }*/
     }
 }

src/main/java/dev/plex/handlers/CommandHandler.java

@@ -5,16 +5,16 @@ import dev.plex.PlexBase;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.System;
 import dev.plex.util.PlexLog;
-import dev.plex.util.PlexUtils;
+import dev.plex.util.ReflectionsUtil;
 import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Set;
 
-public class CommandHandler extends PlexBase
+public class CommandHandler implements PlexBase
 {
     public CommandHandler()
     {
-        Set<Class<? extends PlexCommand>> commandSet = PlexUtils.getClassesBySubType("dev.plex.command.impl", PlexCommand.class);
+        Set<Class<? extends PlexCommand>> commandSet = ReflectionsUtil.getClassesBySubType("dev.plex.command.impl", PlexCommand.class);
         List<PlexCommand> commands = Lists.newArrayList();
 
         commandSet.forEach(clazz ->

src/main/java/dev/plex/handlers/ListenerHandler.java

@@ -6,15 +6,16 @@ import dev.plex.listener.PlexListener;
 import dev.plex.listener.annotation.Toggleable;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.ReflectionsUtil;
 import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Set;
 
-public class ListenerHandler extends PlexBase
+public class ListenerHandler implements PlexBase
 {
     public ListenerHandler()
     {
-        Set<Class<? extends PlexListener>> listenerSet = PlexUtils.getClassesBySubType("dev.plex.listener.impl", PlexListener.class);
+        Set<Class<? extends PlexListener>> listenerSet = ReflectionsUtil.getClassesBySubType("dev.plex.listener.impl", PlexListener.class);
         List<PlexListener> listeners = Lists.newArrayList();
 
         listenerSet.forEach(clazz ->

src/main/java/dev/plex/listener/PlexListener.java

@@ -3,7 +3,7 @@ package dev.plex.listener;
 import dev.plex.PlexBase;
 import org.bukkit.event.Listener;
 
-public abstract class PlexListener extends PlexBase implements Listener
+public abstract class PlexListener implements Listener, PlexBase
 {
     public PlexListener()
     {

src/main/java/dev/plex/listener/impl/AntiNukerListener.java

@@ -0,0 +1,42 @@
+package dev.plex.listener.impl;
+
+import dev.plex.listener.PlexListener;
+import dev.plex.services.impl.TimingService;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+public class AntiNukerListener extends PlexListener
+{
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onBlockPlace(BlockPlaceEvent event)
+    {
+        TimingService.nukerCooldown.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
+        if (getCount(event.getPlayer().getUniqueId()) > 200L)
+        {
+            TimingService.strikes.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
+            event.getPlayer().kick(Component.text("Please turn off your nuker!"));
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onBlockBreak(BlockBreakEvent event)
+    {
+        TimingService.nukerCooldown.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
+        if (getCount(event.getPlayer().getUniqueId()) > 200L)
+        {
+            TimingService.strikes.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
+            event.getPlayer().kick(Component.text("Please turn off your nuker!"));
+            event.setCancelled(true);
+        }
+    }
+
+    public long getCount(UUID uuid)
+    {
+        return TimingService.nukerCooldown.getOrDefault(uuid, 1L);
+    }
+}

src/main/java/dev/plex/listener/impl/AntiSpamListener.java

@@ -0,0 +1,41 @@
+package dev.plex.listener.impl;
+
+import dev.plex.listener.PlexListener;
+import dev.plex.services.impl.TimingService;
+import io.papermc.paper.event.player.AsyncChatEvent;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+
+public class AntiSpamListener extends PlexListener
+{
+    @EventHandler
+    public void onChat(AsyncChatEvent event)
+    {
+        TimingService.spamCooldown.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
+        if (getCount(event.getPlayer().getUniqueId()) > 8L)
+        {
+            event.getPlayer().sendMessage(Component.text("Please refrain from spamming messages.").color(NamedTextColor.GRAY));
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event)
+    {
+        TimingService.spamCooldown.merge(event.getPlayer().getUniqueId(), 1L, Long::sum);
+        if (getCount(event.getPlayer().getUniqueId()) > 8L)
+        {
+            event.getPlayer().sendMessage(Component.text("Please refrain from spamming commands.").color(NamedTextColor.GRAY));
+            event.setCancelled(true);
+        }
+    }
+
+    public long getCount(UUID uuid)
+    {
+        return TimingService.spamCooldown.getOrDefault(uuid, 1L);
+    }
+}

src/main/java/dev/plex/listener/impl/BanListener.java

@@ -37,7 +37,7 @@ public class BanListener extends PlexListener
         if (plugin.getPunishmentManager().isBanned(event.getUniqueId()))
         {
             PlexPlayer player = DataUtils.getPlayer(event.getUniqueId());
-            player.getPunishments().stream().filter(punishment -> punishment.getType() == PunishmentType.BAN && punishment.isActive()).findFirst().ifPresent(punishment ->
+            player.getPunishments().stream().filter(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive()).findFirst().ifPresent(punishment ->
                     event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
                             Punishment.generateBanMessage(punishment)));
         }

src/main/java/dev/plex/listener/impl/PlayerListener.java

@@ -5,6 +5,7 @@ import dev.plex.cache.PlayerCache;
 import dev.plex.listener.PlexListener;
 import dev.plex.player.PlexPlayer;
 import dev.plex.storage.StorageType;
+import dev.plex.util.PermissionsUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import java.util.Arrays;
@@ -80,7 +81,7 @@ public class PlayerListener<T> extends PlexListener
             PlexUtils.broadcast(PlexUtils.mmDeserialize("<aqua>" + player.getName() + " is " + loginMessage));
         }
 
-        PlexUtils.setupPermissions(player);
+        PermissionsUtil.setupPermissions(player);
 
         if (plugin.getStorageType() != StorageType.MONGODB)
         {

src/main/java/dev/plex/listener/impl/ServerListener.java

@@ -3,9 +3,11 @@ package dev.plex.listener.impl;
 import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
 import dev.plex.listener.PlexListener;
 import dev.plex.util.PlexUtils;
+import dev.plex.util.RandomUtil;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.event.EventHandler;
 
@@ -20,16 +22,17 @@ public class ServerListener extends PlexListener
         baseMotd = baseMotd.replace("%mcversion%", Bukkit.getBukkitVersion().split("-")[0]);
         if (plugin.config.getBoolean("server.colorize_motd"))
         {
-            final StringBuilder motd = new StringBuilder();
+            AtomicReference<Component> motd = new AtomicReference<>(Component.empty());
             for (final String word : baseMotd.split(" "))
             {
-                motd.append(PlexUtils.randomChatColor()).append(word).append(" ");
+                motd.set(motd.get().append(Component.text(word).color(RandomUtil.getRandomColor())));
+                motd.set(motd.get().append(Component.space()));
             }
-            event.motd(LegacyComponentSerializer.legacyAmpersand().deserialize(motd.toString().trim()));
+            event.motd(motd.get());
         }
         else
         {
-            event.motd(LegacyComponentSerializer.legacyAmpersand().deserialize(baseMotd.trim()));
+            event.motd(PlexUtils.mmDeserialize(baseMotd.trim()));
         }
         if (plugin.config.contains("server.sample"))
         {

src/main/java/dev/plex/listener/impl/WorldListener.java

@@ -12,101 +12,44 @@ import dev.plex.util.PlexUtils;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.PluginIdentifiableCommand;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.entity.EntitySpawnEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import org.bukkit.event.player.PlayerTeleportEvent;
 import org.jetbrains.annotations.NotNull;
 
 public class WorldListener extends PlexListener
 {
+    private final List<String> EDIT_COMMANDS = Arrays.asList("bigtree", "ebigtree", "largetree", "elargetree",
+            "break", "ebreak", "antioch", "nuke", "editsign", "tree", "etree");
+
     @EventHandler
     public void onBlockPlace(BlockPlaceEvent e)
     {
-        Player player = e.getPlayer();
-        PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
-        World world = player.getWorld();
-        if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        if (!checkPermission(e.getPlayer(), true))
         {
-            String permission = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".permission");
-            if (permission == null)
-            {
-                return;
-            }
-            if (player.hasPermission(permission))
-            {
-                return;
-            }
-        }
-        else if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            if (plugin.config.contains("worlds." + world.getName().toLowerCase() + ".requiredLevels"))
-            {
-                @NotNull List<String> requiredLevel = plugin.config.getStringList("worlds." + world.getName().toLowerCase() + ".requiredLevels");
-                if (checkLevel(plexPlayer, requiredLevel.toArray(String[]::new)))
-                {
-                    return;
-                }
-            }
-            else
-            {
-                return;
-            }
-        }
-
             e.setCancelled(true);
-        String noEdit = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".noEdit");
-        if (noEdit != null)
-        {
-            player.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(noEdit));
         }
     }
 
     @EventHandler
     public void onBlockBreak(BlockBreakEvent e)
     {
-        Player player = e.getPlayer();
-        PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
-        World world = player.getWorld();
-        if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        if (!checkPermission(e.getPlayer(), true))
         {
-            String permission = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".permission");
-            if (permission == null)
-            {
-                return;
-            }
-            if (player.hasPermission(permission))
-            {
-                return;
-            }
-        }
-        else if (plugin.getSystem().equalsIgnoreCase("ranks"))
-        {
-            if (plugin.config.contains("worlds." + world.getName().toLowerCase() + ".requiredLevels"))
-            {
-                @NotNull List<String> requiredLevel = plugin.config.getStringList("worlds." + world.getName().toLowerCase() + ".requiredLevels");
-                if (checkLevel(plexPlayer, requiredLevel.toArray(String[]::new)))
-                {
-                    return;
-                }
-            }
-            else
-            {
-                return;
-            }
-        }
-
             e.setCancelled(true);
-        String noEdit = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".noEdit");
-        if (noEdit != null)
-        {
-            player.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(noEdit));
         }
     }
 
@@ -120,6 +63,32 @@ public class WorldListener extends PlexListener
         e.setCancelled(true);
     }
 
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event)
+    {
+        // If the person has permission to modify the world, we don't need to block WorldEdit
+        if (checkPermission(event.getPlayer(), false))
+        {
+            return;
+        }
+
+        String message = event.getMessage();
+        // Don't check the arguments
+        message = message.replaceAll("\\s.*", "").replaceFirst("/", "");
+        Command command = Bukkit.getCommandMap().getCommand(message);
+        if (command != null)
+        {
+            // This does check for aliases
+            boolean isWeCommand = command instanceof PluginIdentifiableCommand && ((PluginIdentifiableCommand)command).getPlugin().equals(Bukkit.getPluginManager().getPlugin("WorldEdit"));
+            boolean isFaweCommand = command instanceof PluginIdentifiableCommand && ((PluginIdentifiableCommand)command).getPlugin().equals(Bukkit.getPluginManager().getPlugin("FastAsyncWorldEdit"));
+            if (isWeCommand || isFaweCommand || EDIT_COMMANDS.contains(message.toLowerCase()))
+            {
+                event.getPlayer().sendMessage(Component.text("You do not have permission to use that command in this world.").color(NamedTextColor.RED));
+                event.setCancelled(true);
+            }
+        }
+    }
+
     // TODO: Add an entry setting in the config.yml and allow checking for all worlds
     @EventHandler
     public void onWorldTeleport(PlayerTeleportEvent e)
@@ -136,7 +105,7 @@ public class WorldListener extends PlexListener
             {
                 e.setCancelled(true);
             }
-            else if (plugin.getSystem().equals("permissions") && !e.getPlayer().hasPermission("plex.enter.adminworld"))
+            else if (plugin.getSystem().equals("permissions") && !e.getPlayer().hasPermission("plex.adminworld.enter"))
             {
                 e.setCancelled(true);
             }
@@ -183,4 +152,47 @@ public class WorldListener extends PlexListener
         }
         return hasAccess;
     }
+
+    private boolean checkPermission(Player player, boolean showMessage)
+    {
+        PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
+        World world = player.getWorld();
+        if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        {
+            String permission = plugin.config.getString("plex." + world.getName().toLowerCase() + ".permission");
+            if (permission == null)
+            {
+                return true;
+            }
+            if (player.hasPermission(permission))
+            {
+                return true;
+            }
+        }
+        else if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        {
+            if (plugin.config.contains("worlds." + world.getName().toLowerCase() + ".requiredLevels"))
+            {
+                @NotNull List<String> requiredLevel = plugin.config.getStringList("worlds." + world.getName().toLowerCase() + ".requiredLevels");
+                if (checkLevel(plexPlayer, requiredLevel.toArray(String[]::new)))
+                {
+                    return true;
+                }
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        if (showMessage)
+        {
+            String noEdit = plugin.config.getString("worlds." + world.getName().toLowerCase() + ".noEdit");
+            if (noEdit != null)
+            {
+                player.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(noEdit));
+            }
+        }
+        return false;
+    }
 }

src/main/java/dev/plex/module/loader/LibraryLoader.java

@@ -47,7 +47,6 @@ import org.jetbrains.annotations.Nullable;
 
 public class LibraryLoader
 {
-
     private final Logger logger;
     private final RepositorySystem repository;
     private final DefaultRepositorySystemSession session;

src/main/java/dev/plex/player/PlexPlayer.java

@@ -12,11 +12,13 @@ import dev.plex.punishment.Punishment;
 import dev.plex.punishment.extra.Note;
 import dev.plex.rank.enums.Rank;
 import dev.plex.storage.StorageType;
-import dev.plex.util.adapter.LocalDateTimeSerializer;
 import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
+
+import dev.plex.util.adapter.ZonedDateTimeSerializer;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
@@ -140,6 +142,6 @@ public class PlexPlayer
 
     public String toJSON()
     {
-        return new GsonBuilder().registerTypeAdapter(LocalDateTime.class, new LocalDateTimeSerializer()).create().toJson(this);
+        return new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeSerializer()).create().toJson(this);
     }
 }

src/main/java/dev/plex/punishment/Punishment.java

@@ -5,10 +5,12 @@ import dev.morphia.annotations.Entity;
 import dev.plex.Plex;
 import dev.plex.util.MojangUtils;
 import dev.plex.util.PlexUtils;
-import dev.plex.util.adapter.LocalDateTimeDeserializer;
-import dev.plex.util.adapter.LocalDateTimeSerializer;
-import java.time.LocalDateTime;
+import dev.plex.util.TimeUtils;
+import java.time.ZonedDateTime;
 import java.util.UUID;
+
+import dev.plex.util.adapter.ZonedDateTimeDeserializer;
+import dev.plex.util.adapter.ZonedDateTimeSerializer;
 import lombok.Getter;
 import lombok.Setter;
 import net.kyori.adventure.text.Component;
@@ -27,7 +29,7 @@ public class Punishment
     private String reason;
     private boolean customTime;
     private boolean active; // Field is only for bans
-    private LocalDateTime endDate;
+    private ZonedDateTime endDate;
 
     public Punishment()
     {
@@ -43,9 +45,7 @@ public class Punishment
 
     public static Component generateBanMessage(Punishment punishment)
     {
-        return PlexUtils.messageComponent("banMessage", banUrl, punishment.getReason(),
-                PlexUtils.useTimezone(punishment.getEndDate()),
-                punishment.getPunisher() == null ? "CONSOLE" : MojangUtils.getInfo(punishment.getPunisher().toString()).getUsername());
+        return PlexUtils.messageComponent("banMessage", banUrl, punishment.getReason(), TimeUtils.useTimezone(punishment.getEndDate()), punishment.getPunisher() == null ? "CONSOLE" : MojangUtils.getInfo(punishment.getPunisher().toString()).getUsername());
     }
 
     public static Component generateIndefBanMessage(String type)
@@ -55,11 +55,11 @@ public class Punishment
 
     public static Punishment fromJson(String json)
     {
-        return new GsonBuilder().registerTypeAdapter(LocalDateTime.class, new LocalDateTimeDeserializer()).create().fromJson(json, Punishment.class);
+        return new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeDeserializer()).create().fromJson(json, Punishment.class);
     }
 
     public String toJSON()
     {
-        return new GsonBuilder().registerTypeAdapter(LocalDateTime.class, new LocalDateTimeSerializer()).create().toJson(this);
+        return new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeSerializer()).create().toJson(this);
     }
 }

src/main/java/dev/plex/punishment/PunishmentManager.java

@@ -14,19 +14,23 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.Collection;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
+
+import dev.plex.util.TimeUtils;
 import lombok.Data;
 import lombok.Getter;
 import org.apache.commons.io.FileUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.scheduler.BukkitRunnable;
 
-public class PunishmentManager extends PlexBase
+public class PunishmentManager implements PlexBase
 {
     @Getter
     private final List<IndefiniteBan> indefiniteBans = Lists.newArrayList();
@@ -129,17 +133,18 @@ public class PunishmentManager extends PlexBase
         {
             PlexPlayer player = DataUtils.getPlayer(uuid);
             player.loadPunishments();
-            return player.getPunishments().stream().anyMatch(punishment -> punishment.getType() == PunishmentType.BAN && punishment.isActive());
+            return player.getPunishments().stream().anyMatch(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive());
         });
     }
 
     public boolean isBanned(UUID uuid)
     {
+        // TODO: If a person is using MongoDB, this will error out because it is checking for bans on a player that doesn't exist yet
         /*if (!DataUtils.hasPlayedBefore(uuid))
         {
             return false;
         }*/
-        return DataUtils.getPlayer(uuid).getPunishments().stream().anyMatch(punishment -> punishment.getType() == PunishmentType.BAN && punishment.isActive());
+        return DataUtils.getPlayer(uuid).getPunishments().stream().anyMatch(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive());
     }
 
     public boolean isBanned(PlexPlayer player)
@@ -154,18 +159,18 @@ public class PunishmentManager extends PlexBase
             return CompletableFuture.supplyAsync(() ->
             {
                 List<PlexPlayer> players = Plex.get().getMongoPlayerData().getPlayers();
-                return players.stream().map(PlexPlayer::getPunishments).flatMap(Collection::stream).filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN).toList();
+                return players.stream().map(PlexPlayer::getPunishments).flatMap(Collection::stream).filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN).toList();
             });
         }
         else
         {
-            PlexLog.debug("Checking active bans mysql");
+            //PlexLog.debug("Checking active bans mysql");
             CompletableFuture<List<Punishment>> future = new CompletableFuture<>();
             Plex.get().getSqlPunishment().getPunishments().whenComplete((punishments, throwable) ->
             {
-                PlexLog.debug("Received Punishments");
-                List<Punishment> punishmentList = punishments.stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN).toList();
-                PlexLog.debug("Completing with {0} punishments", punishmentList.size());
+                //PlexLog.debug("Received Punishments");
+                List<Punishment> punishmentList = punishments.stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN).toList();
+                //PlexLog.debug("Completing with {0} punishments", punishmentList.size());
                 future.complete(punishmentList);
             });
             return future;
@@ -184,7 +189,7 @@ public class PunishmentManager extends PlexBase
             return CompletableFuture.runAsync(() ->
             {
                 PlexPlayer plexPlayer = DataUtils.getPlayer(uuid);
-                plexPlayer.setPunishments(plexPlayer.getPunishments().stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN)
+                plexPlayer.setPunishments(plexPlayer.getPunishments().stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN)
                         .peek(punishment -> punishment.setActive(false)).collect(Collectors.toList()));
                 DataUtils.update(plexPlayer);
             });
@@ -200,8 +205,8 @@ public class PunishmentManager extends PlexBase
         if (punishment.getType() == PunishmentType.FREEZE)
         {
             player.setFrozen(true);
-            LocalDateTime now = LocalDateTime.now();
-            LocalDateTime then = punishment.getEndDate();
+            ZonedDateTime now = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
+            ZonedDateTime then = punishment.getEndDate();
             long seconds = ChronoUnit.SECONDS.between(now, then);
             new BukkitRunnable()
             {
@@ -221,8 +226,8 @@ public class PunishmentManager extends PlexBase
         else if (punishment.getType() == PunishmentType.MUTE)
         {
             player.setMuted(true);
-            LocalDateTime now = LocalDateTime.now();
-            LocalDateTime then = punishment.getEndDate();
+            ZonedDateTime now = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
+            ZonedDateTime then = punishment.getEndDate();
             long seconds = ChronoUnit.SECONDS.between(now, then);
             new BukkitRunnable()
             {

src/main/java/dev/plex/punishment/PunishmentType.java

@@ -2,5 +2,5 @@ package dev.plex.punishment;
 
 public enum PunishmentType
 {
-    MUTE, FREEZE, BAN, KICK, SMITE
+    MUTE, FREEZE, BAN, KICK, SMITE, TEMPBAN
 }

src/main/java/dev/plex/punishment/extra/Note.java

@@ -2,9 +2,10 @@ package dev.plex.punishment.extra;
 
 import com.google.gson.GsonBuilder;
 import dev.morphia.annotations.Entity;
-import dev.plex.util.adapter.LocalDateTimeSerializer;
-import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
 import java.util.UUID;
+
+import dev.plex.util.adapter.ZonedDateTimeSerializer;
 import lombok.Data;
 
 @Data
@@ -14,12 +15,12 @@ public class Note
     private final UUID uuid;
     private final String note;
     private final UUID writtenBy;
-    private final LocalDateTime timestamp;
+    private final ZonedDateTime timestamp;
 
     private int id; // This will be automatically set from addNote
 
     public String toJSON()
     {
-        return new GsonBuilder().registerTypeAdapter(LocalDateTime.class, new LocalDateTimeSerializer()).create().toJson(this);
+        return new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeSerializer()).create().toJson(this);
     }
 }

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

@@ -5,7 +5,7 @@ import lombok.Getter;
 import lombok.Setter;
 
 @Getter
-public abstract class AbstractService extends PlexBase implements IService
+public abstract class AbstractService implements IService, PlexBase
 {
     private boolean asynchronous;
     private boolean repeating;

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

@@ -6,6 +6,7 @@ import dev.plex.services.impl.AutoWipeService;
 import dev.plex.services.impl.BanService;
 import dev.plex.services.impl.CommandBlockerService;
 import dev.plex.services.impl.GameRuleService;
+import dev.plex.services.impl.TimingService;
 import dev.plex.services.impl.UpdateCheckerService;
 import java.util.List;
 import org.bukkit.Bukkit;
@@ -17,11 +18,12 @@ public class ServiceManager
 
     public ServiceManager()
     {
-        registerService(new BanService());
-        registerService(new GameRuleService());
-        registerService(new UpdateCheckerService());
         registerService(new AutoWipeService());
+        registerService(new BanService());
         registerService(new CommandBlockerService());
+        registerService(new GameRuleService());
+        registerService(new TimingService());
+        registerService(new UpdateCheckerService());
     }
 
     public void startServices()

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

@@ -2,7 +2,9 @@ package dev.plex.services.impl;
 
 import dev.plex.Plex;
 import dev.plex.services.AbstractService;
-import java.time.LocalDateTime;
+import dev.plex.util.TimeUtils;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 
@@ -20,7 +22,7 @@ public class BanService extends AbstractService
         {
             punishments.forEach(punishment ->
             {
-                if (LocalDateTime.now().isAfter(punishment.getEndDate()))
+                if (ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)).isAfter(punishment.getEndDate()))
                 {
                     Plex.get().getPunishmentManager().unban(punishment);
                     Bukkit.broadcast(Component.text("Plex - Unbanned " + Bukkit.getOfflinePlayer(punishment.getPunished()).getName()));
@@ -32,7 +34,7 @@ public class BanService extends AbstractService
     @Override
     public int repeatInSeconds()
     {
-        // Every 5 minutes
-        return 300;
+        // Every 30 seconds
+        return 30;
     }
 }

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

@@ -1,6 +1,7 @@
 package dev.plex.services.impl;
 
 import dev.plex.services.AbstractService;
+import dev.plex.util.GameRuleUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import java.util.Locale;
@@ -19,7 +20,7 @@ public class GameRuleService extends AbstractService
     {
         for (World world : Bukkit.getWorlds())
         {
-            PlexUtils.commitGlobalGameRules(world);
+            GameRuleUtil.commitGlobalGameRules(world);
             PlexLog.log("Set global gamerules for world: " + world.getName());
         }
         for (String world : plugin.config.getConfigurationSection("worlds").getKeys(false))
@@ -27,7 +28,7 @@ public class GameRuleService extends AbstractService
             World bukkitWorld = Bukkit.getWorld(world);
             if (bukkitWorld != null)
             {
-                PlexUtils.commitSpecificGameRules(bukkitWorld);
+                GameRuleUtil.commitSpecificGameRules(bukkitWorld);
                 PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
             }
         }

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

@@ -0,0 +1,67 @@
+package dev.plex.services.impl;
+
+import dev.plex.cache.DataUtils;
+import dev.plex.player.PlexPlayer;
+import dev.plex.punishment.Punishment;
+import dev.plex.punishment.PunishmentType;
+import dev.plex.services.AbstractService;
+import dev.plex.util.PlexLog;
+import dev.plex.util.TimeUtils;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public class TimingService extends AbstractService
+{
+    public static final Map<UUID, Long> spamCooldown = new HashMap<>();
+    public static final Map<UUID, Long> nukerCooldown = new HashMap<>();
+    public static final Map<UUID, Long> strikes = new HashMap<>();
+
+    public TimingService()
+    {
+        super(true, true);
+    }
+
+    @Override
+    public void run()
+    {
+        spamCooldown.clear();
+        nukerCooldown.clear();
+        for (Map.Entry<UUID, Long> map : strikes.entrySet())
+        {
+            PlexLog.debug(map.getKey() + ": " + map.getValue());
+            // Tempban for 5 minutes and reset strikes. This will probably stop people from actually trying to use a Nuker to grief.
+            if (map.getValue() >= 2L)
+            {
+                issueBan(map);
+                strikes.remove(map.getKey());
+            }
+        }
+    }
+
+    private void issueBan(Map.Entry<UUID, Long> map)
+    {
+        Punishment punishment = new Punishment(map.getKey(), null);
+        Player player = Bukkit.getPlayer(map.getKey());
+        PlexPlayer plexPlayer = DataUtils.getPlayer(map.getKey());
+        punishment.setType(PunishmentType.TEMPBAN);
+        punishment.setReason("You are temporarily banned for five minutes for using a Nuker.");
+        if (player != null)
+        {
+            punishment.setPunishedUsername(player.getName());
+            punishment.setIp(player.getAddress().getAddress().getHostAddress());
+        }
+        punishment.setEndDate(TimeUtils.createDate("5m"));
+        punishment.setCustomTime(false);
+        punishment.setActive(!plexPlayer.isAdminActive());
+        plugin.getPunishmentManager().punish(plexPlayer, punishment);
+    }
+
+    @Override
+    public int repeatInSeconds()
+    {
+        return 5;
+    }
+}

src/main/java/dev/plex/storage/MongoConnection.java

@@ -9,7 +9,7 @@ import dev.plex.PlexBase;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 
-public class MongoConnection extends PlexBase
+public class MongoConnection implements PlexBase
 {
     // USE MORPHIA API FOR MONGO <3
 

src/main/java/dev/plex/storage/RedisConnection.java

@@ -5,7 +5,7 @@ import dev.plex.util.PlexLog;
 import java.util.function.Consumer;
 import redis.clients.jedis.Jedis;
 
-public class RedisConnection extends PlexBase
+public class RedisConnection implements PlexBase
 {
     private Jedis jedis;
 

src/main/java/dev/plex/storage/SQLConnection.java

@@ -10,7 +10,7 @@ import java.sql.SQLException;
 import lombok.Getter;
 
 @Getter
-public class SQLConnection extends PlexBase
+public class SQLConnection implements PlexBase
 {
     private HikariDataSource dataSource;
 

src/main/java/dev/plex/storage/player/SQLPlayerData.java

@@ -5,6 +5,9 @@ import com.google.gson.Gson;
 import dev.plex.Plex;
 import dev.plex.cache.PlayerCache;
 import dev.plex.player.PlexPlayer;
+import dev.plex.storage.StorageType;
+import dev.plex.util.PlexLog;
+
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
@@ -35,8 +38,7 @@ public class SQLPlayerData
             statement.setString(1, uuid.toString());
             ResultSet set = statement.executeQuery();
             return set.next();
-        }
-        catch (SQLException throwables)
+        } catch (SQLException throwables)
         {
             throwables.printStackTrace();
         }
@@ -51,8 +53,7 @@ public class SQLPlayerData
             statement.setString(1, username);
             ResultSet set = statement.executeQuery();
             return set.next();
-        }
-        catch (SQLException throwables)
+        } catch (SQLException throwables)
         {
             throwables.printStackTrace();
         }
@@ -103,8 +104,7 @@ public class SQLPlayerData
                 plexPlayer.setCommandSpy(commandspy);
             }
             return plexPlayer;
-        }
-        catch (SQLException throwables)
+        } catch (SQLException throwables)
         {
             throwables.printStackTrace();
         }
@@ -148,8 +148,7 @@ public class SQLPlayerData
                 return plexPlayer;
             }
             return null;
-        }
-        catch (SQLException throwables)
+        } catch (SQLException throwables)
         {
             throwables.printStackTrace();
         }
@@ -171,6 +170,8 @@ public class SQLPlayerData
             return player;
         }
 
+        if (Plex.get().getStorageType() == StorageType.MARIADB)
+        {
             try (Connection con = Plex.get().getSqlConnection().getCon())
             {
                 PreparedStatement statement = con.prepareStatement("select * from `players` where json_search(ips, ?, ?) IS NOT NULL LIMIT 1");
@@ -205,11 +206,55 @@ public class SQLPlayerData
                     plexPlayer.setCommandSpy(commandspy);
                 }
                 return plexPlayer;
-        }
-        catch (SQLException throwables)
+            } catch (SQLException throwables)
             {
                 throwables.printStackTrace();
             }
+        } else if (Plex.get().getStorageType() == StorageType.SQLITE)
+        {
+            PlexLog.warn("Querying a user by IP running SQLite can cause performance issues! Please try to switch to a remote DB ASAP!");
+            try (Connection con = Plex.get().getSqlConnection().getCon())
+            {
+                PreparedStatement statement = con.prepareStatement("select * from `players`");
+                ResultSet set = statement.executeQuery();
+
+                PlexPlayer plexPlayer = null;
+                while (set.next())
+                {
+                    List<String> ips = new Gson().fromJson(set.getString("ips"), new TypeToken<List<String>>()
+                    {
+                    }.getType());
+                    if (!ips.contains(ip))
+                    {
+                        continue;
+                    }
+                    String uuid = set.getString("uuid");
+                    String name = set.getString("name");
+                    String loginMSG = set.getString("login_msg");
+                    String prefix = set.getString("prefix");
+                    String rankName = set.getString("rank").toUpperCase();
+                    boolean adminActive = set.getBoolean("adminActive");
+                    long coins = set.getLong("coins");
+                    boolean vanished = set.getBoolean("vanished");
+                    boolean commandspy = set.getBoolean("commandspy");
+
+                    plexPlayer = new PlexPlayer(UUID.fromString(uuid));
+                    plexPlayer.setName(name);
+                    plexPlayer.setLoginMessage(loginMSG);
+                    plexPlayer.setPrefix(prefix);
+                    plexPlayer.setRank(rankName);
+                    plexPlayer.setAdminActive(adminActive);
+                    plexPlayer.setIps(ips);
+                    plexPlayer.setCoins(coins);
+                    plexPlayer.setVanished(vanished);
+                    plexPlayer.setCommandSpy(commandspy);
+                }
+                return plexPlayer;
+            } catch (SQLException throwables)
+            {
+                throwables.printStackTrace();
+            }
+        }
         return null;
     }
 
@@ -235,8 +280,7 @@ public class SQLPlayerData
             statement.setBoolean(9, player.isCommandSpy());
             statement.setString(10, player.getUuid().toString());
             statement.executeUpdate();
-        }
-        catch (SQLException throwables)
+        } catch (SQLException throwables)
         {
             throwables.printStackTrace();
         }
@@ -264,8 +308,7 @@ public class SQLPlayerData
             statement.setBoolean(9, player.isVanished());
             statement.setBoolean(10, player.isCommandSpy());
             statement.execute();
-        }
-        catch (SQLException throwables)
+        } catch (SQLException throwables)
         {
             throwables.printStackTrace();
         }

src/main/java/dev/plex/storage/punishment/SQLNotes.java

@@ -3,14 +3,13 @@ package dev.plex.storage.punishment;
 import com.google.common.collect.Lists;
 import dev.plex.Plex;
 import dev.plex.punishment.extra.Note;
+import dev.plex.util.TimeUtils;
+
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneId;
-import java.time.ZoneOffset;
+import java.time.*;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -37,7 +36,7 @@ public class SQLNotes
                             uuid,
                             set.getString("note"),
                             UUID.fromString(set.getString("written_by")),
-                            LocalDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("timestamp")), ZoneId.systemDefault())
+                            ZonedDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("timestamp")), ZoneId.of(TimeUtils.TIMEZONE))
                     );
                     note.setId(set.getInt("id"));
                     notes.add(note);
@@ -83,7 +82,7 @@ public class SQLNotes
                     statement.setString(2, note.getUuid().toString());
                     statement.setString(3, note.getWrittenBy().toString());
                     statement.setString(4, note.getNote());
-                    statement.setLong(5, note.getTimestamp().toInstant(ZoneOffset.UTC).toEpochMilli());
+                    statement.setLong(5, note.getTimestamp().toInstant().toEpochMilli());
                     statement.execute();
                     note.setId(notes.size());
                 }

src/main/java/dev/plex/storage/punishment/SQLPunishment.java

@@ -5,14 +5,15 @@ import dev.plex.Plex;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
 import dev.plex.util.PlexLog;
+import dev.plex.util.TimeUtils;
+
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.Instant;
-import java.time.LocalDateTime;
 import java.time.ZoneId;
-import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -41,13 +42,12 @@ public class SQLPunishment
                     punishment.setType(PunishmentType.valueOf(set.getString("type")));
                     punishment.setCustomTime(set.getBoolean("customTime"));
                     punishment.setPunishedUsername(set.getString("punishedUsername"));
-                    punishment.setEndDate(LocalDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("endDate")), ZoneId.systemDefault()));
+                    punishment.setEndDate(ZonedDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("endDate")), ZoneId.of(TimeUtils.TIMEZONE)));
                     punishment.setReason(set.getString("reason"));
                     punishment.setIp(set.getString("ip"));
                     punishments.add(punishment);
                 }
-            }
-            catch (SQLException e)
+            } catch (SQLException e)
             {
                 e.printStackTrace();
                 return punishments;
@@ -71,13 +71,12 @@ public class SQLPunishment
                 punishment.setType(PunishmentType.valueOf(set.getString("type")));
                 punishment.setCustomTime(set.getBoolean("customTime"));
                 punishment.setPunishedUsername(set.getString("punishedUsername"));
-                punishment.setEndDate(LocalDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("endDate")), ZoneId.systemDefault()));
+                punishment.setEndDate(ZonedDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("endDate")), ZoneId.of(TimeUtils.TIMEZONE)));
                 punishment.setReason(set.getString("reason"));
                 punishment.setIp(set.getString("ip"));
                 punishments.add(punishment);
             }
-        }
-        catch (SQLException e)
+        } catch (SQLException e)
         {
             e.printStackTrace();
         }
@@ -101,11 +100,10 @@ public class SQLPunishment
                 statement.setString(6, punishment.getReason());
                 statement.setBoolean(7, punishment.isCustomTime());
                 statement.setBoolean(8, punishment.isActive());
-                statement.setLong(9, punishment.getEndDate().toInstant(ZoneOffset.UTC).toEpochMilli());
+                statement.setLong(9, punishment.getEndDate().toInstant().toEpochMilli());
                 PlexLog.debug("Executing punishment");
                 statement.execute();
-            }
-            catch (SQLException e)
+            } catch (SQLException e)
             {
                 e.printStackTrace();
             }
@@ -121,8 +119,14 @@ public class SQLPunishment
             statement.setBoolean(2, true);
             statement.setString(3, uuid.toString());
             statement.setString(4, PunishmentType.BAN.name());
-        }
-        catch (SQLException e)
+
+            PreparedStatement statement1 = con.prepareStatement(UPDATE_BAN);
+            statement1.setBoolean(1, false);
+            statement1.setBoolean(2, true);
+            statement1.setString(3, uuid.toString());
+            statement1.setString(4, PunishmentType.TEMPBAN.name());
+            statement1.executeUpdate();
+        } catch (SQLException e)
         {
             e.printStackTrace();
         }
@@ -140,8 +144,14 @@ public class SQLPunishment
                 statement.setString(3, uuid.toString());
                 statement.setString(4, PunishmentType.BAN.name());
                 statement.executeUpdate();
-            }
-            catch (SQLException e)
+
+                PreparedStatement statement1 = con.prepareStatement(UPDATE_BAN);
+                statement1.setBoolean(1, false);
+                statement1.setBoolean(2, true);
+                statement1.setString(3, uuid.toString());
+                statement1.setString(4, PunishmentType.TEMPBAN.name());
+                statement1.executeUpdate();
+            } catch (SQLException e)
             {
                 e.printStackTrace();
             }

src/main/java/dev/plex/util/AshconInfo.java

@@ -2,6 +2,8 @@ package dev.plex.util;
 
 import com.google.gson.annotations.SerializedName;
 import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -25,7 +27,7 @@ public class AshconInfo
     {
         private String username;
         @SerializedName("changed_at")
-        private LocalDateTime localDateTime;
+        private ZonedDateTime zonedDateTime;
     }
 
     @Getter

src/main/java/dev/plex/util/BuildInfo.java

@@ -0,0 +1,39 @@
+package dev.plex.util;
+
+import dev.plex.Plex;
+import java.io.InputStream;
+import java.util.Properties;
+import lombok.Getter;
+
+public class BuildInfo
+{
+    @Getter
+    public static String number;
+    @Getter
+    public static String author;
+    @Getter
+    public static String date;
+    @Getter
+    public static String head;
+
+    public void load(Plex plugin)
+    {
+        try
+        {
+            Properties props;
+            try (InputStream in = plugin.getResource("build.properties"))
+            {
+                props = new Properties();
+                props.load(in);
+            }
+
+            number = props.getProperty("buildNumber", "unknown");
+            author = props.getProperty("buildAuthor", "unknown");
+            date = props.getProperty("buildDate", "unknown");
+            head = props.getProperty("buildHead", "unknown");
+        }
+        catch (Exception ignored)
+        {
+        }
+    }
+}

src/main/java/dev/plex/util/GameRuleUtil.java

@@ -0,0 +1,56 @@
+package dev.plex.util;
+
+import dev.plex.Plex;
+import java.util.Locale;
+import org.apache.commons.lang.math.NumberUtils;
+import org.bukkit.GameRule;
+import org.bukkit.World;
+
+public class GameRuleUtil
+{
+    public static <T> void commitGlobalGameRules(World world)
+    {
+        for (String s : Plex.get().config.getStringList("global_gamerules"))
+        {
+            readGameRules(world, s);
+        }
+    }
+
+    public static <T> void commitSpecificGameRules(World world)
+    {
+        for (String s : Plex.get().config.getStringList("worlds." + world.getName().toLowerCase(Locale.ROOT) + ".gameRules"))
+        {
+            readGameRules(world, s);
+        }
+    }
+
+    private static <T> void readGameRules(World world, String s)
+    {
+        String gameRule = s.split(";")[0];
+        T value = (T)s.split(";")[1];
+        GameRule<T> rule = (GameRule<T>)GameRule.getByName(gameRule);
+        if (rule != null && check(value).getClass().equals(rule.getType()))
+        {
+            world.setGameRule(rule, value);
+            PlexLog.debug("Setting game rule " + gameRule + " for world " + world.getName() + " with value " + value);
+        }
+        else
+        {
+            PlexLog.error(String.format("Failed to set game rule %s for world %s with value %s!", gameRule, world.getName().toLowerCase(Locale.ROOT), value));
+        }
+    }
+
+    public static <T> Object check(T value)
+    {
+        if (value.toString().equalsIgnoreCase("true") || value.toString().equalsIgnoreCase("false"))
+        {
+            return Boolean.parseBoolean(value.toString());
+        }
+
+        if (NumberUtils.isNumber(value.toString()))
+        {
+            return Integer.parseInt(value.toString());
+        }
+        return value;
+    }
+}

src/main/java/dev/plex/util/MojangUtils.java

@@ -7,8 +7,11 @@ import java.nio.charset.StandardCharsets;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
+
+import dev.plex.Plex;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.impl.client.CloseableHttpClient;
@@ -37,16 +40,16 @@ public class MojangUtils
                 return null;
             }
             client.close();
-            AshconInfo ashconInfo = new GsonBuilder().registerTypeAdapter(LocalDateTime.class, (JsonDeserializer<LocalDateTime>)(json1, typeOfT, context) ->
-                    LocalDateTime.ofInstant(Instant.from(DateTimeFormatter.ISO_INSTANT.parse(json1.getAsJsonPrimitive().getAsString())), ZoneId.systemDefault())).create().fromJson(json, AshconInfo.class);
+            AshconInfo ashconInfo = new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, (JsonDeserializer<ZonedDateTime>)(json1, typeOfT, context) ->
+                    ZonedDateTime.ofInstant(Instant.from(DateTimeFormatter.ISO_INSTANT.parse(json1.getAsJsonPrimitive().getAsString())), ZoneId.of(Plex.get().config.getString("server.timezone")))).create().fromJson(json, AshconInfo.class);
 
             Arrays.sort(ashconInfo.getUsernameHistories(), (o1, o2) ->
             {
-                if (o1.getLocalDateTime() == null || o2.getLocalDateTime() == null)
+                if (o1.getZonedDateTime() == null || o2.getZonedDateTime() == null)
                 {
                     return 1;
                 }
-                return o1.getLocalDateTime().compareTo(o2.getLocalDateTime());
+                return o1.getZonedDateTime().compareTo(o2.getZonedDateTime());
             });
 
             return ashconInfo;

src/main/java/dev/plex/util/PermissionsUtil.java

@@ -0,0 +1,65 @@
+package dev.plex.util;
+
+import dev.plex.Plex;
+import dev.plex.cache.DataUtils;
+import dev.plex.permission.Permission;
+import dev.plex.player.PlexPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.PermissionAttachment;
+import org.jetbrains.annotations.NotNull;
+
+public class PermissionsUtil
+{
+    public static void setupPermissions(@NotNull Player player)
+    {
+        PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
+        PermissionAttachment attachment = player.addAttachment(Plex.get());
+        plexPlayer.getPermissions().forEach(permission -> attachment.setPermission(permission.getPermission(), permission.isAllowed()));
+        plexPlayer.setPermissionAttachment(attachment);
+    }
+
+    public static void addPermission(PlexPlayer player, Permission permission)
+    {
+        Plex.get().getSqlPermissions().addPermission(PlexUtils.addToArrayList(player.getPermissions(), permission));
+        Player p = Bukkit.getPlayer(player.getUuid());
+        if (p == null)
+        {
+            return;
+        }
+        player.getPermissionAttachment().setPermission(permission.getPermission(), permission.isAllowed());
+    }
+
+    public static void addPermission(PlexPlayer player, String permission)
+    {
+        addPermission(player, new Permission(player.getUuid(), permission));
+    }
+
+    public static void removePermission(PlexPlayer player, String permission)
+    {
+        Plex.get().getSqlPermissions().removePermission(player.getUuid(), permission);
+        player.getPermissions().removeIf(permission1 -> permission1.getPermission().equalsIgnoreCase(permission));
+        Player p = Bukkit.getPlayer(player.getUuid());
+        if (p == null)
+        {
+            return;
+        }
+        player.getPermissionAttachment().unsetPermission(permission);
+    }
+
+    public static void updatePermission(PlexPlayer player, String permission, boolean newValue)
+    {
+        player.getPermissions().stream().filter(permission1 -> permission.equalsIgnoreCase(permission)).findFirst().ifPresent(permission1 ->
+        {
+            Plex.get().getSqlPermissions().updatePermission(permission1, newValue);
+        });
+        player.getPermissions().removeIf(permission1 -> permission1.getPermission().equalsIgnoreCase(permission));
+        Player p = Bukkit.getPlayer(player.getUuid());
+        if (p == null)
+        {
+            return;
+        }
+        player.getPermissionAttachment().unsetPermission(permission);
+
+    }
+}

src/main/java/dev/plex/util/PlexLog.java

@@ -34,7 +34,21 @@ public class PlexLog
                 message = message.replace("{" + i + "}", strings[i].toString());
             }
         }
-        Bukkit.getConsoleSender().sendMessage(String.format(ChatColor.RED + "[Plex Error] " + ChatColor.GOLD + "%s", message));
+        Bukkit.getConsoleSender().sendMessage(PlexUtils.mmDeserialize("<red>[Plex Error] <gold>" + message));
+//        Bukkit.getConsoleSender().sendMessage(String.format(ChatColor.RED + "[Plex Error] " + ChatColor.GOLD + "%s", message));
+    }
+
+    public static void warn(String message, Object... strings)
+    {
+        for (int i = 0; i < strings.length; i++)
+        {
+            if (message.contains("{" + i + "}"))
+            {
+                message = message.replace("{" + i + "}", strings[i].toString());
+            }
+        }
+//        Bukkit.getConsoleSender().sendMessage(String.format(ChatColor.YELLOW + "[Plex Warning] " + ChatColor.GOLD + "%s", message));
+        Bukkit.getConsoleSender().sendMessage(PlexUtils.mmDeserialize("<#eb7c0e>[Plex Warning] <gold>" + message));
     }
 
     public static void debug(String message, Object... strings)
@@ -48,7 +62,8 @@ public class PlexLog
         }
         if (Plex.get().config.getBoolean("debug"))
         {
-            Bukkit.getConsoleSender().sendMessage(String.format(ChatColor.DARK_PURPLE + "[Plex Debug] " + ChatColor.GOLD + "%s", message));
+            Bukkit.getConsoleSender().sendMessage(PlexUtils.mmDeserialize("<dark_purple>[Plex Debug] <gold>" + message));
+//            Bukkit.getConsoleSender().sendMessage(String.format(ChatColor.DARK_PURPLE + "[Plex Debug] " + ChatColor.GOLD + "%s", message));
         }
     }
 }

src/main/java/dev/plex/util/PlexUtils.java

@@ -1,40 +1,20 @@
 package dev.plex.util;
 
-import com.google.common.collect.ImmutableSet;
-import com.google.common.reflect.ClassPath;
 import dev.plex.Plex;
 import dev.plex.PlexBase;
-import dev.plex.cache.DataUtils;
 import dev.plex.cache.PlayerCache;
-import dev.plex.config.Config;
-import dev.plex.permission.Permission;
-import dev.plex.player.PlexPlayer;
 import dev.plex.storage.StorageType;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.net.HttpURLConnection;
-import java.net.URL;
 import java.sql.Connection;
 import java.sql.SQLException;
-import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.Month;
 import java.time.ZoneId;
-import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
+import java.time.ZonedDateTime;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.Date;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Random;
-import java.util.Set;
-import java.util.TimeZone;
-import java.util.UUID;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
 import net.kyori.adventure.text.Component;
@@ -42,111 +22,25 @@ import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
-import org.apache.commons.lang.math.NumberUtils;
+import org.apache.commons.lang.time.DateUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
-import org.bukkit.GameRule;
 import org.bukkit.Location;
-import org.bukkit.Material;
 import org.bukkit.Particle;
-import org.bukkit.World;
 import org.bukkit.command.Command;
 import org.bukkit.command.PluginCommandYamlParser;
 import org.bukkit.entity.Player;
-import org.bukkit.permissions.PermissionAttachment;
 import org.bukkit.plugin.Plugin;
-import org.jetbrains.annotations.NotNull;
-import org.json.simple.JSONObject;
-import org.json.simple.parser.JSONParser;
-import org.json.simple.parser.ParseException;
 
-public class PlexUtils extends PlexBase
+public class PlexUtils implements PlexBase
 {
-    private static final Random RANDOM;
-    private static final List<String> regxList = new ArrayList<>()
-    {{
-        add("y");
-        add("mo");
-        add("w");
-        add("d");
-        add("h");
-        add("m");
-        add("s");
-    }};
-    public static Map<String, ChatColor> CHAT_COLOR_NAMES;
-    public static List<ChatColor> CHAT_COLOR_POOL;
     public static List<String> DEVELOPERS =
             Arrays.asList("78408086-1991-4c33-a571-d8fa325465b2", // Telesphoreo
                     "f5cd54c4-3a24-4213-9a56-c06c49594dff", // Taahh
+                    "53b1512e-3481-4702-9f4f-63cb9c8be6a1", // supernt
                     "ca83b658-c03b-4106-9edc-72f70a80656d", // ayunami2000
-                    "2e06e049-24c8-42e4-8bcf-d35372af31e6" //Fleek
+                    "2e06e049-24c8-42e4-8bcf-d35372af31e6" // Fleek
             );
-    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("MM/dd/yyyy 'at' hh:mm:ss a z");
-    private static final Set<String> TIMEZONES = Set.of(TimeZone.getAvailableIDs());
-    private static String TIMEZONE = Plex.get().config.getString("server.timezone");
-
-    static
-    {
-        RANDOM = new Random();
-        CHAT_COLOR_NAMES = new HashMap<>();
-        CHAT_COLOR_POOL = Arrays.asList(ChatColor.DARK_RED, ChatColor.RED, ChatColor.GOLD, ChatColor.YELLOW, ChatColor.GREEN, ChatColor.DARK_GREEN, ChatColor.AQUA, ChatColor.DARK_AQUA, ChatColor.BLUE, ChatColor.DARK_BLUE, ChatColor.DARK_PURPLE, ChatColor.LIGHT_PURPLE);
-        for (final ChatColor chatColor : CHAT_COLOR_POOL)
-        {
-            CHAT_COLOR_NAMES.put(chatColor.name().toLowerCase().replace("_", ""), chatColor);
-        }
-    }
-
-    public static void setupPermissions(@NotNull Player player)
-    {
-        PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
-        PermissionAttachment attachment = player.addAttachment(Plex.get());
-        plexPlayer.getPermissions().forEach(permission -> attachment.setPermission(permission.getPermission(), permission.isAllowed()));
-        plexPlayer.setPermissionAttachment(attachment);
-    }
-
-    public static void addPermission(PlexPlayer player, Permission permission)
-    {
-        Plex.get().getSqlPermissions().addPermission(addToArrayList(player.getPermissions(), permission));
-        Player p = Bukkit.getPlayer(player.getUuid());
-        if (p == null)
-        {
-            return;
-        }
-        player.getPermissionAttachment().setPermission(permission.getPermission(), permission.isAllowed());
-    }
-
-    public static void addPermission(PlexPlayer player, String permission)
-    {
-        addPermission(player, new Permission(player.getUuid(), permission));
-    }
-
-    public static void removePermission(PlexPlayer player, String permission)
-    {
-        Plex.get().getSqlPermissions().removePermission(player.getUuid(), permission);
-        player.getPermissions().removeIf(permission1 -> permission1.getPermission().equalsIgnoreCase(permission));
-        Player p = Bukkit.getPlayer(player.getUuid());
-        if (p == null)
-        {
-            return;
-        }
-        player.getPermissionAttachment().unsetPermission(permission);
-    }
-
-    public static void updatePermission(PlexPlayer player, String permission, boolean newValue)
-    {
-        player.getPermissions().stream().filter(permission1 -> permission.equalsIgnoreCase(permission)).findFirst().ifPresent(permission1 ->
-        {
-            Plex.get().getSqlPermissions().updatePermission(permission1, newValue);
-        });
-        player.getPermissions().removeIf(permission1 -> permission1.getPermission().equalsIgnoreCase(permission));
-        Player p = Bukkit.getPlayer(player.getUuid());
-        if (p == null)
-        {
-            return;
-        }
-        player.getPermissionAttachment().unsetPermission(permission);
-
-    }
 
     public static <T> T addToArrayList(List<T> list, T object)
     {
@@ -171,11 +65,6 @@ public class PlexUtils extends PlexBase
         players[0].getWorld().playSound(location, org.bukkit.Sound.BLOCK_FIRE_EXTINGUISH, 0.5f, 0.5f);
     }
 
-    public static ChatColor randomChatColor()
-    {
-        return CHAT_COLOR_POOL.get(RANDOM.nextInt(CHAT_COLOR_POOL.size()));
-    }
-
     public static void testConnections()
     {
         if (Plex.get().getSqlConnection().getDataSource() != null)
@@ -228,11 +117,6 @@ public class PlexUtils extends PlexBase
         return false;
     }
 
-    public static String colorize(final String string)
-    {
-        return ChatColor.translateAlternateColorCodes('&', string);
-    }
-
     private static final MiniMessage safeMessage = MiniMessage.builder().tags(TagResolver.builder().resolvers(
             StandardTags.color(),
             StandardTags.decorations(),
@@ -253,7 +137,7 @@ public class PlexUtils extends PlexBase
         {
             aprilFools = plugin.config.getBoolean("april_fools");
         }
-        LocalDateTime date = LocalDateTime.now();
+        ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
         if (aprilFools && date.getMonth() == Month.APRIL && date.getDayOfMonth() == 1)
         {
             Component component = MiniMessage.miniMessage().deserialize(input); // removes existing tags
@@ -286,148 +170,6 @@ public class PlexUtils extends PlexBase
         return f;
     }
 
-    private static long a(String parse)
-    {
-        StringBuilder sb = new StringBuilder();
-
-        regxList.forEach(obj ->
-        {
-            if (parse.endsWith(obj))
-            {
-                sb.append(parse.split(obj)[0]);
-            }
-        });
-
-        return Long.parseLong(sb.toString());
-    }
-
-    private static TimeUnit verify(String arg)
-    {
-        TimeUnit unit = null;
-        for (String c : regxList)
-        {
-            if (arg.endsWith(c))
-            {
-                switch (c)
-                {
-                    case "y" -> unit = TimeUnit.YEAR;
-                    case "mo" -> unit = TimeUnit.MONTH;
-                    case "w" -> unit = TimeUnit.WEEK;
-                    case "d" -> unit = TimeUnit.DAY;
-                    case "h" -> unit = TimeUnit.HOUR;
-                    case "m" -> unit = TimeUnit.MINUTE;
-                    case "s" -> unit = TimeUnit.SECOND;
-                }
-                break;
-            }
-        }
-        return (unit != null) ? unit : TimeUnit.DAY;
-    }
-
-    public static String useTimezone(LocalDateTime date)
-    {
-        // Use UTC if the timezone is null or not set correctly
-        if (TIMEZONE == null || !TIMEZONES.contains(TIMEZONE))
-        {
-            TIMEZONE = "Etc/UTC";
-        }
-        return DATE_FORMAT.withZone(ZoneId.of(TIMEZONE)).format(date);
-    }
-
-    public static LocalDateTime parseDateOffset(String... time)
-    {
-        Instant instant = Instant.now();
-        for (String arg : time)
-        {
-            instant = instant.plusSeconds(verify(arg).get() * a(arg));
-        }
-        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault().getRules().getOffset(instant));
-    }
-
-    public static ChatColor getChatColorFromConfig(Config config, ChatColor def, String path)
-    {
-        ChatColor color;
-        if (config.getString(path) == null)
-        {
-            color = def;
-        }
-        else if (ChatColor.getByChar(config.getString(path)) == null)
-        {
-            color = def;
-        }
-        else
-        {
-            color = ChatColor.getByChar(config.getString(path));
-        }
-        return color;
-    }
-
-    public static void setBlocks(Location c1, Location c2, Material material)
-    {
-        if (!c1.getWorld().getName().equals(c1.getWorld().getName()))
-        {
-            return;
-        }
-        int sy = Math.min(c1.getBlockY(), c2.getBlockY()), ey = Math.max(c1.getBlockY(), c2.getBlockY()), sx = Math.min(c1.getBlockX(), c2.getBlockX()), ex = Math.max(c1.getBlockX(), c2.getBlockX()), sz = Math.min(c1.getBlockZ(), c2.getBlockZ()), ez = Math.max(c1.getBlockZ(), c2.getBlockZ());
-        World world = c1.getWorld();
-        for (int y = sy; y <= ey; y++)
-        {
-            for (int x = sx; x <= ex; x++)
-            {
-                for (int z = sz; z <= ez; z++)
-                {
-                    world.getBlockAt(x, y, z).setType(material);
-                }
-            }
-        }
-    }
-
-    public static <T> void commitGlobalGameRules(World world)
-    {
-        for (String s : Plex.get().config.getStringList("global_gamerules"))
-        {
-            readGameRules(world, s);
-        }
-    }
-
-    public static <T> void commitSpecificGameRules(World world)
-    {
-        for (String s : Plex.get().config.getStringList("worlds." + world.getName().toLowerCase(Locale.ROOT) + ".gameRules"))
-        {
-            readGameRules(world, s);
-        }
-    }
-
-    private static <T> void readGameRules(World world, String s)
-    {
-        String gameRule = s.split(";")[0];
-        T value = (T)s.split(";")[1];
-        GameRule<T> rule = (GameRule<T>)GameRule.getByName(gameRule);
-        if (rule != null && check(value).getClass().equals(rule.getType()))
-        {
-            world.setGameRule(rule, value);
-            PlexLog.debug("Setting game rule " + gameRule + " for world " + world.getName() + " with value " + value);
-        }
-        else
-        {
-            PlexLog.error(String.format("Failed to set game rule %s for world %s with value %s!", gameRule, world.getName().toLowerCase(Locale.ROOT), value));
-        }
-    }
-
-    public static <T> Object check(T value)
-    {
-        if (value.toString().equalsIgnoreCase("true") || value.toString().equalsIgnoreCase("false"))
-        {
-            return Boolean.parseBoolean(value.toString());
-        }
-
-        if (NumberUtils.isNumber(value.toString()))
-        {
-            return Integer.parseInt(value.toString());
-        }
-        return value;
-    }
-
     public static List<String> getPlayerNameList()
     {
         return Bukkit.getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
@@ -446,127 +188,8 @@ public class PlexUtils extends PlexBase
     public static void broadcastToAdmins(Component component)
     {
         Bukkit.getOnlinePlayers().stream().filter(pl -> PlayerCache.getPlexPlayer(pl.getUniqueId()).isAdminActive()).forEach(pl ->
-                Bukkit.broadcast(component));
-    }
-
-    public static Object simpleGET(String url)
         {
-        try
-        {
-            URL u = new URL(url);
-            HttpURLConnection connection = (HttpURLConnection)u.openConnection();
-            connection.setRequestMethod("GET");
-            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
-            String line;
-            StringBuilder content = new StringBuilder();
-            while ((line = in.readLine()) != null)
-            {
-                content.append(line);
-            }
-            in.close();
-            connection.disconnect();
-            return new JSONParser().parse(content.toString());
-        }
-        catch (IOException | ParseException ex)
-        {
-            return null;
-        }
-    }
-
-    public static UUID getFromName(String name)
-    {
-        JSONObject profile;
-        profile = (JSONObject)simpleGET("https://api.ashcon.app/mojang/v2/user/" + name);
-        if (profile == null)
-        {
-            PlexLog.error("Profile from Ashcon API returned null!");
-            return null;
-        }
-        String uuidString = (String)profile.get("uuid");
-        return UUID.fromString(uuidString);
-    }
-
-    @SuppressWarnings("UnstableApiUsage")
-    public static Set<Class<?>> getClassesFrom(String packageName)
-    {
-        Set<Class<?>> classes = new HashSet<>();
-        try
-        {
-            ClassPath path = ClassPath.from(Plex.class.getClassLoader());
-            ImmutableSet<ClassPath.ClassInfo> infoSet = path.getTopLevelClasses(packageName);
-            infoSet.forEach(info ->
-            {
-                try
-                {
-                    Class<?> clazz = Class.forName(info.getName());
-                    classes.add(clazz);
-                }
-                catch (ClassNotFoundException ex)
-                {
-                    PlexLog.error("Unable to find class " + info.getName() + " in " + packageName);
-                }
+            pl.sendMessage(component);
         });
     }
-        catch (IOException ex)
-        {
-            PlexLog.error("Something went wrong while fetching classes from " + packageName);
-            throw new RuntimeException(ex);
-        }
-        return Collections.unmodifiableSet(classes);
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> Set<Class<? extends T>> getClassesBySubType(String packageName, Class<T> subType)
-    {
-        Set<Class<?>> loadedClasses = getClassesFrom(packageName);
-        Set<Class<? extends T>> classes = new HashSet<>();
-        loadedClasses.forEach(clazz ->
-        {
-            if (clazz.getSuperclass() == subType || Arrays.asList(clazz.getInterfaces()).contains(subType))
-            {
-                classes.add((Class<? extends T>)clazz);
-            }
-        });
-        return Collections.unmodifiableSet(classes);
-    }
-
-    public static boolean randomBoolean()
-    {
-        return ThreadLocalRandom.current().nextBoolean();
-    }
-
-    public static int randomNum()
-    {
-        return ThreadLocalRandom.current().nextInt();
-    }
-
-    public static int randomNum(int limit)
-    {
-        return ThreadLocalRandom.current().nextInt(limit);
-    }
-
-    public static int randomNum(int start, int limit)
-    {
-        return ThreadLocalRandom.current().nextInt(start, limit);
-    }
-
-    public static long getDateNow()
-    {
-        return new Date().getTime();
-    }
-
-    public static Date getDateFromLong(long epoch)
-    {
-        return new Date(epoch);
-    }
-
-    public static long hoursToSeconds(long hours)
-    {
-        return hours * 3600;
-    }
-
-    public static long minutesToSeconds(long minutes)
-    {
-        return minutes * 60;
-    }
 }

src/main/java/dev/plex/util/RandomUtil.java

@@ -0,0 +1,34 @@
+package dev.plex.util;
+
+import java.util.concurrent.ThreadLocalRandom;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+public class RandomUtil
+{
+
+    public static NamedTextColor getRandomColor()
+    {
+        NamedTextColor[] colors = NamedTextColor.NAMES.values().stream().filter(namedTextColor -> namedTextColor != NamedTextColor.BLACK && namedTextColor != NamedTextColor.DARK_BLUE).toArray(NamedTextColor[]::new);
+        return colors[randomNum(colors.length)];
+    }
+
+    public static boolean randomBoolean()
+    {
+        return ThreadLocalRandom.current().nextBoolean();
+    }
+
+    public static int randomNum()
+    {
+        return ThreadLocalRandom.current().nextInt();
+    }
+
+    public static int randomNum(int limit)
+    {
+        return ThreadLocalRandom.current().nextInt(limit);
+    }
+
+    public static int randomNum(int start, int limit)
+    {
+        return ThreadLocalRandom.current().nextInt(start, limit);
+    }
+}

src/main/java/dev/plex/util/ReflectionsUtil.java

@@ -0,0 +1,57 @@
+package dev.plex.util;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.reflect.ClassPath;
+import dev.plex.Plex;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ReflectionsUtil
+{
+    @SuppressWarnings("UnstableApiUsage")
+    public static Set<Class<?>> getClassesFrom(String packageName)
+    {
+        Set<Class<?>> classes = new HashSet<>();
+        try
+        {
+            ClassPath path = ClassPath.from(Plex.class.getClassLoader());
+            ImmutableSet<ClassPath.ClassInfo> infoSet = path.getTopLevelClasses(packageName);
+            infoSet.forEach(info ->
+            {
+                try
+                {
+                    Class<?> clazz = Class.forName(info.getName());
+                    classes.add(clazz);
+                }
+                catch (ClassNotFoundException ex)
+                {
+                    PlexLog.error("Unable to find class " + info.getName() + " in " + packageName);
+                }
+            });
+        }
+        catch (IOException ex)
+        {
+            PlexLog.error("Something went wrong while fetching classes from " + packageName);
+            throw new RuntimeException(ex);
+        }
+        return Collections.unmodifiableSet(classes);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> Set<Class<? extends T>> getClassesBySubType(String packageName, Class<T> subType)
+    {
+        Set<Class<?>> loadedClasses = getClassesFrom(packageName);
+        Set<Class<? extends T>> classes = new HashSet<>();
+        loadedClasses.forEach(clazz ->
+        {
+            if (clazz.getSuperclass() == subType || Arrays.asList(clazz.getInterfaces()).contains(subType))
+            {
+                classes.add((Class<? extends T>)clazz);
+            }
+        });
+        return Collections.unmodifiableSet(classes);
+    }
+}

src/main/java/dev/plex/util/TimeUnit.java

@@ -1,24 +0,0 @@
-package dev.plex.util;
-
-public enum TimeUnit
-{
-    SECOND(1L),
-    MINUTE(SECOND.get() * 60L),
-    HOUR(MINUTE.get() * 60L),
-    DAY(HOUR.get() * 24L),
-    WEEK(DAY.get() * 7L),
-    MONTH(DAY.get() * 30L),
-    YEAR(MONTH.get() * 12L);
-
-    private final long time;
-
-    TimeUnit(long time)
-    {
-        this.time = time;
-    }
-
-    public long get()
-    {
-        return time;
-    }
-}

src/main/java/dev/plex/util/TimeUtils.java

@@ -0,0 +1,81 @@
+package dev.plex.util;
+
+import dev.plex.Plex;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TimeZone;
+import org.apache.commons.lang.math.NumberUtils;
+
+public class TimeUtils
+{
+    public static String TIMEZONE = Plex.get().config.getString("server.timezone");
+    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("MM/dd/yyyy 'at' hh:mm:ss a z");
+    private static final Set<String> TIMEZONES = Set.of(TimeZone.getAvailableIDs());
+    private static final List<String> timeUnits = new ArrayList<>()
+    {{
+        add("s");
+        add("m");
+        add("h");
+        add("d");
+        add("w");
+        add("mo");
+        add("y");
+    }};
+
+    private static int parseInteger(String s) throws NumberFormatException
+    {
+        if (!NumberUtils.isNumber(s))
+        {
+            throw new NumberFormatException();
+        }
+        return Integer.parseInt(s);
+    }
+
+    public static ZonedDateTime createDate(String arg)
+    {
+        ZonedDateTime time = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
+        for (String unit : timeUnits)
+        {
+            if (arg.endsWith(unit))
+            {
+                int duration = parseInteger(arg.replace(unit, ""));
+                switch (unit)
+                {
+                    case "y" -> time = time.plusYears(duration);
+                    case "mo" -> time = time.plusMonths(duration);
+                    case "w" -> time = time.plusWeeks(duration);
+                    case "d" -> time = time.plusDays(duration);
+                    case "h" -> time = time.plusHours(duration);
+                    case "m" -> time = time.plusMinutes(duration);
+                    case "s" -> time = time.plusSeconds(duration);
+                }
+            }
+        }
+        return time;
+    }
+
+    public static String useTimezone(LocalDateTime date)
+    {
+        // Use UTC if the timezone is null or not set correctly
+        if (TIMEZONE == null || !TIMEZONES.contains(TIMEZONE))
+        {
+            TIMEZONE = "Etc/UTC";
+        }
+        return DATE_FORMAT.withZone(ZoneId.of(TIMEZONE)).format(date);
+    }
+
+    public static String useTimezone(ZonedDateTime date)
+    {
+        // Use UTC if the timezone is null or not set correctly
+        if (TIMEZONE == null || !TIMEZONES.contains(TIMEZONE))
+        {
+            TIMEZONE = "Etc/UTC";
+        }
+        return DATE_FORMAT.withZone(ZoneId.of(TIMEZONE)).format(date);
+    }
+}

src/main/java/dev/plex/util/UpdateChecker.java

@@ -27,7 +27,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.json.JSONObject;
 
-public class UpdateChecker extends PlexBase
+public class UpdateChecker implements PlexBase
 {
     /*
      * -4 = Never checked for updates

src/main/java/dev/plex/util/WebUtils.java

@@ -0,0 +1,51 @@
+package dev.plex.util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.UUID;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+public class WebUtils
+{
+    public static Object simpleGET(String url)
+    {
+        try
+        {
+            URL u = new URL(url);
+            HttpURLConnection connection = (HttpURLConnection)u.openConnection();
+            connection.setRequestMethod("GET");
+            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+            String line;
+            StringBuilder content = new StringBuilder();
+            while ((line = in.readLine()) != null)
+            {
+                content.append(line);
+            }
+            in.close();
+            connection.disconnect();
+            return new JSONParser().parse(content.toString());
+        }
+        catch (IOException | ParseException ex)
+        {
+            return null;
+        }
+    }
+
+    public static UUID getFromName(String name)
+    {
+        JSONObject profile;
+        profile = (JSONObject)simpleGET("https://api.ashcon.app/mojang/v2/user/" + name);
+        if (profile == null)
+        {
+            PlexLog.error("Profile from Ashcon API returned null!");
+            return null;
+        }
+        String uuidString = (String)profile.get("uuid");
+        return UUID.fromString(uuidString);
+    }
+}

src/main/java/dev/plex/util/adapter/ZonedDateTimeDeserializer.java

@@ -4,17 +4,21 @@ import com.google.gson.JsonDeserializationContext;
 import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonParseException;
+import dev.plex.Plex;
+
 import java.lang.reflect.Type;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
+import java.time.ZonedDateTime;
 
-public class LocalDateTimeDeserializer implements JsonDeserializer<LocalDateTime>
+public class ZonedDateTimeDeserializer implements JsonDeserializer<ZonedDateTime>
 {
+    private static String TIMEZONE = Plex.get().config.getString("server.timezone");
     @Override
-    public LocalDateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException
+    public ZonedDateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException
     {
         Instant instant = Instant.ofEpochMilli(json.getAsJsonPrimitive().getAsLong());
-        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
+        return ZonedDateTime.ofInstant(instant, ZoneId.of(TIMEZONE));
     }
 }

src/main/java/dev/plex/util/adapter/ZonedDateTimeSerializer.java

@@ -4,16 +4,20 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
+import dev.plex.Plex;
+
 import java.lang.reflect.Type;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
+import java.time.ZonedDateTime;
 
-public class LocalDateTimeSerializer implements JsonSerializer<LocalDateTime>
+public class ZonedDateTimeSerializer implements JsonSerializer<ZonedDateTime>
 {
+    private static String TIMEZONE = Plex.get().config.getString("server.timezone");
     @Override
-    public JsonElement serialize(LocalDateTime src, Type typeOfSrc, JsonSerializationContext context)
+    public JsonElement serialize(ZonedDateTime src, Type typeOfSrc, JsonSerializationContext context)
     {
-        return new JsonPrimitive(src.toInstant(ZoneId.systemDefault().getRules().getOffset(Instant.now())).toEpochMilli());
+        return new JsonPrimitive(src.toInstant().toEpochMilli());
     }
 }

src/main/resources/commands.yml

@@ -14,8 +14,44 @@
 #
 # So these would be valid:
 #   - "m:e:mail sendall:You cannot send messages to everyone on the server"
-#   - "r:e:^[^ :]+::Plugin specific commands are disabled"
-blockedCommands:
-  - "r:e:^[^ :]+::<gray>Plugin specific commands are disabled."
-  - "m:e:mail sendall:<gray>You cannot send messages to everyone on the server."
-  - "m:e:mail sendtempall:<gray>You cannot send messages to everyone on the server."
+#   - "r:e:^[A-z]*:[A-z]*::Plugin specific commands are disabled"
+commands:
+  - "m:a:break:_"
+  - "m:a:delchunks:_"
+  - "m:a:kickall:_"
+  - "m:a:locatebiome:_"
+  - "m:a:playsound:_"
+  - "m:a:setspawn:_"
+  - "m:a:socialspy:_"
+  - "m:a:tpall:_"
+  - "m:e:/eval:_"
+  - "m:e:advancement:_"
+  - "m:e:antioch:_"
+  - "m:e:backup:_"
+  - "m:e:ban-ip:_"
+  - "m:e:co purge:_"
+  - "m:e:d minecart_command:_"
+  - "m:e:debug:_"
+  - "m:e:defaultgamemode:<gray>The default gamemode should not be changed."
+  - "m:e:deljail:_"
+  - "m:e:disguiseradius:_"
+  - "m:e:fill:_"
+  - "m:e:jails:_"
+  - "m:e:mail sendall:<red>You cannot send messages to everyone on the server."
+  - "m:e:mail sendtempall:<red>You cannot send messages to everyone on the server."
+  - "m:e:paper:_"
+  - "m:e:pardon-ip:_"
+  - "m:e:pardon:_"
+  - "m:e:save-off:_"
+  - "m:e:save-on:_"
+  - "m:e:setjail:_"
+  - "m:e:spigot reload:_"
+  - "m:e:time:<gray>Server-side time changing is disabled. Please use /ptime to set your own personal time."
+  - "m:e:togglejail:_"
+  - "m:e:undisguiseradius:_"
+  - "m:e:weather:_"
+  - "m:e:worldborder:<gray>The worldborder does not need to be changed. This command is disabled."
+  - "r:a:^(co|core|coreprotect) (rb|rollback|l|lookup|rl|reload):_"
+  - "r:a:^(gamemode|gm) [^ ]+ .*:<gray>You cannot change the gamemode of other players!"
+  - "r:a:^(gamemode|gm|egamemode|egm) (spectator|sp|3):<gray>You cannot use spectator mode!"
+  - "r:e:^[A-z]*:[A-z]*::<gray>Plugin specific commands are disabled."

src/main/resources/messages.yml

@@ -174,3 +174,5 @@ sayMessage: "<blue>[Server: {0}] {1}"
 # 0 - The command sender
 # 1 - The message being said
 consoleSayMessage: "<gray>[Console: {0}] <white>{1}"
+# 0 - The number attempted to be parsed
+unableToParseNumber: "<red>Unable to parse {0} as a number!"