Remove maven local

(cherry picked from commit 08e2f31eae)

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,47 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master, server ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '30 4 * * *'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        java: [17]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: ${{ matrix.java }}
+          cache: gradle
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2

.github/workflows/gradle.yml

@@ -1,18 +1,26 @@
-name: Gradle
-
-on: [ push ]
+# Adapted from Paper's build script
+name: Build
+on: [push, pull_request]
 
 jobs:
     build:
+        # Only run on PRs if the source branch is on someone else's repo
+        if: ${{ github.event_name != 'pull_request' || github.repository != github.event.pull_request.head.repo.full_name }}
         runs-on: ubuntu-latest
-
+        strategy:
+            matrix:
+                java: [17]
+            fail-fast: true
         steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 17
-        uses: actions/setup-java@v2
+            - uses: actions/checkout@v3
+            - name: JDK ${{ matrix.java }}
+              uses: actions/setup-java@v3
               with:
-          distribution: temurin
-          java-version: 17
-          cache: gradle
-      - name: Build with Gradle
-        run: chmod a+x gradlew && ./gradlew build --no-daemon
+                  java-version: ${{ matrix.java }}
+                  cache: 'gradle'
+                  distribution: 'temurin'
+            - name: Build
+              run: |
+                  git config --global user.email "no-reply@github.com"
+                  git config --global user.name "Github Actions"
+                  ./gradlew build --stacktrace

.gitignore

@@ -1,6 +1,7 @@
 /.idea/
 *.iml
 /target/
+server/src/main/resources/build.properties
 
 # OS
 .DS_Store
@@ -12,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">
-    <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="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>
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Plexus Code Style" />
+  </state>
 </component>

CONTRIBUTING.md

@@ -0,0 +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.
+
+## Steps
+
+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 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
+- 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.
+- 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

@@ -0,0 +1,32 @@
+pipeline {
+    agent any
+    stages {
+        stage("build") {
+            steps {
+                withGradle {
+                    sh "./gradlew build javadoc --no-daemon"
+                }
+            }
+        }
+        stage("publish") {
+            when {
+                branch "master"
+            }
+            steps {
+            withCredentials([usernamePassword(credentialsId: '85b7099f-2e65-461e-b2ce-124edec41ed6', passwordVariable: 'plexPassword', usernameVariable: 'plexUser')]) {
+                withGradle {
+                    sh "./gradlew publish --no-daemon"
+                    }
+                }
+            }
+        }
+    }
+    post {
+        always {
+            archiveArtifacts artifacts: "build/libs/*.jar", fingerprint: true
+            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.WEBHOOK_URL
+            cleanWs()
+        }
+    }
+}

LICENSE.md

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+                            Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+The Corresponding Source for a work in source code form is that
+same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,3 +1,8 @@
-# Plex
+# Plex [![Build Status](https://ci.plex.us.org/job/Plex/job/master/badge/icon)](https://ci.plex.us.org/job/Plex/job/master/) ![CodeQL](https://github.com/plexusorg/Plex/workflows/CodeQL/badge.svg)
 
-A new freedom plugin.
+Plex is a new freedom plugin. It is an alternative to TotalFreedomMod. It has many of the features that make a freedom
+server unique, but also many features that TotalFreedomMod doesn’t have. For example, there is full support for using a
+permissions plugin instead of ranks. It is also much more performance oriented. You can use Redis to store indefinite
+bans and store player data in MongoDB, MariaDB, or SQLite. Plex is also fully customizable as you can change almost all
+of the messages within the plugin. Plex also has a module system which can be used to add additional functionality. Plex
+is not a rewrite, "debloat", or related to TotalFreedomMod. Plex is an entirely new experience.

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.19-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;
@@ -8,7 +8,7 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 /**
- * Event that is ran when a player is added to the admin list
+ * Event that is run when a player is added to the admin list
  */
 @EqualsAndHashCode(callSuper = false)
 @Data
@@ -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;
@@ -8,7 +8,7 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 /**
- * Event that is ran when a player is removed from the admin list
+ * Event that is run when a player is removed from the admin list
  */
 @EqualsAndHashCode(callSuper = false)
 @Data
@@ -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.rank.enums.Rank;
+import dev.plex.api.player.IPlexPlayer;
+import dev.plex.api.rank.IRank;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.bukkit.command.CommandSender;
@@ -9,7 +9,7 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 /**
- * Event that is ran when an admin's rank is set
+ * Event that is run when an admins rank is set
  */
 @EqualsAndHashCode(callSuper = false)
 @Data
@@ -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,7 +1,6 @@
-package dev.plex.event;
+package dev.plex.api.event;
 
-import dev.plex.player.PunishedPlayer;
-import java.util.UUID;
+import dev.plex.api.player.IPlexPlayer;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.Bukkit;
@@ -17,7 +16,7 @@ public abstract class PunishedPlayerEvent extends PlayerEvent implements Cancell
     /**
      * The player who was punished
      */
