Version 1.1

- Add /toggles as an alias for /toggle
- We now use docs.plex.us.org again

.gitignore

@@ -1,7 +1,7 @@
 /.idea/
 *.iml
 /target/
-src/main/resources/build.properties
+server/src/main/resources/build.properties
 
 # OS
 .DS_Store
@@ -13,4 +13,5 @@ Thumbs.db
 
 # Gradle
 /build/
+/*/build/
 /.gradle/

.idea/codeStyles/Plexus_Code_Style.xml

@@ -0,0 +1,49 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Plexus Code Style" version="1">
+    <JavaCodeStyleSettings>
+      <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="20" />
+      <option name="IMPORT_LAYOUT_TABLE">
+        <value>
+          <package name="" withSubpackages="true" static="false" />
+          <package name="" withSubpackages="true" static="true" />
+        </value>
+      </option>
+    </JavaCodeStyleSettings>
+    <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+          <package name="io.ktor" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
+        </value>
+      </option>
+    </JetCodeStyleSettings>
+    <codeStyleSettings language="JAVA">
+      <option name="BRACE_STYLE" value="2" />
+      <option name="CLASS_BRACE_STYLE" value="2" />
+      <option name="METHOD_BRACE_STYLE" value="2" />
+      <option name="LAMBDA_BRACE_STYLE" value="2" />
+      <option name="ELSE_ON_NEW_LINE" value="true" />
+      <option name="WHILE_ON_NEW_LINE" value="true" />
+      <option name="CATCH_ON_NEW_LINE" value="true" />
+      <option name="FINALLY_ON_NEW_LINE" value="true" />
+      <option name="SPACE_AFTER_TYPE_CAST" value="true" />
+      <option name="IF_BRACE_FORCE" value="3" />
+      <option name="DOWHILE_BRACE_FORCE" value="3" />
+      <option name="WHILE_BRACE_FORCE" value="3" />
+      <option name="FOR_BRACE_FORCE" value="3" />
+      <option name="BLANK_LINES_AFTER_CLASS_HEADER" value="0" />
+      <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="1" />
+      <option name="KEEP_FIRST_COLUMN_COMMENT" value="false" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -1,46 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
+  <state>
-    <JavaCodeStyleSettings>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Plexus Code Style" />
-      <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="20" />
+  </state>
-      <option name="IMPORT_LAYOUT_TABLE">
-        <value>
-          <package name="" withSubpackages="true" static="false" />
-          <package name="" withSubpackages="true" static="true" />
-        </value>
-      </option>
-    </JavaCodeStyleSettings>
-    <JetCodeStyleSettings>
-      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
-        <value>
-          <package name="java.util" alias="false" withSubpackages="false" />
-          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
-          <package name="io.ktor" alias="false" withSubpackages="true" />
-        </value>
-      </option>
-      <option name="PACKAGES_IMPORT_LAYOUT">
-        <value>
-          <package name="" alias="false" withSubpackages="true" />
-          <package name="java" alias="false" withSubpackages="true" />
-          <package name="javax" alias="false" withSubpackages="true" />
-          <package name="kotlin" alias="false" withSubpackages="true" />
-          <package name="" alias="true" withSubpackages="true" />
-        </value>
-      </option>
-    </JetCodeStyleSettings>
-    <codeStyleSettings language="JAVA">
-      <option name="BRACE_STYLE" value="2" />
-      <option name="CLASS_BRACE_STYLE" value="2" />
-      <option name="METHOD_BRACE_STYLE" value="2" />
-      <option name="LAMBDA_BRACE_STYLE" value="2" />
-      <option name="ELSE_ON_NEW_LINE" value="true" />
-      <option name="WHILE_ON_NEW_LINE" value="true" />
-      <option name="CATCH_ON_NEW_LINE" value="true" />
-      <option name="FINALLY_ON_NEW_LINE" value="true" />
-      <option name="SPACE_AFTER_TYPE_CAST" value="false" />
-      <option name="IF_BRACE_FORCE" value="3" />
-      <option name="DOWHILE_BRACE_FORCE" value="3" />
-      <option name="WHILE_BRACE_FORCE" value="3" />
-      <option name="FOR_BRACE_FORCE" value="3" />
-    </codeStyleSettings>
-  </code_scheme>
 </component>

CONTRIBUTING.md

@@ -1,23 +1,36 @@
-For those who are wanting to contribute, we fully encourage doing so. There are a few rules we require following when contributing however.
+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.
+
+1. Make an issue 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`.
+2. Fork this project
+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.
+- 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
+- If you are not using IntelliJ, that is fine. We use Allman style so please format your code accordingly.
+
+6. 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.
+
+- 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

@@ -24,8 +24,8 @@ pipeline {
     post {
         always {
             archiveArtifacts artifacts: "build/libs/*.jar", fingerprint: true
-            javadoc javadocDir: "build/docs/javadoc", keepAll: false
+            javadoc javadocDir: "api/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
+            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.WEBHOOK_URL
             cleanWs()
         }
     }

api/build.gradle

@@ -0,0 +1,32 @@
+group = rootProject.group
+version = rootProject.version
+description = "Plex-API"
+
+jar {
+    archiveBaseName.set("Plex-API")
+}
+
+tasks {
+    jar {
+        finalizedBy(rootProject.tasks.copyJars)
+    }
+
+    shadowJar {
+        enabled = false
+    }
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from components.java
+        }
+    }
+}
+
+dependencies {
+    compileOnly "org.projectlombok:lombok:1.18.24"
+    annotationProcessor "org.projectlombok:lombok:1.18.24"
+    compileOnly "io.papermc.paper:paper-api:1.18.2-R0.1-SNAPSHOT"
+    compileOnly "org.json:json:20220320"
+}

api/src/main/java/dev/plex/api/IPlayerCache.java

@@ -0,0 +1,11 @@
+package dev.plex.api;
+
+import java.util.Map;
+import java.util.UUID;
+
+public interface IPlayerCache<T>
+{
+    Map<UUID, T> getPlexPlayerMap();
+
+    T getPlexPlayer(UUID uuid);
+}

api/src/main/java/dev/plex/api/PlexApi.java

@@ -0,0 +1,6 @@
+package dev.plex.api;
+
+public interface PlexApi
+{
+    IPlayerCache<?> getPlayerCache();
+}

api/src/main/java/dev/plex/api/PlexApiProvider.java

@@ -0,0 +1,6 @@
+package dev.plex.api;
+
+public interface PlexApiProvider
+{
+    PlexApi getApi();
+}

api/src/main/java/dev/plex/api/chat/IChatHandler.java

@@ -0,0 +1,8 @@
+package dev.plex.api.chat;
+
+import io.papermc.paper.event.player.AsyncChatEvent;
+
+public interface IChatHandler
+{
+    void doChat(AsyncChatEvent event);
+}

api/src/main/java/dev/plex/api/event/AdminAddEvent.java

@@ -1,6 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.bukkit.command.CommandSender;
@@ -24,7 +24,7 @@ public class AdminAddEvent extends Event
     /**
      * The PlexPlayer that was added
      */
-    private final PlexPlayer plexPlayer;
+    private final IPlexPlayer plexPlayer;
 
     public static HandlerList getHandlerList()
     {
@@ -36,5 +36,4 @@ public class AdminAddEvent extends Event
     {
         return handlers;
     }
-
 }

api/src/main/java/dev/plex/api/event/AdminRemoveEvent.java

@@ -1,6 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.bukkit.command.CommandSender;
@@ -24,7 +24,7 @@ public class AdminRemoveEvent extends Event
     /**
      * The PlexPlayer that was removed
      */