-    protected PunishedPlayer punishedPlayer;
+    protected IPlexPlayer punishedPlayer;
 
     /**
      * Whether the event was cancelled
@@ -29,11 +28,11 @@ public abstract class PunishedPlayerEvent extends PlayerEvent implements Cancell
      * Creates an event object
      *
      * @param punishedPlayer The player who was punished
-     * @see PunishedPlayer
+     * @see IPlexPlayer
      */
-    protected PunishedPlayerEvent(PunishedPlayer punishedPlayer)
+    protected PunishedPlayerEvent(IPlexPlayer punishedPlayer)
     {
-        super(Bukkit.getPlayer(UUID.fromString(punishedPlayer.getUuid())));
+        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.PunishedPlayer;
+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(PunishedPlayer 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.PunishedPlayer;
+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(PunishedPlayer 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.PunishedPlayer;
+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(PunishedPlayer 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.5.1"
     id "com.github.johnrengelman.shadow" version "7.1.2"
 }
 
+group = "dev.plex"
+version = "1.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 {
@@ -19,86 +26,48 @@ repositories {
             url = uri("https://repo.maven.apache.org/maven2/")
         }
 
+        maven {
+            url = uri("https://jitpack.io")
+            content {
+                includeGroup("com.github.MilkBowl")
+            }
+        }
+
         mavenCentral()
     }
 
-dependencies {
-    library "org.projectlombok:lombok:1.18.22"
-    annotationProcessor "org.projectlombok:lombok:1.18.22"
-    library "org.json:json:20211205"
-    library "commons-io:commons-io:2.11.0"
-    library "dev.morphia.morphia:morphia-core:2.2.3"
-    library "redis.clients:jedis:4.1.1"
-    library "org.mariadb.jdbc:mariadb-java-client:3.0.3"
-    library "org.apache.httpcomponents:httpclient:4.5.13"
-    library "org.apache.commons:commons-lang3:3.12.0"
-    compileOnly "io.papermc.paper:paper-api:1.18.2-R0.1-SNAPSHOT"
-    implementation "org.bstats:bstats-base:3.0.0"
-    implementation "org.bstats:bstats-bukkit:3.0.0"
-}
-
-group = "dev.plex"
-version = "0.9-SNAPSHOT"
-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", "super"]
-    apiVersion = "1.18"
-}
-
     java {
         toolchain.languageVersion.set(JavaLanguageVersion.of(17))
     }
 
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from(components.java)
-        }
-        plexReleases(MavenPublication) {
-            from(components.java)
-            repositories {
-                maven {
-                    url("https://nexus.telesphoreo.me/repository/plex-releases/")
-                    credentials {
-                        username = System.getenv("plex_repo_user")
-                        password = System.getenv("plex_repo_pass")
-                    }
-                }
-            }
-        }
-    }
-}
-
     tasks.withType(JavaCompile) {
         options.encoding = "UTF-8"
     }
 
-tasks {
-    build {
-        dependsOn(shadowJar)
-        if (System.getenv("plex_repo_user") != null && System.getenv("plex_repo_pass") != null) {
-            if (!getVersion().toString().toLowerCase().endsWith("-snapshot")) {
-                dependsOn(publishPlexReleasesPublicationToMavenRepository)
+    publishing {
+        repositories {
+            maven {
+                def releasesRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-releases/")
+                def snapshotsRepoUrl = uri("https://nexus.telesphoreo.me/repository/plex-snapshots/")
+                url = rootProject.version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
+                credentials {
+                    username = System.getenv("plexUser")
+                    password = System.getenv("plexPassword")
                 }
             }
         }
-
-    javadoc {
-        options.memberLevel = JavadocMemberLevel.PRIVATE
     }
 }
 
-task publishRelease {
-    dependsOn(publishPlexReleasesPublicationToMavenRepository)
+clean {
+    dependsOn(":api:clean")
+    dependsOn(":server:clean")
+    dependsOn(":proxy:clean")
+}
+
+task copyJars(type: Copy, dependsOn: subprojects.jar) {
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    from(subprojects.jar)
+    from(subprojects.shadowJar)
+    into project.file('build/libs')
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

proxy/build.gradle.kts

@@ -0,0 +1,46 @@
+plugins {
+    id("net.kyori.blossom") version "1.3.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/java/dev/plex/util/ReflectionsUtil.java

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

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.7"
+    library "redis.clients:jedis:4.2.3"
+    library "org.mariadb.jdbc:mariadb-java-client:3.0.5"
+    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.19-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,16 +2,20 @@ 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.MongoPlayerData;
 import dev.plex.cache.PlayerCache;
-import dev.plex.cache.SQLPlayerData;
 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.player.PunishedPlayer;
 import dev.plex.punishment.PunishmentManager;
 import dev.plex.rank.RankManager;
 import dev.plex.services.ServiceManager;
@@ -19,50 +23,66 @@ import dev.plex.storage.MongoConnection;
 import dev.plex.storage.RedisConnection;
 import dev.plex.storage.SQLConnection;
 import dev.plex.storage.StorageType;
+import dev.plex.storage.permission.SQLPermissions;
+import dev.plex.storage.player.MongoPlayerData;
+import dev.plex.storage.player.SQLPlayerData;
+import dev.plex.storage.punishment.SQLNotes;
+import dev.plex.storage.punishment.SQLPunishment;
+import dev.plex.util.BuildInfo;
+import dev.plex.util.BungeeUtil;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.UpdateChecker;
 import dev.plex.world.CustomWorld;
 import java.io.File;
-import java.util.UUID;
 import lombok.Getter;
 import lombok.Setter;
+import org.bson.conversions.Bson;
 import org.bstats.bukkit.Metrics;
 import org.bukkit.Bukkit;
-import org.bukkit.plugin.java.JavaPlugin;
 
 @Getter
 @Setter
-public class Plex extends JavaPlugin
+public class Plex extends PlexPlugin implements PlexApiProvider
 {
     private static Plex plugin;
+
     public Config config;
     public Config messages;
     public Config indefBans;
+    public Config commands;
+    public Config toggles;
+
+    private PlexProvider provider;
 
     public File modulesFolder;
-
     private StorageType storageType = StorageType.SQLITE;
 
+    public static final BuildInfo build = new BuildInfo();
+
     private SQLConnection sqlConnection;
     private MongoConnection mongoConnection;
     private RedisConnection redisConnection;
 
+    private PlayerCache playerCache;
+
     private MongoPlayerData mongoPlayerData;
     private SQLPlayerData sqlPlayerData;
 
+    private SQLPunishment sqlPunishment;
+    private SQLNotes sqlNotes;
+    private SQLPermissions sqlPermissions;
+
     private ModuleManager moduleManager;
     private RankManager rankManager;
     private ServiceManager serviceManager;
-
     private PunishmentManager punishmentManager;
 
     private AdminList adminList;
-
     private UpdateChecker updateChecker;
-
     private String system;
 
+
     public static Plex get()
     {
         return plugin;
@@ -71,10 +91,14 @@ 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");
         if (!modulesFolder.exists())
@@ -82,13 +106,12 @@ public class Plex extends JavaPlugin
             modulesFolder.mkdir();
         }
 
-        sqlConnection = new SQLConnection();
-        mongoConnection = new MongoConnection();
-        redisConnection = new RedisConnection();
-
         moduleManager = new ModuleManager();
         moduleManager.loadAllModules();
         moduleManager.loadModules();
+
+        this.setChatHandler(new ChatListener.ChatHandlerImpl());
+
     }
 
     @Override
@@ -96,13 +119,21 @@ 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);
 
-        moduleManager.enableModules();
+        sqlConnection = new SQLConnection();
+        mongoConnection = new MongoConnection();
+        redisConnection = new RedisConnection();
 
-        system = config.getString("commands.permissions");
+        playerCache = new PlayerCache();
 
+        system = config.getString("system");
+
+        PlexLog.log("Attempting to connect to DB: {0}", plugin.config.getString("data.central.db"));
         try
         {
             PlexUtils.testConnections();
@@ -114,6 +145,23 @@ public class Plex extends JavaPlugin
             e.printStackTrace();
         }
 
+        boolean permissions = false;
+        if (getServer().getPluginManager().isPluginEnabled("Vault"))
+        {
+            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();
         PlexLog.log("Update checking enabled");
 
@@ -121,7 +169,7 @@ public class Plex extends JavaPlugin
         Metrics metrics = new Metrics(this, 14143);
         PlexLog.log("Enabled Metrics");
 
-        if (redisConnection.isEnabled())
+        if (redisConnection != null && redisConnection.isEnabled())
         {
             redisConnection.getJedis();
             PlexLog.log("Connected to Redis!");
@@ -138,6 +186,9 @@ public class Plex extends JavaPlugin
         else
         {
             sqlPlayerData = new SQLPlayerData();
+            sqlPunishment = new SQLPunishment();
+            sqlNotes = new SQLNotes();
+            sqlPermissions = new SQLPermissions();
         }
 
         new ListenerHandler();
@@ -161,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
@@ -168,11 +231,11 @@ 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))
             {
-                plugin.getAdminList().removeFromCache(UUID.fromString(plexPlayer.getUuid()));
+                plugin.getAdminList().removeFromCache(plexPlayer.getUuid());
             }
 
             if (mongoPlayerData != null) //back to mongo checking
@@ -184,12 +247,14 @@ public class Plex extends JavaPlugin
                 sqlPlayerData.update(plexPlayer);
             }
         });
-        if (redisConnection.isEnabled() && redisConnection.getJedis().isConnected())
+        if (redisConnection != null && redisConnection.isEnabled() && redisConnection.getJedis().isConnected())
         {
             PlexLog.log("Disabling Redis/Jedis. No memory leaks in this Anarchy server!");
             redisConnection.getJedis().close();
         }
 
+        this.getServer().getMessenger().unregisterOutgoingPluginChannel(this);
+
         moduleManager.disableModules();
     }
 
@@ -208,15 +273,20 @@ 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.getPunishedPlayerMap().put(player.getUniqueId(), new PunishedPlayer(player.getUniqueId()));
+            playerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
             if (plugin.getRankManager().isAdmin(plexPlayer))
             {
-                Admin admin = new Admin(UUID.fromString(plexPlayer.getUuid()));
+                Admin admin = new Admin(plexPlayer.getUuid());
                 admin.setRank(plexPlayer.getRankFromString());
 
                 plugin.getAdminList().addToCache(admin);
             }
         });
     }