-    private final PlexPlayer plexPlayer;
+    private final IPlexPlayer plexPlayer;
 
     public static HandlerList getHandlerList()
     {

api/src/main/java/dev/plex/api/event/AdminSetRankEvent.java

@@ -1,7 +1,7 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
-import dev.plex.rank.enums.Rank;
+import dev.plex.api.rank.IRank;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.bukkit.command.CommandSender;
@@ -25,12 +25,12 @@ public class AdminSetRankEvent extends Event
     /**
      * The PlexPlayer that was removed
      */
-    private final PlexPlayer plexPlayer;
+    private final IPlexPlayer plexPlayer;
 
     /**
      * The rank the player was set to
      */
-    private final Rank rank;
+    private final IRank rank;
 
     public static HandlerList getHandlerList()
     {

api/src/main/java/dev/plex/api/event/GameModeUpdateEvent.java

@@ -1,4 +1,4 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
 import lombok.Data;
 import lombok.EqualsAndHashCode;

api/src/main/java/dev/plex/api/event/PunishedPlayerEvent.java

@@ -1,6 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.Bukkit;
@@ -16,7 +16,7 @@ public abstract class PunishedPlayerEvent extends PlayerEvent implements Cancell
     /**
      * The player who was punished
      */
-    protected PlexPlayer punishedPlayer;
+    protected IPlexPlayer punishedPlayer;
 
     /**
      * Whether the event was cancelled
@@ -28,9 +28,9 @@ public abstract class PunishedPlayerEvent extends PlayerEvent implements Cancell
      * Creates an event object
      *
      * @param punishedPlayer The player who was punished
-     * @see PlexPlayer
+     * @see IPlexPlayer
      */
-    protected PunishedPlayerEvent(PlexPlayer punishedPlayer)
+    protected PunishedPlayerEvent(IPlexPlayer punishedPlayer)
     {
         super(Bukkit.getPlayer(punishedPlayer.getUuid()));
         this.punishedPlayer = punishedPlayer;

api/src/main/java/dev/plex/api/event/PunishedPlayerFreezeEvent.java

@@ -1,6 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Getter;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.HandlerList;
@@ -24,7 +24,7 @@ public class PunishedPlayerFreezeEvent extends PunishedPlayerEvent implements Ca
      * @param punishedPlayer The player who was punished
      * @param frozen         The new frozen status
      */
-    public PunishedPlayerFreezeEvent(PlexPlayer punishedPlayer, boolean frozen)
+    public PunishedPlayerFreezeEvent(IPlexPlayer punishedPlayer, boolean frozen)
     {
         super(punishedPlayer);
         this.frozen = frozen;

api/src/main/java/dev/plex/api/event/PunishedPlayerLockupEvent.java

@@ -1,6 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Getter;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.HandlerList;
@@ -24,7 +24,7 @@ public class PunishedPlayerLockupEvent extends PunishedPlayerEvent implements Ca
      * @param punishedPlayer The player who was punished
      * @param lockedUp       The new muted status
      */
-    public PunishedPlayerLockupEvent(PlexPlayer punishedPlayer, boolean lockedUp)
+    public PunishedPlayerLockupEvent(IPlexPlayer punishedPlayer, boolean lockedUp)
     {
         super(punishedPlayer);
         this.lockedUp = lockedUp;

api/src/main/java/dev/plex/api/event/PunishedPlayerMuteEvent.java

@@ -1,6 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PlexPlayer;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Getter;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.HandlerList;
@@ -24,7 +24,7 @@ public class PunishedPlayerMuteEvent extends PunishedPlayerEvent implements Canc
      * @param punishedPlayer The player who was punished
      * @param muted          The new muted status
      */
-    public PunishedPlayerMuteEvent(PlexPlayer punishedPlayer, boolean muted)
+    public PunishedPlayerMuteEvent(IPlexPlayer punishedPlayer, boolean muted)
     {
         super(punishedPlayer);
         this.muted = muted;

api/src/main/java/dev/plex/api/permission/IPermissionHandler.java

@@ -0,0 +1,32 @@
+package dev.plex.api.permission;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface IPermissionHandler
+{
+    default boolean hasPermission(@NotNull Player player, @Nullable String permission)
+    {
+        if (permission == null)
+        {
+            return true;
+        }
+        return player.hasPermission(permission);
+    }
+
+    default boolean hasPermission(@NotNull OfflinePlayer player, @Nullable String permission)
+    {
+        if (permission == null)
+        {
+            return true;
+        }
+        if (player.isOnline() && Bukkit.getPlayer(player.getUniqueId()) != null)
+        {
+            return Bukkit.getPlayer(player.getUniqueId()).hasPermission(permission);
+        }
+        throw new UnsupportedOperationException("Not implemented yet");
+    }
+}

api/src/main/java/dev/plex/api/player/IPlexPlayer.java

@@ -0,0 +1,67 @@
+package dev.plex.api.player;
+
+import java.util.List;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.PermissionAttachment;
+
+public interface IPlexPlayer
+{
+    String getId();
+
+    UUID getUuid();
+
+    String getName();
+
+    Player getPlayer();
+
+    void setPlayer(Player player);
+
+    String getLoginMessage();
+
+    void setLoginMessage(String message);
+
+    String getPrefix();
+
+    void setPrefix(String prefix);
+
+    boolean isVanished();
+
+    void setVanished(boolean vanished);
+
+    boolean isCommandSpy();
+
+    void setCommandSpy(boolean commandSpy);
+
+    boolean isFrozen();
+
+    void setFrozen(boolean frozen);
+
+    boolean isMuted();
+
+    void setMuted(boolean muted);
+
+    boolean isLockedUp();
+
+    void setLockedUp(boolean lockedUp);
+
+    boolean isAdminActive();
+
+    void setAdminActive(boolean active);
+
+    long getCoins();
+
+    void setCoins(long coins);
+
+    String getRank();
+
+    void setRank(String rank);
+
+    List<String> getIps();
+
+    void setIps(List<String> ips);
+
+    PermissionAttachment getPermissionAttachment();
+
+    void setPermissionAttachment(PermissionAttachment attachment);
+}

api/src/main/java/dev/plex/api/plugin/PlexPlugin.java

@@ -0,0 +1,30 @@
+package dev.plex.api.plugin;
+
+import dev.plex.api.chat.IChatHandler;
+import dev.plex.api.permission.IPermissionHandler;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.plugin.java.JavaPlugin;
+
+@Getter
+@Setter
+public abstract class PlexPlugin extends JavaPlugin
+{
+    @Setter(AccessLevel.NONE)
+    private static PlexPlugin plugin;
+
+    private IChatHandler chatHandler;
+    private IPermissionHandler permissionHandler;
+
+    @Override
+    public void onLoad()
+    {
+        plugin = this;
+    }
+
+    public static PlexPlugin get()
+    {
+        return plugin;
+    }
+}

api/src/main/java/dev/plex/api/rank/IRank.java

@@ -0,0 +1,26 @@
+package dev.plex.api.rank;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.json.JSONObject;
+
+public interface IRank<T>
+{
+    int getLevel();
+
+    String getLoginMessage();
+
+    void setLoginMessage(String message);
+
+    String getReadable();
+
+    Component getPrefix();
+
+    void setPrefix(String prefix);
+
+    NamedTextColor getColor();
+
+    boolean isAtLeast(T rank);
+
+    JSONObject toJSON();
+}

build.gradle

@@ -1,14 +1,21 @@
 plugins {
     id "java"
     id "maven-publish"
-    id "net.minecrell.plugin-yml.bukkit" version "0.6.1-SNAPSHOT"
     id "com.github.johnrengelman.shadow" version "7.1.2"
 }
 
+group = "dev.plex"
+version = "1.1"
+description = "Plex"
+
+subprojects {
+    apply plugin: "java"
+    apply plugin: "maven-publish"
+    apply plugin: "com.github.johnrengelman.shadow"
+
     repositories {
-    mavenLocal()
         maven {
-        url = uri("https://papermc.io/repo/repository/maven-public/")
+            url = uri("https://repo.papermc.io/repository/maven-public/")
         }
 
         maven {
@@ -29,129 +36,20 @@ repositories {
         mavenCentral()
     }
 
-dependencies {
-    library "org.projectlombok:lombok:1.18.22"
-    annotationProcessor "org.projectlombok:lombok:1.18.22"
-    library "org.json:json:20220320"
-    library "commons-io:commons-io:2.11.0"
-    library "dev.morphia.morphia:morphia-core:2.2.6"
-    library "redis.clients:jedis:4.2.1"
-    library "org.mariadb.jdbc:mariadb-java-client:3.0.4"
-    library "com.zaxxer:HikariCP:5.0.1"
-    library "org.apache.httpcomponents:httpclient:4.5.13"
-    library "org.apache.commons:commons-lang3:3.12.0"
-    library "org.apache.maven.resolver:maven-resolver-api:1.7.3"
-    library "org.apache.maven.resolver:maven-resolver-impl:1.7.3"
-    library "org.apache.maven.resolver:maven-resolver-connector-basic:1.7.3"
-    library "org.apache.maven.resolver:maven-resolver-transport-http:1.7.3"
-    library "org.apache.maven:maven-resolver-provider:3.8.5"
-    library "org.eclipse.jetty:jetty-server:11.0.9"
-    library "org.eclipse.jetty:jetty-servlet:11.0.9"
-    library "org.eclipse.jetty:jetty-proxy:11.0.9"
-    library "com.google.code.gson:gson:2.9.0"
-    compileOnly "io.papermc.paper:paper-api:1.18.2-R0.1-SNAPSHOT"
-    compileOnly("com.github.MilkBowl:VaultAPI:1.7") {
-        exclude group: "org.bukkit", module: "bukkit"
-    }
-    implementation "org.bstats:bstats-base:3.0.0"
-    implementation "org.bstats:bstats-bukkit:3.0.0"
-}
-
-group = "dev.plex"
-version = "1.0.2"
-description = "Plex"
-
-shadowJar {
-    archiveClassifier.set("")
-    relocate "org.bstats", "dev.plex"
-}
-
-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", "supernt"]
-    softDepend = ["Vault"]
-    apiVersion = "1.18"
-}
-
-String getGitHash() {
-    def stdout = new ByteArrayOutputStream()
-    try {
-        exec {
-            commandLine "git", "rev-parse", "--short", "HEAD"
-            standardOutput = stdout
-            ignoreExitValue = true
-        }
-    } catch (GradleException e) {
-        logger.error("Couldn't determine Git head because Git is not installed. " + e.getMessage())
-    }
-    return stdout.size() > 0 ? stdout.toString().trim() : "unknown"
-}
-
-String getBuildNumber() {
-    def stdout = new ByteArrayOutputStream()
-    try {
-        exec {
-            commandLine "git", "rev-list", "HEAD", "--count"
-            standardOutput = stdout
-            ignoreExitValue = true
-        }
-    } catch (GradleException e) {
-        logger.error("Couldn't determine build number because Git is not installed. " + e.getMessage())
-    }
-    return stdout.size() ? stdout.toString().trim() + " (local)" : "unknown"
-}
-
-static def getDate() {
-    return new Date().format("MM/dd/yyyy '<light_purple>at<gold>' hh:mm:ss a z")
-}
-
-task buildProperties {
-    ant.propertyfile(file: "$project.rootDir/src/main/resources/build.properties") {
-        entry(key: "buildAuthor", default: System.getenv("JENKINS_URL") != null ? "jenkins" : "unknown")
-        entry(key: "buildNumber", value: System.getenv("JENKINS_URL") != null ? System.getenv("BUILD_NUMBER") + " (Jenkins)" : getBuildNumber())
-        entry(key: "buildDate", value: getDate())
-        entry(key: "buildHead", value: getGitHash())
-    }
-}
-
     java {
         toolchain.languageVersion.set(JavaLanguageVersion.of(17))
     }
 
+    tasks.withType(JavaCompile) {
+        options.encoding = "UTF-8"
+    }
+
     publishing {
-    publications {
-        maven(MavenPublication) {
-            pom.withXml {
-                def dependenciesNode = asNode().appendNode("dependencies")
-                configurations.getByName("library").getAllDependencies().each { dependency ->
-                    dependenciesNode.appendNode("dependency").with {
-                        it.appendNode("groupId", dependency.group)
-                        it.appendNode("artifactId", dependency.name)
-                        it.appendNode("version", dependency.version)
-                        it.appendNode("scope", "provided")
-                    }
-                }
-                configurations.getByName("implementation").getAllDependencies().each { dependency ->
-                    dependenciesNode.appendNode("dependency").with {
-                        it.appendNode("groupId", dependency.group)
-                        it.appendNode("artifactId", dependency.name)
-                        it.appendNode("version", dependency.version)
-                        it.appendNode("scope", "runtime")
-                    }
-                }
-            }
-            artifacts = [shadowJar]
-        }
-    }
         repositories {
             maven {
                 def releasesRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-releases/")
                 def snapshotsRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-snapshots/")
-            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
+                url = rootProject.version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
                 credentials {
                     username = System.getenv("plexUser")
                     password = System.getenv("plexPassword")
@@ -159,18 +57,17 @@ publishing {
             }
         }
     }
-
-tasks.withType(JavaCompile) {
-    options.encoding = "UTF-8"
 }
 
-tasks {
+clean {
-    build {
+    dependsOn(":api:clean")
-        dependsOn(shadowJar)
+    dependsOn(":server:clean")
-        finalizedBy(buildProperties)
+    dependsOn(":proxy:clean")
 }
 
-    javadoc {
+task copyJars(type: Copy, dependsOn: subprojects.jar) {
-        options.memberLevel = JavadocMemberLevel.PRIVATE
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    }
+    from(subprojects.jar)
+    from(subprojects.shadowJar)
+    into project.file('build/libs')
 }

proxy/build.gradle.kts

@@ -0,0 +1,46 @@
+plugins {
+    id("net.kyori.blossom") version "1.2.0"
+}
+
+group = rootProject.group
+version = rootProject.version
+description = "Plex-Velocity"
+
+repositories {
+    maven { url = uri("https://papermc.io/repo/repository/maven-public/") }
+}
+
+tasks.getByName<Jar>("jar") {
+    archiveBaseName.set("Plex-Velocity")
+}
+
+tasks {
+    jar {
+        finalizedBy(rootProject.tasks["copyJars"])
+    }
+
+    shadowJar {
+        enabled = false
+    }
+}
+
+blossom {
+    replaceToken("@version@", rootProject.version)
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            from(components["java"])
+        }
+    }
+}
+
+dependencies {
+    compileOnly("org.projectlombok:lombok:1.18.24")
+    annotationProcessor("org.projectlombok:lombok:1.18.24")
+    compileOnly("org.json:json:20220320")
+    compileOnly("com.velocitypowered:velocity-api:3.1.2-SNAPSHOT")
+    annotationProcessor("com.velocitypowered:velocity-api:3.1.2-SNAPSHOT")
+    implementation(project(":api"))
+}

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

@@ -0,0 +1,81 @@
+package dev.plex;
+
+import com.google.inject.Inject;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.plugin.Plugin;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import com.velocitypowered.api.proxy.ProxyServer;
+import dev.plex.config.TomlConfig;
+import dev.plex.handlers.ListenerHandler;
+import dev.plex.settings.ServerSettings;
+import dev.plex.util.PlexLog;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.logging.Logger;
+import lombok.Getter;
+
+/**
+ * Credits for TOML library go to https://github.com/mwanji/toml4j
+ * I was unable to add it back to the package without it glitching, so
+ * I kept it in a separate package.
+ * <p>
+ * Modifications: Properly indent arrays in TOML as well as only append
+ * missing object fields into the file
+ */
+
+@Plugin(
+        name = "Plex",
+        id = "plex",
+        version = "@version@",
+        url = "https://plex.us.org",
+        description = "Plex provides a new experience for freedom servers.",
+        authors = {"Telesphoreo", "Taah"}
+)
+@Getter
+public class Plex
+{
+    private static Plex plugin;
+
+    public final ProxyServer server;
+    private final Logger logger;
+    private final File dataFolder;
+
+    private TomlConfig config;
+
+    @Inject
+    public Plex(ProxyServer server, Logger logger, @DataDirectory Path folder)
+    {
+        plugin = this;
+        this.server = server;
+        this.logger = logger;
+        this.dataFolder = folder.toFile();
+        if (!dataFolder.exists())
+        {
+            dataFolder.mkdir();
+        }
+        PlexLog.log("Enabling Plex-Velocity");
+    }
+
+    @Subscribe
+    public void onStart(ProxyInitializeEvent event)
+    {
+        this.config = new TomlConfig("config.toml");
+        this.config.setOnCreate(toml ->
+        {
+            PlexLog.log("Created configuration 'config.toml'");
+        });
+        this.config.setOnLoad(toml ->
+        {
+            PlexLog.log("Loaded configuration 'config.toml'");
+        });
+        this.config.create(true);
+        this.config.write(new ServerSettings());
+        new ListenerHandler();
+    }
+
+    public static Plex get()
+    {
+        return plugin;
+    }
+}

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

@@ -0,0 +1,102 @@
+package dev.plex.command;
+
+import com.velocitypowered.api.command.CommandMeta;
+import com.velocitypowered.api.command.CommandSource;
+import com.velocitypowered.api.command.SimpleCommand;
+import com.velocitypowered.api.proxy.ConsoleCommandSource;
+import com.velocitypowered.api.proxy.Player;
+import dev.plex.Plex;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.source.RequiredCommandSource;
+import java.util.Arrays;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class PlexCommand implements SimpleCommand
+{
+    /**
+     * Returns the instance of the plugin
+     */
+    protected static Plex plugin = Plex.get();
+
+    /**
+     * The parameters for the command
+     */
+    private final CommandParameters params;
+
+    /**
+     * The permissions for the command
+     */
+    private final CommandPermissions perms;
+    /**
+     * Required command source fetched from the permissions
+     */
+    private final RequiredCommandSource commandSource;
+
+    public PlexCommand()
+    {
+        this.params = getClass().getAnnotation(CommandParameters.class);
+        this.perms = getClass().getAnnotation(CommandPermissions.class);
+        this.commandSource = this.perms.source();
+
+        CommandMeta.Builder meta = plugin.getServer().getCommandManager().metaBuilder(this.params.name());
+        meta.aliases(this.params.aliases());
+        meta.plugin(Plex.get());
+        plugin.getServer().getCommandManager().register(meta.build(), this);
+    }
+
+    protected abstract Component execute(@NotNull CommandSource source, @Nullable Player player, @NotNull String[] args);
+
+    @Override
+    public void execute(Invocation invocation)
+    {
+        if (!matches(invocation.alias()))
+        {
+            return;
+        }
+
+        if (commandSource == RequiredCommandSource.CONSOLE && invocation.source() instanceof Player)
+        {
+            //            sender.sendMessage(messageComponent("noPermissionInGame"));
+            return;
+        }
+
+        if (commandSource == RequiredCommandSource.IN_GAME)
+        {
+            if (invocation.source() instanceof ConsoleCommandSource)
+            {
+                //                send(sender, messageComponent("noPermissionConsole"));
+                return;
+            }
+        }
+        if (!perms.permission().isEmpty())
+        {
+            if (!invocation.source().hasPermission(perms.permission()))
+            {
+                return;
+            }
+        }
+        Component component = this.execute(invocation.source(), invocation.source() instanceof ConsoleCommandSource ? null : (Player) invocation.source(), invocation.arguments());
+        if (component != null)
+        {
+            send(invocation.source(), component);
+        }
+    }
+
+    private boolean matches(String label)
+    {
+        if (params.name().equalsIgnoreCase(label))
+        {
+            return true;
+        }
+        return Arrays.stream(params.aliases()).anyMatch(s -> s.equalsIgnoreCase(label));
+    }
+
+    protected void send(Audience audience, Component component)
+    {
+        audience.sendMessage(component);
+    }
+}

proxy/src/main/java/dev/plex/command/annotation/CommandParameters.java

@@ -0,0 +1,39 @@
+package dev.plex.command.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Storage for a command's parameters
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CommandParameters
+{
+    /**
+     * The name
+     *
+     * @return Name of the command
+     */
+    String name();
+
+    /**
+     * The description
+     *
+     * @return Description of the command
+     */
+    String description() default "";
+
+    /**
+     * The usage (optional)
+     *
+     * @return The usage of the command
+     */
+    String usage() default "/<command>";
+
+    /**
+     * The aliases (optional)
+     *
+     * @return The aliases of the command
+     */
+    String[] aliases() default {};
+}

proxy/src/main/java/dev/plex/command/annotation/CommandPermissions.java

@@ -0,0 +1,27 @@
+package dev.plex.command.annotation;
+
+import dev.plex.command.source.RequiredCommandSource;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Storage for the command's permissions
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CommandPermissions
+{
+    /**
+     * Required command source
+     *
+     * @return The required command source of the command
+     * @see RequiredCommandSource
+     */
+    RequiredCommandSource source() default RequiredCommandSource.ANY;
+
+    /**
+     * The permission
+     *
+     * @return Permission of the command
+     */
+    String permission() default ""; // No idea what to put here
+}

proxy/src/main/java/dev/plex/config/TomlConfig.java

@@ -0,0 +1,99 @@
+package dev.plex.config;
+
+import dev.plex.Plex;
+import dev.plex.toml.Toml;
+import dev.plex.toml.TomlWriter;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.function.Consumer;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class TomlConfig
+{
+    private final File file;
+    private Toml toml;
+
+    @Setter
+    private Consumer<Toml> onCreate;
+
+    @Setter
+    private Consumer<Toml> onLoad;
+
+    public TomlConfig(String fileName)
+    {
+        this.file = new File(Plex.get().getDataFolder(), fileName);
+        this.toml = new Toml();
+    }
+
+    public void create(boolean loadFromFile)
+    {
+        if (!this.file.exists())
+        {
+            if (loadFromFile)
+            {
+                try
+                {
+                    Files.copy(Plex.get().getClass().getResourceAsStream("/" + this.file.getName()), this.file.toPath());
+                    this.load();
+                    if (this.onCreate != null)
+                    {
+                        this.onCreate.accept(this.toml);
+                    }
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+                return;
+            }
+            try
+            {
+                this.file.createNewFile();
+                this.load();
+                if (this.onCreate != null)
+                {
+                    this.onCreate.accept(this.toml);
+                }
+            }
+            catch (IOException e)
+            {
+                e.printStackTrace();
+            }
+            return;
+        }
+        this.load();
+    }
+
+    public void load()
+    {
+        this.toml = new Toml().read(this.file);
+        if (onLoad != null)
+        {
+            this.onLoad.accept(this.toml);
+        }
+    }
+
+    public <T> T as(Class<T> clazz)
+    {
+        return this.toml.to(clazz);
+    }
+
+    public <T> void write(T object)
+    {
+        TomlWriter writer = new TomlWriter.Builder()
+                .indentValuesBy(2)
+                .build();
+        try
+        {
+            writer.write(object, this.file);
+            this.load();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+package dev.plex.handlers;
+
+import com.google.common.collect.Lists;
+import dev.plex.listener.PlexListener;
+import dev.plex.util.PlexLog;
+import dev.plex.util.ReflectionsUtil;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+import java.util.Set;
+
+public class ListenerHandler
+{
+    public ListenerHandler()
+    {
+        Set<Class<? extends PlexListener>> listenerSet = ReflectionsUtil.getClassesBySubType("dev.plex.listener.impl", PlexListener.class);
+        List<PlexListener> listeners = Lists.newArrayList();
+
+        listenerSet.forEach(clazz ->
+        {
+            try
+            {
+                listeners.add(clazz.getConstructor().newInstance());
+            }
+            catch (InvocationTargetException | InstantiationException | IllegalAccessException |
+                   NoSuchMethodException ex)
+            {
+                PlexLog.error("Failed to register " + clazz.getSimpleName() + " as a listener!");
+            }
+        });
+        PlexLog.log(String.format("Registered %s listeners from %s classes!", listeners.size(), listenerSet.size()));
+    }
+}

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

@@ -0,0 +1,13 @@
+package dev.plex.listener;
+
+import dev.plex.Plex;
+
+public class PlexListener
+{
+    protected final Plex plugin = Plex.get();
+
+    public PlexListener()
+    {
+        Plex.get().getServer().getEventManager().register(Plex.get(), this);
+    }
+}

proxy/src/main/java/dev/plex/listener/impl/ConnectionListener.java

@@ -0,0 +1,45 @@
+package dev.plex.listener.impl;
+
+import com.velocitypowered.api.event.PostOrder;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.connection.DisconnectEvent;
+import com.velocitypowered.api.event.player.ServerConnectedEvent;
+import dev.plex.Plex;
+import dev.plex.listener.PlexListener;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public class ConnectionListener extends PlexListener
+{
+    @Subscribe(order = PostOrder.FIRST)
+    public void onPlayerJoin(ServerConnectedEvent event)
+    {
+        if (event.getPreviousServer().isPresent())
+        {
+            Plex.get().server.sendMessage(miniMessage("<dark_gray>[<#ffbf00>o<dark_gray>] <yellow>"
+                    + event.getPlayer().getUsername() + " switched from " + event.getPreviousServer().get().getServerInfo().getName()
+                    + " to " + event.getServer().getServerInfo().getName()));
+        }
+        else
+        {
+            Plex.get().server.sendMessage(miniMessage("<dark_gray>[<green>+<dark_gray>] <yellow>"
+                    + event.getPlayer().getUsername() + " joined server " + event.getServer().getServerInfo().getName()));
+        }
+    }
+
+    @Subscribe(order = PostOrder.FIRST)
+    public void onPlayerLeave(DisconnectEvent event)
+    {
+        if (event.getPlayer().getCurrentServer().isPresent())
+        {
+            Plex.get().server.sendMessage(miniMessage("<dark_gray>[<red>-<dark_gray>] <yellow>"
+                    + event.getPlayer().getUsername() + " left server " +
+                    event.getPlayer().getCurrentServer().get().getServerInfo().getName()));
+        }
+    }
+
+    private Component miniMessage(String message)
+    {
+        return MiniMessage.miniMessage().deserialize(message);
+    }
+}

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

@@ -0,0 +1,62 @@
+package dev.plex.listener.impl;
+
+import com.velocitypowered.api.event.PostOrder;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.proxy.ProxyPingEvent;
+import com.velocitypowered.api.proxy.server.ServerPing;
+import dev.plex.listener.PlexListener;
+import dev.plex.settings.ServerSettings;
+import dev.plex.util.RandomUtil;
+import java.util.UUID;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public class ServerListener extends PlexListener
+{
+    @Subscribe(order = PostOrder.FIRST)
+    public void onPing(ProxyPingEvent event)
+    {
+        String baseMotd = plugin.getConfig().as(ServerSettings.class).getServer().getMotd().get(ThreadLocalRandom.current().nextInt(plugin.getConfig().as(ServerSettings.class).getServer().getMotd().size()));
+        baseMotd = baseMotd.replace("\\n", "\n");
+        baseMotd = baseMotd.replace("%servername%", plugin.getConfig().as(ServerSettings.class).getServer().getName());
+        baseMotd = baseMotd.replace("%mcversion%", plugin.getServer().getVersion().getVersion().split(" ")[0]);
+        baseMotd = baseMotd.replace("%randomgradient%", "<gradient:" + RandomUtil.getRandomColor().toString() + ":" + RandomUtil.getRandomColor().toString() + ">");
+
+        ServerPing.Builder builder = event.getPing().asBuilder();
+
+        if (plugin.getConfig().as(ServerSettings.class).getServer().isColorizeMotd())
+        {
+            AtomicReference<Component> motd = new AtomicReference<>(Component.empty());
+            for (final String word : baseMotd.split(" "))
+            {
+                motd.set(motd.get().append(Component.text(word).color(RandomUtil.getRandomColor())));
+                motd.set(motd.get().append(Component.space()));
+            }
+            builder.description(motd.get());
+        }
+        else
+        {
+            builder.description(MiniMessage.miniMessage().deserialize(baseMotd));
+        }
+
+        builder.samplePlayers(plugin.getConfig().as(ServerSettings.class).getServer().getSample().stream().map(s -> new ServerPing.SamplePlayer(convertColorCodes(s), UUID.randomUUID())).toArray(ServerPing.SamplePlayer[]::new));
+        builder.onlinePlayers(plugin.getServer().getPlayerCount() + plugin.getConfig().as(ServerSettings.class).getServer().getAddPlayerCount());
+        if (plugin.getConfig().as(ServerSettings.class).getServer().isPlusOneMaxPlayer())
+        {
+            builder.maximumPlayers(builder.getOnlinePlayers() + 1);
+        }
+
+        event.setPing(builder.build());
+
+    }
+
+    private String convertColorCodes(String code)
+    {
+        Matcher matcher = Pattern.compile("[&][0-9a-fk-or]{1}").matcher(code);
+        return matcher.replaceAll(matchResult -> "§" + matcher.group().substring(1));
+    }
+}

proxy/src/main/java/dev/plex/settings/ServerSettings.java

@@ -0,0 +1,27 @@
+package dev.plex.settings;
+
+import com.google.common.collect.Lists;
+import com.google.gson.annotations.SerializedName;
+import java.util.List;
+import lombok.Data;
+import lombok.Getter;
+
+@Getter
+public class ServerSettings
+{
+    private final Server server = new Server();
+
+    @Data
+    public static class Server
+    {
+        private String name = "Server";
+        private List<String> motd = Lists.newArrayList("%randomgradient%%servername% - %mcversion%", "Another motd");
+        private boolean colorizeMotd = false;
+        private boolean debug = false;
+        private final List<String> sample = Lists.newArrayList("example", "example");
+        @SerializedName(value = "add-player-count")
+        private int addPlayerCount = 0;
+        @SerializedName(value = "plus-one-max-count")
+        private boolean plusOneMaxPlayer = true;
+    }
+}

proxy/src/main/java/dev/plex/toml/ArrayValueReader.java

@@ -0,0 +1,108 @@
+package dev.plex.toml;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ArrayValueReader implements ValueReader
+{
+
+    public static final ArrayValueReader ARRAY_VALUE_READER = new ArrayValueReader();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("[");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, dev.plex.toml.Context context)
+    {
+        AtomicInteger line = context.line;
+        int startLine = line.get();
+        int startIndex = index.get();
+        List<Object> arrayItems = new ArrayList<Object>();
+        boolean terminated = false;
+        boolean inComment = false;
+        dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
+
+        for (int i = index.incrementAndGet(); i < s.length(); i = index.incrementAndGet())
+        {
+
+            char c = s.charAt(i);
+
+            if (c == '#' && !inComment)
+            {
+                inComment = true;
+            }
+            else if (c == '\n')
+            {
+                inComment = false;
+                line.incrementAndGet();
+            }
+            else if (inComment || Character.isWhitespace(c) || c == ',')
+            {
+                continue;
+            }
+            else if (c == '[')
+            {
+                Object converted = read(s, index, context);
+                if (converted instanceof dev.plex.toml.Results.Errors)
+                {
+                    errors.add((dev.plex.toml.Results.Errors) converted);
+                }
+                else if (!isHomogenousArray(converted, arrayItems))
+                {
+                    errors.heterogenous(context.identifier.getName(), line.get());
+                }
+                else
+                {
+                    arrayItems.add(converted);
+                }
+                continue;
+            }
+            else if (c == ']')
+            {
+                terminated = true;
+                break;
+            }
+            else
+            {
+                Object converted = ValueReaders.VALUE_READERS.convert(s, index, context);
+                if (converted instanceof dev.plex.toml.Results.Errors)
+                {
+                    errors.add((dev.plex.toml.Results.Errors) converted);
+                }
+                else if (!isHomogenousArray(converted, arrayItems))
+                {
+                    errors.heterogenous(context.identifier.getName(), line.get());
+                }
+                else
+                {
+                    arrayItems.add(converted);
+                }
+            }
+        }
+
+        if (!terminated)
+        {
+            errors.unterminated(context.identifier.getName(), s.substring(startIndex), startLine);
+        }
+
+        if (errors.hasErrors())
+        {
+            return errors;
+        }
+
+        return arrayItems;
+    }
+
+    private boolean isHomogenousArray(Object o, List<?> values)
+    {
+        return values.isEmpty() || values.get(0).getClass().isAssignableFrom(o.getClass()) || o.getClass().isAssignableFrom(values.get(0).getClass());
+    }
+
+    private ArrayValueReader()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/ArrayValueWriter.java

@@ -0,0 +1,82 @@
+package dev.plex.toml;
+
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import static dev.plex.toml.ValueWriters.WRITERS;
+
+public abstract class ArrayValueWriter implements dev.plex.toml.ValueWriter
+{
+    static protected boolean isArrayish(Object value)
+    {
+        return value instanceof Collection || value.getClass().isArray();
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return false;
+    }
+
+    static boolean isArrayOfPrimitive(Object array)
+    {
+        Object first = peek(array);
+        if (first != null)
+        {
+            dev.plex.toml.ValueWriter valueWriter = WRITERS.findWriterFor(first);
+            return valueWriter.isPrimitiveType() || isArrayish(first);
+        }
+
+        return true;
+    }
+
+    @SuppressWarnings("unchecked")
+    protected Collection<?> normalize(Object value)
+    {
+        Collection<Object> collection;
+
+        if (value.getClass().isArray())
+        {
+            // Arrays.asList() interprets an array as a single element,
+            // so convert it to a list by hand
+            collection = new ArrayList<Object>(Array.getLength(value));
+            for (int i = 0; i < Array.getLength(value); i++)
+            {
+                Object elem = Array.get(value, i);
+                collection.add(elem);
+            }
+        }
+        else
+        {
+            collection = (Collection<Object>) value;
+        }
+
+        return collection;
+    }
+
+    private static Object peek(Object value)
+    {
+        if (value.getClass().isArray())
+        {
+            if (Array.getLength(value) > 0)
+            {
+                return Array.get(value, 0);
+            }
+            else
+            {
+                return null;
+            }
+        }
+        else
+        {
+            Collection<?> collection = (Collection<?>) value;
+            if (collection.size() > 0)
+            {
+                return collection.iterator().next();
+            }
+        }
+
+        return null;
+    }
+}

proxy/src/main/java/dev/plex/toml/BooleanValueReaderWriter.java

@@ -0,0 +1,57 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+
+class BooleanValueReaderWriter implements ValueReader, ValueWriter
+{
+
+    static final BooleanValueReaderWriter BOOLEAN_VALUE_READER_WRITER = new BooleanValueReaderWriter();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("true") || s.startsWith("false");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, Context context)
+    {
+        s = s.substring(index.get());
+        Boolean b = s.startsWith("true") ? Boolean.TRUE : Boolean.FALSE;
+
+        int endIndex = b == Boolean.TRUE ? 4 : 5;
+
+        index.addAndGet(endIndex - 1);
+
+        return b;
+    }
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return value instanceof Boolean;
+    }
+
+    @Override
+    public void write(Object value, WriterContext context)
+    {
+        context.write(value.toString());
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return true;
+    }
+
+    private BooleanValueReaderWriter()
+    {
+    }
+
+    @Override
+    public String toString()
+    {
+        return "boolean";
+    }
+}

proxy/src/main/java/dev/plex/toml/Container.java

@@ -0,0 +1,152 @@
+package dev.plex.toml;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public abstract class Container
+{
+
+    abstract boolean accepts(String key);
+
+    abstract void put(String key, Object value);
+
+    abstract Object get(String key);
+
+    abstract boolean isImplicit();
+
+    static class Table extends Container
+    {
+        private final Map<String, Object> values = new HashMap<String, Object>();
+        final String name;
+        final boolean implicit;
+
+        Table()
+        {
+            this(null, false);
+        }
+
+        public Table(String name)
+        {
+            this(name, false);
+        }
+
+        public Table(String tableName, boolean implicit)
+        {
+            this.name = tableName;
+            this.implicit = implicit;
+        }
+
+        @Override
+        boolean accepts(String key)
+        {
+            return !values.containsKey(key) || values.get(key) instanceof TableArray;
+        }
+
+        @Override
+        void put(String key, Object value)
+        {
+            values.put(key, value);
+        }
+
+        @Override
+        Object get(String key)
+        {
+            return values.get(key);
+        }
+
+        boolean isImplicit()
+        {
+            return implicit;
+        }
+
+        /**
+         * This modifies the Table's internal data structure, such that it is no longer usable.
+         * <p>
+         * Therefore, this method must only be called when all data has been gathered.
+         *
+         * @return A Map-and-List-based of the TOML data
+         */
+        Map<String, Object> consume()
+        {
+            for (Map.Entry<String, Object> entry : values.entrySet())
+            {
+                if (entry.getValue() instanceof Table)
+                {
+                    entry.setValue(((Table) entry.getValue()).consume());
+                }
+                else if (entry.getValue() instanceof TableArray)
+                {
+                    entry.setValue(((TableArray) entry.getValue()).getValues());
+                }
+            }
+
+            return values;
+        }
+
+        @Override
+        public String toString()
+        {
+            return values.toString();
+        }
+    }
+
+    static class TableArray extends Container
+    {
+        private final List<Table> values = new ArrayList<Table>();
+
+        TableArray()
+        {
+            values.add(new Table());
+        }
+
+        @Override
+        boolean accepts(String key)
+        {
+            return getCurrent().accepts(key);
+        }
+
+        @Override
+        void put(String key, Object value)
+        {
+            values.add((Table) value);
+        }
+
+        @Override
+        Object get(String key)
+        {
+            throw new UnsupportedOperationException();
+        }
+
+        boolean isImplicit()
+        {
+            return false;
+        }
+
+        List<Map<String, Object>> getValues()
+        {
+            ArrayList<Map<String, Object>> unwrappedValues = new ArrayList<Map<String, Object>>();
+            for (Table table : values)
+            {
+                unwrappedValues.add(table.consume());
+            }
+            return unwrappedValues;
+        }
+
+        Table getCurrent()
+        {
+            return values.get(values.size() - 1);
+        }
+
+        @Override
+        public String toString()
+        {
+            return values.toString();
+        }
+    }
+
+    private Container()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/Context.java

@@ -0,0 +1,22 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Context
+{
+    final dev.plex.toml.Identifier identifier;
+    final AtomicInteger line;
+    final Results.Errors errors;
+
+    public Context(dev.plex.toml.Identifier identifier, AtomicInteger line, Results.Errors errors)
+    {
+        this.identifier = identifier;
+        this.line = line;
+        this.errors = errors;
+    }
+
+    public Context with(dev.plex.toml.Identifier identifier)
+    {
+        return new Context(identifier, line, errors);
+    }
+}

proxy/src/main/java/dev/plex/toml/DatePolicy.java

@@ -0,0 +1,26 @@
+package dev.plex.toml;
+
+import java.util.TimeZone;
+
+public class DatePolicy
+{
+
+    private final TimeZone timeZone;
+    private final boolean showFractionalSeconds;
+
+    DatePolicy(TimeZone timeZone, boolean showFractionalSeconds)
+    {
+        this.timeZone = timeZone;
+        this.showFractionalSeconds = showFractionalSeconds;
+    }
+
+    TimeZone getTimeZone()
+    {
+        return timeZone;
+    }
+
+    boolean isShowFractionalSeconds()
+    {
+        return showFractionalSeconds;
+    }
+}

proxy/src/main/java/dev/plex/toml/DateValueReaderWriter.java

@@ -0,0 +1,204 @@
+package dev.plex.toml;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class DateValueReaderWriter implements ValueReader, ValueWriter
+{
+
+    static final DateValueReaderWriter DATE_VALUE_READER_WRITER = new DateValueReaderWriter();
+    static final DateValueReaderWriter DATE_PARSER_JDK_6 = new DateConverterJdk6();
+    private static final Pattern DATE_REGEX = Pattern.compile("(\\d{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9])(\\.\\d*)?(Z|(?:[+\\-]\\d{2}:\\d{2}))(.*)");
+
+    @Override
+    public boolean canRead(String s)
+    {
+        if (s.length() < 5)
+        {
+            return false;
+        }
+
+        for (int i = 0; i < 5; i++)
+        {
+            char c = s.charAt(i);
+
+            if (i < 4)
+            {
+                if (!Character.isDigit(c))
+                {
+                    return false;
+                }
+            }
+            else if (c != '-')
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public Object read(String original, AtomicInteger index, Context context)
+    {
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = index.get(); i < original.length(); i = index.incrementAndGet())
+        {
+            char c = original.charAt(i);
+            if (Character.isDigit(c) || c == '-' || c == '+' || c == ':' || c == '.' || c == 'T' || c == 'Z')
+            {
+                sb.append(c);
+            }
+            else
+            {
+                index.decrementAndGet();
+                break;
+            }
+        }
+
+        String s = sb.toString();
+        Matcher matcher = DATE_REGEX.matcher(s);
+
+        if (!matcher.matches())
+        {
+            Results.Errors errors = new Results.Errors();
+            errors.invalidValue(context.identifier.getName(), s, context.line.get());
+            return errors;
+        }
+
+        String dateString = matcher.group(1);
+        String zone = matcher.group(3);
+        String fractionalSeconds = matcher.group(2);
+        String format = "yyyy-MM-dd'T'HH:mm:ss";
+        if (fractionalSeconds != null && !fractionalSeconds.isEmpty())
+        {
+            format += ".SSS";
+            dateString += fractionalSeconds;
+        }
+        format += "Z";
+        if ("Z".equals(zone))
+        {
+            dateString += "+0000";
+        }
+        else if (zone.contains(":"))
+        {
+            dateString += zone.replace(":", "");
+        }
+
+        try
+        {
+            SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+            dateFormat.setLenient(false);
+            return dateFormat.parse(dateString);
+        }
+        catch (Exception e)
+        {
+            Results.Errors errors = new Results.Errors();
+            errors.invalidValue(context.identifier.getName(), s, context.line.get());
+            return errors;
+        }
+    }
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return value instanceof Date;
+    }
+
+    @Override
+    public void write(Object value, WriterContext context)
+    {
+        DateFormat formatter = getFormatter(context.getDatePolicy());
+        context.write(formatter.format(value));
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return true;
+    }
+
+    private DateFormat getFormatter(DatePolicy datePolicy)
+    {
+        boolean utc = "UTC".equals(datePolicy.getTimeZone().getID());
+        String format;
+
+        if (utc && datePolicy.isShowFractionalSeconds())
+        {
+            format = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
+        }
+        else if (utc)
+        {
+            format = "yyyy-MM-dd'T'HH:mm:ss'Z'";
+        }
+        else if (datePolicy.isShowFractionalSeconds())
+        {
+            format = getTimeZoneAndFractionalSecondsFormat();
+        }
+        else
+        {
+            format = getTimeZoneFormat();
+        }
+        SimpleDateFormat formatter = new SimpleDateFormat(format);
+        formatter.setTimeZone(datePolicy.getTimeZone());
+
+        return formatter;
+    }
+
+    String getTimeZoneFormat()
+    {
+        return "yyyy-MM-dd'T'HH:mm:ssXXX";
+    }
+
+    String getTimeZoneAndFractionalSecondsFormat()
+    {
+        return "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
+    }
+
+    private DateValueReaderWriter()
+    {
+    }
+
+    private static class DateConverterJdk6 extends DateValueReaderWriter
+    {
+        @Override
+        public void write(Object value, WriterContext context)
+        {
+            DateFormat formatter = super.getFormatter(context.getDatePolicy());
+            String date = formatter.format(value);
+
+            if ("UTC".equals(context.getDatePolicy().getTimeZone().getID()))
+            {
+                context.write(date);
+            }
+            else
+            {
+                int insertionIndex = date.length() - 2;
+                context.write(date.substring(0, insertionIndex)).write(':').write(date.substring(insertionIndex));
+            }
+        }
+
+        @Override
+        String getTimeZoneAndFractionalSecondsFormat()
+        {
+            return "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
+        }
+
+        @Override
+        String getTimeZoneFormat()
+        {
+            return "yyyy-MM-dd'T'HH:mm:ssZ";
+        }
+    }
+
+    @Override
+    public String toString()
+    {
+        return "datetime";
+    }
+}

proxy/src/main/java/dev/plex/toml/Identifier.java

@@ -0,0 +1,341 @@
+package dev.plex.toml;
+
+public class Identifier
+{
+
+    static final Identifier INVALID = new Identifier("", null);
+
+    private static final String ALLOWED_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_-";
+
+    private final String name;
+    private final Type type;
+
+    static Identifier from(String name, Context context)
+    {
+        Type type;
+        boolean valid;
+        name = name.trim();
+        if (name.startsWith("[["))
+        {
+            type = Type.TABLE_ARRAY;
+            valid = isValidTableArray(name, context);
+        }
+        else if (name.startsWith("["))
+        {
+            type = Type.TABLE;
+            valid = isValidTable(name, context);
+        }
+        else
+        {
+            type = Type.KEY;
+            valid = isValidKey(name, context);
+        }
+
+        if (!valid)
+        {
+            return Identifier.INVALID;
+        }
+
+        return new Identifier(extractName(name), type);
+    }
+
+    private Identifier(String name, Type type)
+    {
+        this.name = name;
+        this.type = type;
+    }
+
+    String getName()
+    {
+        return name;
+    }
+
+    String getBareName()
+    {
+        if (isKey())
+        {
+            return name;
+        }
+
+        if (isTable())
+        {
+            return name.substring(1, name.length() - 1);
+        }
+
+        return name.substring(2, name.length() - 2);
+    }
+
+    boolean isKey()
+    {
+        return type == Type.KEY;
+    }
+
+    boolean isTable()
+    {
+        return type == Type.TABLE;
+    }
+
+    boolean isTableArray()
+    {
+        return type == Type.TABLE_ARRAY;
+    }
+
+    private enum Type
+    {
+        KEY, TABLE, TABLE_ARRAY
+    }
+
+    private static String extractName(String raw)
+    {
+        boolean quoted = false;
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = 0; i < raw.length(); i++)
+        {
+            char c = raw.charAt(i);
+            if (c == '"' && (i == 0 || raw.charAt(i - 1) != '\\'))
+            {
+                quoted = !quoted;
+                sb.append('"');
+            }
+            else if (quoted || !Character.isWhitespace(c))
+            {
+                sb.append(c);
+            }
+        }
+
+        return StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceUnicodeCharacters(sb.toString());
+    }
+
+    private static boolean isValidKey(String name, Context context)
+    {
+        if (name.trim().isEmpty())
+        {
+            context.errors.invalidKey(name, context.line.get());
+            return false;
+        }
+
+        boolean quoted = false;
+        for (int i = 0; i < name.length(); i++)
+        {
+            char c = name.charAt(i);
+
+            if (c == '"' && (i == 0 || name.charAt(i - 1) != '\\'))
+            {
+                if (!quoted && i > 0 && name.charAt(i - 1) != '.')
+                {
+                    context.errors.invalidKey(name, context.line.get());
+                    return false;
+                }
+                quoted = !quoted;
+            }
+            else if (!quoted && (ALLOWED_CHARS.indexOf(c) == -1))
+            {
+                context.errors.invalidKey(name, context.line.get());
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static boolean isValidTable(String name, Context context)
+    {
+        boolean valid = name.endsWith("]");
+
+        String trimmed = name.substring(1, name.length() - 1).trim();
+        if (trimmed.isEmpty() || trimmed.charAt(0) == '.' || trimmed.endsWith("."))
+        {
+            valid = false;
+        }
+
+        if (!valid)
+        {
+            context.errors.invalidTable(name, context.line.get());
+            return false;
+        }
+
+        boolean quoted = false;
+        boolean dotAllowed = false;
+        boolean quoteAllowed = true;
+        boolean charAllowed = true;
+
+        for (int i = 0; i < trimmed.length(); i++)
+        {
+            char c = trimmed.charAt(i);
+
+            if (!valid)
+            {
+                break;
+            }
+
+            if (Keys.isQuote(c))
+            {
+                if (!quoteAllowed)
+                {
+                    valid = false;
+                }
+                else if (quoted && trimmed.charAt(i - 1) != '\\')
+                {
+                    charAllowed = false;
+                    dotAllowed = true;
+                    quoteAllowed = false;
+                }
+                else if (!quoted)
+                {
+                    quoted = true;
+                    quoteAllowed = true;
+                }
+            }
+            else if (quoted)
+            {
+                continue;
+            }
+            else if (c == '.')
+            {
+                if (dotAllowed)
+                {
+                    charAllowed = true;
+                    dotAllowed = false;
+                    quoteAllowed = true;
+                }
+                else
+                {
+                    context.errors.emptyImplicitTable(name, context.line.get());
+                    return false;
+                }
+            }
+            else if (Character.isWhitespace(c))
+            {
+                char prev = trimmed.charAt(i - 1);
+                if (!Character.isWhitespace(prev) && prev != '.')
+                {
+                    charAllowed = false;
+                    dotAllowed = true;
+                    quoteAllowed = true;
+                }
+            }
+            else
+            {
+                if (charAllowed && ALLOWED_CHARS.indexOf(c) > -1)
+                {
+                    charAllowed = true;
+                    dotAllowed = true;
+                    quoteAllowed = false;
+                }
+                else
+                {
+                    valid = false;
+                }
+            }
+        }
+
+        if (!valid)
+        {
+            context.errors.invalidTable(name, context.line.get());
+            return false;
+        }
+
+        return true;
+    }
+
+    private static boolean isValidTableArray(String line, Context context)
+    {
+        boolean valid = line.endsWith("]]");
+
+        String trimmed = line.substring(2, line.length() - 2).trim();
+        if (trimmed.isEmpty() || trimmed.charAt(0) == '.' || trimmed.endsWith("."))
+        {
+            valid = false;
+        }
+
+        if (!valid)
+        {
+            context.errors.invalidTableArray(line, context.line.get());
+            return false;
+        }
+
+        boolean quoted = false;
+        boolean dotAllowed = false;
+        boolean quoteAllowed = true;
+        boolean charAllowed = true;
+
+        for (int i = 0; i < trimmed.length(); i++)
+        {
+            char c = trimmed.charAt(i);
+
+            if (!valid)
+            {
+                break;
+            }
+
+            if (c == '"')
+            {
+                if (!quoteAllowed)
+                {
+                    valid = false;
+                }
+                else if (quoted && trimmed.charAt(i - 1) != '\\')
+                {
+                    charAllowed = false;
+                    dotAllowed = true;
+                    quoteAllowed = false;
+                }
+                else if (!quoted)
+                {
+                    quoted = true;
+                    quoteAllowed = true;
+                }
+            }
+            else if (quoted)
+            {
+                continue;
+            }
+            else if (c == '.')
+            {
+                if (dotAllowed)
+                {
+                    charAllowed = true;
+                    dotAllowed = false;
+                    quoteAllowed = true;
+                }
+                else
+                {
+                    context.errors.emptyImplicitTable(line, context.line.get());
+                    return false;
+                }
+            }
+            else if (Character.isWhitespace(c))
+            {
+                char prev = trimmed.charAt(i - 1);
+                if (!Character.isWhitespace(prev) && prev != '.' && prev != '"')
+                {
+                    charAllowed = false;
+                    dotAllowed = true;
+                    quoteAllowed = true;
+                }
+            }
+            else
+            {
+                if (charAllowed && ALLOWED_CHARS.indexOf(c) > -1)
+                {
+                    charAllowed = true;
+                    dotAllowed = true;
+                    quoteAllowed = false;
+                }
+                else
+                {
+                    valid = false;
+                }
+            }
+        }
+
+        if (!valid)
+        {
+            context.errors.invalidTableArray(line, context.line.get());
+            return false;
+        }
+
+        return true;
+    }
+}

proxy/src/main/java/dev/plex/toml/IdentifierConverter.java

@@ -0,0 +1,88 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class IdentifierConverter
+{
+
+    static final IdentifierConverter IDENTIFIER_CONVERTER = new IdentifierConverter();
+
+    Identifier convert(String s, AtomicInteger index, Context context)
+    {
+        boolean quoted = false;
+        StringBuilder name = new StringBuilder();
+        boolean terminated = false;
+        boolean isKey = s.charAt(index.get()) != '[';
+        boolean isTableArray = !isKey && s.length() > index.get() + 1 && s.charAt(index.get() + 1) == '[';
+        boolean inComment = false;
+
+        for (int i = index.get(); i < s.length(); i = index.incrementAndGet())
+        {
+            char c = s.charAt(i);
+            if (Keys.isQuote(c) && (i == 0 || s.charAt(i - 1) != '\\'))
+            {
+                quoted = !quoted;
+                name.append(c);
+            }
+            else if (c == '\n')
+            {
+                index.decrementAndGet();
+                break;
+            }
+            else if (quoted)
+            {
+                name.append(c);
+            }
+            else if (c == '=' && isKey)
+            {
+                terminated = true;
+                break;
+            }
+            else if (c == ']' && !isKey)
+            {
+                if (!isTableArray || s.length() > index.get() + 1 && s.charAt(index.get() + 1) == ']')
+                {
+                    terminated = true;
+                    name.append(']');
+                    if (isTableArray)
+                    {
+                        name.append(']');
+                    }
+                }
+            }
+            else if (terminated && c == '#')
+            {
+                inComment = true;
+            }
+            else if (terminated && !Character.isWhitespace(c) && !inComment)
+            {
+                terminated = false;
+                break;
+            }
+            else if (!terminated)
+            {
+                name.append(c);
+            }
+        }
+
+        if (!terminated)
+        {
+            if (isKey)
+            {
+                context.errors.unterminatedKey(name.toString(), context.line.get());
+            }
+            else
+            {
+                context.errors.invalidKey(name.toString(), context.line.get());
+            }
+
+            return Identifier.INVALID;
+        }
+
+        return Identifier.from(name.toString(), context);
+    }
+
+    private IdentifierConverter()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/IndentationPolicy.java

@@ -0,0 +1,35 @@
+package dev.plex.toml;
+
+/**
+ * Controls how a {@link TomlWriter} indents tables and key/value pairs.
+ * <p>
+ * The default policy is to not indent.
+ */
+public class IndentationPolicy
+{
+    private final int tableIndent;
+    private final int keyValueIndent;
+    private final int arrayDelimiterPadding;
+
+    IndentationPolicy(int keyIndentation, int tableIndentation, int arrayDelimiterPadding)
+    {
+        this.keyValueIndent = keyIndentation;
+        this.tableIndent = tableIndentation;
+        this.arrayDelimiterPadding = arrayDelimiterPadding;
+    }
+
+    int getTableIndent()
+    {
+        return tableIndent;
+    }
+
+    int getKeyValueIndent()
+    {
+        return keyValueIndent;
+    }
+
+    int getArrayDelimiterPadding()
+    {
+        return arrayDelimiterPadding;
+    }
+}

proxy/src/main/java/dev/plex/toml/InlineTableValueReader.java

@@ -0,0 +1,94 @@
+package dev.plex.toml;
+
+import java.util.HashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+class InlineTableValueReader implements dev.plex.toml.ValueReader
+{
+
+    static final InlineTableValueReader INLINE_TABLE_VALUE_READER = new InlineTableValueReader();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("{");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger sharedIndex, dev.plex.toml.Context context)
+    {
+        AtomicInteger line = context.line;
+        int startLine = line.get();
+        int startIndex = sharedIndex.get();
+        boolean inKey = true;
+        boolean inValue = false;
+        boolean terminated = false;
+        StringBuilder currentKey = new StringBuilder();
+        HashMap<String, Object> results = new HashMap<String, Object>();
+        dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
+
+        for (int i = sharedIndex.incrementAndGet(); sharedIndex.get() < s.length(); i = sharedIndex.incrementAndGet())
+        {
+            char c = s.charAt(i);
+
+            if (inValue && !Character.isWhitespace(c))
+            {
+                Object converted = dev.plex.toml.ValueReaders.VALUE_READERS.convert(s, sharedIndex, context.with(dev.plex.toml.Identifier.from(currentKey.toString(), context)));
+
+                if (converted instanceof dev.plex.toml.Results.Errors)
+                {
+                    errors.add((dev.plex.toml.Results.Errors) converted);
+                    return errors;
+                }
+
+                String currentKeyTrimmed = currentKey.toString().trim();
+                Object previous = results.put(currentKeyTrimmed, converted);
+
+                if (previous != null)
+                {
+                    errors.duplicateKey(currentKeyTrimmed, context.line.get());
+                    return errors;
+                }
+
+                currentKey = new StringBuilder();
+                inValue = false;
+            }
+            else if (c == ',')
+            {
+                inKey = true;
+                inValue = false;
+                currentKey = new StringBuilder();
+            }
+            else if (c == '=')
+            {
+                inKey = false;
+                inValue = true;
+            }
+            else if (c == '}')
+            {
+                terminated = true;
+                break;
+            }
+            else if (inKey)
+            {
+                currentKey.append(c);
+            }
+        }
+
+        if (!terminated)
+        {
+            errors.unterminated(context.identifier.getName(), s.substring(startIndex), startLine);
+        }
+
+        if (errors.hasErrors())
+        {
+            return errors;
+        }
+
+        return results;
+    }
+
+    private InlineTableValueReader()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/Keys.java

@@ -0,0 +1,86 @@
+package dev.plex.toml;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Keys
+{
+
+    static class Key
+    {
+        final String name;
+        final int index;
+        final String path;
+
+        Key(String name, int index, Key next)
+        {
+            this.name = name;
+            this.index = index;
+            if (next != null)
+            {
+                this.path = name + "." + next.path;
+            }
+            else
+            {
+                this.path = name;
+            }
+        }
+    }
+
+    static Key[] split(String key)
+    {
+        List<Key> splitKey = new ArrayList<Key>();
+        StringBuilder current = new StringBuilder();
+        boolean quoted = false;
+        boolean indexable = true;
+        boolean inIndex = false;
+        int index = -1;
+
+        for (int i = key.length() - 1; i > -1; i--)
+        {
+            char c = key.charAt(i);
+            if (c == ']' && indexable)
+            {
+                inIndex = true;
+                continue;
+            }
+            indexable = false;
+            if (c == '[' && inIndex)
+            {
+                inIndex = false;
+                index = Integer.parseInt(current.toString());
+                current = new StringBuilder();
+                continue;
+            }
+            if (isQuote(c) && (i == 0 || key.charAt(i - 1) != '\\'))
+            {
+                quoted = !quoted;
+                indexable = false;
+            }
+            if (c != '.' || quoted)
+            {
+                current.insert(0, c);
+            }
+            else
+            {
+                splitKey.add(0, new Key(current.toString(), index, !splitKey.isEmpty() ? splitKey.get(0) : null));
+                indexable = true;
+                index = -1;
+                current = new StringBuilder();
+            }
+        }
+
+        splitKey.add(0, new Key(current.toString(), index, !splitKey.isEmpty() ? splitKey.get(0) : null));
+
+        return splitKey.toArray(new Key[0]);
+    }
+
+    static boolean isQuote(char c)
+    {
+        return c == '"' || c == '\'';
+    }
+
+    private Keys()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/LiteralStringValueReader.java

@@ -0,0 +1,48 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class LiteralStringValueReader implements ValueReader
+{
+    public static final LiteralStringValueReader LITERAL_STRING_VALUE_READER = new LiteralStringValueReader();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("'");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, dev.plex.toml.Context context)
+    {
+        int startLine = context.line.get();
+        boolean terminated = false;
+        int startIndex = index.incrementAndGet();
+
+        for (int i = index.get(); i < s.length(); i = index.incrementAndGet())
+        {
+            char c = s.charAt(i);
+
+            if (c == '\'')
+            {
+                terminated = true;
+                break;
+            }
+        }
+
+        if (!terminated)
+        {
+            Results.Errors errors = new Results.Errors();
+            errors.unterminated(context.identifier.getName(), s.substring(startIndex), startLine);
+            return errors;
+        }
+
+        String substring = s.substring(startIndex, index.get());
+
+        return substring;
+    }
+
+    private LiteralStringValueReader()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/MapValueWriter.java

@@ -0,0 +1,181 @@
+package dev.plex.toml;
+
+
+import java.io.File;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+class MapValueWriter implements dev.plex.toml.ValueWriter
+{
+    static final dev.plex.toml.ValueWriter MAP_VALUE_WRITER = new MapValueWriter();
+
+    private static final Pattern REQUIRED_QUOTING_PATTERN = Pattern.compile("^.*[^A-Za-z\\d_-].*$");
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return value instanceof Map;
+    }
+
+    @Override
+    public void write(Object value, WriterContext context)
+    {
+        File file = null;
+        if (context.file != null)
+        {
+            file = context.file;
+        }
+
+        Map<?, ?> from = (Map<?, ?>) value;
+
+        Toml toml = null;
+
+        if (file != null)
+        {
+            toml = new Toml().read(file);
+        }
+
+        if (hasPrimitiveValues(from, context))
+        {
+            if (context.hasRun)
+            {
+                if (toml != null)
+                {
+                    if (!toml.getValues().containsKey(context.key))
+                    {
+                        context.writeKey();
+                    }
+                }
+                else
+                {
+                    context.writeKey();
+                }
+            }
+
+        }
+
+
+        // Render primitive types and arrays of primitive first so they are
+        // grouped under the same table (if there is one)
+        for (Map.Entry<?, ?> entry : from.entrySet())
+        {
+            Object key = entry.getKey();
+            Object fromValue = entry.getValue();
+            if (fromValue == null)
+            {
+                continue;
+            }
+
+            if (context.hasRun && toml != null)
+            {
+                if (context.key != null)
+                {
+                    if (key.toString().equalsIgnoreCase(context.key))
+                    {
+                        continue;
+                    }
+                    if (toml.contains(context.key + "." + key))
+                    {
+                        continue;
+                    }
+                }
+            }
+
+            dev.plex.toml.ValueWriter valueWriter = dev.plex.toml.ValueWriters.WRITERS.findWriterFor(fromValue);
+            if (valueWriter.isPrimitiveType())
+            {
+                context.indent();
+                context.write(quoteKey(key)).write(" = ");
+                valueWriter.write(fromValue, context);
+                context.write('\n');
+            }
+            else if (valueWriter == dev.plex.toml.PrimitiveArrayValueWriter.PRIMITIVE_ARRAY_VALUE_WRITER)
+            {
+                context.indent();
+                context.setArrayKey(key.toString());
+                context.write(quoteKey(key)).write(" = ");
+                valueWriter.write(fromValue, context);
+                context.write('\n');
+            }
+        }
+
+        // Now render (sub)tables and arrays of tables
+        for (Object key : from.keySet())
+        {
+            Object fromValue = from.get(key);
+            if (fromValue == null)
+            {
+                continue;
+            }
+
+            if (context.hasRun && toml != null)
+            {
+                if (context.key != null)
+                {
+                    if (key.toString().equalsIgnoreCase(context.key))
+                    {
+                        continue;
+                    }
+                    if (toml.contains(context.key + "." + key))
+                    {
+                        continue;
+                    }
+                }
+            }
+
+            dev.plex.toml.ValueWriter valueWriter = dev.plex.toml.ValueWriters.WRITERS.findWriterFor(fromValue);
+            if (valueWriter == this || valueWriter == dev.plex.toml.ObjectValueWriter.OBJECT_VALUE_WRITER || valueWriter == dev.plex.toml.TableArrayValueWriter.TABLE_ARRAY_VALUE_WRITER)
+            {
+                WriterContext context1 = context.pushTable(quoteKey(key));
+                context1.parentName = key.toString();
+                context1.hasRun = true;
+                context1.file = context.file;
+                valueWriter.write(fromValue, context1);
+            }
+        }
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return false;
+    }
+
+    private static String quoteKey(Object key)
+    {
+        String stringKey = key.toString();
+        Matcher matcher = REQUIRED_QUOTING_PATTERN.matcher(stringKey);
+        if (matcher.matches())
+        {
+            stringKey = "\"" + stringKey + "\"";
+        }
+
+        return stringKey;
+    }
+
+    private static boolean hasPrimitiveValues(Map<?, ?> values, WriterContext context)
+    {
+        for (Object key : values.keySet())
+        {
+            Object fromValue = values.get(key);
+            if (fromValue == null)
+            {
+                continue;
+            }
+
+            dev.plex.toml.ValueWriter valueWriter = dev.plex.toml.ValueWriters.WRITERS.findWriterFor(fromValue);
+            if (valueWriter.isPrimitiveType() || valueWriter == dev.plex.toml.PrimitiveArrayValueWriter.PRIMITIVE_ARRAY_VALUE_WRITER)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    private MapValueWriter()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/MultilineLiteralStringValueReader.java

@@ -0,0 +1,61 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+class MultilineLiteralStringValueReader implements ValueReader
+{
+
+    static final MultilineLiteralStringValueReader MULTILINE_LITERAL_STRING_VALUE_READER = new MultilineLiteralStringValueReader();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("'''");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, Context context)
+    {
+        AtomicInteger line = context.line;
+        int startLine = line.get();
+        int originalStartIndex = index.get();
+        int startIndex = index.addAndGet(3);
+        int endIndex = -1;
+
+        if (s.charAt(startIndex) == '\n')
+        {
+            startIndex = index.incrementAndGet();
+            line.incrementAndGet();
+        }
+
+        for (int i = startIndex; i < s.length(); i = index.incrementAndGet())
+        {
+            char c = s.charAt(i);
+
+            if (c == '\n')
+            {
+                line.incrementAndGet();
+            }
+
+            if (c == '\'' && s.length() > i + 2 && s.charAt(i + 1) == '\'' && s.charAt(i + 2) == '\'')
+            {
+                endIndex = i;
+                index.addAndGet(2);
+                break;
+            }
+        }
+
+        if (endIndex == -1)
+        {
+            Results.Errors errors = new Results.Errors();
+            errors.unterminated(context.identifier.getName(), s.substring(originalStartIndex), startLine);
+            return errors;
+        }
+
+        return s.substring(startIndex, endIndex);
+    }
+
+    private MultilineLiteralStringValueReader()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/MultilineStringValueReader.java

@@ -0,0 +1,66 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+class MultilineStringValueReader implements ValueReader
+{
+
+    static final MultilineStringValueReader MULTILINE_STRING_VALUE_READER = new MultilineStringValueReader();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("\"\"\"");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, dev.plex.toml.Context context)
+    {
+        AtomicInteger line = context.line;
+        int startLine = line.get();
+        int originalStartIndex = index.get();
+        int startIndex = index.addAndGet(3);
+        int endIndex = -1;
+
+        if (s.charAt(startIndex) == '\n')
+        {
+            startIndex = index.incrementAndGet();
+            line.incrementAndGet();
+        }
+
+        for (int i = startIndex; i < s.length(); i = index.incrementAndGet())
+        {
+            char c = s.charAt(i);
+
+            if (c == '\n')
+            {
+                line.incrementAndGet();
+            }
+            else if (c == '"' && s.length() > i + 2 && s.charAt(i + 1) == '"' && s.charAt(i + 2) == '"')
+            {
+                endIndex = i;
+                index.addAndGet(2);
+                break;
+            }
+        }
+
+        if (endIndex == -1)
+        {
+            dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
+            errors.unterminated(context.identifier.getName(), s.substring(originalStartIndex), startLine);
+            return errors;
+        }
+
+        s = s.substring(startIndex, endIndex);
+        s = s.replaceAll("\\\\\\s+", "");
+        s = dev.plex.toml.StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceUnicodeCharacters(s);
+        s = dev.plex.toml.StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceSpecialCharacters(s);
+
+        return s;
+    }
+
+    private MultilineStringValueReader()
+    {
+    }
+
+}

proxy/src/main/java/dev/plex/toml/NumberValueReaderWriter.java

@@ -0,0 +1,134 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+class NumberValueReaderWriter implements dev.plex.toml.ValueReader, dev.plex.toml.ValueWriter
+{
+    static final NumberValueReaderWriter NUMBER_VALUE_READER_WRITER = new NumberValueReaderWriter();
+
+    @Override
+    public boolean canRead(String s)
+    {
+        char firstChar = s.charAt(0);
+
+        return firstChar == '+' || firstChar == '-' || Character.isDigit(firstChar);
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, dev.plex.toml.Context context)
+    {
+        boolean signable = true;
+        boolean dottable = false;
+        boolean exponentable = false;
+        boolean terminatable = false;
+        boolean underscorable = false;
+        String type = "";
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = index.get(); i < s.length(); i = index.incrementAndGet())
+        {
+            char c = s.charAt(i);
+            boolean notLastChar = s.length() > i + 1;
+
+            if (Character.isDigit(c))
+            {
+                sb.append(c);
+                signable = false;
+                terminatable = true;
+                if (type.isEmpty())
+                {
+                    type = "integer";
+                    dottable = true;
+                }
+                underscorable = notLastChar;
+                exponentable = !type.equals("exponent");
+            }
+            else if ((c == '+' || c == '-') && signable && notLastChar)
+            {
+                signable = false;
+                terminatable = false;
+                if (c == '-')
+                {
+                    sb.append('-');
+                }
+            }
+            else if (c == '.' && dottable && notLastChar)
+            {
+                sb.append('.');
+                type = "float";
+                terminatable = false;
+                dottable = false;
+                exponentable = false;
+                underscorable = false;
+            }
+            else if ((c == 'E' || c == 'e') && exponentable && notLastChar)
+            {
+                sb.append('E');
+                type = "exponent";
+                terminatable = false;
+                signable = true;
+                dottable = false;
+                exponentable = false;
+                underscorable = false;
+            }
+            else if (c == '_' && underscorable && notLastChar && Character.isDigit(s.charAt(i + 1)))
+            {
+                underscorable = false;
+            }
+            else
+            {
+                if (!terminatable)
+                {
+                    type = "";
+                }
+                index.decrementAndGet();
+                break;
+            }
+        }
+
+        if (type.equals("integer"))
+        {
+            return Long.valueOf(sb.toString());
+        }
+        else if (type.equals("float"))
+        {
+            return Double.valueOf(sb.toString());
+        }
+        else if (type.equals("exponent"))
+        {
+            String[] exponentString = sb.toString().split("E");
+
+            return Double.parseDouble(exponentString[0]) * Math.pow(10, Double.parseDouble(exponentString[1]));
+        }
+        else
+        {
+            dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
+            errors.invalidValue(context.identifier.getName(), sb.toString(), context.line.get());
+            return errors;
+        }
+    }
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return value instanceof Number;
+    }
+
+    @Override
+    public void write(Object value, dev.plex.toml.WriterContext context)
+    {
+        context.write(value.toString());
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return true;
+    }
+
+    @Override
+    public String toString()
+    {
+        return "number";
+    }
+}

proxy/src/main/java/dev/plex/toml/ObjectValueWriter.java

@@ -0,0 +1,95 @@
+package dev.plex.toml;
+
+import com.google.gson.annotations.SerializedName;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+class ObjectValueWriter implements ValueWriter
+{
+    static final ValueWriter OBJECT_VALUE_WRITER = new ObjectValueWriter();
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return true;
+    }
+
+    @Override
+    public void write(Object value, WriterContext context)
+    {
+        Map<String, Object> to = new LinkedHashMap<String, Object>();
+        Set<Field> fields = getFields(value.getClass());
+        for (Field field : fields)
+        {
+            if (field.isAnnotationPresent(SerializedName.class))
+            {
+                to.put(field.getDeclaredAnnotation(SerializedName.class).value(), getFieldValue(field, value));
+            }
+            else
+            {
+                to.put(field.getName(), getFieldValue(field, value));
+            }
+        }
+
+        MapValueWriter.MAP_VALUE_WRITER.write(to, context);
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return false;
+    }
+
+    private static Set<Field> getFields(Class<?> cls)
+    {
+        Set<Field> fields = new LinkedHashSet<Field>(Arrays.asList(cls.getDeclaredFields()));
+        while (cls != Object.class)
+        {
+            fields.addAll(Arrays.asList(cls.getDeclaredFields()));
+            cls = cls.getSuperclass();
+        }
+        removeConstantsAndSyntheticFields(fields);
+
+        return fields;
+    }
+
+    private static void removeConstantsAndSyntheticFields(Set<Field> fields)
+    {
+        Iterator<Field> iterator = fields.iterator();
+        while (iterator.hasNext())
+        {
+            Field field = iterator.next();
+            if ((Modifier.isFinal(field.getModifiers()) && Modifier.isStatic(field.getModifiers())) || field.isSynthetic() || Modifier.isTransient(field.getModifiers()))
+            {
+                iterator.remove();
+            }
+        }
+    }
+
+    private static Object getFieldValue(Field field, Object o)
+    {
+        boolean isAccessible = field.isAccessible();
+        field.setAccessible(true);
+        Object value = null;
+        try
+        {
+            value = field.get(o);
+        }
+        catch (IllegalAccessException ignored)
+        {
+        }
+        field.setAccessible(isAccessible);
+
+        return value;
+    }
+
+    private ObjectValueWriter()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/PrimitiveArrayValueWriter.java

@@ -0,0 +1,63 @@
+package dev.plex.toml;
+
+import java.util.Collection;
+
+class PrimitiveArrayValueWriter extends ArrayValueWriter
+{
+    static final ValueWriter PRIMITIVE_ARRAY_VALUE_WRITER = new PrimitiveArrayValueWriter();
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return isArrayish(value) && isArrayOfPrimitive(value);
+    }
+
+    @Override
+    public void write(Object o, WriterContext context)
+    {
+        Collection<?> values = normalize(o);
+
+        context.write('[');
+        context.writeArrayDelimiterPadding();
+
+        boolean first = true;
+        ValueWriter firstWriter = null;
+
+        for (Object value : values)
+        {
+            if (first)
+            {
+                firstWriter = ValueWriters.WRITERS.findWriterFor(value);
+                first = false;
+            }
+            else
+            {
+                ValueWriter writer = ValueWriters.WRITERS.findWriterFor(value);
+                if (writer != firstWriter)
+                {
+                    throw new IllegalStateException(
+                            context.getContextPath() +
+                                    ": cannot write a heterogeneous array; first element was of type " + firstWriter +
+                                    " but found " + writer
+                    );
+                }
+                context.write(", ");
+            }
+
+            ValueWriters.WRITERS.findWriterFor(value).write(value, context);
+        }
+
+        context.writeArrayDelimiterPadding();
+        context.write(']');
+    }
+
+    private PrimitiveArrayValueWriter()
+    {
+    }
+
+    @Override
+    public String toString()
+    {
+        return "primitive-array";
+    }
+}

proxy/src/main/java/dev/plex/toml/Results.java

@@ -0,0 +1,361 @@
+package dev.plex.toml;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+class Results
+{
+
+    static class Errors
+    {
+
+        private final StringBuilder sb = new StringBuilder();
+
+        void duplicateTable(String table, int line)
+        {
+            sb.append("Duplicate table definition on line ")
+                    .append(line)
+                    .append(": [")
+                    .append(table)
+                    .append("]");
+        }
+
+        public void tableDuplicatesKey(String table, AtomicInteger line)
+        {
+            sb.append("Key already exists for table defined on line ")
+                    .append(line.get())
+                    .append(": [")
+                    .append(table)
+                    .append("]");
+        }
+
+        public void keyDuplicatesTable(String key, AtomicInteger line)
+        {
+            sb.append("Table already exists for key defined on line ")
+                    .append(line.get())
+                    .append(": ")
+                    .append(key);
+        }
+
+        void emptyImplicitTable(String table, int line)
+        {
+            sb.append("Invalid table definition due to empty implicit table name: ")
+                    .append(table);
+        }
+
+        void invalidTable(String table, int line)
+        {
+            sb.append("Invalid table definition on line ")
+                    .append(line)
+                    .append(": ")
+                    .append(table)
+                    .append("]");
+        }
+
+        void duplicateKey(String key, int line)
+        {
+            sb.append("Duplicate key");
+            if (line > -1)
+            {
+                sb.append(" on line ")
+                        .append(line);
+            }
+            sb.append(": ")
+                    .append(key);
+        }
+
+        void invalidTextAfterIdentifier(dev.plex.toml.Identifier identifier, char text, int line)
+        {
+            sb.append("Invalid text after key ")
+                    .append(identifier.getName())
+                    .append(" on line ")
+                    .append(line)
+                    .append(". Make sure to terminate the value or add a comment (#).");
+        }
+
+        void invalidKey(String key, int line)
+        {
+            sb.append("Invalid key on line ")
+                    .append(line)
+                    .append(": ")
+                    .append(key);
+        }
+
+        void invalidTableArray(String tableArray, int line)
+        {
+            sb.append("Invalid table array definition on line ")
+                    .append(line)
+                    .append(": ")
+                    .append(tableArray);
+        }
+
+        void invalidValue(String key, String value, int line)
+        {
+            sb.append("Invalid value on line ")
+                    .append(line)
+                    .append(": ")
+                    .append(key)
+                    .append(" = ")
+                    .append(value);
+        }
+
+        void unterminatedKey(String key, int line)
+        {
+            sb.append("Key is not followed by an equals sign on line ")
+                    .append(line)
+                    .append(": ")
+                    .append(key);
+        }
+
+        void unterminated(String key, String value, int line)
+        {
+            sb.append("Unterminated value on line ")
+                    .append(line)
+                    .append(": ")
+                    .append(key)
+                    .append(" = ")
+                    .append(value.trim());
+        }
+
+        public void heterogenous(String key, int line)
+        {
+            sb.append(key)
+                    .append(" becomes a heterogeneous array on line ")
+                    .append(line);
+        }
+
+        boolean hasErrors()
+        {
+            return sb.length() > 0;
+        }
+
+        @Override
+        public String toString()
+        {
+            return sb.toString();
+        }
+
+        public void add(Errors other)
+        {
+            sb.append(other.sb);
+        }
+    }
+
+    final Errors errors = new Errors();
+    private final Set<String> tables = new HashSet<String>();
+    private final Deque<Container> stack = new ArrayDeque<Container>();
+
+    Results()
+    {
+        stack.push(new Container.Table(""));
+    }
+
+    void addValue(String key, Object value, AtomicInteger line)
+    {
+        Container currentTable = stack.peek();
+
+        if (value instanceof Map)
+        {
+            String path = getInlineTablePath(key);
+            if (path == null)
+            {
+                startTable(key, line);
+            }
+            else if (path.isEmpty())
+            {
+                startTables(dev.plex.toml.Identifier.from(key, null), line);
+            }
+            else
+            {
+                startTables(dev.plex.toml.Identifier.from(path, null), line);
+            }
+            @SuppressWarnings("unchecked")
+            Map<String, Object> valueMap = (Map<String, Object>) value;
+            for (Map.Entry<String, Object> entry : valueMap.entrySet())
+            {
+                addValue(entry.getKey(), entry.getValue(), line);
+            }
+            stack.pop();
+        }
+        else if (currentTable.accepts(key))
+        {
+            currentTable.put(key, value);
+        }
+        else
+        {
+            if (currentTable.get(key) instanceof Container)
+            {
+                errors.keyDuplicatesTable(key, line);
+            }
+            else
+            {
+                errors.duplicateKey(key, line != null ? line.get() : -1);
+            }
+        }
+    }
+
+    void startTableArray(dev.plex.toml.Identifier identifier, AtomicInteger line)
+    {
+        String tableName = identifier.getBareName();
+        while (stack.size() > 1)
+        {
+            stack.pop();
+        }
+
+        dev.plex.toml.Keys.Key[] tableParts = dev.plex.toml.Keys.split(tableName);
+        for (int i = 0; i < tableParts.length; i++)
+        {
+            String tablePart = tableParts[i].name;
+            Container currentContainer = stack.peek();
+
+            if (currentContainer.get(tablePart) instanceof Container.TableArray)
+            {
+                Container.TableArray currentTableArray = (Container.TableArray) currentContainer.get(tablePart);
+                stack.push(currentTableArray);
+
+                if (i == tableParts.length - 1)
+                {
+                    currentTableArray.put(tablePart, new Container.Table());
+                }
+
+                stack.push(currentTableArray.getCurrent());
+                currentContainer = stack.peek();
+            }
+            else if (currentContainer.get(tablePart) instanceof Container.Table && i < tableParts.length - 1)
+            {
+                Container nextTable = (Container) currentContainer.get(tablePart);
+                stack.push(nextTable);
+            }
+            else if (currentContainer.accepts(tablePart))
+            {
+                Container newContainer = i == tableParts.length - 1 ? new Container.TableArray() : new Container.Table();
+                addValue(tablePart, newContainer, line);
+                stack.push(newContainer);
+
+                if (newContainer instanceof Container.TableArray)
+                {
+                    stack.push(((Container.TableArray) newContainer).getCurrent());
+                }
+            }
+            else
+            {
+                errors.duplicateTable(tableName, line.get());
+                break;
+            }
+        }
+    }
+
+    void startTables(dev.plex.toml.Identifier id, AtomicInteger line)
+    {
+        String tableName = id.getBareName();
+
+        while (stack.size() > 1)
+        {
+            stack.pop();
+        }
+
+        dev.plex.toml.Keys.Key[] tableParts = dev.plex.toml.Keys.split(tableName);
+        for (int i = 0; i < tableParts.length; i++)
+        {
+            String tablePart = tableParts[i].name;
+            Container currentContainer = stack.peek();
+            if (currentContainer.get(tablePart) instanceof Container)
+            {
+                Container nextTable = (Container) currentContainer.get(tablePart);
+                if (i == tableParts.length - 1 && !nextTable.isImplicit())
+                {
+                    errors.duplicateTable(tableName, line.get());
+                    return;
+                }
+                stack.push(nextTable);
+                if (stack.peek() instanceof Container.TableArray)
+                {
+                    stack.push(((Container.TableArray) stack.peek()).getCurrent());
+                }
+            }
+            else if (currentContainer.accepts(tablePart))
+            {
+                startTable(tablePart, i < tableParts.length - 1, line);
+            }
+            else
+            {
+                errors.tableDuplicatesKey(tablePart, line);
+                break;
+            }
+        }
+    }
+
+    /**
+     * Warning: After this method has been called, this instance is no longer usable.
+     */
+    Map<String, Object> consume()
+    {
+        Container values = stack.getLast();
+        stack.clear();
+
+        return ((Container.Table) values).consume();
+    }
+
+    private Container startTable(String tableName, AtomicInteger line)
+    {
+        Container newTable = new Container.Table(tableName);
+        addValue(tableName, newTable, line);
+        stack.push(newTable);
+
+        return newTable;
+    }
+
+    private Container startTable(String tableName, boolean implicit, AtomicInteger line)
+    {
+        Container newTable = new Container.Table(tableName, implicit);
+        addValue(tableName, newTable, line);
+        stack.push(newTable);
+
+        return newTable;
+    }
+
+    private String getInlineTablePath(String key)
+    {
+        Iterator<Container> descendingIterator = stack.descendingIterator();
+        StringBuilder sb = new StringBuilder();
+
+        while (descendingIterator.hasNext())
+        {
+            Container next = descendingIterator.next();
+            if (next instanceof Container.TableArray)
+            {
+                return null;
+            }
+
+            Container.Table table = (Container.Table) next;
+
+            if (table.name == null)
+            {
+                break;
+            }
+
+            if (sb.length() > 0)
+            {
+                sb.append('.');
+            }
+
+            sb.append(table.name);
+        }
+
+        if (sb.length() > 0)
+        {
+            sb.append('.');
+        }
+
+        sb.append(key)
+                .insert(0, '[')
+                .append(']');
+
+        return sb.toString();
+    }
+}

proxy/src/main/java/dev/plex/toml/StringValueReaderWriter.java

@@ -0,0 +1,154 @@
+package dev.plex.toml;
+
+import java.net.URI;
+import java.net.URL;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+class StringValueReaderWriter implements ValueReader, ValueWriter
+{
+
+    static final StringValueReaderWriter STRING_VALUE_READER_WRITER = new StringValueReaderWriter();
+    private static final Pattern UNICODE_REGEX = Pattern.compile("\\\\[uU](.{4})");
+
+    static private final String[] specialCharacterEscapes = new String[93];
+
+    static
+    {
+        specialCharacterEscapes['\b'] = "\\b";
+        specialCharacterEscapes['\t'] = "\\t";
+        specialCharacterEscapes['\n'] = "\\n";
+        specialCharacterEscapes['\f'] = "\\f";
+        specialCharacterEscapes['\r'] = "\\r";
+        specialCharacterEscapes['"'] = "\\\"";
+        specialCharacterEscapes['\\'] = "\\\\";
+    }
+
+    @Override
+    public boolean canRead(String s)
+    {
+        return s.startsWith("\"");
+    }
+
+    @Override
+    public Object read(String s, AtomicInteger index, Context context)
+    {
+        int startIndex = index.incrementAndGet();
+        int endIndex = -1;
+
+        for (int i = index.get(); i < s.length(); i = index.incrementAndGet())
+        {
+            char ch = s.charAt(i);
+            if (ch == '"' && s.charAt(i - 1) != '\\')
+            {
+                endIndex = i;
+                break;
+            }
+        }
+
+        if (endIndex == -1)
+        {
+            Results.Errors errors = new Results.Errors();
+            errors.unterminated(context.identifier.getName(), s.substring(startIndex - 1), context.line.get());
+            return errors;
+        }
+
+        String raw = s.substring(startIndex, endIndex);
+        s = replaceUnicodeCharacters(raw);
+        s = replaceSpecialCharacters(s);
+
+        if (s == null)
+        {
+            Results.Errors errors = new Results.Errors();
+            errors.invalidValue(context.identifier.getName(), raw, context.line.get());
+            return errors;
+        }
+
+        return s;
+    }
+
+    String replaceUnicodeCharacters(String value)
+    {
+        Matcher unicodeMatcher = UNICODE_REGEX.matcher(value);
+
+        while (unicodeMatcher.find())
+        {
+            value = value.replace(unicodeMatcher.group(), new String(Character.toChars(Integer.parseInt(unicodeMatcher.group(1), 16))));
+        }
+        return value;
+    }
+
+    String replaceSpecialCharacters(String s)
+    {
+        for (int i = 0; i < s.length() - 1; i++)
+        {
+            char ch = s.charAt(i);
+            char next = s.charAt(i + 1);
+
+            if (ch == '\\' && next == '\\')
+            {
+                i++;
+            }
+            else if (ch == '\\' && !(next == 'b' || next == 'f' || next == 'n' || next == 't' || next == 'r' || next == '"' || next == '\\'))
+            {
+                return null;
+            }
+        }
+
+        return s.replace("\\n", "\n")
+                .replace("\\\"", "\"")
+                .replace("\\t", "\t")
+                .replace("\\r", "\r")
+                .replace("\\\\", "\\")
+                .replace("\\/", "/")
+                .replace("\\b", "\b")
+                .replace("\\f", "\f");
+    }
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return value instanceof String || value instanceof Character || value instanceof URL || value instanceof URI || value instanceof Enum;
+    }
+
+    @Override
+    public void write(Object value, WriterContext context)
+    {
+        context.write('"');
+        escapeUnicode(value.toString(), context);
+        context.write('"');
+    }
+
+    @Override
+    public boolean isPrimitiveType()
+    {
+        return true;
+    }
+
+    private void escapeUnicode(String in, WriterContext context)
+    {
+        for (int i = 0; i < in.length(); i++)
+        {
+            int codePoint = in.codePointAt(i);
+            if (codePoint < specialCharacterEscapes.length && specialCharacterEscapes[codePoint] != null)
+            {
+                context.write(specialCharacterEscapes[codePoint]);
+            }
+            else
+            {
+                context.write(in.charAt(i));
+            }
+        }
+    }
+
+    private StringValueReaderWriter()
+    {
+    }
+
+    @Override
+    public String toString()
+    {
+        return "string";
+    }
+}

proxy/src/main/java/dev/plex/toml/TableArrayValueWriter.java

@@ -0,0 +1,38 @@
+package dev.plex.toml;
+
+import java.util.Collection;
+import static dev.plex.toml.ValueWriters.WRITERS;
+
+class TableArrayValueWriter extends ArrayValueWriter
+{
+    static final ValueWriter TABLE_ARRAY_VALUE_WRITER = new TableArrayValueWriter();
+
+    @Override
+    public boolean canWrite(Object value)
+    {
+        return isArrayish(value) && !isArrayOfPrimitive(value);
+    }
+
+    @Override
+    public void write(Object from, WriterContext context)
+    {
+        Collection<?> values = normalize(from);
+
+        WriterContext subContext = context.pushTableFromArray();
+
+        for (Object value : values)
+        {
+            WRITERS.findWriterFor(value).write(value, subContext);
+        }
+    }
+
+    private TableArrayValueWriter()
+    {
+    }
+
+    @Override
+    public String toString()
+    {
+        return "table-array";
+    }
+}

proxy/src/main/java/dev/plex/toml/Toml.java

@@ -0,0 +1,500 @@
+package dev.plex.toml;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import lombok.Getter;
+
+/**
+ * <p>Provides access to the keys and tables in a TOML data source.</p>
+ *
+ * <p>All getters can fall back to default values if they have been provided as a constructor argument.
+ * Getters for simple values (String, Date, etc.) will return null if no matching key exists.
+ * {@link #getList(String)}, {@link #getTable(String)} and {@link #getTables(String)} return empty values if there is no matching key.</p>
+ *
+ * <p>All read methods throw an {@link IllegalStateException} if the TOML is incorrect.</p>
+ *
+ * <p>Example usage:</p>
+ * <pre><code>
+ * Toml toml = new Toml().read(getTomlFile());
+ * String name = toml.getString("name");
+ * Long port = toml.getLong("server.ip"); // compound key. Is equivalent to:
+ * Long port2 = toml.getTable("server").getLong("ip");
+ * MyConfig config = toml.to(MyConfig.class);
+ * </code></pre>
+ */
+public class Toml
+{
+
+    private static final Gson DEFAULT_GSON = new Gson();
+
+    @Getter
+    private Map<String, Object> values = new HashMap<String, Object>();
+    private final Toml defaults;
+
+    /**
+     * Creates Toml instance with no defaults.
+     */
+    public Toml()
+    {
+        this(null);
+    }
+
+    /**
+     * @param defaults fallback values used when the requested key or table is not present in the TOML source that has been read.
+     */
+    public Toml(Toml defaults)
+    {
+        this(defaults, new HashMap<>());
+    }
+
+    /**
+     * Populates the current Toml instance with values from file.
+     *
+     * @param file The File to be read. Expected to be encoded as UTF-8.
+     * @return this instance
+     * @throws IllegalStateException If file contains invalid TOML
+     */
+    public Toml read(File file)
+    {
+        try
+        {
+            return read(new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8));
+        }
+        catch (Exception e)
+        {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Populates the current Toml instance with values from inputStream.
+     *
+     * @param inputStream Closed after it has been read.
+     * @return this instance
+     * @throws IllegalStateException If file contains invalid TOML
+     */
+    public Toml read(InputStream inputStream)
+    {
+        return read(new InputStreamReader(inputStream));
+    }
+
+    /**
+     * Populates the current Toml instance with values from reader.
+     *
+     * @param reader Closed after it has been read.
+     * @return this instance
+     * @throws IllegalStateException If file contains invalid TOML
+     */
+    public Toml read(Reader reader)
+    {
+        BufferedReader bufferedReader = null;
+        try
+        {
+            bufferedReader = new BufferedReader(reader);
+
+            StringBuilder w = new StringBuilder();
+            String line = bufferedReader.readLine();
+            while (line != null)
+            {
+                w.append(line).append('\n');
+                line = bufferedReader.readLine();
+            }
+            read(w.toString());
+        }
+        catch (IOException e)
+        {
+            throw new RuntimeException(e);
+        }
+        finally
+        {
+            try
+            {
+                bufferedReader.close();
+            }
+            catch (IOException e)
+            {
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Populates the current Toml instance with values from otherToml.
+     *
+     * @param otherToml
+     * @return this instance
+     */
+    public Toml read(Toml otherToml)
+    {
+        this.values = otherToml.values;
+
+        return this;
+    }
+
+    /**
+     * Populates the current Toml instance with values from tomlString.
+     *
+     * @param tomlString String to be read.
+     * @return this instance
+     * @throws IllegalStateException If tomlString is not valid TOML
+     */
+    public Toml read(String tomlString) throws IllegalStateException
+    {
+        dev.plex.toml.Results results = dev.plex.toml.TomlParser.run(tomlString);
+        if (results.errors.hasErrors())
+        {
+            throw new IllegalStateException(results.errors.toString());
+        }
+
+        this.values = results.consume();
+
+        return this;
+    }
+
+    public String getString(String key)
+    {
+        return (String) get(key);
+    }
+
+    public String getString(String key, String defaultValue)
+    {
+        String val = getString(key);
+        return val == null ? defaultValue : val;
+    }
+
+    public Long getLong(String key)
+    {
+        return (Long) get(key);
+    }
+
+    public Long getLong(String key, Long defaultValue)
+    {
+        Long val = getLong(key);
+        return val == null ? defaultValue : val;
+    }
+
+    /**
+     * @param key a TOML key
+     * @param <T> type of list items
+     * @return <code>null</code> if the key is not found
+     */
+    public <T> List<T> getList(String key)
+    {
+        @SuppressWarnings("unchecked")
+        List<T> list = (List<T>) get(key);
+
+        return list;
+    }
+
+    /**
+     * @param key          a TOML key
+     * @param defaultValue a list of default values
+     * @param <T>          type of list items
+     * @return <code>null</code> is the key is not found
+     */
+    public <T> List<T> getList(String key, List<T> defaultValue)
+    {
+        List<T> list = getList(key);
+
+        return list != null ? list : defaultValue;
+    }
+
+    public Boolean getBoolean(String key)
+    {
+        return (Boolean) get(key);
+    }
+
+    public Boolean getBoolean(String key, Boolean defaultValue)
+    {
+        Boolean val = getBoolean(key);
+        return val == null ? defaultValue : val;
+    }
+
+    public Date getDate(String key)
+    {
+        return (Date) get(key);
+    }
+
+    public Date getDate(String key, Date defaultValue)
+    {
+        Date val = getDate(key);
+        return val == null ? defaultValue : val;
+    }
+
+    public Double getDouble(String key)
+    {
+        return (Double) get(key);
+    }
+
+    public Double getDouble(String key, Double defaultValue)
+    {
+        Double val = getDouble(key);
+        return val == null ? defaultValue : val;
+    }
+
+    /**
+     * @param key A table name, not including square brackets.
+     * @return A new Toml instance or <code>null</code> if no value is found for key.
+     */
+    @SuppressWarnings("unchecked")
+    public Toml getTable(String key)
+    {
+        Map<String, Object> map = (Map<String, Object>) get(key);
+
+        return map != null ? new Toml(null, map) : null;
+    }
+
+    /**
+     * @param key Name of array of tables, not including square brackets.
+     * @return A {@link List} of Toml instances or <code>null</code> if no value is found for key.
+     */
+    @SuppressWarnings("unchecked")
+    public List<Toml> getTables(String key)
+    {
+        List<Map<String, Object>> tableArray = (List<Map<String, Object>>) get(key);
+
+        if (tableArray == null)
+        {
+            return null;
+        }
+
+        ArrayList<Toml> tables = new ArrayList<Toml>();
+
+        for (Map<String, Object> table : tableArray)
+        {
+            tables.add(new Toml(null, table));
+        }
+
+        return tables;
+    }
+
+    /**
+     * @param key a key name, can be compound (eg. a.b.c)
+     * @return true if key is present
+     */
+    public boolean contains(String key)
+    {
+        return get(key) != null;
+    }
+
+    /**
+     * @param key a key name, can be compound (eg. a.b.c)
+     * @return true if key is present and is a primitive
+     */
+    public boolean containsPrimitive(String key)
+    {
+        Object object = get(key);
+
+        return object != null && !(object instanceof Map) && !(object instanceof List);
+    }
+
+    /**
+     * @param key a key name, can be compound (eg. a.b.c)
+     * @return true if key is present and is a table
+     */
+    public boolean containsTable(String key)
+    {
+        Object object = get(key);
+
+        return object != null && (object instanceof Map);
+    }
+
+    /**
+     * @param key a key name, can be compound (eg. a.b.c)
+     * @return true if key is present and is a table array
+     */
+    public boolean containsTableArray(String key)
+    {
+        Object object = get(key);
+
+        return object != null && (object instanceof List);
+    }
+
+    public boolean isEmpty()
+    {
+        return values.isEmpty();
+    }
+
+    /**
+     * <p>
+     * Populates an instance of targetClass with the values of this Toml instance.
+     * The target's field names must match keys or tables.
+     * Keys not present in targetClass will be ignored.
+     * </p>
+     *
+     * <p>Tables are recursively converted to custom classes or to {@link Map Map&lt;String, Object&gt;}.</p>
+     *
+     * <p>In addition to straight-forward conversion of TOML primitives, the following are also available:</p>
+     *
+     * <ul>
+     *  <li>Integer -&gt; int, long (or wrapper), {@link java.math.BigInteger}</li>
+     *  <li>Float -&gt; float, double (or wrapper), {@link java.math.BigDecimal}</li>
+     *  <li>One-letter String -&gt; char, {@link Character}</li>
+     *  <li>String -&gt; {@link String}, enum, {@link java.net.URI}, {@link java.net.URL}</li>
+     *  <li>Multiline and Literal Strings -&gt; {@link String}</li>
+     *  <li>Array -&gt; {@link List}, {@link Set}, array. The generic type can be anything that can be converted.</li>
+     *  <li>Table -&gt; Custom class, {@link Map Map&lt;String, Object&gt;}</li>
+     * </ul>
+     *
+     * @param targetClass Class to deserialize TOML to.
+     * @param <T>         type of targetClass.
+     * @return A new instance of targetClass.
+     */
+    public <T> T to(Class<T> targetClass)
+    {
+        JsonElement json = DEFAULT_GSON.toJsonTree(toMap());
+
+        if (targetClass == JsonElement.class)
+        {
+            return targetClass.cast(json);
+        }
+
+        return DEFAULT_GSON.fromJson(json, targetClass);
+    }
+
+    public Map<String, Object> toMap()
+    {
+        HashMap<String, Object> valuesCopy = new HashMap<String, Object>(values);
+
+        if (defaults != null)
+        {
+            for (Map.Entry<String, Object> entry : defaults.values.entrySet())
+            {
+                if (!valuesCopy.containsKey(entry.getKey()))
+                {
+                    valuesCopy.put(entry.getKey(), entry.getValue());
+                }
+            }
+        }
+
+        return valuesCopy;
+    }
+
+    /**
+     * @return a {@link Set} of Map.Entry instances. Modifications to the {@link Set} are not reflected in this Toml instance. Entries are immutable, so {@link Map.Entry#setValue(Object)} throws an UnsupportedOperationException.
+     */
+    public Set<Map.Entry<String, Object>> entrySet()
+    {
+        Set<Map.Entry<String, Object>> entries = new LinkedHashSet<Map.Entry<String, Object>>();
+
+        for (Map.Entry<String, Object> entry : values.entrySet())
+        {
+            Class<? extends Object> entryClass = entry.getValue().getClass();
+
+            if (Map.class.isAssignableFrom(entryClass))
+            {
+                entries.add(new Entry(entry.getKey(), getTable(entry.getKey())));
+            }
+            else if (List.class.isAssignableFrom(entryClass))
+            {
+                List<?> value = (List<?>) entry.getValue();
+                if (!value.isEmpty() && value.get(0) instanceof Map)
+                {
+                    entries.add(new Entry(entry.getKey(), getTables(entry.getKey())));
+                }
+                else
+                {
+                    entries.add(new Entry(entry.getKey(), value));
+                }
+            }
+            else
+            {
+                entries.add(new Entry(entry.getKey(), entry.getValue()));
+            }
+        }
+
+        return entries;
+    }
+
+    private class Entry implements Map.Entry<String, Object>
+    {
+
+        private final String key;
+        private final Object value;
+
+        @Override
+        public String getKey()
+        {
+            return key;
+        }
+
+        @Override
+        public Object getValue()
+        {
+            return value;
+        }
+
+        @Override
+        public Object setValue(Object value)
+        {
+            throw new UnsupportedOperationException("TOML entry values cannot be changed.");
+        }
+
+        private Entry(String key, Object value)
+        {
+            this.key = key;
+            this.value = value;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public Object get(String key)
+    {
+        if (values.containsKey(key))
+        {
+            return values.get(key);
+        }
+
+        Object current = new HashMap<>(values);
+
+        dev.plex.toml.Keys.Key[] keys = dev.plex.toml.Keys.split(key);
+
+        for (dev.plex.toml.Keys.Key k : keys)
+        {
+            if (k.index == -1 && current instanceof Map && ((Map<String, Object>) current).containsKey(k.path))
+            {
+                return ((Map<String, Object>) current).get(k.path);
+            }
+
+            current = ((Map<String, Object>) current).get(k.name);
+
+            if (k.index > -1 && current != null)
+            {
+                if (k.index >= ((List<?>) current).size())
+                {
+                    return null;
+                }
+
+                current = ((List<?>) current).get(k.index);
+            }
+
+            if (current == null)
+            {
+                return defaults != null ? defaults.get(key) : null;
+            }
+        }
+
+        return current;
+    }
+
+    private Toml(Toml defaults, Map<String, Object> values)
+    {
+        this.values = values;
+        this.defaults = defaults;
+    }
+}

proxy/src/main/java/dev/plex/toml/TomlParser.java

@@ -0,0 +1,88 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+class TomlParser
+{
+
+    static dev.plex.toml.Results run(String tomlString)
+    {
+        final dev.plex.toml.Results results = new dev.plex.toml.Results();
+
+        if (tomlString.isEmpty())
+        {
+            return results;
+        }
+
+        AtomicInteger index = new AtomicInteger();
+        boolean inComment = false;
+        AtomicInteger line = new AtomicInteger(1);
+        dev.plex.toml.Identifier identifier = null;
+        Object value = null;
+
+        for (int i = index.get(); i < tomlString.length(); i = index.incrementAndGet())
+        {
+            char c = tomlString.charAt(i);
+
+            if (results.errors.hasErrors())
+            {
+                break;
+            }
+
+            if (c == '#' && !inComment)
+            {
+                inComment = true;
+            }
+            else if (!Character.isWhitespace(c) && !inComment && identifier == null)
+            {
+                dev.plex.toml.Identifier id = dev.plex.toml.IdentifierConverter.IDENTIFIER_CONVERTER.convert(tomlString, index, new dev.plex.toml.Context(null, line, results.errors));
+
+                if (id != dev.plex.toml.Identifier.INVALID)
+                {
+                    if (id.isKey())
+                    {
+                        identifier = id;
+                    }
+                    else if (id.isTable())
+                    {
+                        results.startTables(id, line);
+                    }
+                    else if (id.isTableArray())
+                    {
+                        results.startTableArray(id, line);
+                    }
+                }
+            }
+            else if (c == '\n')
+            {
+                inComment = false;
+                identifier = null;
+                value = null;
+                line.incrementAndGet();
+            }
+            else if (!inComment && identifier != null && identifier.isKey() && value == null && !Character.isWhitespace(c))
+            {
+                value = ValueReaders.VALUE_READERS.convert(tomlString, index, new dev.plex.toml.Context(identifier, line, results.errors));
+
+                if (value instanceof dev.plex.toml.Results.Errors)
+                {
+                    results.errors.add((dev.plex.toml.Results.Errors) value);
+                }
+                else
+                {
+                    results.addValue(identifier.getName(), value, line);
+                }
+            }
+            else if (value != null && !inComment && !Character.isWhitespace(c))
+            {
+                results.errors.invalidTextAfterIdentifier(identifier, c, line.get());
+            }
+        }
+
+        return results;
+    }
+
+    private TomlParser()
+    {
+    }
+}

proxy/src/main/java/dev/plex/toml/TomlWriter.java

@@ -0,0 +1,186 @@
+package dev.plex.toml;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+import org.jetbrains.annotations.Nullable;
+import static dev.plex.toml.ValueWriters.WRITERS;
+
+/**
+ * <p>Converts Objects to TOML</p>
+ *
+ * <p>An input Object can comprise arbitrarily nested combinations of Java primitive types,
+ * other {@link Object}s, {@link Map}s, {@link List}s, and Arrays. {@link Object}s and {@link Map}s
+ * are output to TOML tables, and {@link List}s and Array to TOML arrays.</p>
+ *
+ * <p>Example usage:</p>
+ * <pre><code>
+ * class AClass {
+ *   int anInt = 1;
+ *   int[] anArray = { 2, 3 };
+ * }
+ *
+ * String tomlString = new TomlWriter().write(new AClass());
+ * </code></pre>
+ */
+public class TomlWriter
+{
+
+    public static class Builder
+    {
+        private int keyIndentation;
+        private int tableIndentation;
+        private int arrayDelimiterPadding = 0;
+        private TimeZone timeZone = TimeZone.getTimeZone("UTC");
+        private boolean showFractionalSeconds = false;
+
+        public Builder indentValuesBy(int spaces)
+        {
+            this.keyIndentation = spaces;
+
+            return this;
+        }
+
+        public Builder indentTablesBy(int spaces)
+        {
+            this.tableIndentation = spaces;
+
+            return this;
+        }
+
+        public Builder timeZone(TimeZone timeZone)
+        {
+            this.timeZone = timeZone;
+
+            return this;
+        }
+
+        /**
+         * @param spaces number of spaces to put between opening square bracket and first item and between closing square bracket and last item
+         * @return this TomlWriter.Builder instance
+         */
+        public Builder padArrayDelimitersBy(int spaces)
+        {
+            this.arrayDelimiterPadding = spaces;
+
+            return this;
+        }
+
+        public TomlWriter build()
+        {
+            return new TomlWriter(keyIndentation, tableIndentation, arrayDelimiterPadding, timeZone, showFractionalSeconds);
+        }
+
+        public Builder showFractionalSeconds()
+        {
+            this.showFractionalSeconds = true;
+            return this;
+        }
+    }
+
+    private final IndentationPolicy indentationPolicy;
+    private final dev.plex.toml.DatePolicy datePolicy;
+
+    /**
+     * Creates a TomlWriter instance.
+     */
+    public TomlWriter()
+    {
+        this(0, 0, 0, TimeZone.getTimeZone("UTC"), false);
+    }
+
+    private TomlWriter(int keyIndentation, int tableIndentation, int arrayDelimiterPadding, TimeZone timeZone, boolean showFractionalSeconds)
+    {
+        this.indentationPolicy = new IndentationPolicy(keyIndentation, tableIndentation, arrayDelimiterPadding);
+        this.datePolicy = new dev.plex.toml.DatePolicy(timeZone, showFractionalSeconds);
+    }
+
+    /**
+     * Write an Object into TOML String.
+     *
+     * @param from the object to be written
+     * @return a string containing the TOML representation of the given Object
+     */
+    public String write(Object from)
+    {
+        try
+        {
+            StringWriter output = new StringWriter();
+            write(from, output, null);
+
+            return output.toString();
+        }
+        catch (IOException e)
+        {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Write an Object in TOML to a {@link File}. Output is encoded as UTF-8.
+     *
+     * @param from   the object to be written
+     * @param target the File to which the TOML will be written
+     * @throws IOException if any file operations fail
+     */
+    public void write(Object from, File target) throws IOException
+    {
+        OutputStream outputStream = new FileOutputStream(target, true);
+        try
+        {
+            write(from, outputStream, target);
+        }
+        finally
+        {
+            outputStream.close();
+        }
+    }
+
+    /**
+     * Write an Object in TOML to a {@link OutputStream}. Output is encoded as UTF-8.
+     *
+     * @param from   the object to be written
+     * @param target the OutputStream to which the TOML will be written. The stream is NOT closed after being written to.
+     * @throws IOException if target.write() fails
+     */
+    public void write(Object from, OutputStream target, @Nullable File file) throws IOException
+    {
+        OutputStreamWriter writer = new OutputStreamWriter(target, StandardCharsets.UTF_8);
+        write(from, writer, file);
+        writer.flush();
+    }
+
+    /**
+     * Write an Object in TOML to a {@link Writer}. You MUST ensure that the {@link Writer}s's encoding is set to UTF-8 for the TOML to be valid.
+     *
+     * @param from   the object to be written. Can be a Map or a custom type. Must not be null.
+     * @param target the Writer to which TOML will be written. The Writer is not closed.
+     * @throws IOException              if target.write() fails
+     * @throws IllegalArgumentException if from is of an invalid type
+     */
+    public void write(Object from, Writer target, @Nullable File file) throws IOException
+    {
+        dev.plex.toml.ValueWriter valueWriter = WRITERS.findWriterFor(from);
+        if (valueWriter == MapValueWriter.MAP_VALUE_WRITER || valueWriter == dev.plex.toml.ObjectValueWriter.OBJECT_VALUE_WRITER)
+        {
+            WriterContext context = new WriterContext(indentationPolicy, datePolicy, target);
+            if (file != null && file.exists())
+            {
+                context.file = file;
+            }
+            valueWriter.write(from, context);
+        }
+        else
+        {
+            throw new IllegalArgumentException("An object of class " + from.getClass().getSimpleName() + " cannot produce valid TOML. Please pass in a Map or a custom type.");
+        }
+    }
+}

proxy/src/main/java/dev/plex/toml/ValueReader.java

@@ -0,0 +1,21 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+interface ValueReader
+{
+
+    /**
+     * @param s must already have been trimmed
+     */
+    boolean canRead(String s);
+
+    /**
+     * Partial validation. Stops after type terminator, rather than at EOI.
+     *
+     * @param s     must already have been validated by {@link #canRead(String)}
+     * @param index where to start in s
+     * @return a value or a {@link dev.plex.toml.Results.Errors}
+     */
+    Object read(String s, AtomicInteger index, dev.plex.toml.Context context);
+}

proxy/src/main/java/dev/plex/toml/ValueReaders.java

@@ -0,0 +1,40 @@
+package dev.plex.toml;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import static dev.plex.toml.ArrayValueReader.ARRAY_VALUE_READER;
+import static dev.plex.toml.BooleanValueReaderWriter.BOOLEAN_VALUE_READER_WRITER;
+import static dev.plex.toml.DateValueReaderWriter.DATE_VALUE_READER_WRITER;
+import static dev.plex.toml.LiteralStringValueReader.LITERAL_STRING_VALUE_READER;
+import static dev.plex.toml.MultilineLiteralStringValueReader.MULTILINE_LITERAL_STRING_VALUE_READER;
+import static dev.plex.toml.MultilineStringValueReader.MULTILINE_STRING_VALUE_READER;
+import static dev.plex.toml.StringValueReaderWriter.STRING_VALUE_READER_WRITER;
+
+class ValueReaders
+{
+
+    static final ValueReaders VALUE_READERS = new ValueReaders();
+
+    Object convert(String value, AtomicInteger index, dev.plex.toml.Context context)
+    {
+        String substring = value.substring(index.get());
+        for (dev.plex.toml.ValueReader valueParser : READERS)
+        {
+            if (valueParser.canRead(substring))
+            {
+                return valueParser.read(value, index, context);
+            }
+        }
+
+        dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
+        errors.invalidValue(context.identifier.getName(), substring, context.line.get());
+        return errors;
+    }
+
+    private ValueReaders()
+    {
+    }
+
+    private static final dev.plex.toml.ValueReader[] READERS = {
+            MULTILINE_STRING_VALUE_READER, MULTILINE_LITERAL_STRING_VALUE_READER, LITERAL_STRING_VALUE_READER, STRING_VALUE_READER_WRITER, DATE_VALUE_READER_WRITER, NumberValueReaderWriter.NUMBER_VALUE_READER_WRITER, BOOLEAN_VALUE_READER_WRITER, ARRAY_VALUE_READER, InlineTableValueReader.INLINE_TABLE_VALUE_READER
+    };
+}

proxy/src/main/java/dev/plex/toml/ValueWriter.java

@@ -0,0 +1,10 @@
+package dev.plex.toml;
+
+interface ValueWriter
+{
+    boolean canWrite(Object value);
+
+    void write(Object value, WriterContext context);
+
+    boolean isPrimitiveType();
+}

proxy/src/main/java/dev/plex/toml/ValueWriters.java

@@ -0,0 +1,35 @@
+package dev.plex.toml;
+
+class ValueWriters
+{
+
+    static final ValueWriters WRITERS = new ValueWriters();
+
+    ValueWriter findWriterFor(Object value)
+    {
+        for (ValueWriter valueWriter : VALUE_WRITERS)
+        {
+            if (valueWriter.canWrite(value))
+            {
+                return valueWriter;
+            }
+        }
+
+        return ObjectValueWriter.OBJECT_VALUE_WRITER;
+    }
+
+    private ValueWriters()
+    {
+    }
+
+    private static dev.plex.toml.DateValueReaderWriter getPlatformSpecificDateConverter()
+    {
+        String specificationVersion = Runtime.class.getPackage().getSpecificationVersion();
+        return specificationVersion != null && specificationVersion.startsWith("1.6") ? dev.plex.toml.DateValueReaderWriter.DATE_PARSER_JDK_6 : dev.plex.toml.DateValueReaderWriter.DATE_VALUE_READER_WRITER;
+    }
+
+    private static final ValueWriter[] VALUE_WRITERS = {
+            StringValueReaderWriter.STRING_VALUE_READER_WRITER, NumberValueReaderWriter.NUMBER_VALUE_READER_WRITER, dev.plex.toml.BooleanValueReaderWriter.BOOLEAN_VALUE_READER_WRITER, getPlatformSpecificDateConverter(),
+            MapValueWriter.MAP_VALUE_WRITER, dev.plex.toml.PrimitiveArrayValueWriter.PRIMITIVE_ARRAY_VALUE_WRITER, TableArrayValueWriter.TABLE_ARRAY_VALUE_WRITER
+    };
+}

proxy/src/main/java/dev/plex/toml/WriterContext.java

@@ -0,0 +1,185 @@
+package dev.plex.toml;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Arrays;
+
+class WriterContext
+{
+    private String arrayKey = null;
+    private boolean isArrayOfTable = false;
+    private boolean empty = true;
+    public final String key;
+    private final String currentTableIndent;
+    private final String currentFieldIndent;
+    private final Writer output;
+    private final dev.plex.toml.IndentationPolicy indentationPolicy;
+    private final dev.plex.toml.DatePolicy datePolicy;
+
+    public File file;
+    public String parentName;
+    public boolean hasRun = false;
+
+    WriterContext(dev.plex.toml.IndentationPolicy indentationPolicy, dev.plex.toml.DatePolicy datePolicy, Writer output)
+    {
+        this("", "", output, indentationPolicy, datePolicy);
+    }
+
+    WriterContext pushTable(String newKey)
+    {
+        String newIndent = "";
+        if (!key.isEmpty())
+        {
+            newIndent = growIndent(indentationPolicy);
+        }
+
+        String fullKey = key.isEmpty() ? newKey : key + "." + newKey;
+
+        WriterContext subContext = new WriterContext(fullKey, newIndent, output, indentationPolicy, datePolicy);
+        if (!empty)
+        {
+            subContext.empty = false;
+        }
+
+        return subContext;
+    }
+
+    WriterContext pushTableFromArray()
+    {
+        WriterContext subContext = new WriterContext(key, currentTableIndent, output, indentationPolicy, datePolicy);
+        if (!empty)
+        {
+            subContext.empty = false;
+        }
+        subContext.setIsArrayOfTable(true);
+
+        return subContext;
+    }
+
+    WriterContext write(String s)
+    {
+        try
+        {
+            output.write(s);
+            if (empty && !s.isEmpty())
+            {
+                empty = false;
+            }
+
+            return this;
+        }
+        catch (IOException e)
+        {
+            throw new RuntimeException(e);
+        }
+    }
+
+    void write(char[] chars)
+    {
+        for (char c : chars)
+        {
+            write(c);
+        }
+    }
+
+    WriterContext write(char c)
+    {
+        try
+        {
+            output.write(c);
+            empty = false;
+
+            return this;
+        }
+        catch (IOException e)
+        {
+            throw new RuntimeException(e);
+        }
+    }
+
+    void writeKey()
+    {
+        if (key.isEmpty())
+        {
+            return;
+        }
+
+        if (!empty)
+        {
+            write('\n');
+        }
+
+        write(currentTableIndent);
+
+        if (isArrayOfTable)
+        {
+            write("[[").write(key).write("]]\n");
+        }
+        else
+        {
+            write('[').write(key).write("]\n");
+        }
+    }
+
+    void writeArrayDelimiterPadding()
+    {
+        for (int i = 0; i < indentationPolicy.getArrayDelimiterPadding(); i++)
+        {
+            write(' ');
+        }
+    }
+
+    void indent()
+    {
+        if (!key.isEmpty())
+        {
+            write(currentFieldIndent);
+        }
+    }
+
+    dev.plex.toml.DatePolicy getDatePolicy()
+    {
+        return datePolicy;
+    }
+
+    WriterContext setIsArrayOfTable(boolean isArrayOfTable)
+    {
+        this.isArrayOfTable = isArrayOfTable;
+        return this;
+    }
+
+    WriterContext setArrayKey(String arrayKey)
+    {
+        this.arrayKey = arrayKey;
+        return this;
+    }
+
+    String getContextPath()
+    {
+        return key.isEmpty() ? arrayKey : key + "." + arrayKey;
+    }
+
+    private String growIndent(dev.plex.toml.IndentationPolicy indentationPolicy)
+    {
+        return currentTableIndent + fillStringWithSpaces(indentationPolicy.getTableIndent());
+    }
+
+    private String fillStringWithSpaces(int count)
+    {
+        char[] chars = new char[count];
+        Arrays.fill(chars, ' ');
+
+        return new String(chars);
+    }
+
+    private WriterContext(String key, String tableIndent, Writer output, dev.plex.toml.IndentationPolicy indentationPolicy, dev.plex.toml.DatePolicy datePolicy)
+    {
+        this.key = key;
+        this.output = output;
+        this.indentationPolicy = indentationPolicy;
+        this.currentTableIndent = tableIndent;
+        this.datePolicy = datePolicy;
+        this.currentFieldIndent = tableIndent + fillStringWithSpaces(this.indentationPolicy.getKeyValueIndent());
+    }
+}

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

@@ -0,0 +1,66 @@
+package dev.plex.util;
+
+import dev.plex.Plex;
+import dev.plex.settings.ServerSettings;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public class PlexLog
+{
+    public static void log(String message, Object... strings)
+    {
+        for (int i = 0; i < strings.length; i++)
+        {
+            if (message.contains("{" + i + "}"))
+            {
+                message = message.replace("{" + i + "}", strings[i].toString());
+            }
+        }
+        Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<yellow>[Plex] <gray>" + message));
+    }
+
+    public static void log(Component component)
+    {
+        Plex.get().getServer().getConsoleCommandSource().sendMessage(Component.text("[Plex] ").color(NamedTextColor.YELLOW).append(component).colorIfAbsent(NamedTextColor.GRAY));
+    }
+
+    public static void error(String message, Object... strings)
+    {
+        for (int i = 0; i < strings.length; i++)
+        {
+            if (message.contains("{" + i + "}"))
+            {
+                message = message.replace("{" + i + "}", strings[i].toString());
+            }
+        }
+        Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<red>[Plex Error] <gold>" + 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());
+            }
+        }
+        Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<#eb7c0e>[Plex Warning] <gold>" + message));
+    }
+
+    public static void debug(String message, Object... strings)
+    {
+        for (int i = 0; i < strings.length; i++)
+        {
+            if (message.contains("{" + i + "}"))
+            {
+                message = message.replace("{" + i + "}", strings[i].toString());
+            }
+        }
+        if (Plex.get().getConfig().as(ServerSettings.class).getServer().isDebug())
+        {
+            Plex.get().getServer().getConsoleCommandSource().sendMessage(MiniMessage.miniMessage().deserialize("<dark_purple>[Plex Debug] <gold>" + message));
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+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);
+    }
+}

proxy/src/main/resources/config.toml

@@ -0,0 +1,31 @@
+#############################
+#                           #
+#       Plex Velocity       #
+#           v1.1            #
+#                           #
+#############################
+
+[server]
+  name = "Plexus"
+
+  # Placeholders
+  # %mcversion% - The Velocity Version (i.e. 3.1.2-SNAPSHOT)
+  # %servername% - The name provided above
+  # %randomgradient% - Creates a random gradient every ping of two random colors for the whole string
+  # Supports MiniMessage strings, no legacy & and §
+  motd = ["%randomgradient%%servername% - %mcversion%", "Another motd"]
+  colorizeMotd = false
+
+  # Enables debug messages
+  debug = false
+
+  # Due to game code only supporting legacy color codes for
+  # player samples and not components, you may only use § or & here
+  # for colors.
+  sample = ["example", "example"]
+
+  # Adds this amount to the current player count
+  add-player-count = 0
+
+  # The max player count will always display as +1 more than the player count
+  plus-one-max-count = true

server/build.gradle

@@ -0,0 +1,140 @@
+plugins {
+    id "net.minecrell.plugin-yml.bukkit" version "0.6.1-SNAPSHOT"
+}
+
+dependencies {
+    library "org.projectlombok:lombok:1.18.24"
+    annotationProcessor "org.projectlombok:lombok:1.18.24"
+    library "org.json:json:20220320"
+    library "commons-io:commons-io:2.11.0"
+    library "dev.morphia.morphia:morphia-core:2.2.6"
+    library "redis.clients:jedis:4.2.2"
+    library "org.mariadb.jdbc:mariadb-java-client:3.0.4"
+    library "com.zaxxer:HikariCP:5.0.1"
+    library "org.apache.httpcomponents:httpclient:4.5.13"
+    library "org.apache.commons:commons-lang3:3.12.0"
+    library "org.apache.maven.resolver:maven-resolver-api:1.8.0"
+    library "org.apache.maven.resolver:maven-resolver-impl:1.8.0"
+    library "org.apache.maven.resolver:maven-resolver-connector-basic:1.8.0"
+    library "org.apache.maven.resolver:maven-resolver-transport-http:1.8.0"
+    library "org.apache.maven:maven-resolver-provider:3.8.5"
+    library "org.eclipse.jetty:jetty-server:11.0.9"
+    library "org.eclipse.jetty:jetty-servlet:11.0.9"
+    library "org.eclipse.jetty:jetty-proxy:11.0.9"
+    library "com.google.code.gson:gson:2.9.0"
+    compileOnly "io.papermc.paper:paper-api:1.18.2-R0.1-SNAPSHOT"
+    compileOnly("com.github.MilkBowl:VaultAPI:1.7") {
+        exclude group: "org.bukkit", module: "bukkit"
+    }
+    implementation "org.bstats:bstats-base:3.0.0"
+    implementation "org.bstats:bstats-bukkit:3.0.0"
+    implementation project(":api")
+}
+
+group = rootProject.group
+version = rootProject.version
+description = "Plex-Server"
+
+shadowJar {
+    archiveBaseName.set("Plex")
+    archiveClassifier.set("")
+    relocate "org.bstats", "dev.plex"
+}
+
+bukkit {
+    name = "Plex"
+    version = project.version
+    description = "Plex provides a new experience for freedom servers."
+    main = "dev.plex.Plex"
+    website = "https://plex.us.org"
+    authors = ["Telesphoreo", "taahanis", "supernt"]
+    softDepend = ["Vault"]
+    apiVersion = "1.18"
+}
+
+String getGitHash() {
+    def stdout = new ByteArrayOutputStream()
+    try {
+        exec {
+            commandLine "git", "rev-parse", "--short", "HEAD"
+            standardOutput = stdout
+            ignoreExitValue = true
+        }
+    } catch (GradleException e) {
+        logger.error("Couldn't determine Git head because Git is not installed. " + e.getMessage())
+    }
+    return stdout.size() > 0 ? stdout.toString().trim() : "unknown"
+}
+
+String getBuildNumber() {
+    def stdout = new ByteArrayOutputStream()
+    try {
+        exec {
+            commandLine "git", "rev-list", "HEAD", "--count"
+            standardOutput = stdout
+            ignoreExitValue = true
+        }
+    } catch (GradleException e) {
+        logger.error("Couldn't determine build number because Git is not installed. " + e.getMessage())
+    }
+    return stdout.size() ? stdout.toString().trim() + " (local)" : "unknown"
+}
+
+static def getDate() {
+    return new Date().format("MM/dd/yyyy '<light_purple>at<gold>' hh:mm:ss a z")
+}
+
+task buildProperties {
+    ant.propertyfile(file: "$project.projectDir/src/main/resources/build.properties") {
+        entry(key: "buildAuthor", default: System.getenv("JENKINS_URL") != null ? "jenkins" : "unknown")
+        entry(key: "buildNumber", value: System.getenv("JENKINS_URL") != null ? System.getenv("BUILD_NUMBER") + " (Jenkins)" : getBuildNumber())
+        entry(key: "buildDate", value: getDate())
+        entry(key: "buildHead", value: getGitHash())
+    }
+}
+
+tasks {
+    build {
+        dependsOn(shadowJar)
+        finalizedBy(buildProperties)
+    }
+
+    jar {
+        enabled = false
+    }
+
+    shadowJar {
+        finalizedBy(rootProject.tasks.copyJars)
+    }
+
+    javadoc {
+        options.memberLevel = JavadocMemberLevel.PRIVATE
+    }
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            pom.withXml {
+                def dependenciesNode = asNode().appendNode("dependencies")
+                configurations.getByName("library").getAllDependencies().each { dependency ->
+                    dependenciesNode.appendNode("dependency").with {
+                        it.appendNode("groupId", dependency.group)
+                        it.appendNode("artifactId", dependency.name)
+                        it.appendNode("version", dependency.version)
+                        it.appendNode("scope", "provided")
+                    }
+                }
+                configurations.getByName("implementation").getAllDependencies().each { dependency ->
+                    dependenciesNode.appendNode("dependency").with {
+                        it.appendNode("groupId", dependency.group)
+                        it.appendNode("artifactId", dependency.name)
+                        it.appendNode("version", dependency.version)
+                        it.appendNode("scope", "runtime")
+                    }
+                }
+            }
+            artifacts = [shadowJar]
+        }
+    }
+}

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

@@ -2,12 +2,19 @@ package dev.plex;
 
 import dev.plex.admin.Admin;
 import dev.plex.admin.AdminList;
+import dev.plex.api.PlexApi;
+import dev.plex.api.PlexApiProvider;
+import dev.plex.api.plugin.PlexPlugin;
 import dev.plex.cache.DataUtils;
 import dev.plex.cache.PlayerCache;
 import dev.plex.config.Config;
 import dev.plex.handlers.CommandHandler;
 import dev.plex.handlers.ListenerHandler;
+import dev.plex.hook.VaultHook;
+import dev.plex.listener.impl.ChatListener;
 import dev.plex.module.ModuleManager;
+import dev.plex.permission.handler.NativePermissionHandler;
+import dev.plex.permission.handler.VaultPermissionHandler;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.PunishmentManager;
 import dev.plex.rank.RankManager;
@@ -22,6 +29,7 @@ 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.BungeeUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.UpdateChecker;
@@ -29,15 +37,13 @@ import dev.plex.world.CustomWorld;
 import java.io.File;
 import lombok.Getter;
 import lombok.Setter;
-import net.milkbowl.vault.permission.Permission;
+import org.bson.conversions.Bson;
 import org.bstats.bukkit.Metrics;
 import org.bukkit.Bukkit;
-import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.java.JavaPlugin;
 
 @Getter
 @Setter
-public class Plex extends JavaPlugin
+public class Plex extends PlexPlugin implements PlexApiProvider
 {
     private static Plex plugin;
 
@@ -45,6 +51,9 @@ public class Plex extends JavaPlugin
     public Config messages;
     public Config indefBans;
     public Config commands;
+    public Config toggles;
+
+    private PlexProvider provider;
 
     public File modulesFolder;
     private StorageType storageType = StorageType.SQLITE;
@@ -55,6 +64,8 @@ public class Plex extends JavaPlugin
     private MongoConnection mongoConnection;
     private RedisConnection redisConnection;
 
+    private PlayerCache playerCache;
+
     private MongoPlayerData mongoPlayerData;
     private SQLPlayerData sqlPlayerData;
 
@@ -71,7 +82,6 @@ public class Plex extends JavaPlugin
     private UpdateChecker updateChecker;
     private String system;
 
-    private Permission permissions;
 
     public static Plex get()
     {
@@ -81,11 +91,13 @@ public class Plex extends JavaPlugin
     @Override
     public void onLoad()
     {
+        super.onLoad();
         plugin = this;
         config = new Config(this, "config.yml");
         messages = new Config(this, "messages.yml");
         indefBans = new Config(this, "indefbans.yml");
         commands = new Config(this, "commands.yml");
+        toggles = new Config(this, "toggles.yml");
         build.load(this);
 
         modulesFolder = new File(this.getDataFolder() + File.separator + "modules");
@@ -97,6 +109,9 @@ public class Plex extends JavaPlugin
         moduleManager = new ModuleManager();
         moduleManager.loadAllModules();
         moduleManager.loadModules();
+
+        this.setChatHandler(new ChatListener.ChatHandlerImpl());
+
     }
 
     @Override
@@ -104,7 +119,9 @@ public class Plex extends JavaPlugin
     {
         config.load();
         messages.load();
-        // Don't add default entries to indefinite ban file
+        toggles.load();
+
+        // Don't add default entries to these files
         indefBans.load(false);
         commands.load(false);
 
@@ -112,7 +129,7 @@ public class Plex extends JavaPlugin
         mongoConnection = new MongoConnection();
         redisConnection = new RedisConnection();
 
-        moduleManager.enableModules();
+        playerCache = new PlayerCache();
 
         system = config.getString("system");
 
@@ -128,9 +145,21 @@ public class Plex extends JavaPlugin
             e.printStackTrace();
         }
 
-        if (!setupPermissions() && system.equalsIgnoreCase("permissions") && !getServer().getPluginManager().isPluginEnabled("Vault"))
+        boolean permissions = false;
+        if (getServer().getPluginManager().isPluginEnabled("Vault"))
         {
-            throw new RuntimeException("Vault is required to run on the server if you use permissions!");
+            VaultPermissionHandler handler = new VaultPermissionHandler();
+            if (VaultHook.getPermission() != null)
+            {
+                this.setPermissionHandler(handler);
+                permissions = true;
+                PlexLog.debug("Enabling Vault support for permissions with a permission plugin: " + VaultHook.getPermission().getName());
+            }
+        }
+
+        if (!permissions)
+        {
+            this.setPermissionHandler(new NativePermissionHandler());
         }
 
         updateChecker = new UpdateChecker();
@@ -183,6 +212,18 @@ public class Plex extends JavaPlugin
         PlexLog.log("Started " + serviceManager.serviceCount() + " services.");
 
         reloadPlayers();
+        PlexLog.debug("Registered Bukkit -> BungeeCord Plugin Messaging Channel");
+        PlexLog.debug("Velocity Support? " + BungeeUtil.isVelocity());
+        PlexLog.debug("BungeeCord Support? " + BungeeUtil.isBungeeCord());
+        if (BungeeUtil.isBungeeCord() && BungeeUtil.isVelocity())
+        {
+            PlexLog.warn("It seems you have both velocity and bungeecord configuration options enabled! When running Velocity, you do NOT need to enable bungeecord.");
+        }
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
+
+
+        provider = new PlexProvider();
+        moduleManager.enableModules();
     }
 
     @Override
@@ -190,7 +231,7 @@ public class Plex extends JavaPlugin
     {
         Bukkit.getOnlinePlayers().forEach(player ->
         {
-            PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object
+            PlexPlayer plexPlayer = playerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object
 
             if (plugin.getRankManager().isAdmin(plexPlayer))
             {
@@ -212,6 +253,8 @@ public class Plex extends JavaPlugin
             redisConnection.getJedis().close();
         }
 
+        this.getServer().getMessenger().unregisterOutgoingPluginChannel(this);
+
         moduleManager.disableModules();
     }
 
@@ -230,7 +273,7 @@ public class Plex extends JavaPlugin
         Bukkit.getOnlinePlayers().forEach(player ->
         {
             PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
-            PlayerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
+            playerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
             if (plugin.getRankManager().isAdmin(plexPlayer))
             {
                 Admin admin = new Admin(plexPlayer.getUuid());
@@ -241,10 +284,9 @@ public class Plex extends JavaPlugin
         });
     }
 
-    public boolean setupPermissions()
+    @Override
+    public PlexApi getApi()
     {
-        RegisteredServiceProvider<Permission> rsp = Bukkit.getServicesManager().getRegistration(Permission.class);
+        return provider;
-        permissions = rsp.getProvider();
-        return permissions != null;
     }
 }

server/src/main/java/dev/plex/PlexProvider.java

@@ -0,0 +1,14 @@
+package dev.plex;
+
+import dev.plex.api.IPlayerCache;
+import dev.plex.api.PlexApi;
+import dev.plex.player.PlexPlayer;
+
+public class PlexProvider implements PlexApi
+{
+    @Override
+    public IPlayerCache<PlexPlayer> getPlayerCache()
+    {
+        return Plex.get().getPlayerCache();
+    }
+}

server/src/main/java/dev/plex/cache/DataUtils.java

@@ -3,6 +3,7 @@ package dev.plex.cache;
 import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
 import dev.plex.storage.StorageType;
+import java.util.Optional;
 import java.util.UUID;
 
 /**
@@ -49,9 +50,14 @@ public class DataUtils
      */
     public static PlexPlayer getPlayer(UUID uuid)
     {
-        if (PlayerCache.getPlexPlayerMap().containsKey(uuid))
+        return getPlayer(uuid, true);
+    }
+
+    public static PlexPlayer getPlayer(UUID uuid, boolean loadExtraData)
     {
-            return PlayerCache.getPlexPlayerMap().get(uuid);
+        if (Plex.get().getPlayerCache().getPlexPlayerMap().containsKey(uuid))
+        {
+            return Plex.get().getPlayerCache().getPlexPlayerMap().get(uuid);
         }
 
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -60,19 +66,30 @@ public class DataUtils
         }
         else
         {
-            return Plex.get().getSqlPlayerData().getByUUID(uuid);
+            return Plex.get().getSqlPlayerData().getByUUID(uuid, loadExtraData);
         }
     }
 
     public static PlexPlayer getPlayer(String username)
     {
+        return getPlayer(username, true);
+    }
+
+    public static PlexPlayer getPlayer(String username, boolean loadExtraData)
+    {
+        Optional<PlexPlayer> plexPlayer = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream().filter(player -> player.getName().equalsIgnoreCase(username)).findFirst();
+        if (plexPlayer.isPresent())
+        {
+            return plexPlayer.get();
+        }
+
         if (Plex.get().getStorageType() == StorageType.MONGODB)
         {
             return Plex.get().getMongoPlayerData().getByName(username);
         }
         else
         {
-            return Plex.get().getSqlPlayerData().getByName(username);
+            return Plex.get().getSqlPlayerData().getByName(username, loadExtraData);
         }
     }
 
@@ -85,7 +102,7 @@ public class DataUtils
      */
     public static PlexPlayer getPlayerByIP(String ip)
     {
-        PlexPlayer player = PlayerCache.getPlexPlayerMap().values().stream().filter(plexPlayer -> plexPlayer.getIps().contains(ip)).findFirst().orElse(null);
+        PlexPlayer player = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream().filter(plexPlayer -> plexPlayer.getIps().contains(ip)).findFirst().orElse(null);
         if (player != null)
         {
             return player;

server/src/main/java/dev/plex/cache/PlayerCache.java

@@ -1,6 +1,7 @@
 package dev.plex.cache;
 
 import com.google.common.collect.Maps;
+import dev.plex.api.IPlayerCache;
 import dev.plex.player.PlexPlayer;
 import java.util.Map;
 import java.util.UUID;
@@ -9,7 +10,7 @@ import java.util.UUID;
  * Cache storage
  */
 
-public class PlayerCache
+public class PlayerCache implements IPlayerCache<PlexPlayer>
 {
     /**
      * A key/value pair where the key is the unique ID of the Plex Player
@@ -25,7 +26,7 @@ public class PlayerCache
     //    {
     //        return punishedPlayerMap;
     //    }
-    public static Map<UUID, PlexPlayer> getPlexPlayerMap()
+    public Map<UUID, PlexPlayer> getPlexPlayerMap()
     {
         return plexPlayerMap;
     }
@@ -39,7 +40,7 @@ public class PlayerCache
         return getPunishedPlayerMap().get(uuid);
     }
 */
-    public static PlexPlayer getPlexPlayer(UUID uuid)
+    public PlexPlayer getPlexPlayer(UUID uuid)
     {
         return getPlexPlayerMap().get(uuid);
     }

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

@@ -2,7 +2,6 @@ package dev.plex.command;
 
 import dev.plex.Plex;
 import dev.plex.cache.DataUtils;
-import dev.plex.cache.PlayerCache;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
@@ -66,7 +65,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     /**
      * Creates an instance of the command
      */
-    public PlexCommand()
+    public PlexCommand(boolean register)
     {
         super("");
         this.params = getClass().getAnnotation(CommandParameters.class);
@@ -83,8 +82,16 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         this.level = perms.level();
         this.commandSource = perms.source();
 
+        if (register)
+        {
             getMap().register("plex", this);
         }
+    }
+
+    public PlexCommand()
+    {
+        this(true);
+    }
 
     /**
      * Executes the command
@@ -123,7 +130,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
 
         if (sender instanceof Player player)
         {
-            PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
+            PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(player.getUniqueId());
 
             if (plugin.getSystem().equalsIgnoreCase("ranks"))
             {
@@ -143,7 +150,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
             }
             else if (plugin.getSystem().equalsIgnoreCase("permissions"))
             {
-                if (!player.hasPermission(perms.permission()))
+                if (!perms.permission().isEmpty() && !plugin.getPermissionHandler().hasPermission(player, perms.permission()))
                 {
                     send(sender, messageComponent("noPermissionNode", perms.permission()));
                     return true;
@@ -179,7 +186,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
             }
             else if (plugin.getSystem().equalsIgnoreCase("permissions"))
             {
-                if (!plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(plexPlayer.getUuid()), perms.permission()))
+                if (!perms.permission().isEmpty() && !plugin.getPermissionHandler().hasPermission(Bukkit.getOfflinePlayer(plexPlayer.getName()), perms.permission()))
                 {
                     send(sender, messageComponent("noPermissionNode", perms.permission()));
                     return true;
@@ -298,7 +305,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
             }
             else if (plugin.getSystem().equalsIgnoreCase("permissions"))
             {
-                if (!plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(plexPlayer.getUuid()), permission))
+                if (!perms.permission().isEmpty() && !plugin.getPermissionHandler().hasPermission(Bukkit.getOfflinePlayer(plexPlayer.getName()), perms.permission()))
                 {
                     throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
                 }
@@ -336,7 +343,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         }
         else if (plugin.getSystem().equalsIgnoreCase("permissions"))
         {
-            if (!player.hasPermission(permission))
+            if (!perms.permission().isEmpty() && !plugin.getPermissionHandler().hasPermission(player, permission))
             {
                 throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
             }
@@ -357,7 +364,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         }
         else if (plugin.getSystem().equalsIgnoreCase("permissions"))
         {
-            return player.hasPermission(permission);
+            return !perms.permission().isEmpty() && plugin.getPermissionHandler().hasPermission(player, permission);
         }
         return false;
     }
@@ -398,7 +405,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         }
         else if (plugin.getSystem().equalsIgnoreCase("permissions"))
         {
-            return player.hasPermission(permission);
+            return !perms.permission().isEmpty() && plugin.getPermissionHandler().hasPermission(player, permission);
         }
         return true;
     }
@@ -510,6 +517,18 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return PlexUtils.messageComponent(s, objects);
     }
 
+    /**
+     * Converts a message entry from the "messages.yml" to a Component
+     *
+     * @param s       The message entry
+     * @param objects Any objects to replace in order
+     * @return A Kyori Component
+     */
+    protected Component messageComponent(String s, Component... objects)
+    {
+        return PlexUtils.messageComponent(s, objects);
+    }
+
     /**
      * Converts a message entry from the "messages.yml" to a String
      *
@@ -546,6 +565,16 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
 
     protected Player getNonNullPlayer(String name)
     {
+        try
+        {
+            UUID uuid = UUID.fromString(name);
+            return Bukkit.getPlayer(uuid);
+        }
+        catch (IllegalArgumentException ignored)
+        {
+
+        }
+
         Player player = Bukkit.getPlayer(name);
         if (player == null)
         {
@@ -557,7 +586,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     protected PlexPlayer getOnlinePlexPlayer(String name)
     {
         Player player = getNonNullPlayer(name);
-        PlexPlayer plexPlayer = PlayerCache.getPlexPlayer(player.getUniqueId());
+        PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayer(player.getUniqueId());
         if (plexPlayer == null)
         {
             throw new PlayerNotFoundException();

server/src/main/java/dev/plex/command/impl/AdminCMD.java

@@ -1,6 +1,9 @@
 package dev.plex.command.impl;
 
 import com.google.common.collect.ImmutableList;
+import dev.plex.api.event.AdminAddEvent;
+import dev.plex.api.event.AdminRemoveEvent;
+import dev.plex.api.event.AdminSetRankEvent;
 import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
@@ -9,9 +12,6 @@ import dev.plex.command.annotation.System;
 import dev.plex.command.exception.ConsoleOnlyException;
 import dev.plex.command.exception.PlayerNotFoundException;
 import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.event.AdminAddEvent;
-import dev.plex.event.AdminRemoveEvent;
-import dev.plex.event.AdminSetRankEvent;
 import dev.plex.player.PlexPlayer;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;

server/src/main/java/dev/plex/command/impl/AdminChatCMD.java

@@ -1,6 +1,5 @@
 package dev.plex.command.impl;
 
-import dev.plex.cache.PlayerCache;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -38,7 +37,7 @@ public class AdminChatCMD extends PlexCommand
         {
             if (plugin.getSystem().equalsIgnoreCase("ranks"))
             {
-                PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
+                PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(player.getUniqueId());
                 if (plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN) && plexPlayer.isAdminActive())
                 {
                     player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
@@ -46,7 +45,7 @@ public class AdminChatCMD extends PlexCommand
             }
             else if (plugin.getSystem().equalsIgnoreCase("permissions"))
             {
-                if (player.hasPermission("plex.adminchat"))
+                if (plugin.getPermissionHandler().hasPermission(player, "plex.adminchat"))
                 {
                     player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
                 }

server/src/main/java/dev/plex/command/impl/AdventureCMD.java

@@ -1,12 +1,12 @@
 package dev.plex.command.impl;
 
 import com.google.common.collect.ImmutableList;
+import dev.plex.api.event.GameModeUpdateEvent;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.event.GameModeUpdateEvent;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.util.List;
@@ -19,7 +19,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @CommandPermissions(level = Rank.OP, permission = "plex.gamemode.adventure", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "adventure", aliases = "gma", description = "Set your own or another player's gamemode to adventure mode")
+@CommandParameters(name = "adventure", aliases = "gma,egma,eadventure,adventuremode,eadventuremode", description = "Set your own or another player's gamemode to adventure mode")
 public class AdventureCMD extends PlexCommand
 {
     @Override

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

@@ -12,11 +12,11 @@ import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
+import dev.plex.util.BungeeUtil;
 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;
@@ -101,7 +101,7 @@ public class BanCMD extends PlexCommand
             {
                 if (player != null)
                 {
-                    player.kick(Punishment.generateBanMessage(punishment));
+                    BungeeUtil.kickPlayer(player, Punishment.generateBanMessage(punishment));
                 }
             });
             PlexLog.debug("(From /ban command) PunishedPlayer UUID: " + plexPlayer.getUuid());

server/src/main/java/dev/plex/command/impl/BlockEditCMD.java

@@ -7,7 +7,6 @@ import dev.plex.listener.impl.BlockListener;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -30,7 +29,8 @@ public class BlockEditCMD extends PlexCommand
 
         if (args[0].equalsIgnoreCase("list"))
         {
-            send(sender, "The following have block modification abilities restricted:");
+            send(sender, messageComponent("listOfPlayersBlocked"));
+
             int count = 0;
             for (String player : bl.blockedPlayers.stream().toList())
             {
@@ -45,7 +45,7 @@ public class BlockEditCMD extends PlexCommand
         }
         else if (args[0].equalsIgnoreCase("purge"))
         {
-            PlexUtils.broadcast(componentFromString(sender.getName() + " - Unblocking block modification abilities for all players").color(NamedTextColor.AQUA));
+            PlexUtils.broadcast(messageComponent("unblockingEdits", sender.getName(), "all players"));
             int count = 0;
             for (String player : bl.blockedPlayers.stream().toList())
             {
@@ -55,11 +55,11 @@ public class BlockEditCMD extends PlexCommand
                     ++count;
                 }
             }
-            return messageComponent("unblockedEditsSize", count);
+            return messageComponent("blockeditSize", "Unblocked", count);
         }
         else if (args[0].equalsIgnoreCase("all"))
         {
-            PlexUtils.broadcast(componentFromString(sender.getName() + " - Blocking block modification abilities for all non-admins").color(NamedTextColor.RED));
+            PlexUtils.broadcast(messageComponent("blockingEdits", sender.getName(), "all non-admins"));
             int count = 0;
             for (final Player player : Bukkit.getOnlinePlayers())
             {
@@ -70,7 +70,7 @@ public class BlockEditCMD extends PlexCommand
                 }
             }
 
-            return messageComponent("blockedEditsSize", count);
+            return messageComponent("blockeditSize", "Blocked", count);
         }
 
         final Player player = getNonNullPlayer(args[0]);
@@ -81,16 +81,16 @@ public class BlockEditCMD extends PlexCommand
                 send(sender, messageComponent("higherRankThanYou"));
                 return null;
             }
-            PlexUtils.broadcast(messageComponent("blockingEditFor", sender.getName(), player.getName()));
+            PlexUtils.broadcast(messageComponent("blockingEdits", sender.getName(), player.getName()));
             bl.blockedPlayers.add(player.getName());
-            send(player, messageComponent("yourEditsHaveBeenBlocked"));
+            send(player, messageComponent("editsModified", "blocked"));
             send(sender, messageComponent("editsBlocked", player.getName()));
         }
         else
         {
-            PlexUtils.broadcast(messageComponent("unblockingEditFor", sender.getName(), player.getName()));
+            PlexUtils.broadcast(messageComponent("unblockingEdits", sender.getName(), player.getName()));
             bl.blockedPlayers.remove(player.getName());
-            send(player, messageComponent("yourEditsHaveBeenUnblocked"));
+            send(player, messageComponent("editsModified", "unblocked"));
             send(sender, messageComponent("editsUnblocked", player.getName()));
         }
         return null;

server/src/main/java/dev/plex/command/impl/CreativeCMD.java

@@ -1,12 +1,12 @@
 package dev.plex.command.impl;
 
 import com.google.common.collect.ImmutableList;
+import dev.plex.api.event.GameModeUpdateEvent;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
 import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.event.GameModeUpdateEvent;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import java.util.List;
@@ -19,7 +19,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @CommandPermissions(level = Rank.OP, permission = "plex.gamemode.creative", source = RequiredCommandSource.ANY)
-@CommandParameters(name = "creative", aliases = "gmc", description = "Set your own or another player's gamemode to creative mode")
+@CommandParameters(name = "creative", aliases = "gmc,egmc,ecreative,eecreative,creativemode,ecreativemode", description = "Set your own or another player's gamemode to creative mode")
 public class CreativeCMD extends PlexCommand
 {
     @Override