+
+    @Override
+    public PlexApi getApi()
+    {
+        return provider;
+    }
 }

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

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

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/admin/AdminList.java

@@ -0,0 +1,150 @@
+package dev.plex.admin;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.reflect.TypeToken;
+import com.google.gson.Gson;
+import dev.morphia.Datastore;
+import dev.morphia.query.Query;
+import dev.plex.PlexBase;
+import dev.plex.player.PlexPlayer;
+import dev.plex.rank.enums.Rank;
+import dev.plex.storage.StorageType;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * Cached storage for Admin objects
+ *
+ * @see Admin
+ */
+
+public class AdminList implements PlexBase
+{
+    /**
+     * Key / Value storage, where the key is the unique ID of the admin
+     */
+    private final Map<UUID, Admin> admins = Maps.newHashMap();
+
+    /**
+     * Adds the admin to cache
+     *
+     * @param admin The admin object
+     */
+    public void addToCache(Admin admin)
+    {
+        admins.put(admin.getUuid(), admin);
+    }
+
+    /**
+     * Removes an admin from the cache
+     *
+     * @param uuid The unique ID of the admin
+     * @see UUID
+     */
+    public void removeFromCache(UUID uuid)
+    {
+        admins.remove(uuid);
+    }
+
+    /**
+     * Gathers every admins username (cached and in the database)
+     *
+     * @return An array list of the names of every admin
+     */
+    public List<String> getAllAdmins()
+    {
+        List<String> admins = Lists.newArrayList();
+        if (plugin.getStorageType() == StorageType.MONGODB)
+        {
+            Datastore store = plugin.getMongoConnection().getDatastore();
+            Query<PlexPlayer> query = store.find(PlexPlayer.class);
+            admins.addAll(query.stream().filter(plexPlayer -> plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN) && plexPlayer.isAdminActive()).map(PlexPlayer::getName).toList());
+        }
+        else
+        {
+            try (Connection con = plugin.getSqlConnection().getCon())
+            {
+                PreparedStatement statement = con.prepareStatement("SELECT * FROM `players` WHERE rank IN(?, ?, ?) AND adminActive=true");
+                statement.setString(1, Rank.ADMIN.name().toLowerCase());
+                statement.setString(2, Rank.SENIOR_ADMIN.name().toLowerCase());
+                statement.setString(3, Rank.EXECUTIVE.name().toLowerCase());
+
+                ResultSet set = statement.executeQuery();
+                while (set.next())
+                {
+                    admins.add(set.getString("name"));
+                }
+            }
+            catch (SQLException throwables)
+            {
+                throwables.printStackTrace();
+            }
+        }
+        return admins;
+    }
+
+    /**
+     * Gathers every admin (cached and in the database)
+     *
+     * @return An array list of the names of every admin
+     */
+    public List<PlexPlayer> getAllAdminPlayers()
+    {
+        List<PlexPlayer> plexPlayers = Lists.newArrayList();
+        if (plugin.getStorageType() == StorageType.MONGODB)
+        {
+            Datastore store = plugin.getMongoConnection().getDatastore();
+            Query<PlexPlayer> query = store.find(PlexPlayer.class);
+            return query.stream().toList().stream().filter(player -> plugin.getRankManager().isAdmin(player)).collect(Collectors.toList());
+        }
+        else
+        {
+            try (Connection con = plugin.getSqlConnection().getCon())
+            {
+                PreparedStatement statement = con.prepareStatement("SELECT * FROM `players` WHERE rank IN(?, ?, ?) AND adminActive=true");
+                statement.setString(1, Rank.ADMIN.name().toLowerCase());
+                statement.setString(2, Rank.SENIOR_ADMIN.name().toLowerCase());
+                statement.setString(3, Rank.EXECUTIVE.name().toLowerCase());
+
+                ResultSet set = statement.executeQuery();
+                while (set.next())
+                {
+                    String uuid = set.getString("uuid");
+                    String name = set.getString("name");
+                    String loginMSG = set.getString("login_msg");
+                    String prefix = set.getString("prefix");
+                    String rankName = set.getString("rank").toUpperCase();
+                    long coins = set.getLong("coins");
+                    boolean vanished = set.getBoolean("vanished");
+                    boolean commandspy = set.getBoolean("commandspy");
+                    List<String> ips = new Gson().fromJson(set.getString("ips"), new TypeToken<List<String>>()
+                    {
+                    }.getType());
+
+                    PlexPlayer plexPlayer = new PlexPlayer(UUID.fromString(uuid));
+                    plexPlayer.setName(name);
+                    plexPlayer.setLoginMessage(loginMSG);
+                    plexPlayer.setPrefix(prefix);
+                    plexPlayer.setRank(rankName);
+                    plexPlayer.setIps(ips);
+                    plexPlayer.setCoins(coins);
+                    plexPlayer.setVanished(vanished);
+                    plexPlayer.setCommandSpy(commandspy);
+                    plexPlayers.add(plexPlayer);
+                }
+            }
+            catch (SQLException throwables)
+            {
+                throwables.printStackTrace();
+            }
+        }
+        return plexPlayers;
+    }
+}

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

@@ -3,8 +3,8 @@ 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;
-import org.bukkit.Bukkit;
 
 /**
  * Parent cache class
@@ -29,6 +29,18 @@ public class DataUtils
         }
     }
 
+    public static boolean hasPlayedBefore(String username)
+    {
+        if (Plex.get().getStorageType() == StorageType.MONGODB)
+        {
+            return Plex.get().getMongoPlayerData().exists(username);
+        }
+        else
+        {
+            return Plex.get().getSqlPlayerData().exists(username);
+        }
+    }
+
     /**
      * Gets a player from cache or from the database
      *
@@ -38,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)
@@ -49,20 +66,56 @@ 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, loadExtraData);
         }
     }
 
     /**
      * Gets a player from cache or from the database
      *
-     * @param name Username of the player
+     * @param ip The IP address of the player.
      * @return a PlexPlayer object
      * @see PlexPlayer
      */
-    public static PlexPlayer getPlayer(String name)
+    public static PlexPlayer getPlayerByIP(String ip)
     {
-        return getPlayer(Bukkit.getPlayer(name).getUniqueId());
+        PlexPlayer player = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream().filter(plexPlayer -> plexPlayer.getIps().contains(ip)).findFirst().orElse(null);
+        if (player != null)
+        {
+            return player;
+        }
+
+        if (Plex.get().getStorageType() == StorageType.MONGODB)
+        {
+            return Plex.get().getMongoPlayerData().getByIP(ip);
+        }
+        else
+        {
+            return Plex.get().getSqlPlayerData().getByIP(ip);
+        }
     }
 
     /**

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

@@ -1,8 +1,8 @@
 package dev.plex.cache;
 
 import com.google.common.collect.Maps;
+import dev.plex.api.IPlayerCache;
 import dev.plex.player.PlexPlayer;
-import dev.plex.player.PunishedPlayer;
 import java.util.Map;
 import java.util.UUID;
 
@@ -10,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
@@ -20,19 +20,18 @@ public class PlayerCache
     /**
      * A key/value pair where the key is the unique ID of the Punished Player
      */
-    private static final Map<UUID, PunishedPlayer> punishedPlayerMap = Maps.newHashMap();
+    //    private static final Map<UUID, PunishedPlayer> punishedPlayerMap = Maps.newHashMap();
 
-    public static Map<UUID, PunishedPlayer> getPunishedPlayerMap()
-    {
-        return punishedPlayerMap;
-    }
-
-    public static Map<UUID, PlexPlayer> getPlexPlayerMap()
+    //    public static Map<UUID, PunishedPlayer> getPunishedPlayerMap()
+    //    {
+    //        return punishedPlayerMap;
+    //    }
+    public Map<UUID, PlexPlayer> getPlexPlayerMap()
     {
         return plexPlayerMap;
     }
 
-    public static PunishedPlayer getPunishedPlayer(UUID uuid)
+    /*public static PunishedPlayer getPunishedPlayer(UUID uuid)
     {
         if (!getPunishedPlayerMap().containsKey(uuid))
         {
@@ -40,8 +39,8 @@ 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;
@@ -20,7 +19,6 @@ import java.util.UUID;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
@@ -67,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);
@@ -84,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
@@ -124,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"))
             {
@@ -133,10 +139,54 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
                     send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
                     return true;
                 }
+                else
+                {
+                    if (getLevel().isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
+                    {
+                        send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
+                        return true;
+                    }
+                }
             }
             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;
+                }
+            }
+            else
+            {
+                PlexLog.error("Neither permissions or ranks were selected to be used in the configuration file!");
+                send(sender, "There is a server misconfiguration. Please alert a developer or the owner");
+                return true;
+            }
+        }
+
+        if (sender instanceof ConsoleCommandSender && !sender.getName().equalsIgnoreCase("console")) //telnet
+        {
+            PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
+
+            if (plugin.getSystem().equalsIgnoreCase("ranks"))
+            {
+                if (!plexPlayer.getRankFromString().isAtLeast(getLevel()))
+                {
+                    send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
+                    return true;
+                }
+                else
+                {
+                    if (getLevel().isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
+                    {
+                        send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
+                        return true;
+                    }
+                }
+            }
+            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
+            {
+                if (!perms.permission().isEmpty() && !plugin.getPermissionHandler().hasPermission(Bukkit.getOfflinePlayer(plexPlayer.getName()), perms.permission()))
                 {
                     send(sender, messageComponent("noPermissionNode", perms.permission()));
                     return true;
@@ -157,9 +207,10 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
                 send(sender, component);
             }
         }
-        catch (PlayerNotFoundException | CommandFailException | ConsoleOnlyException | ConsoleMustDefinePlayerException | PlayerNotBannedException ex)
+        catch (PlayerNotFoundException | CommandFailException | ConsoleOnlyException |
+               ConsoleMustDefinePlayerException | PlayerNotBannedException | NumberFormatException ex)
         {
-            send(sender, MiniMessage.miniMessage().deserialize(ex.getMessage()));
+            send(sender, PlexUtils.mmDeserialize(ex.getMessage()));
         }
         return true;
     }
@@ -238,6 +289,28 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         {
             return checkRank((Player) sender, rank, permission);
         }
+        if (!sender.getName().equalsIgnoreCase("console"))
+        {
+            PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
+            if (plugin.getSystem().equalsIgnoreCase("ranks"))
+            {
+                if (!plexPlayer.getRankFromString().isAtLeast(rank))
+                {
+                    throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
+                }
+                if (rank.isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
+                {
+                    throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
+                }
+            }
+            else if (plugin.getSystem().equalsIgnoreCase("permissions"))
+            {
+                if (!perms.permission().isEmpty() && !plugin.getPermissionHandler().hasPermission(Bukkit.getOfflinePlayer(plexPlayer.getName()), perms.permission()))
+                {
+                    throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
+                }
+            }
+        }
         return true;
     }
 
@@ -263,10 +336,14 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
             {
                 throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
             }
+            if (rank.isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
+            {
+                throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
+            }
         }
         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));
             }
@@ -274,6 +351,24 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return true;
     }
 
+    protected boolean silentCheckRank(Player player, Rank rank, String permission)
+    {
+        if (player instanceof ConsoleCommandSender)
+        {
+            return true;
+        }
+        PlexPlayer plexPlayer = getPlexPlayer(player);
+        if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        {
+            return rank.isAtLeast(Rank.ADMIN) ? plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(rank) : plexPlayer.getRankFromString().isAtLeast(rank);
+        }
+        else if (plugin.getSystem().equalsIgnoreCase("permissions"))
+        {
+            return !perms.permission().isEmpty() && plugin.getPermissionHandler().hasPermission(player, permission);
+        }
+        return false;
+    }
+
     /**
      * Checks whether a sender has enough permissions or is high enough a rank
      *
@@ -306,11 +401,11 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         PlexPlayer plexPlayer = getPlexPlayer(player);
         if (plugin.getSystem().equalsIgnoreCase("ranks"))
         {
-            return plexPlayer.getRankFromString().isAtLeast(rank);
+            return rank.isAtLeast(Rank.ADMIN) ? plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(rank) : plexPlayer.getRankFromString().isAtLeast(rank);
         }
         else if (plugin.getSystem().equalsIgnoreCase("permissions"))
         {
-            return player.hasPermission(permission);
+            return !perms.permission().isEmpty() && plugin.getPermissionHandler().hasPermission(player, permission);
         }
         return true;
     }
@@ -422,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
      *
@@ -458,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)
         {
@@ -469,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();
@@ -521,7 +638,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      */
     protected Component mmString(String s)
     {
-        return MiniMessage.miniMessage().deserialize(s);
+        return PlexUtils.mmDeserialize(s);
     }
 
     public Rank getLevel()

server/src/main/java/dev/plex/command/annotation/System.java

@@ -1,5 +1,9 @@
 package dev.plex.command.annotation;
 
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
 public @interface System
 {
     String value() default "";

server/src/main/java/dev/plex/command/blocking/BlockedCommand.java

@@ -0,0 +1,16 @@
+package dev.plex.command.blocking;
+
+import com.google.common.collect.Lists;
+import java.util.List;
+import lombok.Data;
+import net.kyori.adventure.text.Component;
+
+@Data
+public class BlockedCommand
+{
+    private Component message;
+    private String requiredLevel;
+    private String regex;
+    private String command;
+    private List<String> commandAliases = Lists.newArrayList();
+}

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,17 +12,13 @@ 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;
 import java.util.Arrays;
 import java.util.List;
-import java.util.UUID;
 import net.kyori.adventure.text.Component;
-import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -28,7 +27,7 @@ import org.jetbrains.annotations.Nullable;
 
 @CommandPermissions(level = Rank.OP, source = RequiredCommandSource.ANY)
 @CommandParameters(name = "admin", usage = "/<command> <add <player> | remove <player> | setrank <player> <rank> | list>", aliases = "saconfig,slconfig,adminconfig,adminmanage", description = "Manage all admins")
-@System("ranks")
+@System(value = "ranks")
 public class AdminCMD extends PlexCommand
 {
     //TODO: Better return messages
@@ -53,13 +52,18 @@ public class AdminCMD extends PlexCommand
                 throw new ConsoleOnlyException();
             }
 
-            UUID targetUUID = PlexUtils.getFromName(args[1]);
+            /*UUID targetUUID = PlexUtils.getFromName(args[1]);
 
-            if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+            if (targetUUID != null)
+            {
+                PlexLog.debug("Admin Adding UUID: " + targetUUID);
+            }*/
+
+            if (!DataUtils.hasPlayedBefore(args[1]))
             {
                 throw new PlayerNotFoundException();
             }
-            PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
+            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
 
             if (isAdmin(plexPlayer))
             {
@@ -81,13 +85,13 @@ public class AdminCMD extends PlexCommand
                 throw new ConsoleOnlyException();
             }
 
-            UUID targetUUID = PlexUtils.getFromName(args[1]);
+            //            UUID targetUUID = PlexUtils.getFromName(args[1]);
 
-            if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+            if (!DataUtils.hasPlayedBefore(args[1]))
             {
                 throw new PlayerNotFoundException();
             }
-            PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
+            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
 
             if (!isAdmin(plexPlayer))
             {
@@ -110,9 +114,9 @@ public class AdminCMD extends PlexCommand
                 throw new ConsoleOnlyException();
             }
 
-            UUID targetUUID = PlexUtils.getFromName(args[1]);
+            //            UUID targetUUID = PlexUtils.getFromName(args[1]);
 
-            if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+            if (!DataUtils.hasPlayedBefore(args[1]))
             {
                 throw new PlayerNotFoundException();
             }
@@ -129,7 +133,7 @@ public class AdminCMD extends PlexCommand
                 return messageComponent("rankMustBeHigherThanAdmin");
             }
 
-            PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
+            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
 
             if (!isAdmin(plexPlayer))
             {

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;
@@ -9,7 +8,7 @@ import dev.plex.player.PlexPlayer;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
 import net.kyori.adventure.text.Component;
-import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -38,15 +37,15 @@ public class AdminChatCMD extends PlexCommand
         {
             if (plugin.getSystem().equalsIgnoreCase("ranks"))
             {
-                PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
-                if (plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN))
+                PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(player.getUniqueId());
+                if (plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN) && plexPlayer.isAdminActive())
                 {
                     player.sendMessage(PlexUtils.messageComponent("adminChatFormat", sender.getName(), message));
                 }
             }
             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

@@ -0,0 +1,118 @@
+package dev.plex.command.impl;
+
+import com.google.common.collect.ImmutableList;
+import dev.plex.Plex;
+import dev.plex.cache.DataUtils;
+import dev.plex.command.PlexCommand;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.exception.PlayerNotFoundException;
+import dev.plex.command.source.RequiredCommandSource;
+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.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.List;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "ban", usage = "/<command> <player> [reason]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.ban", source = RequiredCommandSource.ANY)
+
+public class BanCMD extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+
+        UUID targetUUID = WebUtils.getFromName(args[0]);
+
+        if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
+        {
+            throw new PlayerNotFoundException();
+        }
+        PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
+        Player player = Bukkit.getPlayer(targetUUID);
+
+        if (plugin.getSystem().equalsIgnoreCase("ranks"))
+        {
+            if (isAdmin(plexPlayer))
+            {
+                if (!isConsole(sender))
+                {
+                    assert playerSender != null;
+                    PlexPlayer plexPlayer1 = getPlexPlayer(playerSender);
+                    if (!plexPlayer1.getRankFromString().isAtLeast(plexPlayer.getRankFromString()))
+                    {
+                        return messageComponent("higherRankThanYou");
+                    }
+                }
+            }
+        }
+
+        plugin.getPunishmentManager().isAsyncBanned(targetUUID).whenComplete((aBoolean, throwable) ->
+        {
+            if (aBoolean)
+            {
+                send(sender, messageComponent("playerBanned"));
+                return;
+            }
+            String reason;
+            Punishment punishment = new Punishment(targetUUID, getUUID(sender));
+            punishment.setType(PunishmentType.BAN);
+            if (args.length > 1)
+            {
+                reason = StringUtils.join(args, " ", 1, args.length);
+                punishment.setReason(reason);
+            }
+            else
+            {
+                punishment.setReason("No reason provided.");
+            }
+            punishment.setPunishedUsername(plexPlayer.getName());
+            ZonedDateTime date = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
+            punishment.setEndDate(date.plusDays(1));
+            punishment.setCustomTime(false);
+            punishment.setActive(!isAdmin(plexPlayer));
+            if (player != null)
+            {
+                punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
+            }
+            plugin.getPunishmentManager().punish(plexPlayer, punishment);
+            PlexUtils.broadcast(messageComponent("banningPlayer", sender.getName(), plexPlayer.getName()));
+            Bukkit.getScheduler().runTask(Plex.get(), () ->
+            {
+                if (player != null)
+                {
+                    BungeeUtil.kickPlayer(player, Punishment.generateBanMessage(punishment));
+                }
+            });
+            PlexLog.debug("(From /ban command) PunishedPlayer UUID: " + plexPlayer.getUuid());
+        });
+
+        return null;
+    }
+
+    @Override
+    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    {
+        return args.length == 1 && checkTab(sender, Rank.ADMIN, "plex.ban") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
+    }
+}

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

@@ -0,0 +1,98 @@
+package dev.plex.command.impl;
+
+import dev.plex.command.PlexCommand;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.listener.impl.BlockListener;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.blockedit")
+@CommandParameters(name = "blockedit", usage = "/<command> [list | purge | all | <player>]", aliases = "bedit", description = "Prevent players from modifying blocks")
+public class BlockEditCMD extends PlexCommand
+{
+    private final BlockListener bl = new BlockListener();
+
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+
+        if (args[0].equalsIgnoreCase("list"))
+        {
+            send(sender, messageComponent("listOfPlayersBlocked"));
+
+            int count = 0;
+            for (String player : bl.blockedPlayers.stream().toList())
+            {
+                send(sender, "- " + player);
+                ++count;
+            }
+            if (count == 0)
+            {
+                send(sender, "- none");
+            }
+            return null;
+        }
+        else if (args[0].equalsIgnoreCase("purge"))
+        {
+            PlexUtils.broadcast(messageComponent("unblockingEdits", sender.getName(), "all players"));
+            int count = 0;
+            for (String player : bl.blockedPlayers.stream().toList())
+            {
+                if (bl.blockedPlayers.contains(player))
+                {
+                    bl.blockedPlayers.remove(player);
+                    ++count;
+                }
+            }
+            return messageComponent("blockeditSize", "Unblocked", count);
+        }
+        else if (args[0].equalsIgnoreCase("all"))
+        {
+            PlexUtils.broadcast(messageComponent("blockingEdits", sender.getName(), "all non-admins"));
+            int count = 0;
+            for (final Player player : Bukkit.getOnlinePlayers())
+            {
+                if (!silentCheckRank(player, Rank.ADMIN, "plex.blockedit"))
+                {
+                    bl.blockedPlayers.add(player.getName());
+                    ++count;
+                }
+            }
+
+            return messageComponent("blockeditSize", "Blocked", count);
+        }
+
+        final Player player = getNonNullPlayer(args[0]);
+        if (!bl.blockedPlayers.contains(player.getName()))
+        {
+            if (silentCheckRank(player, Rank.ADMIN, "plex.blockedit"))
+            {
+                send(sender, messageComponent("higherRankThanYou"));
+                return null;
+            }
+            PlexUtils.broadcast(messageComponent("blockingEdits", sender.getName(), player.getName()));
+            bl.blockedPlayers.add(player.getName());
+            send(player, messageComponent("editsModified", "blocked"));
+            send(sender, messageComponent("editsBlocked", player.getName()));
+        }
+        else
+        {
+            PlexUtils.broadcast(messageComponent("unblockingEdits", sender.getName(), player.getName()));
+            bl.blockedPlayers.remove(player.getName());
+            send(player, messageComponent("editsModified", "unblocked"));
+            send(sender, messageComponent("editsUnblocked", player.getName()));
+        }
+        return null;
+    }
+}

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

@@ -7,9 +7,7 @@ import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.player.PlexPlayer;
 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.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -27,9 +25,9 @@ public class CommandSpyCMD extends PlexCommand
             PlexPlayer plexPlayer = DataUtils.getPlayer(playerSender.getUniqueId());
             plexPlayer.setCommandSpy(!plexPlayer.isCommandSpy());
             DataUtils.update(plexPlayer);
-            return Component.text(PlexUtils.messageString("toggleCommandSpy")).color(NamedTextColor.GRAY)
+            send(sender, messageComponent("toggleCommandSpy")
                     .append(Component.space())
-                    .append(Component.text(plexPlayer.isCommandSpy() ? PlexUtils.messageString("enabled") : PlexUtils.messageString("disabled")).color(NamedTextColor.GRAY));
+                    .append(plexPlayer.isCommandSpy() ? messageComponent("enabled") : messageComponent("disabled")));
         }
         return null;
     }

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

@@ -0,0 +1,31 @@
+package dev.plex.command.impl;
+
+import dev.plex.command.PlexCommand;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import net.kyori.adventure.text.Component;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.consolesay", source = RequiredCommandSource.CONSOLE)
+@CommandParameters(name = "consolesay", usage = "/<command> <message>", description = "Displays a message to everyone", aliases = "csay")
+public class ConsoleSayCMD extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+
+        PlexUtils.broadcast(PlexUtils.messageComponent("consoleSayMessage", sender.getName(), PlexUtils.mmStripColor(StringUtils.join(args, " "))));
+        return null;
+    }
+}