3.3.2

optimizations in CPUManager

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,6 +1,6 @@
 name: Bug Report
-description: Unwanted behavior that does not match configuration.
-labels: ["Bug"]
+description: Plugin does not work as described.
+labels: ["Type: Bug"]
 body:
   - type: input
     attributes:
@@ -45,7 +45,7 @@ body:
   - type: textarea
     attributes:
       label: Additional info
-      description: Any other info you want to provide, such as screenshots.
+      description: Anything else you want to provide that will help in resolving the issue faster, such as screenshots or videos.
     validations:
       required: false
   - type: checkboxes
@@ -57,5 +57,7 @@ body:
           required: true
         - label: I have read the wiki to make sure it's not an issue with configuration
           required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
         - label: I have read the Compatibility wiki page and am not trying to run the plugin on an unsupported server version / platform
           required: true

.github/ISSUE_TEMPLATE/error.yml

@@ -1,6 +1,6 @@
 name: Error
 description: Error message with a stack trace in console or error file.
-labels: ["Error"]
+labels: ["Type: Error"]
 body:
   - type: input
     attributes:
@@ -51,5 +51,7 @@ body:
           required: true
         - label: I have included a paste of the error
           required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
         - label: I have read the Compatibility wiki page and am not trying to run the plugin on an unsupported server version / platform
           required: true

.github/ISSUE_TEMPLATE/memory_leak.yml

@@ -0,0 +1,56 @@
+name: Memory leak
+description: Memory leak caused by TAB.
+labels: ["Type: Memory leak"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Heap dump
+      description: Link to uploaded memory dump which I can look into.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Uncleared object(s)
+      description: Objects you believe should have been removed from the memory but are not
+      placeholder: |
+        There is only 1 player online, but heap dump has 100 instances of TabPlayer
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included download link of my heap dump
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
+        - label: I have explained what I believe is wrong with the heap dump
+          required: true

.github/ISSUE_TEMPLATE/performance_issue.yml

@@ -0,0 +1,55 @@
+name: Performance issue
+description: Performance issue in TAB or in server caused by TAB
+labels: ["Type: Performance"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Evidence
+      description: Any evidence proving the performance issue, such as output of /tab cpu or timings.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce (if known)
+      description: What to do in order to reproduce this issue
+      placeholder: |
+        Step 1: ..
+        Step 2: ..
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included sufficient evidence of the issue
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false

.github/ISSUE_TEMPLATE/wiki_change.yml

@@ -1,6 +1,6 @@
 name: Wiki change
 description: Change to text on a wiki page or adding a new section.
-labels: ["Wiki"]
+labels: ["Type: Wiki change"]
 body:
   - type: input
     attributes:

.github/workflows/build.yml

@@ -3,7 +3,6 @@ on:
   push:
     branches:
       - master
-      - v3
   pull_request:
     types: [opened, synchronize, reopened]
 jobs:
@@ -11,21 +10,22 @@ jobs:
     name: Build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3.3.0 #https://github.com/actions/checkout/releases
         with:
           fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
       - name: Set up JDK 11
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3.9.0 #https://github.com/actions/setup-java/releases
         with:
+          distribution: 'temurin'
           java-version: 11
       - name: Cache SonarCloud packages
-        uses: actions/cache@v1
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
         with:
           path: ~/.sonar/cache
           key: ${{ runner.os }}-sonar
           restore-keys: ${{ runner.os }}-sonar
       - name: Cache Gradle
-        uses: actions/cache@v2
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
         with:
           path: |
             ~/.gradle/caches
@@ -38,7 +38,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
         run: ./gradlew clean build
       - name: Upload a Build Artifact
-        uses: actions/upload-artifact@v2.3.1
+        uses: actions/upload-artifact@v3.1.2 #https://github.com/actions/upload-artifact/releases
         with:
           name: Jar
           path: jar/build/libs/TAB-**.jar

CONTRIBUTING.md

@@ -0,0 +1,10 @@
+If this plugin has helped you in any way, and you would like to return something back 
+to make the plugin even better, there is a lot of ways to contribute:  
+* Open a **pull request** containing a new feature or a bug fix, which you believe many users will benefit from.
+* Make detailed high-quality **bug reports**. The difference between a bug getting fixed in 1 week vs 1 hour 
+is in quality of the report (typically providing correct steps to reproduce that actually work).
+* Test **experimental builds**, which can be found in [GitHub Actions](https://github.com/NEZNAMY/TAB/actions) for problems of any kind including bugs. 
+This way you will help make the actual releases more stable / help get stable releases sooner.
+* Help improve the wiki by opening a [Wiki change issue](https://github.com/NEZNAMY/TAB/issues/new?assignees=&labels=Wiki&template=wiki_change.yml), 
+where you can improve existing descriptions, add information you found missing, fix typos / grammar mistakes or add more examples of usage of functions.
+* [Buy a copy](https://builtbybit.com/resources/14009/) of the plugin or [send a donation](https://paypal.me/neznamy1) to keep the plugin active.

LICENSE

@@ -0,0 +1,174 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.

README.md

@@ -6,27 +6,71 @@ More information can be found at [Why TAB?](https://github.com/NEZNAMY/TAB/wiki/
 # Distribution
 As of TAB 3.0.0, released with MC 1.18 (November 30th, 2021), there is no free / premium
 version anymore. Only one version of the plugin exists now, which contains all implemented features
-and is available to everyone for free. However, official support on discord is only provided to 
-those who have purchased the plugin.  
+and is available to everyone for free. However, customer support is only provided to 
+customers who have purchased the plugin (see [Customer support](#customer-support)).  
 
 # Compiling
 Compilation requires JDK 8 and up.  
 To compile the plugin, run `./gradlew build` from the terminal.  
-Once the plugin compiles, grab the jar from `/jar/build/libs/` folder.
+Once the plugin compiles, grab the jar from `/jar/build/libs/` folder.  
+The universal jar contains all modules for all supported platforms.
 
-# Links
-The precompiled JAR can be downloaded for free from:  
-* Releases: https://github.com/NEZNAMY/TAB/releases
-* MC-Market: https://www.mc-market.org/resources/20631/
+# Customer support
+Unlike with other projects where requirements and level of support provided are unclear,
+we provide a clear answer to what kind of service you will or will not receive. Some don't
+even clearly state if they are free or paid. While they are listed as paid on spigot, they have
+a free download link in description, which can be confusing.  
+  
+Free plugins typically do have a support discord, however you will rarely receive
+official support from the developers, especially for large projects with tons of users, where
+helping everyone in the world (theoretically) would consume too much time, leaving authors
+no time left to actually work on the project.
+In the end, they are free, made by people in their free time, and they are allowed to choose
+what they do or don't want to do in their free time. They often leave support to other people,
+possibly staff members, who are, however, in the end just more volunteers who may not even know
+the answer.  
+  
+With paid plugins you are more likely to receive support, but unless explicitly said, nothing is
+guaranteed. There are lots of paid plugins where authors don't provide any support or redirect
+it to helpers, where again they are unpaid volunteers who might not even know the answer.  
+  
+In TAB, everything is clearly defined. The plugin is free to download for everyone.
+Customer support, however, is only provided to customers who have formally purchased a copy 
+of the plugin on any of the websites the plugin is being sold on:  
+* [BuiltByBit](https://builtbybit.com/resources/14009/) (accepts any payment method)  
+* [Polymart](https://polymart.org/resource/484) (only PayPal)
+  
+After purchasing, you can request assistance via either private messages on the website where you
+have purchased it, or using [TAB's Discord server](https://discord.gg/EaSvdk6) (which is highly 
+preferred, since the communication will be much faster thanks to notifications and more).  
+* We use a ticket system, which allows us to effectively track any amount of unresolved problems.
+No more questions getting lost in the sea of messages from other people asking. Tickets are only closed
+after user confirmed all of their questions were answered and then receive a transcript of the ticket
+from the bot after ticket is closed into private messages (unless user is blocking them).
+* We do not rely on the community helping, which often makes things even worse. We know people have
+better things to do than helping random people with a random plugin, especially when most people only
+have a very basic knowledge of the plugin, not being able to answer more complicated problems.
+* We have notifications enabled and reply as soon as possible. We do not have the server muted unlike
+most mods on most servers who only check it when they are really bored, give a wiki link and 
+disappear again.
+* As the developer, I do not rely on helpers providing support instead of me. They are handy as
+I am obviously not available 24/7, but I do not intentionally leave anything to them. I reply
+whenever I am available without any intentional delays.  
+  
+The wiki contains everything about the plugin in one way or another, so support should not 
+even be needed. It also contains a few examples, but obviously cannot contain a pre-made config
+for every possible idea anyone can come up with.  
+Support is provided to people who decided paying for support is more time efficient than reading the wiki,
+especially for serious servers, where price of the plugin is nothing compared to other server costs.
 
-Supporting my work:  
-* MC-Market: https://www.mc-market.org/resources/14009/
-* Polymart: https://polymart.org/resource/484
-* Donation link: https://paypal.me/neznamy1
-
-Other links:
-* Discord: https://discord.gg/EaSvdk6  
-* Wiki: https://github.com/NEZNAMY/TAB/wiki  
+# Other links
+Download the plugin for free: 
+* [GitHub releases](https://github.com/NEZNAMY/TAB/releases)
+* [BuiltByBit](https://builtbybit.com/resources/20631/)
+* [Modrinth](https://modrinth.com/plugin/tab-was-taken)
+  
+[Wiki](https://github.com/NEZNAMY/TAB/wiki)  
+[Donate](https://paypal.me/neznamy1) if you are feeling extra generous
 
 # Issues
 The [Issues](https://github.com/NEZNAMY/TAB/issues) section is **only** available for cases included in templates.
@@ -34,15 +78,9 @@ In other words, they **are not available for**:
 * **Support** - support is provided on discord for buyers, where roles are given to verified users
 allowing us to know who bought it and who didn't. It also serves as a much faster way of communication.
 * **Feature requests** - closed indefinitely.
+  
+**If you're a customer, please use discord for reporting bugs, especially if you aren't good at making bug reports. 
+You will be provided with a much faster and higher quality service.**
 
 # Contributing
-If this plugin has helped you in any way, and you would like to return something back 
-to make the plugin even better, there is a lot of ways to contribute:  
-* Open a **pull request** containing a new feature or a bug fix, which you believe many users will benefit from.
-* Make detailed high-quality **bug reports**. The difference between a bug getting fixed in 1 week vs 1 hour 
-is in quality of the report (typically providing correct steps to reproduce that actually work).
-* Test **experimental builds**, which can be found in [Github Actions](https://github.com/NEZNAMY/TAB/actions) or in a form of pre-releases on discord
-for problems of any kind including bugs. This way you will help make the actual releases more stable / help get stable releases sooner.
-* Help improve the wiki by opening a [Wiki change issue](https://github.com/NEZNAMY/TAB/issues/new?assignees=&labels=Wiki&template=wiki_change.yml), 
-where you can improve existing descriptions, add information you found missing, fix typos / grammar mistakes or add more examples of usage of functions.
-* [Buy a copy](https://www.mc-market.org/resources/14009/) of the plugin or [send a donation](https://paypal.me/neznamy1) to keep the plugin active.
+See [CONTRIBUTING.md](https://github.com/NEZNAMY/TAB/blob/master/CONTRIBUTING.md)

SECURITY.md

@@ -0,0 +1,2 @@
+# Security Policy
+If you found a security issue, send me a private message anywhere.

api/build.gradle.kts

@@ -1,3 +1,7 @@
+plugins {
+    id("net.kyori.blossom") version "1.2.0"
+}
+
 dependencies {
     compileOnlyApi(libs.netty)
     api(libs.jsonSimple) {
@@ -5,5 +9,22 @@ dependencies {
     }
     compileOnlyApi(libs.snakeyaml)
     api(libs.yamlAssist)
-    compileOnlyApi(libs.gson)
+    compileOnlyApi(libs.adventureMiniMessage)
+    compileOnlyApi(libs.adventureApi)
+    compileOnlyApi(libs.adventureLegacy)
+    compileOnlyApi(libs.via)
+}
+
+blossom {
+    replaceToken("@name@", rootProject.name)
+    replaceToken("@id@", rootProject.ext.get("id")!!.toString())
+    replaceToken("@version@", project.version)
+    replaceToken("@description@", project.description)
+    replaceToken("@website@", rootProject.ext.get("website")!!.toString())
+    replaceToken("@author@", rootProject.ext.get("author")!!.toString())
+    replaceTokenIn("src/main/java/me/neznamy/tab/api/TabConstants.java")
+}
+
+tasks.javadoc {
+    enabled = project.hasProperty("enable-javadoc")
 }

api/src/main/java/me/neznamy/tab/api/ArmorStand.java

@@ -1,60 +1,40 @@
 package me.neznamy.tab.api;
 
+/**
+ * Interface representing an armor stand attached to player
+ * for displaying text in game.
+ */
 public interface ArmorStand {
 
     /**
      * Returns true if offset is static, false if not
-     * @return true if static, false if dynamic
+     *
+     * @return  true if static, false if dynamic
      */
-    boolean hasStaticOffset();
+    boolean isStaticOffset();
     
     /**
      * Changes offset of the armor stand
-     * @param offset - new offset
+     *
+     * @param   offset
+     *          new offset
      */
     void setOffset(double offset);
 
     /**
      * Returns offset of the armor stand
-     * @return offset from base
+     *
+     * @return  offset from base
      */
     double getOffset();
     
     /**
      * Returns property for armor stand's name
-     * @return property for armor stand's name
+     *
+     * @return  property for armor stand's name
      */
     Property getProperty();
-    
-    /**
-     * Teleports armor stand to owner's current location for everyone in range
-     */
-    void teleport();
-    
-    /**
-     * Teleports armor stand to owner's current location for specified player
-     * @param viewer - player to send packet to
-     */
-    void teleport(TabPlayer viewer);
-    
-    /**
-     * Changes sneaking flag and sends packets to everyone in range
-     * @param    sneaking
-     *             new sneaking status
-     */
-    void sneak(boolean sneaking);
-    
-    /**
-     * DeSpawns armor stand for everyone
-     */
-    void destroy();
-    
-    /**
-     * DeSpawns armor stand for specified player
-     * @param viewer - player to send packet to
-     */
-    void destroy(TabPlayer viewer);
-    
+
     /**
      * Updates armor stand's name if needed
      */
@@ -62,21 +42,16 @@ public interface ArmorStand {
     
     /**
      * Updates visibility if needed
-     * @param force - if refresh should be forced
+     *
+     * @param   force
+     *          if refresh should be forced
      */
     void updateVisibility(boolean force);
     
     /**
      * Returns entity ID of this armor stand
-     * @return entity ID of this armor stand
+     *
+     * @return  entity ID of this armor stand
      */
     int getEntityId();
-    
-    /**
-     * Spawns armor stand for specified player
-     * @param viewer - player to spawn for
-     */
-    void spawn(TabPlayer viewer);
-    
-    void respawn(TabPlayer viewer);
 }

api/src/main/java/me/neznamy/tab/api/ArmorStandManager.java

@@ -10,5 +10,11 @@ public interface ArmorStandManager {
      */
     void destroy();
 
+    /**
+     * Refreshes text of all armor stands for all nearby players
+     *
+     * @param   force
+     *          If refresh should be force despite no update seemingly being needed
+     */
     void refresh(boolean force);
 }

api/src/main/java/me/neznamy/tab/api/BossBarHandler.java

@@ -0,0 +1,74 @@
+package me.neznamy.tab.api;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+
+import java.util.UUID;
+
+public interface BossBarHandler {
+
+    /**
+     * Creates boss bar and sends it to the player
+     *
+     * @param   id
+     *          Unique identifier to match the bossbar with other functions
+     * @param   title
+     *          BossBar title
+     * @param   progress
+     *          BossBar progress (0-1)
+     * @param   color
+     *          BossBar color
+     * @param   style
+     *          BossBar style
+     */
+    void create(@NonNull UUID id, @NonNull String title, float progress, @NonNull BarColor color, @NonNull BarStyle style);
+
+    /**
+     * Updates title
+     *
+     * @param   id
+     *          Unique identifier to match the bossbar with other functions
+     * @param   title
+     *          New title
+     */
+    void update(@NonNull UUID id, @NonNull String title);
+
+    /**
+     * Updates progress
+     *
+     * @param   id
+     *          Unique identifier to match the bossbar with other functions
+     * @param   progress
+     *          New progress (0-1)
+     */
+    void update(@NonNull UUID id, float progress);
+
+    /**
+     * Updates style
+     *
+     * @param   id
+     *          Unique identifier to match the bossbar with other functions
+     * @param   style
+     *          New style
+     */
+    void update(@NonNull UUID id, @NonNull BarStyle style);
+
+    /**
+     * Updates color
+     *
+     * @param   id
+     *          Unique identifier to match the bossbar with other functions
+     * @param   color
+     *          New color
+     */
+    void update(@NonNull UUID id, @NonNull BarColor color);
+
+    /**
+     * Removes boss bar
+     *
+     * @param   id
+     *          Unique identifier to match the bossbar with other functions
+     */
+    void remove(@NonNull UUID id);
+}

api/src/main/java/me/neznamy/tab/api/FeatureManager.java

@@ -1,35 +1,102 @@
 package me.neznamy.tab.api;
 
+import me.neznamy.tab.api.feature.TabFeature;
+
+import java.util.UUID;
+
+/**
+ * Feature manager allows registration and work with features.
+ */
 public interface FeatureManager {
 
     /**
      * Registers a feature, which will start receiving events
      * 
-     * @param name - name of feature
-     * @param feature - the handler
+     * @param   name
+     *          name of feature
+     * @param   feature
+     *          the handler
      */
     void registerFeature(String name, TabFeature feature);
     
     /**
      * Unregisters feature making it no longer receive events. This does not run unload method nor cancel
      * tasks created by the feature
-     * @param name - feature name defined in registerFeature
+     *
+     * @param   name
+     *          feature name defined in registerFeature
      */
     void unregisterFeature(String name);
     
     /**
      * Returns whether a feature with said name is registered or not
      * 
-     * @param name - name of feature defined in registerFeature method
-     * @return true if feature exists, false if not
+     * @param   name
+     *          name of feature defined in registerFeature method
+     * @return  true if feature exists, false if not
      */
     boolean isFeatureEnabled(String name);
 
     /**
      * Returns feature handler by its name
      * 
-     * @param name - name of feature defined in registerFeature method
-     * @return the feature or null if feature does not exist
+     * @param   name
+     *          name of feature defined in registerFeature method
+     * @return  the feature or null if feature does not exist
      */
     TabFeature getFeature(String name);
+
+    /**
+     * Calls onQuit(TabPlayer) to all enabled features
+     *
+     * @param   disconnectedPlayer
+     *          player who disconnected
+     */
+    void onQuit(TabPlayer disconnectedPlayer);
+
+    /**
+     * Calls onJoin(TabPlayer) to all enabled features
+     *
+     * @param   connectedPlayer
+     *          player who connected
+     */
+    void onJoin(TabPlayer connectedPlayer);
+
+    /**
+     * Calls onServerChange(TabPlayer, String, String) to all enabled features
+     *
+     * @param   playerUUID
+     *          player who switched server
+     * @param   to
+     *          name of the new server
+     */
+    void onServerChange(UUID playerUUID, String to);
+
+    /**
+     * Calls onWorldChange(TabPlayer, String, String) to all enabled features
+     *
+     * @param   playerUUID
+     *          player who switched world
+     * @param   to
+     *          name of the new world
+     */
+    void onWorldChange(UUID playerUUID, String to);
+
+    /**
+     * Calls onCommand(TabPlayer, String) to all enabled features
+     *
+     * @param   sender
+     *          command sender
+     * @param   command
+     *          command line including /
+     * @return  {@code true} if some feature marked the command for cancel, {@code false} if not
+     */
+    boolean onCommand(TabPlayer sender, String command);
+
+    /**
+     * Returns array of all currently enabled features
+     *
+     * @return  array of all currently enabled features
+     */
+    TabFeature[] getValues();
 }

api/src/main/java/me/neznamy/tab/api/HeaderFooterManager.java

@@ -1,16 +1,82 @@
 package me.neznamy.tab.api;
 
+/**
+ * Interface allowing to send header/footer to players.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getHeaderFooterManager()}.
+ * This requires the Header/footer feature to be enabled in config, otherwise
+ * the method will return {@code null}.
+ */
 public interface HeaderFooterManager {
 
+    /**
+     * Sets raw value of header to specified value. This overrides plugin
+     * configuration until reset is called. Has full placeholder support
+     * and will send update packet whenever a placeholder used inside
+     * changes its value.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   header
+     *          Raw header value
+     */
     void setHeader(TabPlayer player, String header);
 
+    /**
+     * Sets raw value of footer to specified value. This overrides plugin
+     * configuration until reset is called. Has full placeholder support
+     * and will send update packet whenever a placeholder used inside
+     * changes its value.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   footer
+     *          Raw footer value
+     */
     void setFooter(TabPlayer player, String footer);
 
+    /**
+     * Sets raw value of header and footer to specified values. This overrides plugin
+     * configuration until reset is called. Has full placeholder support
+     * and will send update packet whenever a placeholder used inside
+     * changes its value.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   header
+     *          Raw header value
+     * @param   footer
+     *          Raw footer value
+     */
     void setHeaderAndFooter(TabPlayer player, String header, String footer);
 
+    /**
+     * Resets header value previously set using {@link #setHeader(TabPlayer, String)}
+     * or {@link #setHeaderAndFooter(TabPlayer, String, String)} and restores internal
+     * logic using configuration files.
+     *
+     * @param   player
+     *          Player to reset header for
+     */
     void resetHeader(TabPlayer player);
 
+    /**
+     * Resets footer value previously set using {@link #setFooter(TabPlayer, String)}
+     * or {@link #setHeaderAndFooter(TabPlayer, String, String)} and restores internal
+     * logic using configuration files.
+     *
+     * @param   player
+     *          Player to reset header for
+     */
     void resetFooter(TabPlayer player);
 
+    /**
+     * Resets values previously set using {@link #setHeader(TabPlayer, String)},
+     * {@link #setFooter(TabPlayer, String)} or {@link #setHeaderAndFooter(TabPlayer, String, String)}
+     * and restores internal logic using configuration files.
+     *
+     * @param   player
+     *          Player to reset header and footer for
+     */
     void resetHeaderAndFooter(TabPlayer player);
 }

api/src/main/java/me/neznamy/tab/api/Property.java

@@ -1,54 +1,68 @@
 package me.neznamy.tab.api;
 
+/**
+ * An interface representing a property assigned to a player,
+ * which may contain placeholders and can be changed using the API.
+ */
 public interface Property {
 
     /**
      * Returns original raw value ignoring API calls
-     * @return original raw value
+     *
+     * @return  original raw value
      */
     String getOriginalRawValue();
 
     /**
      * Temporarily overrides current raw value with an API call
-     * @param temporaryValue - temporary value to be assigned
+     *
+     * @param   temporaryValue
+     *          temporary value to be assigned
      */
     void setTemporaryValue(String temporaryValue);
 
     /**
      * Returns current temporary value
-     * @return temporary value or null if not set
+     *
+     * @return  temporary value or null if not set
      */
     String getTemporaryValue();
 
     /**
      * Returns temporary value (via API) if present, raw value otherwise
-     * @return current raw value
+     *
+     * @return  current raw value
      */
     String getCurrentRawValue();
 
     /**
      * Returns last known value
-     * @return last known value
+     *
+     * @return  last known value
      */
     String get();
 
     /**
      * Replaces all placeholders in current raw value, colorizes it, removes remove-strings and returns whether value changed or not
-     * @return if updating changed value or not
+     *
+     * @return  if updating changed value or not
      */
     boolean update();
 
     /**
      * Replaces all placeholders in current raw value, colorizes it, removes remove-strings and returns it.
      * Equal to calling update() and then get().
-     * @return updated value
+     *
+     * @return  updated value
      */
     String updateAndGet();
 
     /**
      * Returns value for defined viewer by applying relational placeholders to last known value
-     * @param viewer - the viewer
-     * @return format for the viewer
+     *
+     * @param   viewer
+     *          the viewer
+     * @return  format for the viewer
      */
     String getFormat(TabPlayer viewer);
 }

api/src/main/java/me/neznamy/tab/api/PropertyConfiguration.java

@@ -1,30 +1,147 @@
 package me.neznamy.tab.api;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+import java.util.stream.Collectors;
 
+/**
+ * Interface representing user or group configuration.
+ * Implementation is either using file or MySQL, if it's enabled.
+ */
 public interface PropertyConfiguration {
 
-    void setProperty(String name, String property, String server, String world, String value);
+    /**
+     * Sets property value of group or user to specified value. If {@code world} or
+     * {@code server} is not {@code null}, value will be inserted as a per-world or
+     * per-server setting. If both {@code world} and {@code server} are {@code null},
+     * value is inserted as a global setting.
+     *
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     * @param   property
+     *          Name of property to set
+     * @param   server
+     *          Name of server to apply setting to, {@code null} for global setting
+     * @param   world
+     *          Name of world to apply setting to, {@code null} for global setting
+     * @param   value
+     *          Value of the property
+     */
+    void setProperty(String groupOrUser, String property, String server, String world, String value);
 
-    String[] getProperty(String name, String property, String server, String world);
+    /**
+     * Gets property of group or user. If {@code server} or {@code world}
+     * are not {@code null}, per-server / per-world settings are checked first
+     * to try to find a match. If no match is found, global value is returned.
+     * Returned value is an array with 2 elements, with first argument being value
+     * and second being source. If nothing is found, empty array is returned.
+     *
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     * @param   property
+     *          Name of property to get
+     * @param   server
+     *          Server the player is currently in, to allow check for per-server settings
+     * @param   world
+     *          World the player is currently in, to allow check for per-world settings
+     * @return  Array with 2 elements with value being first, source second if found,
+     *          empty array if nothing was found.
+     */
+    String[] getProperty(String groupOrUser, String property, String server, String world);
 
-    void remove(String name);
+    /**
+     * Removes all data applied to specified group or user.
+     *
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     */
+    void remove(String groupOrUser);
 
-    Map<String, String> getGlobalSettings(String name);
+    /**
+     * Returns map of global settings applied to specified group or user.
+     * Map key is property name, value is property value.
+     *
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     * @return  Map of global settings of specified group or user
+     */
+    Map<String, Object> getGlobalSettings(String groupOrUser);
 
-    Map<String, Map<String, String>> getPerWorldSettings(String name);
+    /**
+     * Returns map of per-world settings of specified group or user.
+     * Map key is world name, value is property name-value map in that world.
+     *
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     * @return  Map of per-world settings of specified group or user
+     */
+    Map<String, Map<String, Object>> getPerWorldSettings(String groupOrUser);
 
-    Map<String, Map<String, String>> getPerServerSettings(String name);
+    /**
+     * Returns map of per-server settings of specified group or user.
+     * Map key is server name, value is property name-value map in that server.
+     *
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     * @return  Map of per-server settings of specified group or user
+     */
+    Map<String, Map<String, Object>> getPerServerSettings(String groupOrUser);
 
+    /**
+     * Returns set of all groups or users that have anything configured,
+     * either globally or in some world or server.
+     *
+     * @return  Set of all entries with something configured
+     */
     Set<String> getAllEntries();
 
-    default Map<String, Map<String, String>> convertMap(Map<String, Map<String, Map<String, String>>> map, String key) {
-        Map<String, Map<String, String>> converted = new HashMap<>();
-        for (Map.Entry<String, Map<String, Map<String, String>>> entry : map.entrySet()) {
-            converted.put(entry.getKey(), entry.getValue().get(key));
+    /**
+     * Converts per-world or per-server map into a per-world or per-server map
+     * with values only belonging to entered group or user. In other words, extracts
+     * settings belonging to group or user from the map.
+     *
+     * @param   map
+     *          Original per-world or per-server setting map
+     * @param   groupOrUser
+     *          Name of group or user, depending on what this instance handles
+     * @return  Converted map only containing data of specified group or user
+     */
+    default Map<String, Map<String, Object>> convertMap(Map<String, Map<String, Map<String, Object>>> map, String groupOrUser) {
+        Map<String, Map<String, Object>> converted = new HashMap<>();
+        for (Map.Entry<String, Map<String, Map<String, Object>>> entry : map.entrySet()) {
+            converted.put(entry.getKey(), entry.getValue().get(groupOrUser));
         }
         return converted;
     }
+
+    /**
+     * Converts object into string. For most objects, {@link Object#toString()} is called.
+     * For lists, entries are connected with {@code "\n"}.
+     *
+     * @param   obj
+     *          Object to convert
+     * @return  Converted string
+     */
+    @SuppressWarnings("unchecked")
+    default String toString(Object obj) {
+        if (obj instanceof List) {
+            return ((List<Object>)obj).stream().map(Object::toString).collect(Collectors.joining("\n"));
+        }
+        return obj.toString();
+    }
+
+    /**
+     * Converts string into object. If string contains {@code "\n"},
+     * a list is created using {@code "\n"} as a separator. Otherwise,
+     * inserted string is returned.
+     *
+     * @param   string
+     *          String to convert
+     * @return  Converted object
+     */
+    default Object fromString(String string) {
+        if (string != null && string.contains("\n")) {
+            return Arrays.asList(string.split("\n"));
+        }
+        return string;
+    }
 }

api/src/main/java/me/neznamy/tab/api/ProtocolVersion.java

@@ -1,5 +1,11 @@
 package me.neznamy.tab.api;
 
+import com.viaversion.viaversion.api.Via;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.UUID;
+
 /**
  * Enum class representing all possibly used protocol versions
  */
@@ -8,6 +14,11 @@ public enum ProtocolVersion {
     UNKNOWN_SERVER_VERSION ("Unknown"),
     UNKNOWN_CLIENT_VERSION ("Unknown"),
     PROXY   ("Proxy"),
+    V1_19_4 (762),
+    V1_19_3 (761),
+    V1_19_2 (760),
+    V1_19_1 (760),
+    V1_19   (759),
     V1_18_2 (758),
     V1_18_1 (757),
     V1_18   (757),
@@ -65,20 +76,25 @@ public enum ProtocolVersion {
     /** Value array to iterate over to avoid array creations on each call */
     public static final ProtocolVersion[] VALUES = values();
 
-    //version's network id found at https://wiki.vg/Protocol_version_numbers
-    private final int networkId;
+    /** Version's network id found at https://wiki.vg/Protocol_version_numbers */
+    @Getter private final int networkId;
 
-    //minor version, such as 16
-    private int minorVersion;
+    /** Version's minor version, such as 16 for 1.16.x. Allowing override to
+     * set minor version of UNKNOWN_SERVER_VERSION value to value from package to fix compatibility
+     * with server forks that set bukkit version field value to "Unknown".
+     */
+    @Getter @Setter private int minorVersion;
 
-    //friendly name displayed in %player-version% placeholder
-    private final String friendlyName;
+    /** Version's friendly name displayed in %player-version% placeholder */
+    @Getter private final String friendlyName;
 
     /**
      * Constructs new instance with given network id
-     * @param networkId - network id of this version
+     *
+     * @param   networkId
+     *          network id of this version
      */
-    ProtocolVersion(int networkId){
+    ProtocolVersion(int networkId) {
         this.networkId = networkId;
         this.minorVersion = Integer.parseInt(toString().split("_")[1]);
         this.friendlyName = toString().substring(1).replace("_", ".");
@@ -86,53 +102,22 @@ public enum ProtocolVersion {
 
     /**
      * Constructs new instance with given friendly name
-     * @param friendlyName - friendly name to display
+     *
+     * @param   friendlyName
+     *          friendly name to display
      */
-    ProtocolVersion(String friendlyName){
+    ProtocolVersion(String friendlyName) {
         this.networkId = 999;
         this.minorVersion = 18;
         this.friendlyName = friendlyName;
     }
 
-    /**
-     * Returns the version's network id
-     * @return version's network id
-     */
-    public int getNetworkId() {
-        return networkId;
-    }
-
-    /**
-     * Returns user-friendly name of the version (such as 1.16.2 instead of V1_16_2)
-     * @return    user-friendly name of the version
-     */
-    public String getFriendlyName() {
-        return friendlyName;
-    }
-
-    /**
-     * Returns minor version of this release, such as 8 for 1.8.x or 13 for 1.13.x
-     * @return version's minor version
-     */
-    public int getMinorVersion() {
-        return minorVersion;
-    }
-
-    /**
-     * Overrides minor version of the version instance. This is used internally to
-     * set minor version of UNKNOWN_SERVER_VERSION value to value from package to fix compatibility
-     * with server forks that set bukkit version field value to "Unknown".
-     * @param    minorVersion
-     *             minor version to change value to
-     */
-    public void setMinorVersion(int minorVersion) {
-        this.minorVersion = minorVersion;
-    }
-
     /**
      * Returns enum constant of entered version or UNKNOWN_SERVER_VERSION if unknown version
-     * @param friendlyName - friendly name of the version
-     * @return version or UNKNOWN_SERVER_VERSION if version is unknown
+     *
+     * @param   friendlyName
+     *          friendly name of the version
+     * @return  version or UNKNOWN_SERVER_VERSION if version is unknown
      */
     public static ProtocolVersion fromFriendlyName(String friendlyName) {
         if (friendlyName.startsWith("1.8")) return V1_8;
@@ -145,8 +130,10 @@ public enum ProtocolVersion {
 
     /**
      * Returns version from given network id
-     * @param networkId - network id of protocol version
-     * @return version from given network id
+     *
+     * @param   networkId
+     *          network id of protocol version
+     * @return  version from given network id
      */
     public static ProtocolVersion fromNetworkId(int networkId) {
         for (ProtocolVersion v : VALUES) {
@@ -154,4 +141,19 @@ public enum ProtocolVersion {
         }
         return UNKNOWN_CLIENT_VERSION;
     }
+
+    /**
+     * Gets player's network version using ViaVersion API
+     *
+     * @param   player
+     *          Player's UUID
+     * @param   playerName
+     *          Player's name for debug messages
+     * @return  Player's network version
+     */
+    public static int getPlayerVersionVia(UUID player, String playerName) {
+        int version = Via.getAPI().getPlayerVersion(player);
+        TabAPI.getInstance().debug("ViaVersion returned protocol version " + version + " for " + playerName);
+        return version;
+    }
 }

api/src/main/java/me/neznamy/tab/api/Scoreboard.java

@@ -0,0 +1,57 @@
+package me.neznamy.tab.api;
+
+import lombok.NonNull;
+
+import java.util.Collection;
+
+public interface Scoreboard {
+
+    /**
+     * Sets objective display slot of specified objective
+     *
+     * @param   slot
+     *          Display slot
+     * @param   objective
+     *          Objective name
+     */
+    void setDisplaySlot(DisplaySlot slot, @NonNull String objective);
+
+    /**
+     * Sets scoreboard score
+     * @param   objective
+     *          Objective name
+     * @param   player
+     *          Affected player
+     * @param   score
+     *          New score value
+     */
+    void setScore(@NonNull String objective, @NonNull String player, int score);
+
+    /**
+     * Removes scoreboard score
+     *
+     * @param   objective
+     *          Objective to remove from
+     * @param   player
+     *          Player to remove from sidebar
+     */
+    void removeScore(@NonNull String objective, @NonNull String player);
+
+    void registerObjective(@NonNull String objectiveName, @NonNull String title, boolean hearts);
+
+    void unregisterObjective(@NonNull String objectiveName);
+
+    void updateObjective(@NonNull String objectiveName, @NonNull String title, boolean hearts);
+
+    void registerTeam(@NonNull String name, String prefix, String suffix, String visibility,
+                                String collision, Collection<String> players, int options);
+
+    void unregisterTeam(@NonNull String name);
+
+    void updateTeam(@NonNull String name, String prefix, String suffix, String visibility, String collision, int options);
+
+    enum DisplaySlot {
+
+        PLAYER_LIST, SIDEBAR, BELOW_NAME
+    }
+}

api/src/main/java/me/neznamy/tab/api/TabAPI.java

@@ -7,7 +7,6 @@ import me.neznamy.tab.api.config.ConfigurationFile;
 import me.neznamy.tab.api.event.EventBus;
 import me.neznamy.tab.api.placeholder.PlaceholderManager;
 import me.neznamy.tab.api.scoreboard.ScoreboardManager;
-import me.neznamy.tab.api.task.ThreadManager;
 import me.neznamy.tab.api.team.TeamManager;
 
 /**
@@ -15,103 +14,196 @@ import me.neznamy.tab.api.team.TeamManager;
  */
 public abstract class TabAPI {
 
+    /** Instance of the API */
     private static TabAPI instance;
 
-    public static TabAPI getInstance() {
-        return instance;
+    /**
+     * Constructs new instance and sets it as new API instance
+     */
+    public TabAPI() {
+        instance = this;
     }
 
-    public static void setInstance(TabAPI instance) {
-        TabAPI.instance = instance;
+    /**
+     * Returns API instance. If instance was not set by the plugin, throws
+     * {@code IllegalStateException}. This is usually caused by shading the API
+     * into own project, which is not allowed. Another option is calling the method
+     * before plugin was able to load.
+     *
+     * @return  API instance
+     * @throws  IllegalStateException
+     *          If instance is {@code null}
+     */
+    public static TabAPI getInstance() {
+        if (instance == null) throw new IllegalStateException("The API instance is null. This can have 2 possible causes: \n" +
+                "#1 - API was called before TAB was loaded. This means your plugin was loaded before TAB was. To make sure your " +
+                "plugin loads after TAB, add it as a depend or softdepend of your plugin.\n" +
+                "#2 - You shaded TAB's classes into your plugin, instead of only using them. This is not allowed. To verify this " +
+                "is your case, unzip your plugin and check for TAB's classes. If they are there, you will need to fix your compiler " +
+                "to not include them, such as scope provided for maven compilation.");
+        return instance;
     }
 
     /**
      * Returns player object from given UUID
-     * @return player object from given UUID
-     * @param id - Player UUID
+     *
+     * @param   id
+     *          Player UUID
+     * @return  player object from given UUID
      */
     public abstract TabPlayer getPlayer(UUID id);
 
     /**
      * Returns player object from given name
-     * @return player object from given name
-     * @param name - Player name
+     *
+     * @param   name
+     *          Player name
+     * @return  player object from given name
      */
     public abstract TabPlayer getPlayer(String name);
 
     /**
      * Returns collection of all online players. Will return empty list if plugin is disabled (due to a broken configuration file for example).
-     * @return collection of online players
+     *
+     * @return  collection of online players
      */
     public abstract TabPlayer[] getOnlinePlayers();
 
     /**
-     * Return BossBar manager instance if the feature is enabled. Returns null otherwise.
-     * @return BossBar manager
+     * Return BossBar manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  BossBar manager
      */
     public abstract BossBarManager getBossBarManager();
 
     /**
-     * Returns scoreboard manager instance if the feature is enabled. Returns null otherwise.
-     * @return scoreboard manager
+     * Returns scoreboard manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  scoreboard manager
      */
     public abstract ScoreboardManager getScoreboardManager();
 
     /**
-     * Returns team manager instance if the feature is enabled, false otherwise
-     * @return team manager
+     * Returns team manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  team manager
      */
     public abstract TeamManager getTeamManager();
 
+    /**
+     * Returns header/footer manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  Header/footer manager
+     */
     public abstract HeaderFooterManager getHeaderFooterManager();
 
     /**
      * Returns PlaceholderManager instance
-     * @return PlaceholderManager instance
+     *
+     * @return  PlaceholderManager instance
      */
     public abstract PlaceholderManager getPlaceholderManager();
 
     /**
      * Returns feature manager instance
-     * @return feature manager instance
+     *
+     * @return  feature manager instance
      */
     public abstract FeatureManager getFeatureManager();
 
+    /**
+     * Returns Tablist name format manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  Tablist name format manager
+     */
     public abstract TablistFormatManager getTablistFormatManager();
 
     /**
      * Gets the event bus for registering listeners for TAB events.
      *
-     * @return the event bus
+     * @return  the event bus
      */
     public abstract EventBus getEventBus();
 
     /**
      * Returns server version. On proxy installation returns PROXY.
-     * @return server version
+     *
+     * @return  server version
      */
     public abstract ProtocolVersion getServerVersion();
 
     /**
      * Prints message into console
-     * @param message - message to print
-     * @param translateColors - true if colors should be translated, false if not
+     *
+     * @param   message
+     *          message to print
+     * @param   translateColors
+     *          {@code true} if colors should be translated, {@code false} if not
      */
     public abstract void sendConsoleMessage(String message, boolean translateColors);
 
-    public abstract ThreadManager getThreadManager();
-
+    /**
+     * Returns TAB's cache file used to store player toggle data
+     *
+     * @return  TAB's player cache file
+     */
     public abstract ConfigurationFile getPlayerCache();
 
+    /**
+     * Returns TAB's config.yml file
+     *
+     * @return  config.yml file
+     */
     public abstract ConfigurationFile getConfig();
 
+    /**
+     * Returns TAB's group configuration
+     *
+     * @return  TAB's group configuration
+     */
     public abstract PropertyConfiguration getGroups();
 
+    /**
+     * Returns TAB's user configuration
+     *
+     * @return  TAB's user configuration
+     */
     public abstract PropertyConfiguration getUsers();
 
+    /**
+     * Sends a debug message into console if the option
+     * is enabled in config.
+     *
+     * @param   message
+     *          Message to send
+     */
     public abstract void debug(String message);
 
+    /**
+     * Logs an error into errors.log file
+     *
+     * @param   message
+     *          Error message
+     * @param   t
+     *          Thrown error
+     */
     public abstract void logError(String message, Throwable t);
 
+    /**
+     * Sets name of file with syntax error, which prevented
+     * the plugin from enabling. Internal use only.
+     *
+     * @param   file
+     *          Name of file with syntax error
+     */
     public abstract void setBrokenFile(String file);
+
+    /**
+     * Returns {@code true} if the plugin is currently disabled due to an error,
+     * either a yaml syntax error or an internal startup error. Returns {@code false}
+     * if the plugin is properly running.
+     *
+     * @return  {@code true} if disabled, {@code false} if running correctly
+     */
+    public abstract boolean isPluginDisabled();
 }

api/src/main/java/me/neznamy/tab/api/TabConstants.java

@@ -1,25 +1,33 @@
-package me.neznamy.tab.shared;
+package me.neznamy.tab.api;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
 
 /**
  * A class containing various constants used everywhere in the plugin
  * to allow easier overview and modification to prevent inconsistencies.
  */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class TabConstants {
 
-    public static final String PLUGIN_VERSION = "@plugin_version@";
-    public static final String DEFAULT_GROUP = "NONE";
-    public static final String PLUGIN_MESSAGE_CHANNEL_NAME = "tab:bridge-2";
-    public static final String REDIS_CHANNEL_NAME = "TAB";
+    public static final String PLUGIN_NAME = "@name@";
+    public static final String PLUGIN_ID = "@id@";
+    public static final String PLUGIN_VERSION = "@version@";
+    public static final String PLUGIN_DESCRIPTION = "@description@";
+    public static final String PLUGIN_WEBSITE = "@website@";
+    public static final String PLUGIN_AUTHOR = "@author@";
 
-    /**
-     * Private constructor to prevent the class from being instantiated
-     */
-    private TabConstants() {}
+    public static final String NO_GROUP = "NONE";
+    public static final String DEFAULT_GROUP = "_DEFAULT_";
+    public static final String PLUGIN_MESSAGE_CHANNEL_NAME = "tab:bridge-2";
+    public static final String REDIS_CHANNEL_NAME = PLUGIN_NAME;
+    public static final String PIPELINE_HANDLER_NAME = PLUGIN_NAME;
 
     /**
      * Feature sub-category explaining why / when a certain feature
      * needed CPU time to process tasks.
      */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
     public static class CpuUsageCategory {
 
         public static final String PLAYER_JOIN = "Player Join";
@@ -31,8 +39,6 @@ public class TabConstants {
         public static final String PLAYER_RESPAWN = "Player Respawn";
         public static final String PLUGIN_MESSAGE = "PluginMessageEvent";
         public static final String REDIS_BUNGEE_MESSAGE = "PubSubMessageEvent";
-        public static final String LUCKPERMS_USER_RECALCULATE_EVENT = "UserDataRecalculateEvent";
-        public static final String LUCKPERMS_GROUP_RECALCULATE_EVENT = "GroupDataRecalculateEvent";
         public static final String VANISH_CHANGE = "Vanish status change";
         public static final String ANTI_OVERRIDE = "Anti override";
 
@@ -49,59 +55,18 @@ public class TabConstants {
         public static final String RAW_PACKET_OUT = "Packet reading (out)";
 
         public static final String PLACEHOLDER_REFRESHING = "Refreshing placeholders";
+        public static final String GROUP_REFRESHING = "Refreshing groups";
 
-        public static final String V1_8_0_BUG_COMPENSATION = "Compensating for 1.8.0 bugs";
         public static final String REFRESHING_NAME_TAG_VISIBILITY = "Refreshing NameTag visibility";
         public static final String SCOREBOARD_PACKET_CHECK = "Checking for other plugins";
         public static final String PROCESSING_PLAYER_MOVEMENT = "Processing player movement";
         public static final String TELEPORTING_WITHER = "Teleporting wither";
-
-        /**
-         * Private constructor to prevent the class from being instantiated
-         */
-        private CpuUsageCategory() {}
-    }
-
-    /**
-     * Information why a specific feature sent a packet
-     * and what the packet sent is supposed to do.
-     */
-    public static class PacketCategory {
-
-        public static final String BOSSBAR_COLOR_STYLE = "BossBar (Color and style)";
-        public static final String BOSSBAR_PROGRESS = "BossBar (Progress)";
-        public static final String BOSSBAR_TEXT = "BossBar (Text)";
-        public static final String BOSSBAR_WITHER_TELEPORT = "BossBar (Teleporting Wither)";
-
-        public static final String GLOBAL_PLAYERLIST_LATENCY = "Global PlayerList (Updating latency)";
-        public static final String GLOBAL_PLAYERLIST_VANISH = "Global PlayerList (Vanishing)";
-
-        public static final String LAYOUT_FIXED_SLOTS = "Layout (Fixed slots)";
-        public static final String LAYOUT_PLAYER_SLOTS = "Layout (Player slots)";
-
-        public static final String NAMETAGS_TEAM_REGISTER = "NameTags (Team register)";
-        public static final String NAMETAGS_TEAM_UNREGISTER = "NameTags (Team unregister)";
-        public static final String NAMETAGS_TEAM_UPDATE = "NameTags (Team update)";
-
-        public static final String SCOREBOARD_TITLE = "Scoreboard (Title)";
-        public static final String SCOREBOARD_LINES = "Scoreboard (Lines)";
-
-        public static final String UNLIMITED_NAMETAGS_OFFSET_CHANGE = "Unlimited NameTags (Changing offset)";
-        public static final String UNLIMITED_NAMETAGS_SPAWN = "Unlimited NameTags (Spawning)";
-        public static final String UNLIMITED_NAMETAGS_DESPAWN = "Unlimited NameTags (Despawning)";
-        public static final String UNLIMITED_NAMETAGS_TELEPORT = "Unlimited NameTags (Teleporting)";
-        public static final String UNLIMITED_NAMETAGS_SNEAK = "Unlimited NameTags (Sneaking)";
-        public static final String UNLIMITED_NAMETAGS_METADATA = "Unlimited NameTags (Metadata)";
-
-        /**
-         * Private constructor to prevent the class from being instantiated
-         */
-        private PacketCategory() {}
     }
 
     /**
      * Permission nodes used by the plugin
      */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
     public static class Permission {
 
         public static final String COMMAND_ALL = "tab.admin";
@@ -116,7 +81,11 @@ public class TabConstants {
         public static final String COMMAND_MYSQL_DOWNLOAD = "tab.mysql.download";
         public static final String COMMAND_MYSQL_UPLOAD = "tab.mysql.upload";
         public static final String COMMAND_NAMETAG_TOGGLE = "tab.nametag.toggle";
+
+        public static final String COMMAND_NAMETAG_TOGGLE_OTHER = "tab.nametag.toggle.other";
         public static final String COMMAND_NAMETAG_PREVIEW = "tab.nametag.preview";
+
+        public static final String COMMAND_NAMETAG_PREVIEW_OTHER = "tab.nametag.preview.other";
         public static final String COMMAND_PARSE = "tab.parse";
         public static final String COMMAND_SCOREBOARD_ANNOUNCE = "tab.announce.scoreboard";
         public static final String COMMAND_SCOREBOARD_TOGGLE = "tab.scoreboard.toggle";
@@ -138,17 +107,13 @@ public class TabConstants {
         public static final String TEST_PERMISSION = "tab.testpermission";
 
         public static final String GROUP_PREFIX = "tab.group.";
-
-        /**
-         * Private constructor to prevent the class from being instantiated
-         */
-        private Permission(){}
     }
 
     /**
      * Internal property names used to store text
      * under a specific key
      */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
     public static class Property {
 
         public static final String HEADER = "header";
@@ -173,11 +138,6 @@ public class TabConstants {
 
         public static final String YELLOW_NUMBER = "yellow-number";
 
-        /**
-         * Private constructor to prevent the class from being instantiated
-         */
-        private Property() {}
-
         public static String bossbarTitle(String name) {
             return "bossbar-title-" + name;
         }
@@ -211,6 +171,7 @@ public class TabConstants {
      * Feature names used to register features under in the
      * feature manager which they can be retrieved by.
      */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
     public static class Feature {
 
         //universal features
@@ -225,6 +186,7 @@ public class TabConstants {
         public static final String PING_SPOOF = "PingSpoof";
         public static final String SORTING = "sorting";
         public static final String LAYOUT = "layout";
+        public static final String LAYOUT_LATENCY = "layout-latency";
         public static final String NICK_COMPATIBILITY = "nick";
         public static final String PIPELINE_INJECTION = "injection";
         public static final String BOSS_BAR = "BossBar";
@@ -237,6 +199,7 @@ public class TabConstants {
         public static final String UNLIMITED_NAME_TAGS = "NameTagX";
         public static final String UNLIMITED_NAME_TAGS_PACKET_LISTENER = "nametagx-packet";
         public static final String UNLIMITED_NAME_TAGS_VEHICLE_REFRESHER = "nametagx-vehicle";
+        public static final String UNLIMITED_NAME_TAGS_GAMEMODE_LISTENER = "nametagx-gamemode";
 
         //Bukkit only
         public static final String PER_WORLD_PLAYER_LIST = "PerWorldPlayerList";
@@ -250,15 +213,14 @@ public class TabConstants {
         public static final String PACKET_SERIALIZING = "Packet serializing";
         public static final String PACKET_DESERIALIZING = "Packet deserializing";
 
-        /**
-         * Private constructor to prevent the class from being instantiated
-         */
-        private Feature(){}
-
         public static String scoreboardLine(String line) {
             return "scoreboard-" + line;
         }
 
+        public static String scoreboardLine(String scoreboard, int index) {
+            return "scoreboard-score-" + scoreboard + "-" + index;
+        }
+
         public static String layout(String name) {
             return "layout-" + name;
         }
@@ -275,12 +237,104 @@ public class TabConstants {
             return "BossBar-progress-" + name;
         }
 
-        public static String bossBarColorStyle(String name) {
-            return "BossBar-color-style-" + name;
+        public static String bossBarColor(String color) {
+            return "BossBar-color-" + color;
         }
 
-        public static String scoreboardLine(String scoreboard, int index) {
-            return "scoreboard-score-" + scoreboard + "-" + index;
+        public static String bossBarStyle(String style) {
+            return "BossBar-style-" + style;
         }
     }
+
+    /**
+     * All internal placeholders offered by the plugin
+     */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class Placeholder {
+
+        // Universal
+        public static final String DISPLAY_NAME = "%displayname%";
+        public static final String GROUP = "%group%";
+        public static final String VANISHED = "%vanished%";
+        public static final String WORLD = "%world%";
+        public static final String WORLD_ONLINE = "%worldonline%";
+        public static final String SERVER = "%server%";
+        public static final String SERVER_ONLINE = "%serveronline%";
+        public static final String PLAYER = "%player%";
+        public static final String TIME = "%time%";
+        public static final String DATE = "%date%";
+        public static final String PING = "%ping%";
+        public static final String PLAYER_VERSION = "%player-version%";
+        public static final String PLAYER_VERSION_ID = "%player-version-id%";
+        public static final String MEMORY_USED = "%memory-used%";
+        public static final String MEMORY_MAX = "%memory-max%";
+        public static final String MEMORY_USED_GB = "%memory-used-gb%";
+        public static final String MEMORY_MAX_GB = "%memory-max-gb%";
+        public static final String ONLINE = "%online%";
+        public static final String STAFF_ONLINE = "%staffonline%";
+        public static final String NON_STAFF_ONLINE = "%nonstaffonline%";
+        public static final String LUCKPERMS_PREFIX = "%luckperms-prefix%";
+        public static final String LUCKPERMS_SUFFIX = "%luckperms-suffix%";
+        public static final String COUNTDOWN = "%countdown%";
+
+        // Placeholders for internal use
+        public static final String COLLISION = "%collision%";
+        public static final String INVISIBLE = "%invisible%";
+        public static final String VEHICLE = "%vehicle%";
+
+        // Bukkit only
+        public static final String TPS = "%tps%";
+        public static final String MSPT = "%mspt%";
+        public static final String AFK = "%afk%";
+        public static final String ESSENTIALS_NICK = "%essentialsnick%";
+        public static final String VAULT_PREFIX = "%vault-prefix%";
+        public static final String VAULT_SUFFIX = "%vault-suffix%";
+        public static final String HEALTH = "%health%";
+
+        public static final int MINIMUM_REFRESH_INTERVAL = 50;
+
+        public static String condition(String name) {
+            return "%condition:" + name + "%";
+        }
+
+        public static String animation(String name) {
+            return "%animation:" + name + "%";
+        }
+
+        public static String globalPlayerListGroup(String group) {
+            return "%playerlist-group_" + group + "%";
+        }
+    }
+
+    /**
+     * All plugins TAB hooks into
+     */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class Plugin {
+
+        public static final String LUCKPERMS = "LuckPerms";
+        public static final String VAULT = "Vault";
+        public static final String PLACEHOLDER_API = "PlaceholderAPI";
+        public static final String LIBS_DISGUISES = "LibsDisguises";
+        public static final String VIAREWIND = "ViaRewind";
+        public static final String VIAVERSION = "ViaVersion";
+        public static final String PROTOCOL_SUPPORT = "ProtocolSupport";
+        public static final String ESSENTIALS = "Essentials";
+        public static final String REDIS_BUNGEE = "RedisBungee";
+        public static final String PREMIUM_VANISH = "PremiumVanish";
+    }
+
+    /**
+     * TAB's custom metrics charts
+     */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class MetricsChart {
+
+        public static final String PERMISSION_SYSTEM = "permission_system";
+        public static final String GLOBAL_PLAYER_LIST_ENABLED = "global_playerlist_enabled";
+        public static final String PLACEHOLDER_API = "placeholderapi";
+        public static final String SERVER_VERSION = "server_version";
+        public static final String UNLIMITED_NAME_TAG_MODE_ENABLED = "unlimited_nametag_mode_enabled";
+
+    }
 }

api/src/main/java/me/neznamy/tab/api/TabFeature.java

@@ -1,267 +0,0 @@
-package me.neznamy.tab.api;
-
-import java.util.*;
-
-import me.neznamy.tab.api.protocol.PacketPlayOutPlayerInfo;
-import me.neznamy.tab.api.protocol.PacketPlayOutScoreboardDisplayObjective;
-import me.neznamy.tab.api.protocol.PacketPlayOutScoreboardObjective;
-
-public abstract class TabFeature {
-
-    private final String featureName;
-    private final String refreshDisplayName;
-    protected final String[] disabledServers;
-    private final boolean serverWhitelistMode;
-    protected final String[] disabledWorlds;
-    private final boolean worldWhitelistMode;
-    private final Set<TabPlayer> disabledPlayers = Collections.newSetFromMap(new WeakHashMap<>());
-    private final List<String> methodOverrides = new ArrayList<>();
-
-    protected TabFeature(String featureName, String refreshDisplayName) {
-        this(featureName, refreshDisplayName, null, null);
-    }
-
-    protected TabFeature(String featureName, String refreshDisplayName, List<String> disabledServers, List<String> disabledWorlds) {
-        this.featureName = featureName;
-        this.refreshDisplayName = refreshDisplayName;
-        if (disabledServers != null) {
-            this.disabledServers = disabledServers.toArray(new String[0]);
-            serverWhitelistMode = disabledServers.contains("WHITELIST");
-        } else {
-            this.disabledServers = new String[0];
-            serverWhitelistMode = false;
-        }
-        if (disabledWorlds != null) {
-            this.disabledWorlds = disabledWorlds.toArray(new String[0]);
-            worldWhitelistMode = disabledWorlds.contains("WHITELIST");
-        } else {
-            this.disabledWorlds = new String[0];
-            worldWhitelistMode = false;
-        }
-        try {
-            if (getClass().getMethod("onCommand", TabPlayer.class, String.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onCommand");
-            if (getClass().getMethod("onJoin", TabPlayer.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onJoin");
-            if (getClass().getMethod("onQuit", TabPlayer.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onQuit");
-            if (getClass().getMethod("onWorldChange", TabPlayer.class, String.class, String.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onWorldChange");
-            if (getClass().getMethod("onServerChange", TabPlayer.class, String.class, String.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onServerChange");
-            if (getClass().getMethod("onDisplayObjective", TabPlayer.class, PacketPlayOutScoreboardDisplayObjective.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onDisplayObjective");
-            if (getClass().getMethod("onLoginPacket", TabPlayer.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onLoginPacket");
-            if (getClass().getMethod("onObjective", TabPlayer.class, PacketPlayOutScoreboardObjective.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onObjective");
-            if (getClass().getMethod("onPlayerInfo", TabPlayer.class, PacketPlayOutPlayerInfo.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onPlayerInfo");
-            if (getClass().getMethod("onPacketReceive", TabPlayer.class, Object.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onPacketReceive");
-            if (getClass().getMethod("onPacketSend", TabPlayer.class, Object.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onPacketSend");
-            if (getClass().getMethod("refresh", TabPlayer.class, boolean.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("refresh");
-            if (getClass().getMethod("onVanishStatusChange", TabPlayer.class).getDeclaringClass() != TabFeature.class)
-                methodOverrides.add("onVanishStatusChange");
-        } catch (NoSuchMethodException e) {
-            //this will never happen
-        }
-    }
-
-    /**
-     * Loads all players and sends packets
-     */
-    public void load() {
-        //empty by default
-    }
-
-    /**
-     * Unloads all players and sends clear packets
-     */
-    public void unload() {
-        //empty by default
-    }
-
-    /**
-     * Processes command from player
-     * @param sender - command sender
-     * @param message - command line
-     * @return true if event should be cancelled, false if not
-     */
-    public boolean onCommand(TabPlayer sender, String message) {
-        return false;
-    }
-
-    /**
-     * Processes join event
-     * @param connectedPlayer - player who connected
-     */
-    public void onJoin(TabPlayer connectedPlayer) {
-        //empty by default
-    }
-
-    /**
-     * Processes quit event
-     * @param disconnectedPlayer - player who disconnected
-     */
-    public void onQuit(TabPlayer disconnectedPlayer) {
-    }
-
-    /**
-     * Processes world switch
-     * @param changed - player who switched world
-     * @param from - world player changed from
-     * @param to - world player changed to
-     */
-    public void onWorldChange(TabPlayer changed, String from, String to) {
-        //empty by default
-    }
-
-    /**
-     * Processes server switch
-     * @param changed - player who switched server
-     * @param from - server player changed from
-     * @param to - server player changed to
-     */
-    public void onServerChange(TabPlayer changed, String from, String to) {
-        //empty by default
-    }
-
-    /**
-     * Processes the packet send and returns true if packet should be cancelled
-     * @param receiver - player receiving packet
-     * @param packet - received packet
-     */
-    public void onDisplayObjective(TabPlayer receiver, PacketPlayOutScoreboardDisplayObjective packet) {
-        //empty by default
-    }
-
-    /**
-     * Processes login packet, only available on BungeeCord
-     * @param packetReceiver - player receiving client reset packet
-     */
-    public void onLoginPacket(TabPlayer packetReceiver) {
-        //empty by default
-    }
-
-    /**
-     * Processes the packet send
-     * @param receiver - player receiving packet
-     * @param packet - received packet
-     */
-    public void onObjective(TabPlayer receiver, PacketPlayOutScoreboardObjective packet) {
-        //empty by default
-    }
-
-    /**
-     * Processes the packet send and possibly modifies it
-     * @param receiver - player receiving packet
-     * @param info - received packet
-     */
-    public void onPlayerInfo(TabPlayer receiver, PacketPlayOutPlayerInfo info) {
-        //empty by default
-    }
-
-    /**
-     * Processes raw packet sent by client
-     * @param sender - packet sender
-     * @param packet - packet received
-     * @return true if false should be cancelled, false if not
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public boolean onPacketReceive(TabPlayer sender, Object packet) throws ReflectiveOperationException {
-        return false;
-    }
-
-    /**
-     * Processes raw packet sent to client
-     * @param receiver - packet receiver
-     * @param packet - the packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public void onPacketSend(TabPlayer receiver, Object packet) throws ReflectiveOperationException {
-        //empty by default
-    }
-
-    /**
-     * Performs refresh of specified player
-     * @param refreshed - player to refresh
-     * @param force - if refresh should be forced despite refresh seemingly not needed
-     */
-    public void refresh(TabPlayer refreshed, boolean force) {
-        //empty by default
-    }
-
-    public void onVanishStatusChange(TabPlayer player){
-        //empty by default
-    }
-
-    /**
-     * Registers this feature as one using specified placeholders
-     * @param placeholders - placeholders to add as used in this feature
-     */
-    public void addUsedPlaceholders(Collection<String> placeholders) {
-        if (placeholders.isEmpty()) return;
-        placeholders.forEach(p -> TabAPI.getInstance().getPlaceholderManager().addUsedPlaceholder(p, this));
-    }
-
-    /**
-     * Returns true if world or server is disabled, false if not
-     * @param world - world to check
-     * @param server - server to check
-     * @return true if feature should be disabled, false if not
-     */
-    public boolean isDisabled(String server, String world) {
-        boolean contains = contains(disabledWorlds, world);
-        if (worldWhitelistMode) contains = !contains;
-        if (contains) return true;
-        contains = contains(disabledServers, server);
-        if (serverWhitelistMode) contains = !contains;
-        return contains;
-    }
-
-    protected boolean contains(String[] list, String element) {
-        if (element == null) return false;
-        for (String s : list) {
-            if (s.endsWith("*")) {
-                if (element.toLowerCase().startsWith(s.substring(0, s.length()-1).toLowerCase())) return true;
-            } else {
-                if (element.equalsIgnoreCase(s)) return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Returns name of the feature displayed in /tab cpu.
-     * @return name of the feature displayed in /tab cpu
-     */
-    public String getFeatureName() {
-        return featureName;
-    }
-
-    public boolean overridesMethod(String method) {
-        return methodOverrides.contains(method);
-    }
-
-    public boolean isDisabledPlayer(TabPlayer p) {
-        return disabledPlayers.contains(p);
-    }
-
-    public void addDisabledPlayer(TabPlayer p) {
-        if (disabledPlayers.contains(p)) return;
-        disabledPlayers.add(p);
-    }
-
-    public void removeDisabledPlayer(TabPlayer p) {
-        disabledPlayers.remove(p);
-    }
-
-    public String getRefreshDisplayName() {
-        return refreshDisplayName;
-    }
-}

api/src/main/java/me/neznamy/tab/api/TabPlayer.java

@@ -2,10 +2,11 @@ package me.neznamy.tab.api;
 
 import java.util.UUID;
 
-import io.netty.channel.Channel;
+import lombok.NonNull;
 import me.neznamy.tab.api.chat.IChatBaseComponent;
-import me.neznamy.tab.api.protocol.Skin;
-import me.neznamy.tab.api.protocol.TabPacket;
+import me.neznamy.tab.api.feature.Refreshable;
+import me.neznamy.tab.api.tablist.Skin;
+import me.neznamy.tab.api.tablist.TabList;
 
 /**
  * An interface representing a player
@@ -19,225 +20,280 @@ public interface TabPlayer {
 
     /**
      * Returns player's name
-     * @return Player's name
+     *
+     * @return  Player's name
      */
     String getName();
 
     /**
      * Returns player's UUID
-     * @return Player's UUID
+     *
+     * @return  Player's UUID
      */
     UUID getUniqueId();
 
     /**
      * Returns player's uuid used in TabList. This may only be different from real uuid if
-     * TAB is installed on velocity with some specific velocity setup
-     * @return player's uuid in TabList
+     * TAB is installed on a proxy which does not rewrite UUIDs.
+     *
+     * @return  player's uuid in TabList
      */
-    UUID getTablistUUID();
+    UUID getTablistId();
 
     /**
      * Returns player's protocol version
-     * @return player's protocol version
+     *
+     * @return  player's protocol version
      */
     ProtocolVersion getVersion();
 
     /**
      * Returns platform-specific entity
-     * @return an instance of bukkit/bungee player depending on platform
+     *
+     * @return  an instance of bukkit/bungee player depending on platform
      */
     Object getPlayer();
 
     /**
      * Returns player's current world name (on BungeeCord this requires bridge installed)
-     * @return name of world where player is currently in, "N/A" on BungeeCord if bridge is not installed
+     *
+     * @return  name of world where player is currently in, "N/A" on BungeeCord if bridge is not installed
      */
     String getWorld();
     
     /**
      * Returns player's current server name on BungeeCord (on bukkit this returns "N/A")
-     * @return name of server where player is currently in, "N/A" on bukkit
+     *
+     * @return  name of server where player is currently in, "N/A" on bukkit
      */
     String getServer();
 
     /**
      * Performs platform-specific API call to check for permission and returns the result
-     * @param permission - the permission to check for
-     * @return - true if player has permission, false if not
+     *
+     * @param   permission
+     *          the permission to check for
+     * @return  true if player has permission, false if not
      */
     boolean hasPermission(String permission);
 
-    /**
-     * Sends the player a custom universal packet
-     * @param packet - packet to send
-     */
-    void sendCustomPacket(TabPacket packet);
-
-    /**
-     * Sends the player a custom universal packet and adds that packet into counter that
-     * is displayed in /tab cpu
-     * @param packet - packet to send
-     * @param feature - feature to increment sent packet counter of 
-     */
-    void sendCustomPacket(TabPacket packet, TabFeature feature);
-    
-    /**
-     * Sends the player a custom universal packet and adds that packet into counter that
-     * is displayed in /tab cpu
-     * @param packet - packet to send
-     * @param feature - feature to increment sent packet counter of 
-     */
-    void sendCustomPacket(TabPacket packet, String feature);
-
     /**
      * Sends the player a platform-specific packet
-     * @param packet - an instance of packet depending on platform
+     *
+     * @param   packet
+     *          an instance of packet depending on platform
      */
     void sendPacket(Object packet);
 
-    /**
-     * Sends the player a platform-specific packet and adds that packet into counter that
-     * is displayed in /tab cpu
-     * @param packet - an instance of packet depending on platform
-     * @param feature - feature to increment sent packet counter of 
-     */
-    void sendPacket(Object packet, TabFeature feature);
-
-    /**
-     * Sends the player a platform-specific packet and adds that packet into counter that
-     * is displayed in /tab cpu
-     * @param packet - an instance of packet depending on platform
-     * @param feature - feature to increment sent packet counter of
-     */
-    void sendPacket(Object packet, String feature);
-
     /**
      * Returns player's property by name
-     * @param name - name of property
-     * @return the property or null if not found
+     *
+     * @param   name
+     *          name of property
+     * @return  the property or {@code null} if not found
      */
     Property getProperty(String name);
 
     /**
      * Sends a message to the player
-     * @param message - message to be sent
-     * @param translateColors - whether colors should be translated or not
+     *
+     * @param   message
+     *          message to be sent
+     * @param   translateColors
+     *          whether colors should be translated or not
      */
     void sendMessage(String message, boolean translateColors);
 
     /**
      * Sends specified component as a chat message
-     * @param message - message to send
+     *
+     * @param   message
+     *          message to send
      */
     void sendMessage(IChatBaseComponent message);
 
-    /**
-     * Returns player's primary permission group
-     * @return player's group depending on configuration
-     */
-    String getGroup();
-
-    /**
-     * Returns player's channel or null if server is 1.7 or older
-     * @return player's channel
-     */
-    Channel getChannel();
-
     /**
      * Returns player's ping calculated by server
-     * @return player's ping
+     *
+     * @return  player's ping
      */
     int getPing();
 
     /**
      * Returns player's skin data
-     * @return player's skin
+     *
+     * @return  player's skin
      */
     Skin getSkin();
 
     /**
      * Returns true once the player is successfully loaded (onJoin method ran through all methods)
-     * @return true if player is fully loaded, false otherwise
+     *
+     * @return  {@code true} if player is fully loaded, {@code false} otherwise
      */
     boolean isLoaded();
 
     /**
      * Sets property with specified name to new value. If property did not exist before, it is
-     * created and true is returned. If it existed, it is overridden and true is returned. False is returned otherwise.
-     * @param feature - feature using this property to get placeholders registered
-     * @param identifier - property name
-     * @param rawValue - new raw value
-     * @return true if value changed / did not exist, false if value did not change
+     * created and {@code true} is returned. If it existed, it is overridden and {@code true} is returned.
+     * {@code false} is returned otherwise.
+     *
+     * @param   feature
+     *          feature using this property to get placeholders registered
+     * @param   identifier
+     *          property name
+     * @param   rawValue
+     *          new raw value
+     * @return  {@code true} if value changed / did not exist, {@code false} if value did not change
      */
-    boolean setProperty(TabFeature feature, String identifier, String rawValue);
+    boolean setProperty(Refreshable feature, String identifier, String rawValue);
 
     /**
      * Loads property from config using standard property loading algorithm
-     * @param property - property name to load
-     * @return true if value did not exist or changed, false otherwise
+     *
+     * @param   property
+     *          property name to load
+     * @return  {@code true} if value did not exist or changed, {@code false} otherwise
      */
-    boolean loadPropertyFromConfig(TabFeature feature, String property);
+    boolean loadPropertyFromConfig(Refreshable feature, String property);
 
     /**
      * Loads property from config using standard property loading algorithm. If the property is
-     * not set in config, sets it to ifNotSet value
-     * @param property - property name to load
-     * @param ifNotSet - value to use if property is not defined in config
-     * @return true if value did not exist or changed, false otherwise
+     * not set in config, {@code ifNotSet} value is used.
+     *
+     * @param   property
+     *          property name to load
+     * @param   ifNotSet
+     *          value to use if property is not defined in config
+     * @return  {@code true} if value did not exist or changed, {@code false} otherwise
      */
-    boolean loadPropertyFromConfig(TabFeature feature, String property, String ifNotSet);
+    boolean loadPropertyFromConfig(Refreshable feature, String property, String ifNotSet);
 
     /**
-     * Returns name of player's scoreboard team or null if NameTag feature is disabled
-     * @return name of player's team
+     * Returns name of player's scoreboard team or {@code null} if NameTag feature is disabled
+     *
+     * @return  name of player's team
      */
     String getTeamName();
 
     /**
-     * Returns user-friendly explanation of team name
-     * @return explanation behind team name
-     */
-    String getTeamNameNote();
-
-    /**
-     * Returns true if player is disguised using LibsDisguises
-     * @return true if player is disguised, false if not
+     * Returns {@code true} if player is disguised using LibsDisguises, {@code false} if not
+     *
+     * @return  {@code true} if player is disguised, {@code false} if not
      */
     boolean isDisguised();
 
     /**
-     * Returns true if player has invisibility potion, false if not. For bukkit, API is used, for BungeeCord
-     * bukkit bridge is used
-     * @return true if player has invisibility potion, false if not
+     * Returns {@code true} if player has invisibility potion, {@code false} if not.
+     * For bukkit, API is used, for BungeeCord, bridge is used.
+     *
+     * @return  {@code true} if player has invisibility potion, {@code false} if not
      */
     boolean hasInvisibilityPotion();
 
     /**
-     * Currently only PV hook on BungeeCord for global PlayerList function. Looking to expand this
-     * in the future
-     * @return true if vanished with PV on BungeeCord
+     * Checks if player is vanished using any supported vanish plugin and returns the result.
+     *
+     * @return  {@code true} if player is vanished, {@code false} if not
      */
     boolean isVanished();
 
     /**
-     * Returns true if player is online according to server
-     * @return true if online, false if not
+     * Calls platform-specific method and returns the result
+     *
+     * @return  {@code true} if player is online, {@code false} if not
      */
     boolean isOnline();
     
     /**
      * Returns GameMode of the player (0 for survival, 1 creative, 2 adventure, 3 spectator)
-     * @return GameMode of the player
+     *
+     * @return  GameMode of the player
      */
     int getGamemode();
-    
+
+    /**
+     * Returns {@code true} if this is a bedrock player, {@code false} if not
+     *
+     * @return  {@code true} if player is a bedrock player, {@code false} if not
+     */
     boolean isBedrockPlayer();
 
+    /**
+     * Returns player's primary permission group. If group has been changed using
+     * {@link #setTemporaryGroup(String)}, returns that value. Otherwise, returns group
+     * detected by standard group assign logic
+     *
+     * @return  player's primary permission group
+     */
+    String getGroup();
+
+    /**
+     * Temporarily overrides player's group and applies all changes coming from new group.
+     * This includes all properties and sorting, if used.
+     *
+     * @param   group
+     *          New group to use
+     * @see     #hasTemporaryGroup()
+     * @see     #resetTemporaryGroup()
+     */
     void setTemporaryGroup(String group);
 
+    /**
+     * Returns temporary group applied to the player using {@link #setTemporaryGroup(String)}.
+     * If no group was set, returns {@code null}
+     *
+     * @return  Temporary group assigned to player or {@code null} if not set
+     * @see     #setTemporaryGroup(String)
+     * @see     #resetTemporaryGroup()
+     */
     boolean hasTemporaryGroup();
 
+    /**
+     * Resets temporary group assigned using {@link #setTemporaryGroup(String)}.
+     * If no temporary group is set, doesn't do anything.
+     *
+     * @see     #setTemporaryGroup(String)
+     * @see     #hasTemporaryGroup()
+     */
     void resetTemporaryGroup();
 
+    /**
+     * Returns player's game profile name as seen by other players. By default,
+     * this returns player's name. If using a nickname / disguise plugin that changes
+     * game profile name for other players and change was successfully detected, returns
+     * that value.
+     *
+     * @return  player's game profile name as seen by other players
+     */
     String getNickname();
+
+    /**
+     * Sets header and footer to specified values
+     *
+     * @param   header
+     *          Header to use
+     * @param   footer
+     *          Footer to use
+     */
+    void setPlayerListHeaderFooter(@NonNull IChatBaseComponent header, @NonNull IChatBaseComponent footer);
+
+    /**
+     * Returns scoreboard interface for calling scoreboard-related methods
+     *
+     * @return  scoreboard interface for calling scoreboard-related methods
+     */
+    Scoreboard getScoreboard();
+
+    /**
+     * Returns TabList interface for calling tablist-related methods
+     * @return  TabList interface for calling tablist-related methods
+     */
+    TabList getTabList();
+
+    /**
+     * Returns handler for calling bossbar-related methods
+     * @return  handler for calling bossbar-related methods
+     */
+    BossBarHandler getBossBarHandler();
 }

api/src/main/java/me/neznamy/tab/api/TablistFormatManager.java

@@ -1,29 +1,168 @@
 package me.neznamy.tab.api;
 
+/**
+ * An interface allowing to modify tablist display names
+ * of players.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getTablistFormatManager()}.
+ * This requires the feature to be enabled in config, otherwise the method will
+ * return {@code null}.
+ */
 public interface TablistFormatManager {
 
+    /**
+     * Changes player's prefix to provided value. Supports placeholders,
+     * as well as any supported RGB formats.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   prefix
+     *          new prefix value
+     * @see     #resetPrefix(TabPlayer)
+     * @see     #getCustomPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
     void setPrefix(TabPlayer player, String prefix);
-    
+
+    /**
+     * Changes player's name to provided value. Supports placeholders,
+     * as well as any supported RGB formats.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   customName
+     *          new customName value
+     * @see     #resetName(TabPlayer)
+     * @see     #getCustomName(TabPlayer)
+     * @see     #getOriginalName(TabPlayer)
+     */
     void setName(TabPlayer player, String customName);
-    
+
+    /**
+     * Changes player's suffix to provided value. Supports placeholders,
+     * as well as any supported RGB formats.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   suffix
+     *          new suffix value
+     * @see     #resetSuffix(TabPlayer)
+     * @see     #getCustomSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
     void setSuffix(TabPlayer player, String suffix);
-    
+
+    /**
+     * Resets player's prefix previously assigned using {@link #setPrefix(TabPlayer, String)}
+     * method. If nothing was set, this method will not do anything.
+     *
+     * @param   player
+     *          player to reset prefix of
+     * @see     #setPrefix(TabPlayer, String)
+     * @see     #getCustomPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
     void resetPrefix(TabPlayer player);
-    
+
+    /**
+     * Resets player's custom name previously assigned using {@link #setName(TabPlayer, String)}
+     * method. If nothing was set, this method will not do anything.
+     *
+     * @param   player
+     *          player to reset name of
+     * @see     #setName(TabPlayer, String)
+     * @see     #getCustomName(TabPlayer)
+     * @see     #getOriginalName(TabPlayer)
+     */
     void resetName(TabPlayer player);
-    
+
+    /**
+     * Resets player's suffix previously assigned using {@link #setSuffix(TabPlayer, String)}
+     * method. If nothing was set, this method will not do anything.
+     *
+     * @param   player
+     *          player to reset suffix of
+     * @see     #setSuffix(TabPlayer, String)
+     * @see     #getCustomSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
     void resetSuffix(TabPlayer player);
-    
+
+    /**
+     * Returns prefix assigned using {@link #setPrefix(TabPlayer, String)} method.
+     * If the method was not used, {@code null} is returned.
+     *
+     * @param   player
+     *          player to get custom prefix of
+     * @return  player's custom prefix or {@code null} if not defined
+     * @see     #setPrefix(TabPlayer, String)
+     * @see     #resetPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
     String getCustomPrefix(TabPlayer player);
-    
+
+    /**
+     * Returns custom name assigned using {@link #setName(TabPlayer, String)} method.
+     * If the method was not used, {@code null} is returned.
+     *
+     * @param   player
+     *          player to get custom name of
+     * @return  player's custom name or {@code null} if not defined
+     * @see     #setName(TabPlayer, String)
+     * @see     #resetName(TabPlayer)
+     * @see     #getOriginalName(TabPlayer)
+     */
     String getCustomName(TabPlayer player);
-    
+
+    /**
+     * Returns suffix assigned using {@link #setSuffix(TabPlayer, String)} method.
+     * If the method was not used, {@code null} is returned.
+     *
+     * @param   player
+     *          player to get custom suffix of
+     * @return  player's custom suffix or {@code null} if not defined
+     * @see     #setSuffix(TabPlayer, String)
+     * @see     #resetSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
     String getCustomSuffix(TabPlayer player);
-    
+
+    /**
+     * Returns player's original prefix applied using plugin's internal logic.
+     * This value is not affected by API calls in any way.
+     *
+     * @param   player
+     *          player to get original prefix of
+     * @return  player's original prefix
+     * @see     #setPrefix(TabPlayer, String)
+     * @see     #resetPrefix(TabPlayer)
+     * @see     #getCustomPrefix(TabPlayer)
+     */
     String getOriginalPrefix(TabPlayer player);
-    
+
+    /**
+     * Returns player's original name applied using plugin's internal logic.
+     * This value is not affected by API calls in any way.
+     *
+     * @param   player
+     *          player to get original name of
+     * @return  player's original name
+     * @see     #setName(TabPlayer, String)
+     * @see     #resetName(TabPlayer)
+     * @see     #getCustomName(TabPlayer)
+     */
     String getOriginalName(TabPlayer player);
-    
+
+    /**
+     * Returns player's original suffix applied using plugin's internal logic.
+     * This value is not affected by API calls in any way.
+     *
+     * @param   player
+     *          player to get original suffix of
+     * @return  player's original suffix
+     * @see     #setSuffix(TabPlayer, String)
+     * @see     #resetSuffix(TabPlayer)
+     * @see     #getCustomSuffix(TabPlayer)
+     */
     String getOriginalSuffix(TabPlayer player);
-    
 }

api/src/main/java/me/neznamy/tab/api/bossbar/BarStyle.java

@@ -1,10 +1,14 @@
 package me.neznamy.tab.api.bossbar;
 
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
 /**
  * An enum representing all available BossBar styles.
  * Calling ordinal() will return style's network ID.
  * Style names are equal to NMS names.
  */
+@AllArgsConstructor
 public enum BarStyle {
 
     PROGRESS("SOLID"),
@@ -14,23 +18,5 @@ public enum BarStyle {
     NOTCHED_20("SEGMENTED_20");
 
     /** Style's name used in Bukkit API */
-    private final String bukkitName;
-
-    /**
-     * Initializes enum constant with given bukkit name
-     *
-     * @param     bukkitName
-     *             Name of color to be returned in {@code getBukkitName()}
-     */
-    BarStyle(String bukkitName){
-        this.bukkitName = bukkitName;
-    }
-
-    /**
-     * Returns name of this style in Bukkit API
-     * @return    name of this style in Bukkit API
-     */
-    public String getBukkitName() {
-        return bukkitName;
-    }
+    @Getter private final String bukkitName;
 }

api/src/main/java/me/neznamy/tab/api/bossbar/BossBar.java

@@ -23,14 +23,16 @@ public interface BossBar {
      * Returns name of this BossBar. If it was defined in config, returns
      * the name specified in config. If it was made using the API, returns
      * randomly generated ID given to this BossBar when creating.
-     * @return    name of BossBar
+     *
+     * @return  name of BossBar
      */
     String getName();
 
     /**
      * Returns randomly generated uuid of this BossBar used internally to match
      * the BossBar in client with packets or with Bukkit API BossBar instances.
-     * @return    uuid of this BossBar
+     *
+     * @return  uuid of this BossBar
      */
     UUID getUniqueId();
 
@@ -43,8 +45,8 @@ public interface BossBar {
      * <p>
      * If specified title is equal to the current one, nothing happens.
      *
-     * @param    title
-     *             New title to display in this BossBar
+     * @param   title
+     *          New title to display in this BossBar
      */
     void setTitle(String title);
 
@@ -59,8 +61,8 @@ public interface BossBar {
      * <p>
      * If specified progress is equal to the current one, nothing happens.
      *
-     * @param    progress
-     *             New progress to use in this BossBar
+     * @param   progress
+     *          New progress to use in this BossBar
      */
     void setProgress(String progress);
 
@@ -68,8 +70,9 @@ public interface BossBar {
      * Changes BossBar progress to specified value ranging from 0 to 100.
      * <p>
      * If specified progress is equal to the current one, nothing happens.
-     * @param    progress
-     *             New progress to use in this BossBar
+     *
+     * @param   progress
+     *          New progress to use in this BossBar
      */
     void setProgress(float progress);
 
@@ -84,8 +87,8 @@ public interface BossBar {
      * <p>
      * If specified color is equal to the current one, nothing happens.
      *
-     * @param    color
-     *             New color to use in this BossBar
+     * @param   color
+     *          New color to use in this BossBar
      */
     void setColor(String color);
 
@@ -94,8 +97,8 @@ public interface BossBar {
      * <p>
      * If specified color is equal to the current one, nothing happens.
      *
-     * @param    color
-     *             New color to use in this BossBar
+     * @param   color
+     *          New color to use in this BossBar
      */
     void setColor(BarColor color);
 
@@ -110,8 +113,8 @@ public interface BossBar {
      * <p>
      * If specified style is equal to the current one, nothing happens.
      *
-     * @param    style
-     *             New style to use in this BossBar
+     * @param   style
+     *          New style to use in this BossBar
      */
     void setStyle(String style);
 
@@ -120,36 +123,40 @@ public interface BossBar {
      * <p>
      * If specified style is equal to the current one, nothing happens.
      *
-     * @param    style
-     *             New style to use in this BossBar
+     * @param   style
+     *          New style to use in this BossBar
      */
     void setStyle(BarStyle style);
 
     /**
      * Returns current title of the BossBar in raw format. If it contains placeholders,
      * their raw identifiers are used in the result.
-     * @return    title of the BossBar
+     *
+     * @return  title of the BossBar
      */
     String getTitle();
 
     /**
      * Returns progress of the BossBar as a string, which is either entered string
      * containing placeholders or entered number converted to string
-     * @return    entered progress as a string
+     *
+     * @return  entered progress as a string
      */
     String getProgress();
 
     /**
      * Returns color of the BossBar as a string, which is either entered string
      * containing placeholders or entered enum value converted to string
-     * @return    entered color as a string
+     *
+     * @return  entered color as a string
      */
     String getColor();
 
     /**
      * Returns style of the BossBar as a string, which is either entered string
      * containing placeholders or entered enum value converted to string
-     * @return    entered style as a string
+     *
+     * @return  entered style as a string
      */
     String getStyle();
 
@@ -158,8 +165,8 @@ public interface BossBar {
      * <p>
      * If the player already sees this BossBar, nothing happens.
      *
-     * @param    player
-     *             Player to register this BossBar to
+     * @param   player
+     *          Player to register this BossBar to
      */
     void addPlayer(TabPlayer player);
 
@@ -168,8 +175,8 @@ public interface BossBar {
      * <p>
      * If the player does not see this BossBar, nothing happens.
      *
-     * @param    player
-     *             Player to unregister this BossBar from
+     * @param   player
+     *          Player to unregister this BossBar from
      */
     void removePlayer(TabPlayer player);
 
@@ -179,15 +186,25 @@ public interface BossBar {
      * The returned list can only be used to read. Writing
      * will not work properly. For adding/removing players see {@link #addPlayer(TabPlayer)}
      * and {@link #removePlayer(TabPlayer)}.
-     * @return    List of players seeing this BossBar
+     *
+     * @return  List of players seeing this BossBar
      */
     List<TabPlayer> getPlayers();
 
     /**
      * Returns {@code true} if specified player can see this BossBar, {@code false} if not
-     * @param    player
-     *             Player to check for
-     * @return    {@code true} if contains, {@code false} if not
+     *
+     * @param   player
+     *          Player to check for
+     * @return  {@code true} if contains, {@code false} if not
      */
     boolean containsPlayer(TabPlayer player);
+
+    /**
+     * Returns {@code true} if this bossbar in configured as announcement-only bar,
+     * {@code false} if not.
+     *
+     * @return  {@code true} if bar is announcement only, {@code false} if not
+     */
+    boolean isAnnouncementBar();
 }

api/src/main/java/me/neznamy/tab/api/bossbar/BossBarManager.java

@@ -4,15 +4,16 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
+import me.neznamy.tab.api.TabAPI;
 import me.neznamy.tab.api.TabPlayer;
 
 /**
  * An interface allowing work with BossBars such as creating, sending
  * and toggling.
  * <p>
- * Instance can be obtained using {@link me.neznamy.tab.api.TabAPI#getBossBarManager()}.
+ * Instance can be obtained using {@link TabAPI#getBossBarManager()}.
  * This requires the BossBar feature to be enabled in config, otherwise the method will
- * return null.
+ * return {@code null}.
  */
 public interface BossBarManager {
 
@@ -20,18 +21,15 @@ public interface BossBarManager {
      * Creates BossBar with specified parameters and registers it to BossBar manager,
      * allowing to retrieve it later.
      * 
-     * @param    title
-     *             Title to display, supports placeholders
-     * 
-     * @param    progress
-     *             Progress to use. Must be between 0 and 100
-     * 
-     * @param    color
-     *             Color to use
-     * 
-     * @param    style
-     *             Style to use
-     * @return    The newly created BossBar
+     * @param   title
+     *          Title to display, supports placeholders
+     * @param   progress
+     *          Progress to use. Must be between 0 and 100
+     * @param   color
+     *          Color to use
+     * @param   style
+     *          Style to use
+     * @return  The newly created BossBar
      */
     BossBar createBossBar(String title, float progress, BarColor color, BarStyle style);
 
@@ -39,21 +37,18 @@ public interface BossBarManager {
      * Creates BossBar with specified parameters and registers it to BossBar manager,
      * allowing to retrieve it later.
      * 
-     * @param    title
-     *             Title to display, supports placeholders
-     * 
-     * @param    progress
-     *             Progress to use. Must be a string version of a number, or
-     *             a placeholder that returns a number
-     * 
-     * @param    color
-     *             Color to use. Must be a string version of one of enum constants, or
-     *             a placeholder that returns one of them
-     * 
-     * @param    style
-     *             Style to use. Must be a string version of one of enum constants, or
-     *             a placeholder that returns one of them
-     * @return    The newly created BossBar
+     * @param   title
+     *          Title to display, supports placeholders
+     * @param   progress
+     *          Progress to use. Must be a string version of a number, or
+     *          a placeholder that returns a number
+     * @param   color
+     *          Color to use. Must be a string version of one of enum constants, or
+     *          a placeholder that returns one of them
+     * @param   style
+     *          Style to use. Must be a string version of one of enum constants, or
+     *          a placeholder that returns one of them
+     * @return  The newly created BossBar
      */
     BossBar createBossBar(String title, String progress, String color, String style);
 
@@ -63,9 +58,9 @@ public interface BossBarManager {
      * retrieved using {@link me.neznamy.tab.api.bossbar.BossBar#getName()}.
      * Returns null if no such BossBar exists.
      * 
-     * @param    name
-     *             Name of registered BossBar
-     * @return    BossBar with specified name
+     * @param   name
+     *          Name of registered BossBar
+     * @return  BossBar with specified name
      */
     BossBar getBossBar(String name);
 
@@ -74,9 +69,9 @@ public interface BossBarManager {
      * BossBar is created and used in packets / to match which the one from Bukkit API.
      * Returns null if no such BossBar exists.
      * 
-     * @param    id
-     *             UUID to return BossBar by
-     * @return    BossBar with specified uuid
+     * @param   id
+     *          UUID to return BossBar by
+     * @return  BossBar with specified uuid
      */
     BossBar getBossBar(UUID id);
 
@@ -86,31 +81,31 @@ public interface BossBarManager {
      * <p>
      * Map key is BossBar's name available in {@link me.neznamy.tab.api.bossbar.BossBar#getName()},
      * map value is the BossBar interface.
-     * @return    all registered BossBars
+     *
+     * @return  all registered BossBars
      */
     Map<String, BossBar> getRegisteredBossBars();
 
     /**
      * Toggles BossBar for this player and sends toggle message if {@code sendToggleMessage} is true.
      * 
-     * @param    player
-     *             Player to toggle BossBar for
-     * 
-     * @param    sendToggleMessage
-     *             {@code true} if toggle message should be sent, {@code false} if not
-     * @see #hasBossBarVisible(TabPlayer)
-     * @see #setBossBarVisible(TabPlayer, boolean, boolean)
+     * @param   player
+     *          Player to toggle BossBar for
+     * @param   sendToggleMessage
+     *          {@code true} if toggle message should be sent, {@code false} if not
+     * @see     #hasBossBarVisible(TabPlayer)
+     * @see     #setBossBarVisible(TabPlayer, boolean, boolean)
      */
     void toggleBossBar(TabPlayer player, boolean sendToggleMessage);
 
     /**
      * Returns true if player can see BossBars, false if toggled via command or API.
      * 
-     * @param    player
-     *             Player to check toggle status of
-     * @return    {@code true} if visible, {@code false} if disabled (toggled)
-     * @see #toggleBossBar(TabPlayer, boolean)
-     * @see #setBossBarVisible(TabPlayer, boolean, boolean)
+     * @param   player
+     *          Player to check toggle status of
+     * @return  {@code true} if visible, {@code false} if disabled (toggled)
+     * @see     #toggleBossBar(TabPlayer, boolean)
+     * @see     #setBossBarVisible(TabPlayer, boolean, boolean)
      */
     boolean hasBossBarVisible(TabPlayer player);
 
@@ -118,12 +113,12 @@ public interface BossBarManager {
      * Sets BossBar visibility of player to set value. If value did not change, nothing happens.
      * If visibility changed, toggle message is sent if {@code sendToggleMessage} is {@code true}.
      * 
-     * @param    player
-     *             Player to set BossBar visibility of
-     * @param    visible
-     *             {@code true} if BossBar should be visible, {@code false} if not
-     * @param    sendToggleMessage
-     *             {@code true} if toggle message should be sent if value changed, {@code false} if not
+     * @param   player
+     *          Player to set BossBar visibility of
+     * @param   visible
+     *          {@code true} if BossBar should be visible, {@code false} if not
+     * @param   sendToggleMessage
+     *          {@code true} if toggle message should be sent if value changed, {@code false} if not
      * @see #toggleBossBar(TabPlayer, boolean)
      * @see #hasBossBarVisible(TabPlayer)
      */
@@ -131,37 +126,40 @@ public interface BossBarManager {
 
     /**
      * Temporarily displays registered BossBar to player for specified amount of time in milliseconds.
-     * @param    player
-     *             Player to show BossBar to
-     * @param    bossBar
-     *             Name of registered BossBar to show
-     * @param    duration
-     *             In milliseconds for how long should BossBar be displayed
-     * @throws    IllegalArgumentException
-     *             if no BossBar with specified name exists
-     * @see #announceBossBar(String, int)
-     * @see #getAnnouncedBossBars()
+     *
+     * @param   player
+     *          Player to show BossBar to
+     * @param   bossBar
+     *          Name of registered BossBar to show
+     * @param   duration
+     *          In milliseconds for how long should BossBar be displayed
+     * @throws  IllegalArgumentException
+     *          if no BossBar with specified name exists
+     * @see     #announceBossBar(String, int)
+     * @see     #getAnnouncedBossBars()
      */
     void sendBossBarTemporarily(TabPlayer player, String bossBar, int duration);
 
     /**
      * Temporarily displays registered BossBar to all players for specified amount of time in milliseconds.
-     * @param    bossBar
-     *             Name of registered BossBar to show
-     * @param    duration
-     *             In milliseconds for how long should BossBar be displayed
-     * @throws    IllegalArgumentException
-     *             if no BossBar with specified name exists
-     * @see #sendBossBarTemporarily(TabPlayer, String, int)
-     * @see #getAnnouncedBossBars()
+     *
+     * @param   bossBar
+     *          Name of registered BossBar to show
+     * @param   duration
+     *          In milliseconds for how long should BossBar be displayed
+     * @throws  IllegalArgumentException
+     *          if no BossBar with specified name exists
+     * @see     #sendBossBarTemporarily(TabPlayer, String, int)
+     * @see     #getAnnouncedBossBars()
      */
     void announceBossBar(String bossBar, int duration);
 
     /**
      * Returns list of BossBars which are currently being announced.
-     * @return    list of currently active BossBar announcements
-     * @see #sendBossBarTemporarily(TabPlayer, String, int)
-     * @see #announceBossBar(String, int)
+     *
+     * @return  list of currently active BossBar announcements
+     * @see     #sendBossBarTemporarily(TabPlayer, String, int)
+     * @see     #announceBossBar(String, int)
      */
     List<BossBar> getAnnouncedBossBars();
 }

api/src/main/java/me/neznamy/tab/api/chat/ChatClickable.java

@@ -1,49 +1,19 @@
 package me.neznamy.tab.api.chat;
 
-import me.neznamy.tab.api.util.Preconditions;
+import lombok.Data;
+import lombok.NonNull;
 
 /**
  * Class for click event action in chat component
  */
+@Data
 public class ChatClickable {
 
     /** Click action */
-    private final EnumClickAction action;
+    @NonNull private final EnumClickAction action;
 
     /** Click value */
-    private final String value;
-
-    /**
-     * Constructs new instance with given action and value.
-     * @param    action
-     *             click event action
-     * @param    value
-     *             click event value
-     * @throws    IllegalArgumentException
-     *             if {@code action} is null or {@code value} is null
-     */
-    public ChatClickable(EnumClickAction action, String value) {
-        Preconditions.checkNotNull(action, "hover action");
-        Preconditions.checkNotNull(value, "hover value");
-        this.action = action;
-        this.value = value;
-    }
-
-    /**
-     * Returns click action defined in constructor
-     * @return    click action
-     */
-    public EnumClickAction getAction() {
-        return action;
-    }
-
-    /**
-     * Returns click action defined in constructor
-     * @return    click action
-     */
-    public String getValue() {
-        return value;
-    }
+    @NonNull private final String value;
 
     /**
      * Enum for all possible click actions

api/src/main/java/me/neznamy/tab/api/chat/ChatComponentEntity.java

@@ -1,22 +1,22 @@
 package me.neznamy.tab.api.chat;
 
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+
 import java.util.UUID;
 
-import com.google.gson.JsonObject;
-import me.neznamy.tab.api.util.Preconditions;
-
 public class ChatComponentEntity extends IChatBaseComponent {
 
-    private final String type;
-    private final UUID id;
-    private final String name;
-    
-    public ChatComponentEntity(String type, UUID id, String name) {
-        Preconditions.checkNotNull(type, "type");
-        Preconditions.checkNotNull(id, "id");
-        this.type = type;
-        this.id = id;
-        this.name = name;
+    private final String CONTENTS;
+    private final String VALUE_1_13;
+    private final String VALUE_1_12;
+    private final String VALUE_1_8;
+
+    public ChatComponentEntity(@NonNull String type, @NonNull UUID id, String name) {
+        this.CONTENTS = String.format("{\"type\":\"%s\",\"id\":\"%s\",\"name\":{\"text\":\"%s\"}}", type, id, name);
+        this.VALUE_1_13 = String.format("{type:\"%s\",id:\"%s\",name:\"{\\\"text\\\":\\\"%s\\\"}\"}", type, id, name);
+        this.VALUE_1_12 = String.format("{type:\"%s\",id:\"%s\",name:\"%s\"}", type, id, name);
+        this.VALUE_1_8 = String.format("{type:%s,id:%s,name:%s}", type, id, name);
     }
 
     @Override
@@ -26,16 +26,10 @@ public class ChatComponentEntity extends IChatBaseComponent {
     
     @Override
     public String toString() {
-        return String.format("{\"type\":\"%s\",\"id\":\"%s\",\"name\":{\"text\":\"%s\"}}", type, id, name);
-    }
-    
-    public JsonObject toJson() {
-        JsonObject json = new JsonObject();
-        json.addProperty("type", type);
-        json.addProperty("id", id.toString());
-        JsonObject json2 = new JsonObject();
-        json2.addProperty("text", name);
-        json.add("name", json2);
-        return json;
+        if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 16) return CONTENTS;
+        if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 13) return VALUE_1_13;
+        if (TabAPI.getInstance().getServerVersion().getMinorVersion() == 12) return VALUE_1_12;
+        if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 8) return VALUE_1_8;
+        throw new IllegalStateException("show_entity hover action is not supported on <1.8");
     }
 }

api/src/main/java/me/neznamy/tab/api/chat/ChatHoverable.java

@@ -1,57 +1,32 @@
 package me.neznamy.tab.api.chat;
 
-import me.neznamy.tab.api.util.Preconditions;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NonNull;
 
 /**
  * Class for hover event action in chat component
  */
+@Data
 public class ChatHoverable {
 
     /** Hover action */
-    private final EnumHoverAction action;
+    @NonNull private final EnumHoverAction action;
 
     /** Hover value */
-    private final IChatBaseComponent value;
-
-    /**
-     * Constructs new instance with given action and value.
-     * @param    action
-     *             hover event action
-     * @param    value
-     *             hover event value
-     * @throws    IllegalArgumentException
-     *             if {@code action} is null or {@code value} is null
-     */
-    public ChatHoverable(EnumHoverAction action, IChatBaseComponent value) {
-        Preconditions.checkNotNull(action, "hover action");
-        Preconditions.checkNotNull(value, "hover value");
-        this.action = action;
-        this.value = value;
-    }
-
-    /**
-     * Returns hover action defined in constructor
-     * @return    hover action
-     */
-    public EnumHoverAction getAction() {
-        return action;
-    }
-
-    /**
-     * Returns hover value defined in constructor
-     * @return    hover value
-     */
-    public IChatBaseComponent getValue() {
-        return value;
-    }
+    @NonNull private final IChatBaseComponent value;
 
     /**
      * Enum for all possible hover actions
      */
+    @AllArgsConstructor
     public enum EnumHoverAction {
 
-        SHOW_TEXT,
-        SHOW_ITEM,
-        SHOW_ENTITY
+        SHOW_TEXT("contents"),
+        SHOW_ITEM("value"),
+        SHOW_ENTITY("contents");
+
+        @Getter private final String preferredKey;
     }
 }

api/src/main/java/me/neznamy/tab/api/chat/ChatModifier.java

@@ -1,37 +1,31 @@
 package me.neznamy.tab.api.chat;
 
-import java.util.UUID;
-
-import me.neznamy.tab.api.util.Preconditions;
-import org.json.simple.JSONObject;
-
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
 import me.neznamy.tab.api.ProtocolVersion;
 import me.neznamy.tab.api.TabAPI;
 import me.neznamy.tab.api.chat.ChatClickable.EnumClickAction;
 import me.neznamy.tab.api.chat.ChatHoverable.EnumHoverAction;
+import org.json.simple.JSONObject;
 
+import java.util.UUID;
+
+@Data @NoArgsConstructor
 public class ChatModifier {
 
     private TextColor color;
-
     private Boolean bold;
     private Boolean italic;
     private Boolean underlined;
     private Boolean strikethrough;
     private Boolean obfuscated;
-
     private ChatClickable clickEvent;
     private ChatHoverable hoverEvent;
-
     private String font;
-
     private ProtocolVersion targetVersion;
 
-    public ChatModifier() {
-    }
-
-    public ChatModifier(ChatModifier modifier) {
-        Preconditions.checkNotNull(modifier, "modifier");
+    public ChatModifier(@NonNull ChatModifier modifier) {
         this.color = modifier.color == null ? null : new TextColor(modifier.color);
         this.bold = modifier.bold;
         this.italic = modifier.italic;
@@ -44,140 +38,87 @@ public class ChatModifier {
         this.targetVersion = modifier.targetVersion;
     }
 
-    public TextColor getColor() {
-        return color;
-    }
-
-    public void setColor(TextColor color) {
-        this.color = color;
-    }
-
-    public Boolean getBold() {
-        return bold;
-    }
-
-    public void setBold(Boolean bold) {
-        this.bold = bold;
-    }
-
-    public Boolean getItalic() {
-        return italic;
-    }
-
-    public void setItalic(Boolean italic) {
-        this.italic = italic;
-    }
-
-    public Boolean getUnderlined() {
-        return underlined;
-    }
-
-    public void setUnderlined(Boolean underlined) {
-        this.underlined = underlined;
-    }
-
-    public Boolean getStrikethrough() {
-        return strikethrough;
-    }
-
-    public void setStrikethrough(Boolean strikethrough) {
-        this.strikethrough = strikethrough;
-    }
-
-    public Boolean getObfuscated() {
-        return obfuscated;
-    }
-
-    public void setObfuscated(Boolean obfuscated) {
-        this.obfuscated = obfuscated;
-    }
 
     /**
      * Returns true if bold is defined and set to true, false otherwise
-     * @return true if bold is defined and set to true, false otherwise
+     *
+     * @return  true if bold is defined and set to true, false otherwise
      */
-    public boolean isBold(){
+    public boolean isBold() {
         return Boolean.TRUE.equals(bold);
     }
 
     /**
      * Returns true if italic is defined and set to true, false otherwise
-     * @return true if italic is defined and set to true, false otherwise
+     *
+     * @return  true if italic is defined and set to true, false otherwise
      */
-    public boolean isItalic(){
+    public boolean isItalic() {
         return Boolean.TRUE.equals(italic);
     }
 
     /**
      * Returns true if underlined is defined and set to true, false otherwise
-     * @return true if underlined is defined and set to true, false otherwise
+     *
+     * @return  true if underlined is defined and set to true, false otherwise
      */
-    public boolean isUnderlined(){
+    public boolean isUnderlined() {
         return Boolean.TRUE.equals(underlined);
     }
 
     /**
      * Returns true if strikethrough is defined and set to true, false otherwise
-     * @return true if strikethrough is defined and set to true, false otherwise
+     *
+     * @return  true if strikethrough is defined and set to true, false otherwise
      */
-    public boolean isStrikethrough(){
+    public boolean isStrikethrough() {
         return Boolean.TRUE.equals(strikethrough);
     }
 
     /**
      * Returns true if obfuscation is defined and set to true, false otherwise
-     * @return true if obfuscation is defined and set to true, false otherwise
+     *
+     * @return  true if obfuscation is defined and set to true, false otherwise
      */
-    public boolean isObfuscated(){
+    public boolean isObfuscated() {
         return Boolean.TRUE.equals(obfuscated);
     }
 
-    public ChatClickable getClickEvent() {
-        return clickEvent;
-    }
-
-    public void setClickEvent(ChatClickable clickEvent) {
-        this.clickEvent = clickEvent;
-    }
-
-    public ChatHoverable getHoverEvent() {
-        return hoverEvent;
-    }
-
-    public void setHoverEvent(ChatHoverable hoverEvent) {
-        this.hoverEvent = hoverEvent;
-    }
-
     /**
      * Sets click action to OPEN_URL and url to given value
-     * @param url - url to open
+     *
+     * @param   url
+     *          url to open
      */
-    public void onClickOpenUrl(String url) {
-        Preconditions.checkNotNull(url, "url");
+    public void onClickOpenUrl(@NonNull String url) {
         clickEvent = new ChatClickable(EnumClickAction.OPEN_URL, url);
     }
 
     /**
      * Sets click action to RUN_COMMAND and command to given value
-     * @param command - command to perform, might be without / to send a chat message
+     *
+     * @param   command
+     *          command to perform, might be without / to send a chat message
      */
-    public void onClickRunCommand(String command) {
-        Preconditions.checkNotNull(command, "command");
+    public void onClickRunCommand(@NonNull String command) {
         clickEvent = new ChatClickable(EnumClickAction.RUN_COMMAND, command);
     }
 
     /**
      * Sets click action to SUGGEST_COMMAND and command to given value
-     * @param command - command to suggest
+     *
+     * @param   command
+     *          command to suggest
      */
-    public void onClickSuggestCommand(String command) {
-        Preconditions.checkNotNull(command, "command");
+    public void onClickSuggestCommand(@NonNull String command) {
         clickEvent = new ChatClickable(EnumClickAction.SUGGEST_COMMAND, command);
     }
 
     /**
      * Sets click action to CHANGE_PAGE and page id to given value
-     * @param newPage - id of new page
+     *
+     * @param   newPage
+     *          id of new page
      */
     public void onClickChangePage(int newPage) {
         if (TabAPI.getInstance().getServerVersion().getMinorVersion() < 8) throw new UnsupportedOperationException("change_page click action is not supported on <1.8");
@@ -186,73 +127,56 @@ public class ChatModifier {
 
     /**
      * Sets click action to COPY_TO_CLIPBOARD and text to provided value
-     * @param text - text to copy to clipboard on click
+     *
+     * @param   text
+     *          text to copy to clipboard on click
      */
-    public void onClickCopyToClipBoard(String text) {
-        Preconditions.checkNotNull(text, "text");
+    public void onClickCopyToClipBoard(@NonNull String text) {
         clickEvent = new ChatClickable(EnumClickAction.COPY_TO_CLIPBOARD, text);
     }
 
-    public void onClick(EnumClickAction action, String value) {
-        Preconditions.checkNotNull(action, "action");
-        Preconditions.checkNotNull(value, "value");
+    public void onClick(@NonNull EnumClickAction action, @NonNull String value) {
         clickEvent = new ChatClickable(action, value);
     }
 
     /**
      * Sets hover action to SHOW_TEXT and text to given value
-     * @param text - text to show
+     *
+     * @param   text
+     *          text to show
      */
-    public void onHoverShowText(IChatBaseComponent text) {
-        Preconditions.checkNotNull(text, "text");
+    public void onHoverShowText(@NonNull IChatBaseComponent text) {
         hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_TEXT, text);
     }
 
     /**
      * Sets hover action to SHOW_ITEM and item to given value
-     * @param serializedItem - item to show
+     *
+     * @param   serializedItem
+     *          item to show
      */
-    public void onHoverShowItem(String serializedItem) {
-        Preconditions.checkNotNull(serializedItem, "item");
+    public void onHoverShowItem(@NonNull String serializedItem) {
         hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_ITEM, new IChatBaseComponent(serializedItem));
     }
 
     /**
      * Sets hover action to SHOW_ENTITY and entity data to given values
-     * @param type - entity type
-     * @param id - entity uuid
-     * @param name - entity custom name
+     *
+     * @param   type
+     *          entity type
+     * @param   id
+     *          entity uuid
+     * @param   name
+     *          entity custom name
      */
-    public void onHoverShowEntity(String type, UUID id, String name) {
-        Preconditions.checkNotNull(type, "type");
-        Preconditions.checkNotNull(id, "id");
-        if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 16) {
-            hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_ENTITY, new ChatComponentEntity(type, id, name));
-        } else if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 13) {
-            hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_ENTITY, new IChatBaseComponent(String.format("{type:\"%s\",id:\"%s\",name:\"{\\\"text\\\":\\\"%s\\\"}\"}", type, id, name)));
-        } else if (TabAPI.getInstance().getServerVersion().getMinorVersion() == 12) {
-            hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_ENTITY, new IChatBaseComponent(String.format("{type:\"%s\",id:\"%s\",name:\"%s\"}", type, id, name)));
-        } else if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 8) {
-            hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_ENTITY, new IChatBaseComponent(String.format("{type:%s,id:%s,name:%s}", type, id, name)));
-        } else {
-            throw new IllegalStateException("show_entity hover action is not supported on <1.8");
-        }
+    public void onHoverShowEntity(@NonNull String type, @NonNull UUID id, String name) {
+        hoverEvent = new ChatHoverable(EnumHoverAction.SHOW_ENTITY, new ChatComponentEntity(type, id, name));
     }
 
-    public void onHover(EnumHoverAction action, IChatBaseComponent value) {
-        Preconditions.checkNotNull(action, "action");
-        Preconditions.checkNotNull(value, "value");
+    public void onHover(@NonNull EnumHoverAction action, @NonNull IChatBaseComponent value) {
         hoverEvent = new ChatHoverable(action, value);
     }
 
-    public String getFont() {
-        return font;
-    }
-
-    public void setFont(String font) {
-        this.font = font;
-    }
-
     @SuppressWarnings("unchecked")
     public JSONObject serialize() {
         JSONObject json = new JSONObject();
@@ -272,7 +196,7 @@ public class ChatModifier {
             JSONObject hover = new JSONObject();
             hover.put("action", hoverEvent.getAction().toString().toLowerCase());
             if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 16) {
-                hover.put("contents", hoverEvent.getValue());
+                hover.put(hoverEvent.getAction().getPreferredKey(), hoverEvent.getValue());
             } else {
                 hover.put("value", TabAPI.getInstance().getServerVersion().getMinorVersion() >= 9 ?
                         hoverEvent.getValue() : hoverEvent.getValue().toRawText());
@@ -292,12 +216,4 @@ public class ChatModifier {
         if (isObfuscated()) builder.append(EnumChatFormat.OBFUSCATED.getFormat());
         return builder.toString();
     }
-
-    public void setTargetVersion(ProtocolVersion targetVersion) {
-        this.targetVersion = targetVersion;
-    }
-
-    public ProtocolVersion getTargetVersion() {
-        return targetVersion;
-    }
 }

api/src/main/java/me/neznamy/tab/api/chat/DeserializedChatComponent.java

@@ -1,8 +1,10 @@
 package me.neznamy.tab.api.chat;
 
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
 import me.neznamy.tab.api.ProtocolVersion;
 import me.neznamy.tab.api.TabAPI;
-import me.neznamy.tab.api.util.Preconditions;
+import org.jetbrains.annotations.NotNull;
 import org.json.simple.JSONObject;
 import org.json.simple.parser.JSONParser;
 import org.json.simple.parser.ParseException;
@@ -23,10 +25,11 @@ import java.util.List;
  * will act like a normal chat component.
  */
 @SuppressWarnings("unchecked")
+@RequiredArgsConstructor
 public class DeserializedChatComponent extends IChatBaseComponent {
 
     /** The original serialized component string */
-    private final String json;
+    @NonNull private final String json;
 
     /**
      * Flag tracking whether this component was fully deserialized
@@ -41,17 +44,6 @@ public class DeserializedChatComponent extends IChatBaseComponent {
      */
     private boolean modified;
 
-    /**
-     * Constructs new instance with given parameter
-     *
-     * @param   json
-     *          serialized component as string
-     */
-    public DeserializedChatComponent(String json) {
-        Preconditions.checkNotNull(json, "json");
-        this.json = json;
-    }
-
     @Override
     public String toString() {
         if (modified) return super.toString();
@@ -65,7 +57,7 @@ public class DeserializedChatComponent extends IChatBaseComponent {
     }
 
     @Override
-    public List<IChatBaseComponent> getExtra(){
+    public List<IChatBaseComponent> getExtra() {
         if (!deserialized) deserialize();
         return super.getExtra();
     }
@@ -77,27 +69,27 @@ public class DeserializedChatComponent extends IChatBaseComponent {
     }
 
     @Override
-    public ChatModifier getModifier() {
+    public @NotNull ChatModifier getModifier() {
         if (!deserialized) deserialize();
         return super.getModifier();
     }
 
     @Override
-    public IChatBaseComponent setExtra(List<IChatBaseComponent> components){
+    public IChatBaseComponent setExtra(List<IChatBaseComponent> components) {
         if (!deserialized) deserialize();
         modified = true;
         return super.setExtra(components);
     }
 
     @Override
-    public void addExtra(IChatBaseComponent child) {
+    public void addExtra(@NotNull IChatBaseComponent child) {
         if (!deserialized) deserialize();
         modified = true;
         super.addExtra(child);
     }
 
     @Override
-    public void setModifier(ChatModifier modifier) {
+    public void setModifier(@NotNull ChatModifier modifier) {
         if (!deserialized) deserialize();
         modified = true;
         super.setModifier(modifier);
@@ -156,15 +148,13 @@ public class DeserializedChatComponent extends IChatBaseComponent {
     /**
      * Returns boolean value of requested key from map
      *
-     * @param    jsonObject
-     *             map to get value from
-     * @param    key
-     *             name of key
-     * @return    value from json object or null if not present
+     * @param   jsonObject
+     *          map to get value from
+     * @param   key
+     *          name of key
+     * @return  value from json object or null if not present
      */
-    private static Boolean getBoolean(JSONObject jsonObject, String key) {
-        Preconditions.checkNotNull(jsonObject, "json object");
-        Preconditions.checkNotNull(key, "key");
+    private static Boolean getBoolean(@NonNull JSONObject jsonObject, @NonNull String key) {
         String value = String.valueOf(jsonObject.getOrDefault(key, null));
         return "null".equals(value) ? null : Boolean.parseBoolean(value);
     }

api/src/main/java/me/neznamy/tab/api/chat/EnumChatFormat.java

@@ -1,5 +1,6 @@
 package me.neznamy.tab.api.chat;
 
+import lombok.Getter;
 import me.neznamy.tab.api.chat.rgb.RGBUtils;
 
 /**
@@ -40,33 +41,34 @@ public enum EnumChatFormat {
     public static final String COLOR_STRING = String.valueOf(COLOR_CHAR);
 
     /** Character representing the color or magic code */
-    private final char character;
+    @Getter private final char character;
 
     /** Red value of this constant, 0 for magic codes */
-    private final short red;
+    @Getter private final short red;
 
     /** Green value of this constant, 0 for magic codes */
-    private final short green;
+    @Getter private final short green;
 
     /** Blue value of this constant, 0 for magic codes */
-    private final short blue;
+    @Getter private final short blue;
 
     /** Color as 6-digit hex code, null for magic codes */
-    private final String hexCode;
+    @Getter private final String hexCode;
 
     /** Color symbol followed by constant's character */
-    private final String chatFormat;
+    @Getter private final String format;
 
     /**
      * Constructs new color instance with given character and hex code
-     * @param    character
-     *             character which the color goes by
-     * @param    hexCode
-     *             6-digit hex code of the color
+     *
+     * @param   character
+     *          character which the color goes by
+     * @param   hexCode
+     *          6-digit hex code of the color
      */
     EnumChatFormat(char character, String hexCode) {
         this.character = character;
-        this.chatFormat = String.valueOf(COLOR_CHAR) + character;
+        this.format = String.valueOf(COLOR_CHAR) + character;
         this.hexCode = hexCode;
         int hexColor = Integer.parseInt(hexCode, 16);
         red = (short) ((hexColor >> 16) & 0xFF);
@@ -76,47 +78,25 @@ public enum EnumChatFormat {
 
     /**
      * Constructs new magic code instance with given character
-     * @param    character
-     *             character representing the magic code
+     *
+     * @param   character
+     *          character representing the magic code
      */
     EnumChatFormat(char character) {
         this.character = character;
-        this.chatFormat = String.valueOf(COLOR_CHAR) + character;
+        this.format = String.valueOf(COLOR_CHAR) + character;
         red = 0;
         green = 0;
         blue = 0;
         hexCode = null;
     }
 
-    /**
-     * Returns red value of this color code
-     * @return    red value
-     */
-    public short getRed() {
-        return red;
-    }
-
-    /**
-     * Returns green value of this color code
-     * @return    green value
-     */
-    public short getGreen() {
-        return green;
-    }
-
-    /**
-     * Returns blue value of this color code
-     * @return    blue value
-     */
-    public short getBlue() {
-        return blue;
-    }
-
     /**
      * Returns enum value based on provided character or null if character is not valid
-     * @param    c
-     *             color code character (0-9, a-f, k-o, r)
-     * @return    instance from the character or null if character is not valid
+     *
+     * @param   c
+     *          color code character (0-9, a-f, k-o, r)
+     * @return  instance from the character or null if character is not valid
      */
     public static EnumChatFormat getByChar(char c) {
         for (EnumChatFormat format : VALUES) {
@@ -128,9 +108,10 @@ public enum EnumChatFormat {
     /**
      * Returns enum value of last colors used in given string.
      * If it's null, empty or does not contain color codes, WHITE is returned.
-     * @param    string
-     *             string to check last colors of
-     * @return    last used color code in given string or WHITE if nothing is found
+     *
+     * @param   string
+     *          string to check last colors of
+     * @return  last used color code in given string or WHITE if nothing is found
      */
     public static EnumChatFormat lastColorsOf(String string) {
         if (string == null || string.length() == 0) return EnumChatFormat.WHITE;
@@ -145,41 +126,18 @@ public enum EnumChatFormat {
         return EnumChatFormat.WHITE;
     }
 
-    /**
-     * Returns color char followed by color's character
-     * @return color char followed by color's character
-     */
-    public String getFormat() {
-        return chatFormat;
-    }
-
-    /**
-     * Returns character representing this color
-     * @return character representing this color
-     */
-    public char getCharacter() {
-        return character;
-    }
-
-    /**
-     * Returns hex code of this format, null if this is a magic code
-     * @return hex code of this format
-     */
-    public String getHexCode() {
-        return hexCode;
-    }
-
     /**
      * Returns enum value with exact red, green and blue values or null if no match was found
-     * @param    red
-     *             exact red value
-     * @param    green
-     *             exact green value
-     * @param    blue
-     *             exact blue value
-     * @return    enum value or null if no such combination exists
+     *
+     * @param   red
+     *          exact red value
+     * @param   green
+     *          exact green value
+     * @param   blue
+     *          exact blue value
+     * @return  enum value or null if no such combination exists
      */
-    public static EnumChatFormat fromRGBExact(int red, int green, int blue){
+    public static EnumChatFormat fromRGBExact(int red, int green, int blue) {
         for (EnumChatFormat format : VALUES) {
             if (format.red == red && format.green == green && format.blue == blue) return format;
         }
@@ -189,16 +147,17 @@ public enum EnumChatFormat {
     /**
      * Color translation method taken from bukkit, which converts '&' symbol into
      * the actual color character if followed by a valid color character.
-     * @param    textToTranslate
-     *             text to replace color symbol in
-     * @return    colorized string from provided text
+     *
+     * @param   textToTranslate
+     *          text to replace color symbol in
+     * @return  colorized string from provided text
      */
-    public static String color(String textToTranslate){
+    public static String color(String textToTranslate) {
         if (textToTranslate == null) return null;
         if (!textToTranslate.contains("&")) return textToTranslate;
         char[] b = textToTranslate.toCharArray();
         for (int i = 0; i < b.length - 1; i++) {
-            if ((b[i] == '&') && ("0123456789AaBbCcDdEeFfKkLlMmNnOoRrXx".indexOf(b[(i + 1)]) > -1)){
+            if ((b[i] == '&') && ("0123456789AaBbCcDdEeFfKkLlMmNnOoRrXx".indexOf(b[(i + 1)]) > -1)) {
                 b[i] = COLOR_CHAR;
                 b[(i + 1)] = Character.toLowerCase(b[(i + 1)]);
             }
@@ -208,9 +167,10 @@ public enum EnumChatFormat {
 
     /**
      * Turns back the color symbol into '&amp;' symbol in provided text.
-     * @param    text
-     *             text to revert colors in
-     * @return    reverted text
+     *
+     * @param   text
+     *          text to revert colors in
+     * @return  reverted text
      */
     public static String decolor(String text) {
         if (text == null) return null;
@@ -220,17 +180,18 @@ public enum EnumChatFormat {
 
     /**
      * Code taken from bukkit, which returns last color codes used in provided text.
-     * @param    input
-     *             text to get last colors from
-     * @return    last colors used in provided text or empty string if nothing was found
+     *
+     * @param   input
+     *          text to get last colors from
+     * @return  last colors used in provided text or empty string if nothing was found
      */
     public static String getLastColors(String input) {
         if (input == null) return "";
         StringBuilder result = new StringBuilder();
         int length = input.length();
-        for (int index = length - 1; index > -1; index--){
+        for (int index = length - 1; index > -1; index--) {
             char section = input.charAt(index);
-            if ((section == COLOR_CHAR || section == '&') && (index < length - 1)){
+            if ((section == COLOR_CHAR || section == '&') && (index < length - 1)) {
                 char c = input.charAt(index + 1);
                 if ("0123456789AaBbCcDdEeFfKkLlMmNnOoRr".contains(String.valueOf(c))) {
                     result.insert(0, COLOR_CHAR);

api/src/main/java/me/neznamy/tab/api/chat/IChatBaseComponent.java

@@ -1,9 +1,13 @@
 package me.neznamy.tab.api.chat;
 
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.Setter;
 import me.neznamy.tab.api.ProtocolVersion;
 import me.neznamy.tab.api.TabAPI;
 import me.neznamy.tab.api.chat.rgb.RGBUtils;
-import me.neznamy.tab.api.util.Preconditions;
+import me.neznamy.tab.api.util.ComponentCache;
 import org.json.simple.JSONObject;
 
 import java.util.*;
@@ -12,38 +16,37 @@ import java.util.*;
  * A class representing the n.m.s.IChatBaseComponent class to make work with it much easier
  */
 @SuppressWarnings("unchecked")
+@NoArgsConstructor
 public class IChatBaseComponent {
 
     /**
      * Component cache maps to avoid large memory allocations as well as
      * higher CPU usage when using animations which send the same text on repeat.
      */
-    private static final Map<String, IChatBaseComponent> componentCache = new HashMap<>();
-    private static final Map<IChatBaseComponent, String> serializeCacheModern = new HashMap<>();
-    private static final Map<IChatBaseComponent, String> serializeCacheLegacy = new HashMap<>();
+    private static final ComponentCache<String, IChatBaseComponent> stringCache = new ComponentCache<>(10000, (text, clientVersion) -> {
+                return text.contains("#") || text.contains("&x") || text.contains(EnumChatFormat.COLOR_CHAR + "x") || text.contains("<") ?
+                    IChatBaseComponent.fromColoredText(text) : //contains RGB colors
+                    new IChatBaseComponent(text); //no RGB
+            });
+    private static final ComponentCache<IChatBaseComponent, String> serializeCache = new ComponentCache<>(10000,
+            (component, clientVersion) -> component.toString());
 
     /** Text of the component */
-    private String text;
+    @Getter @Setter private String text;
 
     /** Chat modifier containing color, magic codes, hover and click event */
-    private ChatModifier modifier = new ChatModifier();
+    @Getter @Setter @NonNull private ChatModifier modifier = new ChatModifier();
 
     /** Extra components used in "extra" field */
     private List<IChatBaseComponent> extra;
 
-    /**
-     * Constructs a new empty component
-     */
-    public IChatBaseComponent() {
-    }
-    
     /**
      * Constructs a new component which is a clone of provided component
-     * @param    component
-     *             component to clone
+     *
+     * @param   component
+     *          component to clone
      */
-    public IChatBaseComponent(IChatBaseComponent component) {
-        Preconditions.checkNotNull(component, "component");
+    public IChatBaseComponent(@NonNull IChatBaseComponent component) {
         this.text = component.text;
         this.modifier = new ChatModifier(component.modifier);
         for (IChatBaseComponent child : component.getExtra()) {
@@ -53,8 +56,9 @@ public class IChatBaseComponent {
 
     /**
      * Constructs new instance with given text
-     * @param    text
-     *             text to display
+     *
+     * @param   text
+     *          text to display
      */
     public IChatBaseComponent(String text) {
         this.text = text;
@@ -62,22 +66,24 @@ public class IChatBaseComponent {
 
     /**
      * Returns list of extra components. If no extra components are defined, returns empty list.
-     * @return    list of extra components
+     *
+     * @return  list of extra components
      */
-    public List<IChatBaseComponent> getExtra(){
+    public List<IChatBaseComponent> getExtra() {
         if (extra == null) return Collections.emptyList();
         return extra;
     }
 
     /**
      * Sets full list of extra components to given list. Does not allow empty list.
-     * @param    components
-     *             components to use as extra
-     * @return    self
-     * @throws    IllegalArgumentException
-     *             if {@code components} is an empty list
+     *
+     * @param   components
+     *          components to use as extra
+     * @return  self
+     * @throws  IllegalArgumentException
+     *          if {@code components} is an empty list
      */
-    public IChatBaseComponent setExtra(List<IChatBaseComponent> components){
+    public IChatBaseComponent setExtra(List<IChatBaseComponent> components) {
         if (components.isEmpty()) throw new IllegalArgumentException("Unexpected empty array of components"); //exception taken from minecraft
         this.extra = components;
         return this;
@@ -85,57 +91,21 @@ public class IChatBaseComponent {
 
     /**
      * Appends provided component as extra component
-     * @param    child
-     *            component to append
+     *
+     * @param   child
+     *          component to append
      */
-    public void addExtra(IChatBaseComponent child) {
-        Preconditions.checkNotNull(child, "extra");
+    public void addExtra(@NonNull IChatBaseComponent child) {
         if (extra == null) extra = new ArrayList<>();
         extra.add(child);
     }
 
-    /**
-     * Returns text of this component
-     * @return    text of this component
-     */
-    public String getText() {
-        return text;
-    }
-
-    /**
-     * Returns chat modifier of this component
-     * @return    chat modifier of this component
-     */
-    public ChatModifier getModifier() {
-        return modifier;
-    }
-
-    /**
-     * Sets modifier to provided value
-     * @param    modifier
-     *             modifier to set value to
-     * @throws    IllegalArgumentException
-     *             if {@code modifier} is null
-     */
-    public void setModifier(ChatModifier modifier) {
-        Preconditions.checkNotNull(modifier, "modifier");
-        this.modifier = modifier;
-    }
-
-    /**
-     * Changes text of this component
-     * @param    text
-     *             text to show
-     */
-    public void setText(String text) {
-        this.text = text;
-    }
-
     /**
      * Deserializes string and returns created component. If provided string is null, returns null.
-     * @param    json
-     *             serialized string
-     * @return    Deserialized component or null if input is null
+     *
+     * @param   json
+     *          serialized string
+     * @return  Deserialized component or null if input is null
      */
     public static IChatBaseComponent deserialize(String json) {
         if (json == null) return null;
@@ -146,8 +116,9 @@ public class IChatBaseComponent {
      * Converts the component to a string representing the serialized component.
      * This method is only used internally by json library since it's missing
      * protocol version field used by the method.
-     * @return    serialized component in string form
-     * @see #toString(ProtocolVersion)
+     *
+     * @return  serialized component in string form
+     * @see     #toString(ProtocolVersion)
      */
     @Override
     public String toString() {
@@ -162,9 +133,10 @@ public class IChatBaseComponent {
     /**
      * Serializes this component with colors based on client version.
      * If client version is &lt;1.16, HEX colors will be converted to legacy colors.
-     * @param    clientVersion
-     *             client version to adapt component for
-     * @return    serialized string
+     *
+     * @param   clientVersion
+     *          client version to adapt component for
+     * @return  serialized string
      */
     public String toString(ProtocolVersion clientVersion) {
         return toString(clientVersion, false);
@@ -173,11 +145,12 @@ public class IChatBaseComponent {
     /**
      * Serializes this component with colors based on client version.
      * If client version is &lt;1.16, HEX colors will be converted to legacy colors.
-     * @param    clientVersion
-     *             client version to adapt component for
-     * @param    sendTranslatableIfEmpty
-     *             whether empty translatable should be sent if text is empty or not
-     * @return    serialized string
+     *
+     * @param   clientVersion
+     *          client version to adapt component for
+     * @param   sendTranslatableIfEmpty
+     *          whether empty translatable should be sent if text is empty or not
+     * @return  serialized string
      */
     public String toString(ProtocolVersion clientVersion, boolean sendTranslatableIfEmpty) {
         if (extra == null) {
@@ -194,36 +167,24 @@ public class IChatBaseComponent {
         for (IChatBaseComponent child : getExtra()) {
             child.modifier.setTargetVersion(clientVersion);
         }
-        String string;
-        if (clientVersion.getMinorVersion() >= 16) {
-            if (serializeCacheModern.containsKey(this)) return serializeCacheModern.get(this);
-            string = toString();
-            if (serializeCacheModern.size() > 10000) serializeCacheModern.clear();
-            serializeCacheModern.put(this, string);
-        } else {
-            if (serializeCacheLegacy.containsKey(this)) return serializeCacheLegacy.get(this);
-            string = toString();
-            if (serializeCacheLegacy.size() > 10000) serializeCacheLegacy.clear();
-            serializeCacheLegacy.put(this, string);
-        }
-        return string;
+        return serializeCache.get(this, clientVersion);
     }
 
     /**
      * Returns organized component from colored text
-     * @param    originalText
-     *             text to convert
-     * @return    organized component from colored text
+     *
+     * @param   originalText
+     *          text to convert
+     * @return  organized component from colored text
      */
-    public static IChatBaseComponent fromColoredText(String originalText){
-        Preconditions.checkNotNull(originalText, "text");
-        String text = RGBUtils.getInstance().applyFormats(EnumChatFormat.color(originalText), false);
+    public static IChatBaseComponent fromColoredText(@NonNull String originalText) {
+        String text = RGBUtils.getInstance().applyFormats(EnumChatFormat.color(originalText));
         List<IChatBaseComponent> components = new ArrayList<>();
         StringBuilder builder = new StringBuilder();
         IChatBaseComponent component = new IChatBaseComponent();
-        for (int i = 0; i < text.length(); i++){
+        for (int i = 0; i < text.length(); i++) {
             char c = text.charAt(i);
-            if (c == EnumChatFormat.COLOR_CHAR){
+            if (c == EnumChatFormat.COLOR_CHAR) {
                 i++;
                 if (i >= text.length()) {
                     break;
@@ -233,7 +194,7 @@ public class IChatBaseComponent {
                     c = (char)(c + ' ');
                 }
                 EnumChatFormat format = EnumChatFormat.getByChar(c);
-                if (format != null){
+                if (format != null) {
                     if (builder.length() > 0) {
                         component.setText(builder.toString());
                         components.add(component);
@@ -241,7 +202,7 @@ public class IChatBaseComponent {
                         component.text = null;
                         builder = new StringBuilder();
                     }
-                    switch (format){
+                    switch (format) {
                     case BOLD: 
                         component.modifier.setBold(true);
                         break;
@@ -267,7 +228,7 @@ public class IChatBaseComponent {
                         break;
                     }
                 }
-            } else if (c == '#' && text.length() > i+6){
+            } else if (c == '#' && text.length() > i+6) {
                 String hex = text.substring(i+1, i+7);
                 if (RGBUtils.getInstance().isHexCode(hex)) {
                     TextColor color;
@@ -278,7 +239,7 @@ public class IChatBaseComponent {
                         color = new TextColor(hex);
                         i += 6;
                     }
-                    if (builder.length() > 0){
+                    if (builder.length() > 0) {
                         component.setText(builder.toString());
                         components.add(component);
                         builder = new StringBuilder();
@@ -299,11 +260,12 @@ public class IChatBaseComponent {
 
     /**
      * Returns true if text contains legacy color request at defined RGB index start
-     * @param    text
-     *             text to check
-     * @param    i
-     *             current index start
-     * @return    true if legacy color is defined, false if not
+     *
+     * @param   text
+     *          text to check
+     * @param   i
+     *          current index start
+     * @return  true if legacy color is defined, false if not
      */
     private static boolean containsLegacyCode(String text, int i) {
         if (text.length() - i < 9 || text.charAt(i+7) != '|') return false;
@@ -312,7 +274,8 @@ public class IChatBaseComponent {
 
     /**
      * Converts this component into a simple text with legacy colors (the closest match if color is set to RGB)
-     * @return    The simple text format
+     *
+     * @return  The simple text format
      */
     public String toLegacyText() {
         StringBuilder builder = new StringBuilder();
@@ -323,11 +286,12 @@ public class IChatBaseComponent {
     /**
      * Appends text to string builder, might also add color and magic codes if they are different
      * from previous component in chain.
-     * @param    builder
-     *             builder to append text to
-     * @param    previousFormatting
-     *             colors and magic codes in previous component
-     * @return    wew formatting, might be identical to previous one
+     *
+     * @param   builder
+     *          builder to append text to
+     * @param   previousFormatting
+     *          colors and magic codes in previous component
+     * @return  new formatting, might be identical to previous one
      */
     private String append(StringBuilder builder, String previousFormatting) {
         String formatting = previousFormatting;
@@ -347,7 +311,8 @@ public class IChatBaseComponent {
 
     /**
      * Returns colors and magic codes of this component
-     * @return    used colors and magic codes
+     *
+     * @return  used colors and magic codes
      */
     private String getFormatting() {
         StringBuilder builder = new StringBuilder();
@@ -365,7 +330,8 @@ public class IChatBaseComponent {
 
     /**
      * Returns raw text without colors, only works correctly when component is organized
-     * @return    raw text in this component and all child components
+     *
+     * @return  raw text in this component and all child components
      */
     public String toRawText() {
         StringBuilder builder = new StringBuilder();
@@ -378,7 +344,8 @@ public class IChatBaseComponent {
 
     /**
      * Converts the component into flat text with used colors (including rgb) and magic codes
-     * @return    converted text
+     *
+     * @return  converted text
      */
     public String toFlatText() {
         StringBuilder builder = new StringBuilder();
@@ -395,23 +362,12 @@ public class IChatBaseComponent {
      * Returns the most optimized component based on text. Returns null if text is null,
      * organized component if RGB colors are used or simple component with only text field
      * containing the whole text when no RGB colors are used
-     * @param    text
-     *             text to create component from
-     * @return    The most performance-optimized component based on text
+     *
+     * @param   text
+     *          text to create component from
+     * @return  The most performance-optimized component based on text
      */
-    public static IChatBaseComponent optimizedComponent(String text){
-        if (text == null) return null;
-        if (componentCache.containsKey(text)) return componentCache.get(text);
-        IChatBaseComponent component;
-        if (text.contains("#") || text.contains("&x") || text.contains(EnumChatFormat.COLOR_CHAR + "x")){
-            //contains RGB colors
-            component = IChatBaseComponent.fromColoredText(text);
-        } else {
-            //no RGB
-            component = new IChatBaseComponent(text);
-        }
-        if (componentCache.size() > 10000) componentCache.clear();
-        componentCache.put(text, component);
-        return component;
+    public static IChatBaseComponent optimizedComponent(String text) {
+        return stringCache.get(text, null);
     }
 }

api/src/main/java/me/neznamy/tab/api/chat/TextColor.java

@@ -1,5 +1,7 @@
 package me.neznamy.tab.api.chat;
 
+import lombok.Getter;
+import lombok.NonNull;
 import me.neznamy.tab.api.util.Preconditions;
 
 /**
@@ -24,18 +26,17 @@ public class TextColor {
      * Boolean value whether the legacy color was forced with constructor or should be
      * automatically assigned as closest color.
      * This value is used in gradients when converting text for legacy players. */
-    private boolean legacyColorForced;
+    @Getter private boolean legacyColorForced;
 
     /**
      * Constructs new instance as a clone of the provided color.
      *
-     * @param    color
-     *             color to create a clone of
-     * @throws    IllegalArgumentException
-     *             if color is {@code null}
+     * @param   color
+     *          color to create a clone of
+     * @throws  IllegalArgumentException
+     *          if color is {@code null}
      */
-    public TextColor(TextColor color) {
-        Preconditions.checkNotNull(color, "color");
+    public TextColor(@NonNull TextColor color) {
         rgb = color.rgb;
         legacyColor = color.legacyColor;
         hexCode = color.hexCode;
@@ -45,29 +46,26 @@ public class TextColor {
     /**
      * Constructs new instance from provided 6-digit hex code string
      *
-     * @param    hexCode
-     *             a 6-digit combination of hex numbers as a string
-     * @throws    IllegalArgumentException
-     *             if hexCode is {@code null}
+     * @param   hexCode
+     *          a 6-digit combination of hex numbers as a string
+     * @throws  IllegalArgumentException
+     *          if hexCode is {@code null}
      */
-    public TextColor(String hexCode) {
-        Preconditions.checkNotNull(hexCode, "hex code");
+    public TextColor(@NonNull String hexCode) {
         this.hexCode = hexCode;
     }
 
     /**
      * Constructs new instance from provided 6-digit hex code and forced legacy color
      *
-     * @param    hexCode
-     *             6-digit combination of hex numbers as a string
-     * @param    legacyColor
-     *             color to use for legacy clients instead of using the closest legacy color
-     * @throws    IllegalArgumentException
-     *             if {@code hexCode} is {@code null} or {@code legacyColor} is {@code null}
+     * @param   hexCode
+     *          6-digit combination of hex numbers as a string
+     * @param   legacyColor
+     *          color to use for legacy clients instead of using the closest legacy color
+     * @throws  IllegalArgumentException
+     *          if {@code hexCode} is {@code null} or {@code legacyColor} is {@code null}
      */
-    public TextColor(String hexCode, EnumChatFormat legacyColor) {
-        Preconditions.checkNotNull(hexCode, "hex code");
-        Preconditions.checkNotNull(legacyColor, "legacy color");
+    public TextColor(@NonNull String hexCode, EnumChatFormat legacyColor) {
         this.hexCode = hexCode;
         this.legacyColorForced = true;
         this.legacyColor = legacyColor;
@@ -76,13 +74,12 @@ public class TextColor {
     /**
      * Constructs new instance from provided legacy color
      *
-     * @param    legacyColor
-     *             legacy color to construct the instance from
-     * @throws    IllegalArgumentException
-     *             if {@code legacyColor} is {@code null}
+     * @param   legacyColor
+     *          legacy color to construct the instance from
+     * @throws  IllegalArgumentException
+     *          if {@code legacyColor} is {@code null}
      */
-    public TextColor(EnumChatFormat legacyColor) {
-        Preconditions.checkNotNull(legacyColor, "legacy color");
+    public TextColor(@NonNull EnumChatFormat legacyColor) {
         this.rgb = (legacyColor.getRed() << 16) + (legacyColor.getGreen() << 8) + legacyColor.getBlue();
         this.hexCode = legacyColor.getHexCode();
     }
@@ -90,14 +87,14 @@ public class TextColor {
     /**
      * Constructs new instance with red, green and blue values
      *
-     * @param    red
-     *             red value
-     * @param    green
-     *             green value
-     * @param    blue
-     *             blue value
-     * @throws    IllegalArgumentException
-     *             if {@code red}, {@code green} or {@code blue} is out of range ({@code 0-255})
+     * @param   red
+     *          red value
+     * @param   green
+     *          green value
+     * @param   blue
+     *          blue value
+     * @throws  IllegalArgumentException
+     *          if {@code red}, {@code green} or {@code blue} is out of range ({@code 0-255})
      */
     public TextColor(int red, int green, int blue) {
         Preconditions.checkRange(red, 0, 255, "red");
@@ -130,7 +127,8 @@ public class TextColor {
 
     /**
      * Returns {@code red} value
-     * @return    red value
+     *
+     * @return  red value
      */
     public int getRed() {
         if (rgb == -1) rgb = Integer.parseInt(hexCode, 16);
@@ -139,7 +137,8 @@ public class TextColor {
 
     /**
      * Returns {@code green} value
-     * @return    green value
+     *
+     * @return  green value
      */
     public int getGreen() {
         if (rgb == -1) rgb = Integer.parseInt(hexCode, 16);
@@ -148,7 +147,8 @@ public class TextColor {
 
     /**
      * Returns {@code blue} value
-     * @return    blue value
+     *
+     * @return  blue value
      */
     public int getBlue() {
         if (rgb == -1) rgb = Integer.parseInt(hexCode, 16);
@@ -159,7 +159,8 @@ public class TextColor {
      * Returns the closest legacy color of this color object.
      * If the color was defined in constructor, it's returned.
      * Otherwise, the closest color is calculated the then returned.
-     * @return    closest legacy color
+     *
+     * @return  closest legacy color
      */
     public EnumChatFormat getLegacyColor() {
         if (legacyColor == null) legacyColor = loadClosestColor();
@@ -168,7 +169,8 @@ public class TextColor {
 
     /**
      * Returns the rgb combination as a 6-digit hex code string
-     * @return    the rgb combination as a 6-digit hex code string
+     *
+     * @return  the rgb combination as a 6-digit hex code string
      */
     public String getHexCode() {
         if (hexCode == null) hexCode = String.format("%06X", rgb);
@@ -178,7 +180,8 @@ public class TextColor {
     /**
      * Converts the color into a valid color value used in color field in chat component.
      * That is either 6-digit hex code prefixed with '#', or lowercase legacy color.
-     * @return    the color serialized for use in chat component
+     *
+     * @return  the color serialized for use in chat component
      */
     public String toString() {
         EnumChatFormat legacyEquivalent = EnumChatFormat.fromRGBExact(getRed(), getGreen(), getBlue());
@@ -189,22 +192,15 @@ public class TextColor {
         return "#" + getHexCode();
     }
 
-    /**
-     * Returns true if legacy color was forced with a constructor, false if not
-     * @return    true if forced, false if not
-     */
-    public boolean isLegacyColorForced() {
-        return legacyColorForced;
-    }
-
     /**
      * Reads the string as it appears in chat component and turns it into the color object.
      * If the entered string is null, returns null.
      * If it's prefixed with '#', it's considered as a hex code.
      * Otherwise, it is considered being a lowercase legacy color.
-     * @param    string
-     *             string from color field in chat component
-     * @return    An instance from specified string or null if string is null
+     *
+     * @param   string
+     *          string from color field in chat component
+     * @return  An instance from specified string or null if string is null
      */
     public static TextColor fromString(String string) {
         if (string == null) return null;

api/src/main/java/me/neznamy/tab/api/chat/WrappedChatComponent.java

@@ -0,0 +1,62 @@
+package me.neznamy.tab.api.chat;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NonNull;
+import me.neznamy.tab.api.ProtocolVersion;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * A class extending IChatBaseComponent that holds the original value
+ * to avoid deserializing it, which is an unnecessary operation that
+ * slows down the performance, as well as makes code more complicated
+ * and open to problems.
+ */
+@AllArgsConstructor
+public class WrappedChatComponent extends IChatBaseComponent {
+
+    /** Original NMS component */
+    @Getter private final Object originalComponent;
+
+    @Override
+    public String toString() {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public String toString(ProtocolVersion clientVersion) {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public List<IChatBaseComponent> getExtra() {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public String getText() {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public @NotNull ChatModifier getModifier() {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public IChatBaseComponent setExtra(List<IChatBaseComponent> components) {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public void addExtra(@NonNull IChatBaseComponent child) {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+
+    @Override
+    public void setModifier(@NotNull ChatModifier modifier) {
+        throw new UnsupportedOperationException("Not supported for " + getClass().getSimpleName());
+    }
+}

api/src/main/java/me/neznamy/tab/api/chat/rgb/RGBUtils.java

@@ -1,20 +1,20 @@
 package me.neznamy.tab.api.chat.rgb;
 
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
+import lombok.Getter;
+import lombok.NonNull;
 import me.neznamy.tab.api.chat.EnumChatFormat;
-import me.neznamy.tab.api.chat.TextColor;
-import me.neznamy.tab.api.chat.rgb.format.BukkitFormat;
-import me.neznamy.tab.api.chat.rgb.format.CMIFormat;
-import me.neznamy.tab.api.chat.rgb.format.HtmlFormat;
-import me.neznamy.tab.api.chat.rgb.format.RGBFormatter;
-import me.neznamy.tab.api.chat.rgb.format.UnnamedFormat1;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import me.neznamy.tab.api.chat.rgb.format.*;
 import me.neznamy.tab.api.chat.rgb.gradient.CMIGradient;
 import me.neznamy.tab.api.chat.rgb.gradient.CommonGradient;
 import me.neznamy.tab.api.chat.rgb.gradient.GradientPattern;
 import me.neznamy.tab.api.chat.rgb.gradient.KyoriGradient;
-import me.neznamy.tab.api.util.Preconditions;
+import me.neznamy.tab.api.util.ReflectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * A helper class to reformat all RGB formats into the default #RRGGBB and apply gradients
@@ -22,7 +22,7 @@ import me.neznamy.tab.api.util.Preconditions;
 public class RGBUtils {
 
     /** Instance of the class */
-    private static final RGBUtils instance = new RGBUtils();
+    @Getter private static final RGBUtils instance = new RGBUtils();
 
     /** Registered RGB formatters */
     private final RGBFormatter[] formats;
@@ -40,12 +40,17 @@ public class RGBUtils {
      * Constructs new instance and loads all RGB patterns and gradients
      */
     public RGBUtils() {
-        formats = new RGBFormatter[] {
-                new BukkitFormat(),
-                new CMIFormat(),
-                new UnnamedFormat1(),
-                new HtmlFormat()
-        };
+        List<RGBFormatter> list = new ArrayList<>();
+        if (ReflectionUtils.classExists("net.kyori.adventure.text.minimessage.MiniMessage")) {
+            list.add(new MiniMessageFormat());
+        }
+        list.add(new BukkitFormat());
+        list.add(new CMIFormat());
+        list.add(new UnnamedFormat1());
+        list.add(new HtmlFormat());
+        list.add(new KyoriFormat());
+        formats = list.toArray(new RGBFormatter[0]);
+
         gradients = new GradientPattern[] {
                 //{#RRGGBB>}text{#RRGGBB<}
                 new CMIGradient(),
@@ -61,30 +66,17 @@ public class RGBUtils {
         };
     }
 
-    /**
-     * Returns instance of this class
-     * @return    instance
-     */
-    public static RGBUtils getInstance() {
-        return instance;
-    }
-
     /**
      * Applies all RGB formats and gradients to text and returns it.
-     * This method is called on every property initialization to convert formats
-     * once instead of on every refresh, if possible. Because of that, parameter
-     * {@code ignorePlaceholders} exists to not break raw placeholder identifiers
-     * @param    text
-     *             original text
-     * @param    ignorePlaceholders
-     *             whether placeholders should be ignored or not
-     * @return    text where everything is converted to #RRGGBB
+     *
+     * @param   text
+     *          original text
+     * @return  text where everything is converted to #RRGGBB
      */
-    public String applyFormats(String text, boolean ignorePlaceholders) {
-        Preconditions.checkNotNull(text, "text");
+    public String applyFormats(@NonNull String text) {
         String replaced = text;
         for (GradientPattern pattern : gradients) {
-            replaced = pattern.applyPattern(replaced, ignorePlaceholders);
+            replaced = pattern.applyPattern(replaced, false);
         }
         for (RGBFormatter formatter : formats) {
             replaced = formatter.reformat(replaced);
@@ -92,22 +84,39 @@ public class RGBUtils {
         return replaced;
     }
 
+    /**
+     * Applies all gradient formats to text and returns it. This only affects
+     * usage where no placeholder is used inside.
+     *
+     * @param   text
+     *          original text
+     * @return  text where all gradients with static text are converted to #RRGGBB
+     */
+    public String applyCleanGradients(@NonNull String text) {
+        String replaced = text;
+        for (GradientPattern pattern : gradients) {
+            replaced = pattern.applyPattern(replaced, true);
+        }
+        return replaced;
+    }
+
     /**
      * Converts TAB's RGB format (#RRGGBB) into bukkit one
      * (&amp;x&amp;r&amp;r&amp;g&amp;g&amp;b&amp;b) for modern
      * clients (1.16+), for legacy clients it will use the closest color.
-     * @param    text
-     *             text to convert
-     * @param    rgbClient
-     *             whether client accepts RGB or not
-     * @return    converted text
+     *
+     * @param   text
+     *          text to convert
+     * @param   rgbClient
+     *          whether client accepts RGB or not
+     * @return  converted text
      */
     public String convertToBukkitFormat(String text, boolean rgbClient) {
         if (text == null) return null;
         if (!text.contains("#")) return text; //no rgb codes
         if (rgbClient) {
             //converting random formats to TAB one
-            String replaced = applyFormats(text, false);
+            String replaced = applyFormats(text);
             for (Pattern p : new Pattern[]{tabPatternLegacy, tabPattern}) {
                 Matcher m = p.matcher(replaced);
                 while (m.find()) {
@@ -123,47 +132,28 @@ public class RGBUtils {
     }
 
     /**
-     * Converts all hex codes in given string to legacy codes
-     * @param    text
-     *             text to convert
-     * @return    translated text
+     * Converts all hex codes in given string to legacy codes.
+     * Also removes redundant color codes caused by this operation
+     * to properly fit in limits.
+     *
+     * @param   text
+     *          text to convert
+     * @return  translated text
      */
     public String convertRGBtoLegacy(String text) {
         if (text == null) return null;
-        if (!text.contains("#")) return EnumChatFormat.color(text);
-        String applied = applyFormats(text, false);
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < applied.length(); i++){
-            char c = applied.charAt(i);
-            if (c == '#' && applied.length() > i+6) {
-                String hexCode = applied.substring(i+1, i+7);
-                if (isHexCode(hexCode)) {
-                    if (containsLegacyCode(applied, i)) {
-                        sb.append(new TextColor(hexCode, EnumChatFormat.getByChar(applied.charAt(i+8))).getLegacyColor().getFormat());
-                        i += 8;
-                    } else {
-                        sb.append(new TextColor(hexCode).getLegacyColor().getFormat());
-                        i += 6;
-                    }
-                } else {
-                    sb.append(c);
-                }
-            } else {
-                sb.append(c);
-            }
-        }
-        return sb.toString();
+        return IChatBaseComponent.fromColoredText(text).toLegacyText();
     }
 
     /**
      * Returns true if entered string is a valid 6-digit combination of
      * hexadecimal numbers, false if not
-     * @param    string
-     *             string to check
-     * @return    {@code true} if valid, {@code false} if not
+     *
+     * @param   string
+     *          string to check
+     * @return  {@code true} if valid, {@code false} if not
      */
-    public boolean isHexCode(String string) {
-        Preconditions.checkNotNull(string, "string");
+    public boolean isHexCode(@NonNull String string) {
         if (string.length() != 6) return false;
         for (int i=0; i<6; i++) {
             char c = string.charAt(i);
@@ -171,17 +161,4 @@ public class RGBUtils {
         }
         return true;
     }
-
-    /**
-     * Returns true if text contains legacy color request at defined RGB index start
-     * @param    text
-     *             text to check
-     * @param    i
-     *             current index start
-     * @return    {@code true} if legacy color is defined and valid, {@code false} otherwise
-     */
-    private static boolean containsLegacyCode(String text, int i) {
-        if (text.length() - i < 9 || text.charAt(i+7) != '|') return false;
-        return EnumChatFormat.getByChar(text.charAt(i+8)) != null;
-    }
 }

api/src/main/java/me/neznamy/tab/api/chat/rgb/format/HtmlFormat.java

@@ -4,7 +4,7 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
- * Formatter for #<RRGGBB>
+ * Formatter for #&lt;RRGGBB&gt;
  */
 public class HtmlFormat implements RGBFormatter {
 

api/src/main/java/me/neznamy/tab/api/chat/rgb/format/KyoriFormat.java

@@ -0,0 +1,25 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Formatter for <#RRGGBB>
+ */
+public class KyoriFormat implements RGBFormatter {
+
+    private final Pattern pattern = Pattern.compile("<#[0-9a-fA-F]{6}>");
+
+    @Override
+    public String reformat(String text) {
+        if (!text.contains("<#")) return text;
+        String replaced = text;
+        Matcher m = pattern.matcher(replaced);
+        while (m.find()) {
+            String hexCode = m.group();
+            String fixed = hexCode.substring(2, 8);
+            replaced = replaced.replace(hexCode, "#" + fixed);
+        }
+        return replaced;
+    }
+}

api/src/main/java/me/neznamy/tab/api/chat/rgb/format/MiniMessageFormat.java

@@ -0,0 +1,20 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+/**
+ * Call to MiniMessage API to reformat text to &x&R&R&G&G&B&B
+ */
+public class MiniMessageFormat implements RGBFormatter {
+
+    @Override
+    public String reformat(String text) {
+        if (!text.contains("<")) return text;
+        try {
+            return LegacyComponentSerializer.legacySection().serialize(MiniMessage.miniMessage().deserialize(text));
+        } catch (Throwable ignored) {
+            return text;
+        }
+    }
+}

api/src/main/java/me/neznamy/tab/api/chat/rgb/format/RGBFormatter.java

@@ -7,8 +7,10 @@ public interface RGBFormatter {
 
     /**
      * Reformats RGB codes in provided text into #RRGGBB format
-     * @param text - text to format
-     * @return reformatted text
+     *
+     * @param   text
+     *          text to format
+     * @return  reformatted text
      */
     String reformat(String text);
 }

api/src/main/java/me/neznamy/tab/api/chat/rgb/gradient/CommonGradient.java

@@ -3,9 +3,11 @@ package me.neznamy.tab.api.chat.rgb.gradient;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import lombok.AllArgsConstructor;
 import me.neznamy.tab.api.chat.EnumChatFormat;
 import me.neznamy.tab.api.chat.TextColor;
 
+@AllArgsConstructor
 public class CommonGradient implements GradientPattern {
 
     private final Pattern pattern;
@@ -15,18 +17,7 @@ public class CommonGradient implements GradientPattern {
     private final int startColorStart;
     private final int messageStart;
     private final int endColorStartSub;
-    
-    public CommonGradient(Pattern pattern, Pattern legacyPattern, String containCheck, int legacyCharPosition,
-            int startColorStart, int messageStart, int endColorStartSub) {
-        this.pattern = pattern;
-        this.legacyPattern = legacyPattern;
-        this.containCheck = containCheck;
-        this.legacyCharPosition = legacyCharPosition;
-        this.startColorStart = startColorStart;
-        this.messageStart = messageStart;
-        this.endColorStartSub = endColorStartSub;
-    }
-    
+
     @Override
     public String applyPattern(String text, boolean ignorePlaceholders) {
         if (!text.contains(containCheck)) return text;

api/src/main/java/me/neznamy/tab/api/chat/rgb/gradient/GradientPattern.java

@@ -10,17 +10,23 @@ public interface GradientPattern {
 
     /**
      * Applies gradients in provided text and returns text using only #RRGGBB
-     * @param text - text to be reformatted
-     * @return reformatted text
+     *
+     * @param   text
+     *          text to be reformatted
+     * @return  reformatted text
      */
     String applyPattern(String text, boolean ignorePlaceholders);
 
     /**
      * Returns gradient text based on start color, text and end color
-     * @param start - start color
-     * @param text - text to be reformatted
-     * @param end - end color
-     * @return reformatted text
+     *
+     * @param   start
+     *          start color
+     * @param   text
+     *          text to be reformatted
+     * @param   end
+     *          end color
+     * @return  reformatted text
      */
     default String asGradient(TextColor start, String text, TextColor end) {
         //lazy support for magic codes in gradients

api/src/main/java/me/neznamy/tab/api/chat/rgb/gradient/KyoriGradient.java

@@ -7,8 +7,8 @@ import me.neznamy.tab.api.chat.EnumChatFormat;
 import me.neznamy.tab.api.chat.TextColor;
 
 /**
- * Gradient applier for <gradient:#RRGGBB:#RRGGBB>Text</gradient>
- * and <gradient:#RRGGBB|L:#RRGGBB>Text</gradient>
+ * Gradient applier for <gradient:#RRGGBB:#RRGGBB>Text</gradient>
+ * and <gradient:#RRGGBB|L:#RRGGBB>Text</gradient>
  */
 public class KyoriGradient implements GradientPattern {
 

api/src/main/java/me/neznamy/tab/api/config/ConfigurationFile.java

@@ -1,14 +1,13 @@
 package me.neznamy.tab.api.config;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+import me.neznamy.tab.api.TabAPI;
+
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -16,9 +15,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
-import me.neznamy.tab.api.TabAPI;
-import me.neznamy.tab.api.util.Preconditions;
-
 /**
  * Abstract class for configuration file
  */
@@ -29,42 +25,32 @@ public abstract class ConfigurationFile {
     protected List<String> header;
 
     /** Configuration file content */
-    protected Map<String, Object> values;
+    @Getter @Setter protected Map<String, Object> values;
 
     /** File to use */
-    protected final File file;
+    @Getter protected final File file;
 
     /**
      * Constructs new instance and attempts to load specified configuration file.
      * If file does not exist, default file is copied from {@code source}.
      *
-     * @param    source
-     *             Source to copy file from if it does not exist
-     * @param    destination
-     *             File destination to use
-     * @throws    IllegalArgumentException
-     *             if {@code destination} is null
-     * @throws    IllegalStateException
-     *             if file does not exist and source is null
-     * @throws    IOException
-     *             if I/O operation with the file unexpectedly fails
+     * @param   source
+     *          Source to copy file from if it does not exist
+     * @param   destination
+     *          File destination to use
+     * @throws  IllegalArgumentException
+     *          if {@code destination} is null
+     * @throws  IllegalStateException
+     *          if file does not exist and source is null
+     * @throws  IOException
+     *          if I/O operation with the file unexpectedly fails
      */
-    protected ConfigurationFile(InputStream source, File destination) throws IOException {
-        Preconditions.checkNotNull(destination, "destination");
+    protected ConfigurationFile(InputStream source, @NonNull File destination) throws IOException {
         this.file = destination;
         if (file.getParentFile() != null && !file.getParentFile().exists()) Files.createDirectories(file.getParentFile().toPath());
-        if (!file.exists() && source == null) throw new IllegalStateException("File does not exist and source is null");
-        if (file.createNewFile()) {
-//            Files.copy(source, file.toPath());
-            //avoiding MalformedInputException thrown on fabric due to file not having UTF8 encoding by default
-            //also automatically using the encoding so users don't have to worry about it anymore
-            try (BufferedReader reader = new BufferedReader(new InputStreamReader(source, StandardCharsets.UTF_8));
-                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8))){
-                String line;
-                while ((line = reader.readLine()) != null) {
-                    writer.write(line + "\n");
-                }
-            }
+        if (!file.exists()) {
+            if (source == null) throw new IllegalStateException("File does not exist and source is null");
+            Files.copy(source, file.toPath());
         }
         detectHeader();
     }
@@ -76,34 +62,23 @@ public abstract class ConfigurationFile {
 
     /**
      * Returns simple name of the file
-     * @return    simple name of the file
+     *
+     * @return  simple name of the file
      */
     public String getName() {
         return file.getName();
     }
 
-    /**
-     * Returns the root value map
-     * @return    the root value map
-     */
-    public Map<String, Object> getValues(){
-        return values;
-    }
-
-    public void setValues(Map<String, Object> values) {
-        this.values = values;
-    }
-
     /**
      * Gets config option with specified path. If the option is not present and
      * {@code defaultValue} is not {@code null}, value is inserted, {@link #save()}
      * called and {@code defaultValue} returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    defaultValue
-     *             Value to be inserted and returned if option is not present
-     * @return    value from configuration file
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   defaultValue
+     *          Value to be inserted and returned if option is not present
+     * @return  value from configuration file
      */
     public Object getObject(String path, Object defaultValue) {
         Object value = values;
@@ -126,9 +101,9 @@ public abstract class ConfigurationFile {
      * Returns config option with specified path. If option is not present,
      * {@code null} is returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @return    value from configuration file or null if not present
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @return  value from configuration file or null if not present
      */
     public Object getObject(String path) {
         return getObject(path, null);
@@ -149,11 +124,11 @@ public abstract class ConfigurationFile {
      * Returns value from map without case sensitivity of the key. Returns
      * {@code null} if no such key is found.
      *
-     * @param    map
-     *             map to get value from
-     * @param    key
-     *             case-insensitive key name
-     * @return    map value from case-insensitive key
+     * @param   map
+     *          map to get value from
+     * @param   key
+     *          case-insensitive key name
+     * @return  map value from case-insensitive key
      */
     private Object getIgnoreCase(Map<Object, Object> map, String key) {
         for (Entry<Object, Object> entry : map.entrySet()) {
@@ -166,9 +141,9 @@ public abstract class ConfigurationFile {
      * Returns config option with specified path as {@code String}. Returns {@code null} if
      * option is not present.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @return    value from file or null if not present
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @return  value from file or null if not present
      */
     public String getString(String path) {
         return getString(path, null);
@@ -179,11 +154,11 @@ public abstract class ConfigurationFile {
      * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called
      * and {@code defaultValue} returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    defaultValue
-     *             Value to be inserted and returned if option is not present
-     * @return    value from configuration file as {@code String}
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   defaultValue
+     *          Value to be inserted and returned if option is not present
+     * @return  value from configuration file as {@code String}
      */
     public String getString(String path, String defaultValue) {
         Object value = getObject(path, defaultValue);
@@ -195,9 +170,9 @@ public abstract class ConfigurationFile {
      * Returns config option with specified path as {@code List<String>}. Returns {@code null} if
      * option is not present.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @return    value from file or null if not present
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @return  value from file or null if not present
      */
     public List<String> getStringList(String path) {
         return getStringList(path, null);
@@ -208,11 +183,11 @@ public abstract class ConfigurationFile {
      * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called
      * and {@code defaultValue} returned.
      *
-     * @param    path
-     *             Path of the option with sections separated with "{@code .}"
-     * @param    defaultValue
-     *             Value to be inserted and returned if option is not present
-     * @return    value from configuration file as {@code List<String>}
+     * @param   path
+     *          Path of the option with sections separated with "{@code .}"
+     * @param   defaultValue
+     *          Value to be inserted and returned if option is not present
+     * @return  value from configuration file as {@code List<String>}
      */
     public List<String> getStringList(String path, List<String> defaultValue) {
         Object value = getObject(path, defaultValue);
@@ -222,7 +197,7 @@ public abstract class ConfigurationFile {
         }
         List<String> fixedList = new ArrayList<>();
         for (Object key : (List<Object>)value) {
-            fixedList.add(key.toString());
+            fixedList.add(String.valueOf(key));
         }
         return fixedList;
     }
@@ -231,9 +206,9 @@ public abstract class ConfigurationFile {
      * Returns config option with specified path as {@code Integer}. Returns {@code null} if
      * option is not present.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @return    value from file or null if not present
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @return  value from file or null if not present
      */
     public Integer getInt(String path) {
         return getInt(path, null);
@@ -244,11 +219,11 @@ public abstract class ConfigurationFile {
      * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called
      * and {@code defaultValue} returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    defaultValue
-     *             Value to be inserted and returned if option is not present
-     * @return    value from configuration file as {@code Integer}
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   defaultValue
+     *          Value to be inserted and returned if option is not present
+     * @return  value from configuration file as {@code Integer}
      */
     public Integer getInt(String path, Integer defaultValue) {
         Object value = getObject(path, defaultValue);
@@ -265,11 +240,11 @@ public abstract class ConfigurationFile {
      * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called
      * and {@code defaultValue} returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    defaultValue
-     *             Value to be inserted and returned if option is not present
-     * @return    value from configuration file as {@code Boolean}
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   defaultValue
+     *          Value to be inserted and returned if option is not present
+     * @return  value from configuration file as {@code Boolean}
      */
     public boolean getBoolean(String path, boolean defaultValue) {
         Object value = getObject(path, defaultValue);
@@ -282,11 +257,11 @@ public abstract class ConfigurationFile {
      * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called
      * and {@code defaultValue} returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    defaultValue
-     *             Value to be inserted and returned if option is not present
-     * @return    value from configuration file as {@code Double}
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   defaultValue
+     *          Value to be inserted and returned if option is not present
+     * @return  value from configuration file as {@code Double}
      */
     public Double getDouble(String path, double defaultValue) {
         Object value = getObject(path, defaultValue);
@@ -302,9 +277,9 @@ public abstract class ConfigurationFile {
      * Returns config option with specified path as {@code Map<K, V>}. If the option
      * is not present or value is not a {@code Map}, new empty {@code Map} is returned.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @return    value from configuration file as {@code Map<K, V>}
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @return  value from configuration file as {@code Map<K, V>}
      */
     public <K, V> Map<K, V> getConfigurationSection(String path) {
         if (path == null || path.length() == 0) return (Map<K, V>) values;
@@ -320,9 +295,9 @@ public abstract class ConfigurationFile {
      * Returns {@code true} if the file has option with specified path, {@code false}
      * if not.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @return    {@code true} if present, {@code false} if not
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @return  {@code true} if present, {@code false} if not
      */
     public boolean hasConfigOption(String path) {
         return getObject(path) != null;
@@ -331,10 +306,10 @@ public abstract class ConfigurationFile {
     /**
      * Sets value to the specified path and saves the file to disk by calling {@link #save()}.
      *
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    value
-     *             Value to save
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   value
+     *          Value to save
      */
     public void set(String path, Object value) {
         set(values, path, value);
@@ -345,13 +320,13 @@ public abstract class ConfigurationFile {
      * Sets value to the specified map with specified path and value. This is an internal method
      * that correctly creates maps to separate sections using "{@code .}".
      *
-     * @param    map
-     *             Map to insert value to
-     * @param    path
-     *             Path to the option with sections separated with "{@code .}"
-     * @param    value
-     *             Value to save
-     * @return    the first argument to allow chaining
+     * @param   map
+     *          Map to insert value to
+     * @param   path
+     *          Path to the option with sections separated with "{@code .}"
+     * @param   value
+     *          Value to save
+     * @return  the first argument to allow chaining
      */
     private Map<String, Object> set(Map<String, Object> map, String path, Object value) {
         if (path.contains(".")) {
@@ -375,11 +350,11 @@ public abstract class ConfigurationFile {
      * Returns the real key name without case sensitivity from map. If not found, inserted key
      * is returned.
      *
-     * @param    map
-     *             Map to check keys of
-     * @param    key
-     *             Key to find
-     * @return    The real key name
+     * @param   map
+     *          Map to check keys of
+     * @param   key
+     *          Key to find
+     * @return  The real key name
      */
     private String getRealKey(Map<?, ?> map, String key) {
         for (Object mapKey : map.keySet()) {
@@ -391,8 +366,8 @@ public abstract class ConfigurationFile {
     /**
      * Detects header of a file (first lines of file starting with #).
      *
-     * @throws    IOException
-     *             if I/O operation fails
+     * @throws  IOException
+     *          if I/O operation fails
      */
     private void detectHeader() throws IOException {
         header = new ArrayList<>();
@@ -409,8 +384,8 @@ public abstract class ConfigurationFile {
      * Inserts header back into file. This is required after calling {@link #save()}, because
      * it destroys the header.
      *
-     * @throws    IOException
-     *             if I/O operation fails
+     * @throws  IOException
+     *          if I/O operation fails
      */
     public void fixHeader() throws IOException {
         if (header == null) return;
@@ -421,8 +396,4 @@ public abstract class ConfigurationFile {
             Files.write(file.toPath(), content);
         }
     }
-
-    public File getFile() {
-        return file;
-    }
 }

api/src/main/java/me/neznamy/tab/api/config/YamlConfigurationFile.java

@@ -36,18 +36,18 @@ public class YamlConfigurationFile extends ConfigurationFile {
      * Constructs new instance and attempts to load specified configuration file.
      * If file does not exist, default file is copied from {@code source}.
      *
-     * @param    source
-     *             Source to copy file from if it does not exist
-     * @param    destination
-     *             File destination to use
-     * @throws    IllegalArgumentException
-     *             if {@code destination} is null
-     * @throws    IllegalStateException
-     *             if file does not exist and source is null
-     * @throws    YAMLException
-     *             if file has invalid YAML syntax
-     * @throws    IOException
-     *             if I/O operation with the file unexpectedly fails
+     * @param   source
+     *          Source to copy file from if it does not exist
+     * @param   destination
+     *          File destination to use
+     * @throws  IllegalArgumentException
+     *          if {@code destination} is null
+     * @throws  IllegalStateException
+     *          if file does not exist and source is null
+     * @throws  YAMLException
+     *          if file has invalid YAML syntax
+     * @throws  IOException
+     *          if I/O operation with the file unexpectedly fails
      */
     public YamlConfigurationFile(InputStream source, File destination) throws YAMLException, IOException {
         super(source, destination);

api/src/main/java/me/neznamy/tab/api/event/player/PlayerLoadEvent.java

@@ -11,14 +11,15 @@ public interface PlayerLoadEvent extends TabEvent {
     /**
      * Gets the player that was loaded.
      *
-     * @return the player that was loaded
+     * @return  the player that was loaded
      */
     TabPlayer getPlayer();
 
     /**
      * Returns true if player was loaded because they joined,
      * false if the player was loaded because tab reload command was executed
-     * @return true if player joined, false if plugin was reloaded
+     *
+     * @return  true if player joined, false if plugin was reloaded
      */
     boolean isJoin();
 }

api/src/main/java/me/neznamy/tab/api/feature/CommandListener.java

@@ -0,0 +1,21 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to command preprocess event
+ * possibly cancelling it.
+ */
+public interface CommandListener {
+
+    /**
+     * Called when player is about to run a command
+     *
+     * @param   sender
+     *          Command sender
+     * @param   message
+     *          Command line including /
+     * @return  Whether the command should be cancelled or not
+     */
+    boolean onCommand(TabPlayer sender, String message);
+}

api/src/main/java/me/neznamy/tab/api/feature/DisplayNameListener.java

@@ -0,0 +1,25 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+
+import java.util.UUID;
+
+/**
+ * Interface for features listening to display name change
+ */
+public interface DisplayNameListener {
+
+    /**
+     * Called when player is about to receive a packet for changing display name
+     *
+     * @param   packetReceiver
+     *          Player who is about to receive the packet
+     * @param   id
+     *          Affected entry
+     * @param   displayName
+     *          Display name in the packet
+     * @return  New display name to write to the packet
+     */
+    IChatBaseComponent onDisplayNameChange(TabPlayer packetReceiver, UUID id, IChatBaseComponent displayName);
+}

api/src/main/java/me/neznamy/tab/api/feature/DisplayObjectiveListener.java

@@ -0,0 +1,21 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Listener for features listening to display objective packet.
+ */
+public interface DisplayObjectiveListener {
+
+    /**
+     * Called when player is about to receive display objective packet
+     *
+     * @param   receiver
+     *          Packet receiver
+     * @param   slot
+     *          Objective slot
+     * @param   objective
+     *          Objective name
+     */
+    void onDisplayObjective(TabPlayer receiver, int slot, String objective);
+}

api/src/main/java/me/neznamy/tab/api/feature/EntryAddListener.java

@@ -0,0 +1,23 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+import java.util.UUID;
+
+/**
+ * Interface for features listening to tablist entry add
+ */
+public interface EntryAddListener {
+
+    /**
+     * Called when player is about to receive packet for adding a tablist entry
+     *
+     * @param   packetReceiver
+     *          Player who received the packet
+     * @param   id
+     *          UUID of added player
+     * @param   name
+     *          Username of added player
+     */
+    void onEntryAdd(TabPlayer packetReceiver, UUID id, String name);
+}

api/src/main/java/me/neznamy/tab/api/feature/GameModeListener.java

@@ -0,0 +1,24 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+import java.util.UUID;
+
+/**
+ * Interface for features listening to gamemode change packet
+ */
+public interface GameModeListener {
+
+    /**
+     * Called when player receives packet to change gamemode
+     *
+     * @param   packetReceiver
+     *          Player who received the packet
+     * @param   id
+     *          UUID of affected player
+     * @param   gameMode
+     *          gamemode in the packet
+     * @return  New gamemode to write to the packet
+     */
+    int onGameModeChange(TabPlayer packetReceiver, UUID id, int gameMode);
+}

api/src/main/java/me/neznamy/tab/api/feature/JoinListener.java

@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to player join event
+ */
+public interface JoinListener {
+
+    /**
+     * Called when player connects to the server. The player is
+     * already added to online player list.
+     *
+     * @param   connectedPlayer
+     *          Player who connected
+     */
+    void onJoin(TabPlayer connectedPlayer);
+}

api/src/main/java/me/neznamy/tab/api/feature/LatencyListener.java

@@ -0,0 +1,24 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+import java.util.UUID;
+
+/**
+ * Called when a packet to change player's latency is sent.
+ */
+public interface LatencyListener {
+
+    /**
+     * Called when a player receives a packet for latency change.
+     *
+     * @param   packetReceiver
+     *          Player who received the packet
+     * @param   id
+     *          UUID of affected player
+     * @param   latency
+     *          Latency in the packet
+     * @return  New latency
+     */
+    int onLatencyChange(TabPlayer packetReceiver, UUID id, int latency);
+}

api/src/main/java/me/neznamy/tab/api/feature/Loadable.java

@@ -0,0 +1,12 @@
+package me.neznamy.tab.api.feature;
+
+/**
+ * Interface for features looking to load players on plugin enable
+ */
+public interface Loadable {
+
+    /**
+     * Called on plugin (re)load
+     */
+    void load();
+}

api/src/main/java/me/neznamy/tab/api/feature/LoginPacketListener.java

@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to Login packet
+ * usually sent by proxy on server switch
+ */
+public interface LoginPacketListener {
+
+    /**
+     * Called when player receives Login packet
+     *
+     * @param   packetReceiver
+     *          Player who received the packet
+     */
+    void onLoginPacket(TabPlayer packetReceiver);
+}

api/src/main/java/me/neznamy/tab/api/feature/ObjectiveListener.java

@@ -0,0 +1,21 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Listener for features listening to objective packet.
+ */
+public interface ObjectiveListener {
+
+    /**
+     * Called when player is about to receive display objective packet
+     *
+     * @param   receiver
+     *          Packet receiver
+     * @param   action
+     *          Packet action (0 = register, 1 = unregister, 2 = update)
+     * @param   objective
+     *          Objective name
+     */
+    void onObjective(TabPlayer receiver, int action, String objective);
+}

api/src/main/java/me/neznamy/tab/api/feature/PacketReceiveListener.java

@@ -0,0 +1,22 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to packets sent by players
+ */
+public interface PacketReceiveListener {
+
+    /**
+     * Called when a player is about to send a packet to the server
+     *
+     * @param   sender
+     *          Packet sender
+     * @param   packet
+     *          The packet
+     * @return  Whether the packet should be cancelled or not
+     * @throws  ReflectiveOperationException
+     *          If thrown by reflective operation
+     */
+    boolean onPacketReceive(TabPlayer sender, Object packet) throws ReflectiveOperationException;
+}

api/src/main/java/me/neznamy/tab/api/feature/PacketSendListener.java

@@ -0,0 +1,21 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to packets sent to players
+ */
+public interface PacketSendListener {
+
+    /**
+     * Called when a player is about to receive a packet from the server
+     *
+     * @param   receiver
+     *          Player who is about to receive a packet
+     * @param   packet
+     *          The packet
+     * @throws  ReflectiveOperationException
+     *          If thrown by reflective operation
+     */
+    void onPacketSend(TabPlayer receiver, Object packet) throws ReflectiveOperationException;
+}

api/src/main/java/me/neznamy/tab/api/feature/QuitListener.java

@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to player quit event
+ */
+public interface QuitListener {
+
+    /**
+     * Called when player disconnected from the server. The player is
+     * still present in online player list.
+     *
+     * @param   disconnectedPlayer
+     *          Player who disconnected
+     */
+    void onQuit(TabPlayer disconnectedPlayer);
+}

api/src/main/java/me/neznamy/tab/api/feature/Refreshable.java

@@ -0,0 +1,48 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+
+import java.util.Collection;
+
+/**
+ * Interface for features periodically refreshing visuals
+ */
+public interface Refreshable {
+
+    /**
+     * Called when a placeholder used by this feature changes value
+     *
+     * @param   refreshed
+     *          Player which a placeholder changed value for
+     * @param   force
+     *          Whether refresh should be forced
+     */
+    void refresh(TabPlayer refreshed, boolean force);
+
+    /**
+     * Returns display name of {@link #refresh(TabPlayer, boolean)}
+     * called for this feature in /tab cpu
+     *
+     * @return  Display name of refresh function in this feature
+     */
+    String getRefreshDisplayName();
+
+    /**
+     * Registers this feature as one using specified placeholders
+     *
+     * @param   placeholders
+     *          placeholders to add as used in this feature
+     */
+    default void addUsedPlaceholders(Collection<String> placeholders) {
+        if (placeholders.isEmpty()) return;
+        placeholders.forEach(p -> TabAPI.getInstance().getPlaceholderManager().addUsedPlaceholder(p, this));
+    }
+
+    /**
+     * Returns name of this feature displayed in /tab cpu
+     *
+     * @return  name of this feature display in /tab cpu
+     */
+    String getFeatureName();
+}

api/src/main/java/me/neznamy/tab/api/feature/ServerSwitchListener.java

@@ -0,0 +1,21 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to players switching servers
+ */
+public interface ServerSwitchListener {
+
+    /**
+     * Called when player switched server
+     *
+     * @param   changed
+     *          Player who changed server
+     * @param   from
+     *          Name of previous server
+     * @param   to
+     *          Name of new server
+     */
+    void onServerChange(TabPlayer changed, String from, String to);
+}

api/src/main/java/me/neznamy/tab/api/feature/TabFeature.java

@@ -0,0 +1,136 @@
+package me.neznamy.tab.api.feature;
+
+import java.util.*;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Abstract class representing a core feature of the plugin.
+ */
+public abstract class TabFeature {
+
+    /** Servers where the feature is disabled (or enabled if using whitelist mode) */
+    protected String[] disabledServers = new String[0];
+
+    /** Flag tracking whether disabled server list is a whitelist or blacklist */
+    private boolean serverWhitelistMode = false;
+
+    /** Worlds where the feature is disabled (or enabled if using whitelist mode) */
+    protected String[] disabledWorlds = new String[0];
+
+    /** Flag tracking whether disabled world list is a whitelist or blacklist */
+    private boolean worldWhitelistMode = false;
+
+    /** Players located in currently disabled worlds / servers */
+    private final Set<TabPlayer> disabledPlayers = Collections.newSetFromMap(new WeakHashMap<>());
+
+    protected TabFeature() {}
+
+    /**
+     * Constructs new instance with given parameters and loads method overrides.
+     * Also loads lists of disabled worlds and servers of this feature with config
+     * section path specified with {@code configSection} parameter.
+     *
+     * @param   configSection
+     *          Configuration section of the feature to load disabled
+     *          servers / worlds from
+     */
+    protected TabFeature(@NonNull String configSection) {
+        List<String> disabledServers = TabAPI.getInstance().getConfig().getStringList(configSection + ".disable-in-servers");
+        List<String> disabledWorlds = TabAPI.getInstance().getConfig().getStringList(configSection + ".disable-in-worlds");
+        if (disabledServers != null) {
+            this.disabledServers = disabledServers.toArray(new String[0]);
+            serverWhitelistMode = disabledServers.contains("WHITELIST");
+        }
+        if (disabledWorlds != null) {
+            this.disabledWorlds = disabledWorlds.toArray(new String[0]);
+            worldWhitelistMode = disabledWorlds.contains("WHITELIST");
+        }
+    }
+
+    /**
+     * Returns {@code true} if world or server is disabled, {@code false} if not
+     *
+     * @param   server
+     *          server to check
+     * @param   world
+     *          world to check
+     * @return  {@code true} if feature should be disabled, {@code false} if not
+     */
+    public boolean isDisabled(String server, String world) {
+        boolean contains = contains(disabledWorlds, world);
+        if (worldWhitelistMode) contains = !contains;
+        if (contains) return true;
+        contains = contains(disabledServers, server);
+        if (serverWhitelistMode) contains = !contains;
+        return contains;
+    }
+
+    /**
+     * Returns {@code true} if list contains the specified element or element
+     * ends with {@code "*"} and element meeting that requirement is present,
+     * {@code false} otherwise.
+     *
+     * @param   list
+     *          List to check
+     * @param   element
+     *          Element to find
+     * @return  {@code true} if element was found, {@code false} if not
+     */
+    protected boolean contains(String[] list, String element) {
+        if (element == null) return false;
+        for (String s : list) {
+            if (s.endsWith("*")) {
+                if (element.toLowerCase().startsWith(s.substring(0, s.length()-1).toLowerCase())) return true;
+            } else {
+                if (element.equalsIgnoreCase(s)) return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns {@code true} if player is currently located in a server
+     * or world, which is marked as disabled, {@code false} if not
+     *
+     * @param   p
+     *          Player to check
+     * @return  {@code true} if player is in disabled server / world,
+     *          {@code false} if not
+     */
+    public boolean isDisabledPlayer(TabPlayer p) {
+        return disabledPlayers.contains(p);
+    }
+
+    /**
+     * Adds specified player into list of players in disabled
+     * servers / worlds.
+     *
+     * @param   p
+     *          Player to add
+     */
+    public void addDisabledPlayer(TabPlayer p) {
+        if (disabledPlayers.contains(p)) return;
+        disabledPlayers.add(p);
+    }
+
+    /**
+     * Removes specified player from list of players in disabled
+     * servers / worlds
+     *
+     * @param   p
+     *          Player to check
+     */
+    public void removeDisabledPlayer(TabPlayer p) {
+        disabledPlayers.remove(p);
+    }
+
+    /**
+     * Returns name of this feature displayed in /tab cpu
+     *
+     * @return  name of this feature display in /tab cpu
+     */
+    public abstract String getFeatureName();
+}

api/src/main/java/me/neznamy/tab/api/feature/UnLoadable.java

@@ -0,0 +1,12 @@
+package me.neznamy.tab.api.feature;
+
+/**
+ * Interface for features looking to unload players on plugin disable
+ */
+public interface UnLoadable {
+
+    /**
+     * Called on plugin unload
+     */
+    void unload();
+}

api/src/main/java/me/neznamy/tab/api/feature/VanishListener.java

@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to vanish status change
+ */
+public interface VanishListener {
+
+    /**
+     * Called when player's vanish status changes. New status
+     * is available in {@link TabPlayer#isVanished()}.
+     *
+     * @param   player
+     *          Player who changed vanish status
+     */
+    void onVanishStatusChange(TabPlayer player);
+}

api/src/main/java/me/neznamy/tab/api/feature/WorldSwitchListener.java

@@ -0,0 +1,21 @@
+package me.neznamy.tab.api.feature;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for features listening to players switching worlds
+ */
+public interface WorldSwitchListener {
+
+    /**
+     * Called when player switched world
+     *
+     * @param   changed
+     *          Player who changed world
+     * @param   from
+     *          Name of previous world
+     * @param   to
+     *          Name of new world
+     */
+    void onWorldChange(TabPlayer changed, String from, String to);
+}

api/src/main/java/me/neznamy/tab/api/placeholder/Placeholder.java

@@ -6,11 +6,9 @@ public interface Placeholder {
 
     String getIdentifier();
 
-    boolean isTriggerMode();
-
-    void enableTriggerMode();
-
     void enableTriggerMode(Runnable onActivation, Runnable onDisable);
 
     void unload();
+
+    boolean isUsed();
 }

api/src/main/java/me/neznamy/tab/api/placeholder/PlaceholderManager.java

@@ -5,10 +5,10 @@ import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-import me.neznamy.tab.api.TabFeature;
+import me.neznamy.tab.api.feature.Refreshable;
 import me.neznamy.tab.api.TabPlayer;
 
-public interface PlaceholderManager {
+public interface PlaceholderManager extends Refreshable {
 
     /**
      * Registers a server placeholder (placeholder with same output for all players)
@@ -27,20 +27,27 @@ public interface PlaceholderManager {
 
     /**
      * Detects placeholders in text using %% pattern and returns list of all detected identifiers
-     * @param text - text to detect placeholders in
-     * @return list of detected identifiers
+     *
+     * @param   text
+     *          text to detect placeholders in
+     * @return  list of detected identifiers
      */
     List<String> detectPlaceholders(String text);
 
     /**
      * Adds placeholder to list of used placeholders and assigns this feature as using it,
      * which will then receive refresh() if values changes
-     * @param identifier - placeholder identifier
-     * @param feature - feature using the placeholder
+     *
+     * @param   identifier
+     *          placeholder identifier
+     * @param   feature
+     *          feature using the placeholder
      */
-    void addUsedPlaceholder(String identifier, TabFeature feature);
+    void addUsedPlaceholder(String identifier, Refreshable feature);
 
     String findReplacement(String placeholder, String output);
 
     List<String> getUsedPlaceholders();
+
+    Placeholder getPlaceholder(String identifier);
 }

api/src/main/java/me/neznamy/tab/api/placeholder/PlayerPlaceholder.java

@@ -8,11 +8,21 @@ public interface PlayerPlaceholder extends Placeholder {
 
     /**
      * Calls the placeholder request function and returns the output.
-     * If the placeholder thrown an exception, it is logged in {@code placeholder-errors.log}
+     * If the placeholder threw an exception, it is logged in {@code placeholder-errors.log}
      * file and "ERROR" is returned.
-     * @param    p
-     *             player to get placeholder value for
-     * @return    value placeholder returned or "ERROR" if it threw an error
+     *
+     * @param   p
+     *          player to get placeholder value for
+     * @return  value placeholder returned or "ERROR" if it threw an error
      */
     Object request(TabPlayer p);
+
+    /**
+     * Returns last known value for given player.
+     *
+     * @param   player
+     *          player to get last value for
+     * @return  last known value for entered player
+     */
+    String getLastValue(TabPlayer player);
 }

api/src/main/java/me/neznamy/tab/api/placeholder/RelationalPlaceholder.java

@@ -6,5 +6,28 @@ public interface RelationalPlaceholder extends Placeholder {
 
     void updateValue(TabPlayer viewer, TabPlayer target, Object value);
 
+    /**
+     * Calls the placeholder request function and returns the output.
+     * If the placeholder threw an exception, it is logged in {@code placeholder-errors.log}
+     * file and "ERROR" is returned.
+     *
+     * @param   viewer
+     *          player looking at output of the placeholder
+     * @param   target
+     *          player the placeholder is displayed on
+     * @return  value placeholder returned or "ERROR" if it threw an error
+     */
     Object request(TabPlayer viewer, TabPlayer target);
+
+    /**
+     * Returns last known value for given players. First player is viewer,
+     * second player is target.
+     *
+     * @param   viewer
+     *          viewer of the placeholder
+     * @param   target
+     *          target who is the text displayed on
+     * @return  last known value for entered player duo
+     */
+    String getLastValue(TabPlayer viewer, TabPlayer target);
 }

api/src/main/java/me/neznamy/tab/api/placeholder/ServerPlaceholder.java

@@ -4,5 +4,19 @@ public interface ServerPlaceholder extends Placeholder {
 
     void updateValue(Object value);
 
+    /**
+     * Calls the placeholder request function and returns the output.
+     * If the placeholder threw an exception, it is logged in {@code placeholder-errors.log}
+     * file and "ERROR" is returned.
+     *
+     * @return  value placeholder returned or "ERROR" if it threw an error
+     */
     Object request();
+
+    /**
+     * Returns last known value of the placeholder.
+     *
+     * @return  last known value
+     */
+    String getLastValue();
 }

api/src/main/java/me/neznamy/tab/api/protocol/PacketBuilder.java

@@ -1,268 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import me.neznamy.tab.api.ProtocolVersion;
-import me.neznamy.tab.api.chat.EnumChatFormat;
-import me.neznamy.tab.api.chat.IChatBaseComponent;
-import me.neznamy.tab.api.chat.rgb.RGBUtils;
-import me.neznamy.tab.api.util.BiFunctionWithException;
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class for packet building, methods are overridden in
- * platform-specific builders which extend this class to build actual packets.
- * Packets which don't have a method override are forwarded into
- * sendPacket method, where they are handled using platform's API instead.
- */
-public class PacketBuilder {
-
-    /** Function map turning custom packet class into platform-specific packets */
-    protected final Map<Class<? extends TabPacket>, BiFunctionWithException<TabPacket, ProtocolVersion, Object>> buildMap = new HashMap<>();
-
-    /**
-     * Constructs new instance and fills {@link #buildMap} with abstract build methods
-     * of packets present on all platforms.
-     */
-    public PacketBuilder() {
-        buildMap.put(PacketPlayOutBoss.class, (packet, version) -> build((PacketPlayOutBoss)packet, version));
-        buildMap.put(PacketPlayOutChat.class, (packet, version) -> build((PacketPlayOutChat)packet, version));
-        buildMap.put(PacketPlayOutPlayerInfo.class, (packet, version) -> build((PacketPlayOutPlayerInfo)packet, version));
-        buildMap.put(PacketPlayOutPlayerListHeaderFooter.class, (packet, version) -> build((PacketPlayOutPlayerListHeaderFooter)packet, version));
-        buildMap.put(PacketPlayOutScoreboardDisplayObjective.class, (packet, version) -> build((PacketPlayOutScoreboardDisplayObjective)packet, version));
-        buildMap.put(PacketPlayOutScoreboardObjective.class, (packet, version) -> build((PacketPlayOutScoreboardObjective)packet, version));
-        buildMap.put(PacketPlayOutScoreboardScore.class, (packet, version) -> build((PacketPlayOutScoreboardScore)packet, version));
-        buildMap.put(PacketPlayOutScoreboardTeam.class, (packet, version) -> build((PacketPlayOutScoreboardTeam)packet, version));
-    }
-
-    /**
-     * Converts custom packet into platform-specific packet by calling a function from
-     * {@link #buildMap}.
-     *
-     * @param    packet
-     *             Packet to build
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if reflection fails
-     */
-    public Object build(TabPacket packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        Preconditions.checkNotNull(packet, "packet");
-        Preconditions.checkNotNull(clientVersion, "clientVersion");
-        return buildMap.get(packet.getClass()).apply(packet, clientVersion);
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutBoss class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutBoss packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutChat class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutChat packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutPlayerInfo class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutPlayerInfo packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutPlayerListHeaderFooter class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutPlayerListHeaderFooter packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutScoreboardDisplayObjective class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutScoreboardDisplayObjective packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutScoreboardObjective class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutScoreboardObjective packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutScoreboardScore class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutScoreboardScore packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Constructs platform-specific PacketPlayOutScoreboardTeam class based on custom packet class
-     *
-     * @param    packet
-     *             Custom packet to be built
-     * @param    clientVersion
-     *             Protocol version of player to build the packet for
-     * @return    Platform-specific packet
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public Object build(PacketPlayOutScoreboardTeam packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return packet;
-    }
-
-    /**
-     * Cuts given string to specified character length (or length-1 if last character is a color character)
-     * and translates RGB to legacy colors. If string is not that long, the original string is returned.
-     * RGB codes are converted into legacy, since cutting is only needed for &lt;1.13.
-     * If {@code string} is {@code null}, empty string is returned.
-     * @param    string
-     *             String to cut
-     * @param    length
-     *             Length to cut to
-     * @return    string cut to {@code length} characters
-     */
-    public String cutTo(String string, int length) {
-        if (string == null) return "";
-        String legacyText = string;
-        if (string.contains("#")) {
-            //converting RGB to legacy colors
-            legacyText = RGBUtils.getInstance().convertRGBtoLegacy(string);
-        }
-        if (legacyText.length() <= length) return legacyText;
-        if (legacyText.charAt(length-1) == EnumChatFormat.COLOR_CHAR) {
-            return legacyText.substring(0, length-1); //cutting one extra character to prevent prefix ending with "&"
-        } else {
-            return legacyText.substring(0, length);
-        }
-    }
-
-    /**
-     * If {@code clientVersion} is >= 1.13, creates a component from given text and returns
-     * it as a serialized component, which BungeeCord uses.
-     * <p>
-     * If {@code clientVersion} is &lt; 1.12, the text is cut to {@code length} characters if
-     * needed and returned.
-     *
-     * @param    text
-     *             Text to convert
-     * @param    clientVersion
-     *             Version of player to convert text for
-     * @return    serialized component for 1.13+ clients, cut string for 1.12-
-     */
-    public String jsonOrCut(String text, ProtocolVersion clientVersion, int length) {
-        if (text == null) return null;
-        if (clientVersion.getMinorVersion() >= 13) {
-            return IChatBaseComponent.optimizedComponent(text).toString(clientVersion);
-        } else {
-            return cutTo(text, length);
-        }
-    }
-
-    /**
-     * Converts platform-specific instance of player info packet into
-     * {@link PacketPlayOutPlayerInfo} object.
-     *
-     * @param    packet
-     *             platform-specific info packet
-     * @param    clientVersion
-     *             Version of client receiving the packet
-     * @return    The packet converted into {@link PacketPlayOutPlayerInfo}
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public PacketPlayOutPlayerInfo readPlayerInfo(Object packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
-        return null;
-    }
-
-    /**
-     * Converts platform-specific instance of objective packet into
-     * {@link PacketPlayOutScoreboardObjective} object.
-     *
-     * @param    packet
-     *             platform-specific objective packet
-     * @return    The packet converted into {@link PacketPlayOutScoreboardObjective}
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public PacketPlayOutScoreboardObjective readObjective(Object packet) throws ReflectiveOperationException {
-        return null;
-    }
-
-    /**
-     * Converts platform-specific instance of display objective packet into
-     * {@link PacketPlayOutScoreboardDisplayObjective} object.
-     *
-     * @param    packet
-     *             platform-specific display objective packet
-     * @return    The packet converted into {@link PacketPlayOutScoreboardDisplayObjective}
-     * @throws    ReflectiveOperationException
-     *             if thrown by reflective operation
-     */
-    public PacketPlayOutScoreboardDisplayObjective readDisplayObjective(Object packet) throws ReflectiveOperationException {
-        return null;
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutBoss.java

@@ -1,293 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import java.util.UUID;
-
-import me.neznamy.tab.api.bossbar.BarColor;
-import me.neznamy.tab.api.bossbar.BarStyle;
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutBoss implements TabPacket {
-
-    /** UUID of the BossBar */
-    private final UUID id;
-
-    /** Action of this packet */
-    private final Action action;
-
-    /** BossBar title */
-    private String name;
-
-    /** BossBar progress (0-1)*/
-    private float pct;
-
-    /** BossBar color */
-    private BarColor color;
-
-    /** BossBar style */
-    private BarStyle overlay;
-
-    /** Darken screen flag */
-    private boolean darkenScreen;
-
-    /** Play music flag */
-    private boolean playMusic;
-
-    /** Create fog flag */
-    private boolean createWorldFog;
-
-    /**
-     * Constructs new instance with given parameters and
-     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.ADD action
-     *
-     * @param    id
-     *             BossBar uuid
-     * @param    name
-     *             BossBar title
-     * @param    pct
-     *             BossBar progress
-     * @param    color
-     *             BossBar color
-     * @param    overlay
-     *             BossBar style
-     */
-    public PacketPlayOutBoss(UUID id, String name, float pct, BarColor color, BarStyle overlay) {
-        Preconditions.checkNotNull(id, "uuid");
-        Preconditions.checkNotNull(name, "title");
-        Preconditions.checkNotNull(color, "color");
-        Preconditions.checkNotNull(overlay, "style");
-        this.action = Action.ADD;
-        this.id = id;
-        this.name = name;
-        this.pct = pct;
-        this.color = color;
-        this.overlay = overlay;
-    }
-
-    /**
-     * Constructs new instance with given parameters and
-     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.REMOVE action
-     *
-     * @param    id
-     *             BossBar uuid
-     */
-    public PacketPlayOutBoss(UUID id) {
-        Preconditions.checkNotNull(id, "uuid");
-        this.action = Action.REMOVE;
-        this.id = id;
-    }
-
-    /**
-     * Constructs new instance with given parameters and
-     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.UPDATE_PCT action
-     *
-     * @param    id
-     *             BossBar uuid
-     * @param    pct
-     *             BossBar progress
-     */
-    public PacketPlayOutBoss(UUID id, float pct) {
-        Preconditions.checkNotNull(id, "uuid");
-        this.action = Action.UPDATE_PCT;
-        this.id = id;
-        this.pct = pct;
-    }
-
-    /**
-     * Constructs new instance with given parameters and
-     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.UPDATE_NAME action
-     *
-     * @param    id
-     *             BossBar uuid
-     * @param    name
-     *             BossBar title
-     */
-    public PacketPlayOutBoss(UUID id, String name) {
-        Preconditions.checkNotNull(id, "uuid");
-        Preconditions.checkNotNull(name, "title");
-        this.action = Action.UPDATE_NAME;
-        this.id = id;
-        this.name = name;
-    }
-
-    /**
-     * Constructs new instance with given parameters and
-     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.UPDATE_STYLE action
-     *
-     * @param    id
-     *             BossBar uuid
-     * @param    color
-     *             BossBar color
-     * @param    overlay
-     *             BossBar style
-     */
-    public PacketPlayOutBoss(UUID id, BarColor color, BarStyle overlay) {
-        Preconditions.checkNotNull(id, "uuid");
-        Preconditions.checkNotNull(color, "color");
-        Preconditions.checkNotNull(overlay, "style");
-        this.action = Action.UPDATE_STYLE;
-        this.id = id;
-        this.color = color;
-        this.overlay = overlay;
-    }
-
-    /**
-     * Constructs new instance with given parameters and
-     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.UPDATE_PROPERTIES action
-     *
-     * @param    darkenScreen
-     *             Darken screen flag
-     * @param    playMusic
-     *             Play music flag
-     * @param    createWorldFog
-     *             Create fog flag
-     */
-    public PacketPlayOutBoss(UUID id, boolean darkenScreen, boolean playMusic, boolean createWorldFog) {
-        Preconditions.checkNotNull(id, "uuid");
-        this.action = Action.UPDATE_PROPERTIES;
-        this.id = id;
-        this.darkenScreen = darkenScreen;
-        this.playMusic = playMusic;
-        this.createWorldFog = createWorldFog;
-    }
-
-    /**
-     * Returns bitmask based on {@link #darkenScreen}, {@link #playMusic} and {@link #darkenScreen} values.
-     * <p>
-     * {@link #darkenScreen} adds {@code 1}, {@link #playMusic} {@code 2} and {@link #darkenScreen} {@code 4}
-     * to the final value.
-     *
-     * @return the bitmask
-     */
-    public byte getFlags(){
-        byte value = 0;
-        if (darkenScreen) value += 1;
-        if (playMusic) value += 2;
-        if (createWorldFog) value += 4;
-        return value;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutBoss{id=%s,operation=%s,name=%s,pct=%s,color=%s,overlay=%s,darkenScreen=%s,playMusic=%s,createWorldFog=%s}",
-                id, action, name, pct, color, overlay, darkenScreen, playMusic, createWorldFog);
-    }
-
-    /**
-     * Returns {@link #color}
-     * @return    color
-     */
-    public BarColor getColor() {
-        return color;
-    }
-
-    /**
-     * Returns {@link #overlay}
-     * @return    style
-     */
-    public BarStyle getOverlay() {
-        return overlay;
-    }
-
-    /**
-     * Returns {@link #name}
-     * @return    name
-     */
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * Returns {@link #id}
-     * @return    id
-     */
-    public UUID getId() {
-        return id;
-    }
-
-    /**
-     * Returns {@link #pct}
-     * @return    progress
-     */
-    public float getPct() {
-        return pct;
-    }
-
-    /**
-     * Returns {@link #action}
-     * @return    packet action
-     */
-    public Action getAction() {
-        return action;
-    }
-
-    /**
-     * Returns {@link #darkenScreen}
-     * @return    darkenScreen
-     */
-    public boolean isDarkenScreen() {
-        return darkenScreen;
-    }
-
-    /**
-     * Returns {@link #createWorldFog}
-     * @return    createWorldFog
-     */
-    public boolean isCreateWorldFog() {
-        return createWorldFog;
-    }
-
-    /**
-     * Returns {@link #playMusic}
-     * @return    playMusic
-     */
-    public boolean isPlayMusic() {
-        return playMusic;
-    }
-
-    /**
-     * Sets {@link #darkenScreen} to specified value
-     *
-     * @param    darkenScreen
-     *             Darken screen flag
-     */
-    public void setDarkenScreen(boolean darkenScreen) {
-        this.darkenScreen = darkenScreen;
-    }
-
-    /**
-     * Sets {@link #createWorldFog} to specified value
-     *
-     * @param    createWorldFog
-     *             Create fog flag
-     */
-    public void setCreateWorldFog(boolean createWorldFog) {
-        this.createWorldFog = createWorldFog;
-    }
-
-    /**
-     * Sets {@link #playMusic} to specified value
-     *
-     * @param    playMusic
-     *             Play music flag
-     */
-    public void setPlayMusic(boolean playMusic) {
-        this.playMusic = playMusic;
-    }
-
-    /**
-     * An enum representing all valid boss packet actions.
-     * Calling ordinal() will return action's network ID.
-     */
-    public enum Action {
-
-        ADD,
-        REMOVE,
-        UPDATE_PCT,
-        UPDATE_NAME,
-        UPDATE_STYLE,
-        UPDATE_PROPERTIES
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutChat.java

@@ -1,63 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import me.neznamy.tab.api.chat.IChatBaseComponent;
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutChat implements TabPacket {
-
-    /** Message to be sent */
-    private final IChatBaseComponent message;
-
-    /** Message position */
-    private final ChatMessageType type;
-
-    /**
-     * Constructs new instance with given parameters
-     * 
-     * @param    message
-     *             Chat message to be sent
-     * @param    type
-     *             Message position
-     */
-    public PacketPlayOutChat(IChatBaseComponent message, ChatMessageType type) {
-        Preconditions.checkNotNull(message, "message");
-        Preconditions.checkNotNull(type, "message type");
-        this.message = message;
-        this.type = type;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutChat{message=%s,type=%s}", message, type);
-    }
-
-    /**
-     * Returns {@link #message}
-     * @return    message
-     */
-    public IChatBaseComponent getMessage() {
-        return message;
-    }
-
-    /**
-     * Returns {@link #type}
-     * @return    type
-     */
-    public ChatMessageType getType() {
-        return type;
-    }
-
-    /**
-     * An enum representing positions of a chat message
-     * Calling ordinal() will return type's network ID.
-     */
-    public enum ChatMessageType {
-
-        CHAT,
-        SYSTEM,
-        GAME_INFO
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutPlayerInfo.java

@@ -1,317 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.UUID;
-
-import me.neznamy.tab.api.chat.IChatBaseComponent;
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutPlayerInfo implements TabPacket {
-
-    /** Packet action */
-    private final EnumPlayerInfoAction action;
-
-    /** List of affected entries */
-    private final List<PlayerInfoData> entries;
-
-    /**
-     * Constructs new instance with given parameters.
-     * 
-     * @param    action
-     *             Packet action
-     * @param    entries
-     *             Affected entries
-     */
-    public PacketPlayOutPlayerInfo(EnumPlayerInfoAction action, PlayerInfoData... entries) {
-        Preconditions.checkNotNull(action, "action");
-        Preconditions.checkNotNull(entries, "entries");
-        this.action = action;
-        this.entries = Arrays.asList(entries);
-    }
-
-    /**
-     * Constructs new instance with given parameters.
-     * 
-     * @param    action
-     *             Packet action
-     * @param    entries
-     *             Affected entries
-     */
-    public PacketPlayOutPlayerInfo(EnumPlayerInfoAction action, List<PlayerInfoData> entries) {
-        Preconditions.checkNotNull(action, "action");
-        Preconditions.checkNotNull(entries, "entries");
-        this.action = action;
-        this.entries = entries;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutPlayerInfo{action=%s,entries=%s}", action, entries);
-    }
-
-    /**
-     * Returns {@link #action}
-     * @return    packet action
-     */
-    public EnumPlayerInfoAction getAction() {
-        return action;
-    }
-
-    /**
-     * Returns {@link #entries}
-     * @return    affected entries
-     */
-    public List<PlayerInfoData> getEntries() {
-        return entries;
-    }
-
-    /**
-     * A subclass representing player list entry
-     */
-    public static class PlayerInfoData {
-
-        /** Latency */
-        private int latency;
-
-        /** GameMode */
-        private EnumGamemode gameMode = EnumGamemode.SURVIVAL; //ProtocolLib causes NPE even when action does not use GameMode
-
-        /** 
-         * Display name displayed in TabList. Using {@code null} results in no display name
-         * and scoreboard team prefix/suffix being visible in TabList instead.
-         */
-        private IChatBaseComponent displayName;
-
-        /** Real name of affected player */
-        private String name;
-
-        /** Player UUID */
-        private UUID uniqueId;
-
-        /** Player's skin, null for empty skin */
-        private Skin skin;
-
-        /**
-         * Constructs new instance with given parameters. Suitable for 
-         * {@link EnumPlayerInfoAction}.ADD_PLAYER action
-         * 
-         * @param    name
-         *             Player's name
-         * @param    uniqueId
-         *             Player's uuid
-         * @param    skin
-         *             Player's platform-specific skin object
-         * @param    latency
-         *             Player's ping
-         * @param    gameMode
-         *             Player's GameMode
-         * @param    displayName
-         *             Player's display name
-         */
-        public PlayerInfoData(String name, UUID uniqueId, Skin skin, int latency, EnumGamemode gameMode, IChatBaseComponent displayName) {
-            Preconditions.checkNotNull(uniqueId, "uuid");
-            this.name = name;
-            this.uniqueId = uniqueId;
-            this.skin = skin;
-            this.latency = latency;
-            this.gameMode = gameMode;
-            this.displayName = displayName;
-        }
-
-        /**
-         * Constructs new instance with given parameters. Suitable for 
-         * {@link EnumPlayerInfoAction}.UPDATE_GAME_MODE action
-         * 
-         * @param    uniqueId
-         *             Player's uuid
-         * @param    gameMode
-         *             Player's GameMode
-         */
-        public PlayerInfoData(UUID uniqueId, EnumGamemode gameMode) {
-            Preconditions.checkNotNull(uniqueId, "uuid");
-            this.uniqueId = uniqueId;
-            this.gameMode = gameMode;
-        }
-
-        /**
-         * Constructs new instance with given parameters. Suitable for 
-         * {@link EnumPlayerInfoAction}.UPDATE_LATENCY action
-         * 
-         * @param    uniqueId
-         *             Player's uuid
-         * @param    latency
-         *             Player's ping
-         */
-        public PlayerInfoData(UUID uniqueId, int latency) {
-            Preconditions.checkNotNull(uniqueId, "uuid");
-            this.uniqueId = uniqueId;
-            this.latency = latency;
-        }
-
-        /**
-         * Constructs new instance with given parameters. Suitable for 
-         * {@link EnumPlayerInfoAction}.UPDATE_DISPLAY_NAME action
-         * 
-         * @param    uniqueId
-         *             Player's uuid
-         * @param    displayName
-         *             Player's display name
-         */
-        public PlayerInfoData(UUID uniqueId, IChatBaseComponent displayName) {
-            Preconditions.checkNotNull(uniqueId, "uuid");
-            this.uniqueId = uniqueId;
-            this.displayName = displayName;
-        }
-
-        /**
-         * Constructs new instance with given parameter. Suitable for 
-         * {@link EnumPlayerInfoAction}.REMOVE_PLAYER action
-         * 
-         * @param    uniqueId
-         *             Player's uuid
-         */
-        public PlayerInfoData(UUID uniqueId) {
-            this.uniqueId = uniqueId;
-        }
-
-        @Override
-        public String toString() {
-            return String.format("PlayerInfoData{latency=%s,gameMode=%s,displayName=%s,name=%s,uniqueId=%s,skin=%s}",
-                    latency, gameMode, displayName, name, uniqueId, skin);
-        }
-
-        /**
-         * Returns {@link #latency}
-         * @return    latency
-         */
-        public int getLatency() {
-            return latency;
-        }
-
-        /**
-         * Sets {@link #latency} to specified value
-         * @param    latency
-         *             Latency to use
-         */
-        public void setLatency(int latency) {
-            this.latency = latency;
-        }
-
-        /**
-         * Returns {@link #displayName}
-         * @return    displayName
-         */
-        public IChatBaseComponent getDisplayName() {
-            return displayName;
-        }
-
-        /**
-         * Sets {@link #displayName} to specified value
-         * @param    displayName
-         *             Display name to use
-         */
-        public void setDisplayName(IChatBaseComponent displayName) {
-            this.displayName = displayName;
-        }
-
-        /**
-         * Returns {@link #uniqueId}
-         * @return    uniqueId
-         */
-        public UUID getUniqueId() {
-            return uniqueId;
-        }
-
-        /**
-         * Sets {@link #uniqueId} to specified value
-         * @param    uniqueId
-         *             UUID to use
-         */
-        public void setUniqueId(UUID uniqueId) {
-            this.uniqueId = uniqueId;
-        }
-
-        /**
-         * Returns {@link #name}
-         * @return    name
-         */
-        public String getName() {
-            return name;
-        }
-
-        /**
-         * Sets {@link #name} to specified value
-         * @param    name
-         *             name to use
-         */
-        public void setName(String name) {
-            this.name = name;
-        }
-
-        /**
-         * Returns {@link #gameMode}
-         * @return    gameMode
-         */
-        public EnumGamemode getGameMode() {
-            return gameMode;
-        }
-
-        /**
-         * Sets {@link #gameMode} to specified value
-         * @param    gameMode
-         *             GameMode to use
-         */
-        public void setGameMode(EnumGamemode gameMode) {
-            this.gameMode = gameMode;
-        }
-
-        /**
-         * Returns {@link #skin}
-         * @return    skin
-         */
-        public Skin getSkin() {
-            return skin;
-        }
-
-        /**
-         * Sets {@link #skin} to specified value
-         * @param    skin
-         *             Skin to use
-         */
-        public void setSkin(Skin skin) {
-            this.skin = skin;
-        }
-    }
-
-    /**
-     * En enum representing packet action
-     * Calling ordinal() will return action's network ID.
-     */
-    public enum EnumPlayerInfoAction {
-
-        ADD_PLAYER,
-        UPDATE_GAME_MODE,
-        UPDATE_LATENCY,
-        UPDATE_DISPLAY_NAME,
-        REMOVE_PLAYER
-    }
-
-    /**
-     * An enum representing GameMode
-     */
-    public enum EnumGamemode {
-
-        NOT_SET,
-        SURVIVAL,
-        CREATIVE,
-        ADVENTURE,
-        SPECTATOR;
-
-        /** Value array to iterate over to avoid array creations on each call */
-        public static final EnumGamemode[] VALUES = values();
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutPlayerListHeaderFooter.java

@@ -1,68 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import me.neznamy.tab.api.chat.IChatBaseComponent;
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutPlayerListHeaderFooter implements TabPacket {
-
-    /** TabList header */
-    private final IChatBaseComponent header;
-
-    /** TabList footer */
-    private final IChatBaseComponent footer;
-
-    /**
-     * Constructs new instance with given parameters. They are converted to {@link IChatBaseComponent}
-     * using {@link IChatBaseComponent#optimizedComponent(String)} method.
-     * 
-     * @param    header
-     *             TabList header
-     * @param    footer
-     *             TabList footer
-     */
-    public PacketPlayOutPlayerListHeaderFooter(String header, String footer) {
-        Preconditions.checkNotNull(header, "header");
-        Preconditions.checkNotNull(footer, "footer");
-        this.header = IChatBaseComponent.optimizedComponent(header);
-        this.footer = IChatBaseComponent.optimizedComponent(footer);
-    }
-
-    /**
-     * Constructs new instance with given parameters.
-     * 
-     * @param    header
-     *             TabList header
-     * @param    footer
-     *             TabList footer
-     */
-    public PacketPlayOutPlayerListHeaderFooter(IChatBaseComponent header, IChatBaseComponent footer) {
-        Preconditions.checkNotNull(header, "header");
-        Preconditions.checkNotNull(footer, "footer");
-        this.header = header;
-        this.footer = footer;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutPlayerListHeaderFooter{header=%s,footer=%s}", header, footer);
-    }
-
-    /**
-     * Returns {@link #header}
-     * @return    header
-     */
-    public IChatBaseComponent getHeader() {
-        return header;
-    }
-
-    /**
-     * Returns {@link #footer}
-     * @return    footer
-     */
-    public IChatBaseComponent getFooter() {
-        return footer;
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutScoreboardDisplayObjective.java

@@ -1,57 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutScoreboardDisplayObjective implements TabPacket {
-
-    /**
-     * Display slot.
-     * 0 = PlayerList,
-     * 1 = SideBar,
-     * 2 = BelowName.
-     */
-    private final int slot;
-
-    /** Up to 16 characters long objective name */
-    private final String objectiveName;
-
-    /**
-     * Constructs new instance with given parameters
-     * @param    slot
-     *             Display slot
-     * @param    objectiveName
-     *             Internal name of the objective
-     * @throws    IllegalArgumentException
-     *             if {@code objectiveName} is null or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardDisplayObjective(int slot, String objectiveName) {
-        Preconditions.checkNotNull(objectiveName, "objective name");
-        Preconditions.checkMaxLength(objectiveName, 16, "objective name");
-        this.slot = slot;
-        this.objectiveName = objectiveName;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutScoreboardDisplayObjective{slot=%s,objectiveName=%s}", slot, objectiveName);
-    }
-
-    /**
-     * Returns {@link #slot}
-     * @return    slot
-     */
-    public int getSlot() {
-        return slot;
-    }
-
-    /**
-     * Returns {@link #objectiveName}
-     * @return    objectiveName
-     */
-    public String getObjectiveName() {
-        return objectiveName;
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutScoreboardObjective.java

@@ -1,113 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutScoreboardObjective implements TabPacket {
-
-    /** Up to 16 characters long objective name */
-    private final String objectiveName;
-
-    /** Display name */
-    private final String displayName;
-
-    /** Display type, only takes effect in PlayerList */
-    private final EnumScoreboardHealthDisplay renderType;
-
-    /**
-     * Packet action.
-     * 0 = register,
-     * 1 = unregister,
-     * 2 = update title
-     */
-    private final int action;
-
-    /**
-     * Constructs new instance with given parameters.
-     *
-     * @param    action
-     *             Packet action (0 = add, 1 = remove, 2 = update title)
-     * @param    objectiveName
-     *             objective name, up to 16 characters long
-     * @param displayName - title
-     * @param renderType - display type
-     * @throws    IllegalArgumentException
-     *             if {@code objectiveName} is null or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardObjective(int action, String objectiveName, String displayName, EnumScoreboardHealthDisplay renderType) {
-        Preconditions.checkRange(action, 0, 2, "action");
-        Preconditions.checkNotNull(objectiveName, "objective name");
-        Preconditions.checkMaxLength(objectiveName, 16, "objective name");
-        Preconditions.checkNotNull(renderType, "render type");
-        this.objectiveName = objectiveName;
-        this.displayName = displayName;
-        this.renderType = renderType;
-        this.action = action;
-    }
-
-    /**
-     * Constructs new packet with given objective name and 1 (unregister) action.
-     *
-     * @param    objectiveName
-     *             objective name, up to 16 characters long
-     * @throws    IllegalArgumentException
-     *             if {@code objectiveName} is null or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardObjective(String objectiveName) {
-        Preconditions.checkNotNull(objectiveName, "objective name");
-        Preconditions.checkMaxLength(objectiveName, 16, "objective name");
-        this.objectiveName = objectiveName;
-        this.displayName = ""; //avoiding NPE on <1.7
-        this.action = 1;
-        this.renderType = null;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutScoreboardObjective{objectiveName=%s,displayName=%s,renderType=%s,method=%s}",
-                objectiveName, displayName, renderType, action);
-    }
-
-    /**
-     * Returns {@link #displayName}
-     * @return    displayName
-     */
-    public String getDisplayName() {
-        return displayName;
-    }
-
-    /**
-     * Returns {@link #objectiveName}
-     * @return    objectiveName
-     */
-    public String getObjectiveName() {
-        return objectiveName;
-    }
-
-    /**
-     * Returns {@link #renderType}
-     * @return    renderType
-     */
-    public EnumScoreboardHealthDisplay getRenderType() {
-        return renderType;
-    }
-
-    /**
-     * Returns {@link #action}
-     * @return    packet action
-     */
-    public int getAction() {
-        return action;
-    }
-
-    /**
-     * An enum representing available display types.
-     * They only take effect in PlayerList position.
-     */
-    public enum EnumScoreboardHealthDisplay {
-
-        INTEGER, HEARTS
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutScoreboardScore.java

@@ -1,93 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutScoreboardScore implements TabPacket {
-
-    /** Packet action */
-    private final Action action;
-
-    /** Objective name */
-    private final String objectiveName;
-
-    /** Affected player */
-    private final String player;
-
-    /** Player's score */
-    private final int score;
-
-    /**
-     * Constructs new instance with given parameters
-     *
-     * @param    action
-     *             Packet action
-     * @param    objectiveName
-     *             Objective name
-     * @param    player
-     *             Affected player
-     * @param    score
-     *             Player's score
-     * @throws    IllegalArgumentException
-     *             if {@code objectiveName} is null or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardScore(Action action, String objectiveName, String player, int score) {
-        Preconditions.checkNotNull(action, "action");
-        Preconditions.checkNotNull(objectiveName, "objective name");
-        Preconditions.checkMaxLength(objectiveName, 16, "objective name");
-        Preconditions.checkNotNull(player, "player");
-        this.action = action;
-        this.objectiveName = objectiveName;
-        this.player = player;
-        this.score = score;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutScoreboardScore{action=%s,objectiveName=%s,player=%s,score=%s}",
-                action, objectiveName, player, score);
-    }
-
-    /**
-     * Returns {@link #action}
-     * @return    packet action
-     */
-    public Action getAction() {
-        return action;
-    }
-
-    /**
-     * Returns {@link #objectiveName}
-     * @return    objective name
-     */
-    public String getObjectiveName() {
-        return objectiveName;
-    }
-
-    /**
-     * Returns {@link #player}
-     * @return    player
-     */
-    public String getPlayer() {
-        return player;
-    }
-
-    /**
-     * Returns {@link #score}
-     * @return    score
-     */
-    public int getScore() {
-        return score;
-    }
-
-    /**
-     * An enum representing action types
-     */
-    public enum Action {
-
-        CHANGE,
-        REMOVE
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/PacketPlayOutScoreboardTeam.java

@@ -1,276 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import java.util.Collection;
-import java.util.Collections;
-
-import me.neznamy.tab.api.chat.EnumChatFormat;
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * A class representing platform specific packet class
- */
-public class PacketPlayOutScoreboardTeam implements TabPacket {
-
-    /**
-     * Up to 16 characters long team name.
-     * It is used to sort players alphabetically in TabList by team names.
-     * Team-less players appear on top, sorted by usernames.
-     * Players with teams are below them, players of the same team are
-     * sorted alphabetically by usernames.
-     */
-    private final String name;
-
-    /** Team prefix, limited to 16 characters, on <1.13 */
-    private String playerPrefix;
-
-    /** Team suffix, limited to 16 characters, on <1.13 */
-    private String playerSuffix;
-
-    /** 
-     * NameTag visibility rule since 1.8. Possible options are:
-     * {@code always}, {@code hideForOtherTeams}, {@code hideForOwnTeam}, {@code never}
-     */
-    private String nameTagVisibility;
-
-    /**
-     * Collision rule added in 1.9. Possible options are:
-     * {@code always}, {@code pushOtherTeams}, {@code pushOwnTeam}, {@code never}
-     */
-    private String collisionRule;
-
-    /**
-     * Team color field added in 1.13. It determines name color,
-     * prefix and suffix color start.
-     */
-    private EnumChatFormat color;
-
-    /** 
-     * Affected entities. For players, it is their name, for other entities their UUID
-     * Player name length is limited to 16 characters for <1.8, 40 characters since 1.8.
-     * Entity UUID option was added in 1.8.
-     */
-    private Collection<String> players = Collections.emptyList();
-
-    /**
-     * Packet action.
-     * 0 = create team,
-     * 1 = remove team,
-     * 2 = update team info,
-     * 3 = add entries,
-     * 4 = remove entries
-     */
-    private final int action;
-
-    /**
-     * Bit mask.
-     * 0x01: Allow friendly fire,
-     * 0x02: Can see invisible players on the same team.
-     */
-    private int options;
-
-    /**
-     * Constructs new instance with given parameters. Private constructor used
-     * internally to validate team name and set action.
-     * 
-     * @param    action
-     *             Packet action (0 = create team, 1 = remove team, 2 = update team info,
-     *             3 = add entries, 4 = remove entries)
-     * @param    name
-     *             Team name, up to 16 characters long
-     * @throws    IllegalArgumentException
-     *             if {@code name} is null, empty or longer than 16 characters
-     */
-    private PacketPlayOutScoreboardTeam(int action, String name) {
-        Preconditions.checkNotNull(name, "team name");
-        Preconditions.checkMaxLength(name, 16, "team name");
-        this.action = action;
-        this.name = name;
-    }
-
-    /**
-     * Constructs new instance with given parameters and 0 (CREATE) action
-     * 
-     * @param    team
-     *             Team name, up to 16 characters long
-     * @param    prefix
-     *             Prefix of players in team
-     * @param    suffix
-     *             Suffix of players in team
-     * @param    visibility
-     *             NameTag visibility rule
-     * @param    collision
-     *             Collision rule
-     * @param    players
-     *             Affected entities
-     * @param    options
-     *             bitmask of team options
-     * @throws    IllegalArgumentException
-     *             if {@code name} is null, empty or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardTeam(String team, String prefix, String suffix, String visibility, String collision, Collection<String> players, int options) {
-        this(0, team);
-        Preconditions.checkNotNull(prefix, "prefix");
-        Preconditions.checkNotNull(suffix, "suffix");
-        Preconditions.checkNotNull(visibility, "visibility");
-        Preconditions.checkNotNull(collision, "collision");
-        Preconditions.checkNotNull(players, "players");
-        this.playerPrefix = prefix;
-        this.playerSuffix = suffix;
-        this.nameTagVisibility = visibility;
-        this.collisionRule = collision;
-        this.players = players;
-        this.options = options;
-    }
-
-    /**
-     * Constructs new instance with given parameters and 1 (REMOVE) action
-     * 
-     * @param    team
-     *             Team name, up to 16 characters long
-     * @throws    IllegalArgumentException
-     *             if {@code name} is null, empty or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardTeam(String team) {
-        this(1, team);
-    }
-
-    /**
-     * Constructs new instance with given parameters and 2 (UPDATE_TEAM_INFO) action
-     * 
-     * @param    team
-     *             Team name, up to 16 characters long
-     * @param    prefix
-     *             Prefix of players in team
-     * @param    suffix
-     *             Suffix of players in team
-     * @param    visibility
-     *             NameTag visibility rule
-     * @param    collision
-     *             Collision rule
-     * @param    options
-     *             bitmask of team options
-     * @throws    IllegalArgumentException
-     *             if {@code name} is null, empty or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardTeam(String team, String prefix, String suffix, String visibility, String collision, int options) {
-        this(2, team);
-        Preconditions.checkNotNull(prefix, "prefix");
-        Preconditions.checkNotNull(suffix, "suffix");
-        Preconditions.checkNotNull(visibility, "visibility");
-        Preconditions.checkNotNull(collision, "collision");
-        Preconditions.checkNotNull(players, "players");
-        this.playerPrefix = prefix;
-        this.playerSuffix = suffix;
-        this.nameTagVisibility = visibility;
-        this.collisionRule = collision;
-        this.options = options;
-    }
-
-    /**
-     * Constructs new instance with given parameters and 3 (ADD_PLAYERS) if {@code add} is {@code true}, 
-     * 4 (REMOVE_PLAYERS) if {@code add} is {@code false} action.
-     * 
-     * @param    team
-     *             Team name, up to 16 characters long
-     * @param    players
-     *             Affected entities
-     * @param    add
-     *             {@code true} if players should be added, {@code false} if removed from team
-     * @throws    IllegalArgumentException
-     *             if {@code name} is null, empty or longer than 16 characters
-     */
-    public PacketPlayOutScoreboardTeam(String team, Collection<String> players, boolean add) {
-        this(add ? 3 : 4, team);
-        Preconditions.checkNotNull(players, "players");
-        this.players = players;
-    }
-
-    @Override
-    public String toString() {
-        return String.format("PacketPlayOutScoreboardTeam{name=%s,playerPrefix=%s,playerSuffix=%s,nameTagVisibility=%s,"
-                + "collisionRule=%s,color=%s,players=%s,method=%s,options=%s}",
-                name, playerPrefix, playerSuffix, nameTagVisibility, collisionRule, color, players, action, options);
-    }
-
-    /**
-     * Returns {@link #name}
-     * @return    team name
-     */
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * Returns {@link #playerPrefix}
-     * @return    playerPrefix
-     */
-    public String getPlayerPrefix() {
-        return playerPrefix;
-    }
-
-    /**
-     * Returns {@link #playerSuffix}
-     * @return    playerSuffix
-     */
-    public String getPlayerSuffix() {
-        return playerSuffix;
-    }
-
-    /**
-     * Returns {@link #nameTagVisibility}
-     * @return    nameTagVisibility
-     */
-    public String getNameTagVisibility() {
-        return nameTagVisibility;
-    }
-    
-    /**
-     * Returns {@link #collisionRule}
-     * @return    collisionRule
-     */
-    public String getCollisionRule() {
-        return collisionRule;
-    }
-
-    /**
-     * Sets {@link #color} to specified color
-     * 
-     * @param    color
-     *             color to use
-     */
-    public void setColor(EnumChatFormat color) {
-        this.color = color;
-    }
-
-    /**
-     * Returns {@link #color}
-     * @return    color
-     */
-    public EnumChatFormat getColor() {
-        return color;
-    }
-
-    /**
-     * Returns {@link #players}
-     * @return    players
-     */
-    public Collection<String> getPlayers() {
-        return players;
-    }
-
-    /**
-     * Returns {@link #options}
-     * @return    team options
-     */
-    public int getOptions() {
-        return options;
-    }
-    
-    /**
-     * Returns {@link #action}
-     * @return    packet action
-     */
-    public int getAction() {
-        return action;
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/Skin.java

@@ -1,54 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-import me.neznamy.tab.api.util.Preconditions;
-
-/**
- * Class representing a minecraft skin as a value - signature pair.
- */
-public class Skin {
-
-    /** Skin value */
-    private final String value;
-
-    /** Skin signature */
-    private final String signature;
-
-    /**
-     * Constructs new instance with given parameters
-     * @param   value
-     *          skin value
-     * @param   signature
-     *          skin signature
-     */
-    public Skin(String value, String signature) {
-        Preconditions.checkNotNull(value, "value");
-        Preconditions.checkNotNull(signature, "signature");
-        this.value = value;
-        this.signature = signature;
-    }
-
-    /**
-     * Returns skin value
-     * @return  skin value
-     */
-    public String getValue() {
-        return value;
-    }
-
-    /**
-     * Returns skin signature
-     * @return  skin signature
-     */
-    public String getSignature() {
-        return signature;
-    }
-
-    /**
-     * Returns user-friendly representation of this object
-     * @return  user-friendly representation of this object
-     */
-    @Override
-    public String toString() {
-        return String.format("Skin{value=%s,signature=%s}", value, signature);
-    }
-}

api/src/main/java/me/neznamy/tab/api/protocol/TabPacket.java

@@ -1,16 +0,0 @@
-package me.neznamy.tab.api.protocol;
-
-/**
- * Interface representing a packet that can be sent to client independently of platform.
- * It is technically empty, existence is only present to restrict type access
- * when sending packets to player, so {@link me.neznamy.tab.api.TabPlayer#sendCustomPacket(TabPacket)} cannot
- * be called with an actual packet.
- */
-public interface TabPacket {
-
-    /**
-     * Returns user-friendly string representation of the packet
-     * @return user-friendly string representation of the packet
-     */
-    String toString();
-}

api/src/main/java/me/neznamy/tab/api/scoreboard/Line.java

@@ -11,7 +11,7 @@ public interface Line {
      * Returns configured raw text of this line. Placeholders
      * remain in raw format.
      * 
-     * @return    raw text of this line
+     * @return  raw text of this line
      */
     String getText();
     
@@ -22,8 +22,8 @@ public interface Line {
      * keep placeholders up to date. If value is identical to previous 
      * one, nothing happens.
      * 
-     * @param    text
-     *             Raw text to display in the line
+     * @param   text
+     *          Raw text to display in the line
      */
     void setText(String text);
 }

api/src/main/java/me/neznamy/tab/api/scoreboard/Scoreboard.java

@@ -15,7 +15,7 @@ public interface Scoreboard {
      * scoreboards from config use name they were defined with. This value is
      * used internally and in /tab announce scoreboard command.
      * 
-     * @return    custom name of this scoreboard
+     * @return  custom name of this scoreboard
      */
     String getName();
 
@@ -23,8 +23,8 @@ public interface Scoreboard {
      * Returns raw title of this scoreboard. Placeholders stay in their
      * raw format.
      * 
-     * @return    scoreboard title
-     * @see        #setTitle(String)
+     * @return  scoreboard title
+     * @see     #setTitle(String)
      */
     String getTitle();
 
@@ -39,9 +39,9 @@ public interface Scoreboard {
      * <p>
      * Calling this method with same title as before will not do anything.
      * 
-     * @param    title
-     *             New title to use with placeholder support
-     * @see        #getTitle()
+     * @param   title
+     *          New title to use with placeholder support
+     * @see     #getTitle()
      */
     void setTitle(String title);
 
@@ -50,9 +50,9 @@ public interface Scoreboard {
      * in game (first line is on top). This list should only be used for reading,
      * for adding/removing lines see {@link #addLine(String)} and {@link #removeLine(int)}.
      * 
-     * @return    list of lines in this scoreboard
-     * @see        #addLine(String)
-     * @see        #removeLine(int)
+     * @return  list of lines in this scoreboard
+     * @see     #addLine(String)
+     * @see     #removeLine(int)
      */
     List<Line> getLines();
 
@@ -60,10 +60,10 @@ public interface Scoreboard {
      * Adds line with specified text on the bottom of scoreboard. Supports
      * placeholders, which will automatically be refreshed.
      * 
-     * @param    text
-     *             Text to display
-     * @see        #getLines()
-     * @see        #removeLine(int)
+     * @param   text
+     *          Text to display
+     * @see     #getLines()
+     * @see     #removeLine(int)
      */
     void addLine(String text);
 
@@ -71,12 +71,12 @@ public interface Scoreboard {
      * Removes line with specified index. Index starts at {@code 0} and ends at 
      * {@link #getLines()}.size()-1.
      * 
-     * @param    index
-     *             Index of line to remove, starting at 0
-     * @throws    IndexOutOfBoundsException
-     *             if the index is out of range (index &lt; 0 || index >= {@link #getLines()}.size())
-     * @see        #getLines()
-     * @see        #addLine(String)
+     * @param   index
+     *          Index of line to remove, starting at 0
+     * @throws  IndexOutOfBoundsException
+     *          if the index is out of range (index &lt; 0 || index &gt;= {@link #getLines()}.size())
+     * @see     #getLines()
+     * @see     #addLine(String)
      */
     void removeLine(int index);
 

api/src/main/java/me/neznamy/tab/api/scoreboard/ScoreboardManager.java

@@ -29,15 +29,15 @@ public interface ScoreboardManager {
      * Client can only see up to 15 lines at a time, however you can define
      * more, if some of them only consist of placeholder that might be empty.
      * 
-     * @param    name
-     *             Internal name of the scoreboard
-     * @param    title
-     *             The scoreboard title
-     * @param    lines
-     *             Lines of text in scoreboard (supports placeholders)
-     * @return    The new scoreboard with given parameters
-     * @throws    NullPointerException
-     *             if {@code name} or {@code lines} is {@code null}
+     * @param   name
+     *          Internal name of the scoreboard
+     * @param   title
+     *          The scoreboard title
+     * @param   lines
+     *          Lines of text in scoreboard (supports placeholders)
+     * @return  The new scoreboard with given parameters
+     * @throws  NullPointerException
+     *          if {@code name} or {@code lines} is {@code null}
      */
     Scoreboard createScoreboard(String name, String title, List<String> lines);
     
@@ -47,7 +47,7 @@ public interface ScoreboardManager {
      * or using {@link #createScoreboard(String, String, List)}.
      * Map value is reference to the actual scoreboard.
      * 
-     * @return    map of registered scoreboards
+     * @return  map of registered scoreboards
      */
     Map<String, Scoreboard> getRegisteredScoreboards();
     
@@ -57,14 +57,14 @@ public interface ScoreboardManager {
      * {@link #resetScoreboard(TabPlayer)}. If the player already sees
      * this scoreboard, nothing will happen.
      * 
-     * @param    player
-     *             Player to send scoreboard to
-     * @param    scoreboard
-     *             Scoreboard to display
-     * @throws    NullPointerException
-     *             if {@code player} or {@code scoreboard} is {@code null}
-     * @see        #hasCustomScoreboard(TabPlayer)
-     * @see        #resetScoreboard(TabPlayer)
+     * @param   player
+     *          Player to send scoreboard to
+     * @param   scoreboard
+     *          Scoreboard to display
+     * @throws  NullPointerException
+     *          if {@code player} or {@code scoreboard} is {@code null}
+     * @see     #hasCustomScoreboard(TabPlayer)
+     * @see     #resetScoreboard(TabPlayer)
      */
     void showScoreboard(TabPlayer player, Scoreboard scoreboard);
     
@@ -72,12 +72,12 @@ public interface ScoreboardManager {
      * Returns {@code true} if player has custom scoreboard set using
      * {@link #showScoreboard(TabPlayer, Scoreboard)}, {@code false} if not.
      * 
-     * @param    player
-     *             Player to check
-     * @return    {@code true} if player has custom scoreboard set using API, 
-     *             {@code false} if not
-     * @see        #showScoreboard(TabPlayer, Scoreboard)
-     * @see        #resetScoreboard(TabPlayer)
+     * @param   player
+     *          Player to check
+     * @return  {@code true} if player has custom scoreboard set using API,
+     *          {@code false} if not
+     * @see      #showScoreboard(TabPlayer, Scoreboard)
+     * @see     #resetScoreboard(TabPlayer)
      */
     boolean hasCustomScoreboard(TabPlayer player);
     
@@ -86,10 +86,10 @@ public interface ScoreboardManager {
      * and re-enables internal display logic with conditions. If player does not
      * have any forced scoreboard, nothing happens.
      * 
-     * @param    player
-     *             Player to hide custom scoreboard from
-     * @see        #showScoreboard(TabPlayer, Scoreboard)
-     * @see        #hasCustomScoreboard(TabPlayer)
+     * @param   player
+     *          Player to hide custom scoreboard from
+     * @see     #showScoreboard(TabPlayer, Scoreboard)
+     * @see     #hasCustomScoreboard(TabPlayer)
      */
     void resetScoreboard(TabPlayer player);
     
@@ -99,11 +99,11 @@ public interface ScoreboardManager {
      * {@link #toggleScoreboard(TabPlayer, boolean)} or
      * {@link #setScoreboardVisible(TabPlayer, boolean, boolean)}.
      * 
-     * @param    player
-     *             Player to get visibility status of
-     * @return    {@code true} if visible, {@code false} if disabled
-     * @see        #setScoreboardVisible(TabPlayer, boolean, boolean)
-     * @see        #toggleScoreboard(TabPlayer, boolean)
+     * @param   player
+     *          Player to get visibility status of
+     * @return  {@code true} if visible, {@code false} if disabled
+     * @see     #setScoreboardVisible(TabPlayer, boolean, boolean)
+     * @see     #toggleScoreboard(TabPlayer, boolean)
      */
     boolean hasScoreboardVisible(TabPlayer player);
     
@@ -113,14 +113,14 @@ public interface ScoreboardManager {
      * visibility, scoreboard is toggled. If {@code sendToggleMessage} is {@code true},
      * toggle message defined in configuration is sent.
      * 
-     * @param    player
-     *             Player to set visibility for
-     * @param    visible
-     *             New visibility status
-     * @param    sendToggleMessage
-     *             whether to send toggle message if status changed or not
-     * @see        #toggleScoreboard(TabPlayer, boolean)
-     * @see        #hasScoreboardVisible(TabPlayer)
+     * @param   player
+     *          Player to set visibility for
+     * @param   visible
+     *          New visibility status
+     * @param   sendToggleMessage
+     *          whether to send toggle message if status changed or not
+     * @see     #toggleScoreboard(TabPlayer, boolean)
+     * @see     #hasScoreboardVisible(TabPlayer)
      */
     void setScoreboardVisible(TabPlayer player, boolean visible, boolean sendToggleMessage);
     
@@ -129,12 +129,12 @@ public interface ScoreboardManager {
      * hides it. If hidden, shows it. If {@code sendToggleMessage} is {@code true},
      * toggle message defined in configuration is sent.
      * 
-     * @param    player
-     *             Player to toggle scoreboard for
-     * @param    sendToggleMessage
-     *             Whether to send toggle message or not
-     * @see        #hasScoreboardVisible(TabPlayer)
-     * @see        #setScoreboardVisible(TabPlayer, boolean, boolean)
+     * @param   player
+     *          Player to toggle scoreboard for
+     * @param   sendToggleMessage
+     *          Whether to send toggle message or not
+     * @see     #hasScoreboardVisible(TabPlayer)
+     * @see     #setScoreboardVisible(TabPlayer, boolean, boolean)
      */
     void toggleScoreboard(TabPlayer player, boolean sendToggleMessage);
     
@@ -143,13 +143,13 @@ public interface ScoreboardManager {
      * time (in milliseconds). Scoreboard name is either defined in config, or 
      * through API in {@link #createScoreboard(String, String, List)}.
      * 
-     * @param    scoreboard
-     *             Scoreboard from config or registered via API
-     * @param    duration
-     *             Duration in milliseconds
-     * @throws    IllegalArgumentException
-     *             if no scoreboard was found with such name or {@code duration}
-     *             is &lt; 0.
+     * @param   scoreboard
+     *          Scoreboard from config or registered via API
+     * @param   duration
+     *          Duration in milliseconds
+     * @throws  IllegalArgumentException
+     *          if no scoreboard was found with such name or {@code duration}
+     *          is &lt; 0.
      */
     void announceScoreboard(String scoreboard, int duration);
 
@@ -157,9 +157,10 @@ public interface ScoreboardManager {
      * Returns player's currently displayed scoreboard. This can be either with
      * configuration, overridden with commands or the API. Will return {@code null}
      * if player does not see any scoreboard due to not meeting any display condition.
-     * @param    player
-     *             player to get active scoreboard of
-     * @return    player's active scoreboard or {@code null} if player has no scoreboard
+     *
+     * @param   player
+     *          player to get active scoreboard of
+     * @return  player's active scoreboard or {@code null} if player has no scoreboard
      */
     Scoreboard getActiveScoreboard(TabPlayer player);
 }

api/src/main/java/me/neznamy/tab/api/tablist/Skin.java

@@ -0,0 +1,19 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Class representing a minecraft skin as a value - signature pair.
+ */
+@Data @AllArgsConstructor
+public class Skin {
+
+    /** Skin value */
+    @NonNull private final String value;
+
+    /** Skin signature */
+    @Nullable private final String signature;
+}

api/src/main/java/me/neznamy/tab/api/tablist/TabList.java

@@ -0,0 +1,34 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.UUID;
+
+public interface TabList {
+
+    String TEXTURES_PROPERTY = "textures";
+
+    void removeEntry(@NonNull UUID entry);
+
+    void removeEntries(@NonNull Collection<UUID> entries);
+
+    void updateDisplayName(@NonNull UUID entry, @Nullable IChatBaseComponent displayName);
+
+    void updateDisplayNames(@NonNull Map<UUID, IChatBaseComponent> entries);
+
+    void updateLatency(@NonNull UUID entry, int latency);
+
+    void updateLatencies(@NonNull Map<UUID, Integer> entries);
+
+    void updateGameMode(@NonNull UUID entry, int gameMode);
+
+    void updateGameModes(@NonNull Map<UUID, Integer> entries);
+
+    void addEntry(@NonNull TabListEntry entry);
+
+    void addEntries(@NonNull Collection<TabListEntry> entries);
+}

api/src/main/java/me/neznamy/tab/api/tablist/TabListEntry.java

@@ -0,0 +1,70 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+/**
+ * A subclass representing player list entry
+ */
+@Data
+@AllArgsConstructor
+public class TabListEntry {
+
+    /** Player UUID */
+    @NonNull private UUID uniqueId;
+
+    /** Real name of affected player */
+    @Nullable private String name;
+
+    /** Player's skin, null for empty skin */
+    @Nullable private Skin skin;
+
+    /** If player should appear in tablist or not */
+    private boolean listed;
+
+    /** Latency */
+    private int latency;
+
+    /** GameMode */
+    private int gameMode;
+
+    /**
+     * Display name displayed in TabList. Using {@code null} results in no display name
+     * and scoreboard team prefix/suffix being visible in TabList instead.
+     */
+    @Nullable private IChatBaseComponent displayName;
+
+    /** Player's chat signing key (1.19+), remote chat session (1.19.3+) */
+    @Nullable private Object chatSession;
+
+    @RequiredArgsConstructor
+    public static class Builder {
+
+        @NonNull private UUID uniqueId;
+        @Nullable private String name;
+        @Nullable private Skin skin;
+        private boolean listed;
+        private int latency;
+        private int gameMode;
+        @Nullable private IChatBaseComponent displayName;
+        @Nullable private Object chatSession;
+
+        public Builder name(String name) { this.name = name; return this; }
+        public Builder skin(Skin skin) { this.skin = skin; return this; }
+        public Builder listed(boolean listed) { this.listed = listed; return this; }
+        public Builder latency(int latency) { this.latency = latency; return this; }
+        public Builder gameMode(int gameMode) { this.gameMode = gameMode; return this; }
+        public Builder displayName(IChatBaseComponent displayName) { this.displayName = displayName; return this; }
+        public Builder chatSession(Object chatSession) { this.chatSession = chatSession; return this; }
+
+        public TabListEntry build() {
+            return new TabListEntry(uniqueId, name, skin, listed, latency, gameMode, displayName, chatSession);
+        }
+    }
+}

api/src/main/java/me/neznamy/tab/api/task/RepeatingTask.java

@@ -1,10 +0,0 @@
-package me.neznamy.tab.api.task;
-
-public interface RepeatingTask {
-    
-    int getInterval();
-
-    void setInterval(int paramInt);
-
-    void cancel();
-}

api/src/main/java/me/neznamy/tab/api/task/ThreadManager.java

@@ -1,53 +0,0 @@
-package me.neznamy.tab.api.task;
-
-import java.util.concurrent.Future;
-
-import me.neznamy.tab.api.TabFeature;
-
-public interface ThreadManager {
-
-    /**
-     * Starts a task in new thread and measures how long it took to process
-     * @param feature - feature to add cpu usage to
-     * @param type - usage type to add cpu usage to
-     * @param task - the task
-     */
-    Future<Void> runMeasuredTask(TabFeature feature, String type, Runnable task);
-
-    /**
-     * Starts a task in new thread and measures how long it took to process
-     * @param feature - feature to add cpu usage to
-     * @param type - usage type to add cpu usage to
-     * @param task - the task
-     */
-    Future<Void> runMeasuredTask(String feature, String type, Runnable task);
-
-    /**
-     * Runs task in a new thread
-     * @param task - the task
-     */
-    Future<Void> runTask(Runnable task);
-
-    /**
-     * Starts a new task with defined repeat interval that measures cpu usage
-     * @param intervalMilliseconds - task interval
-     * @param feature - feature to add cpu usage to
-     * @param type - usage type to add cpu usage to
-     * @param task - the task
-     */
-    RepeatingTask startRepeatingMeasuredTask(int intervalMilliseconds, TabFeature feature, String type, Runnable task);
-
-    RepeatingTask startRepeatingTask(int intervalMilliseconds, Runnable task);
-
-    /**
-     * Runs task with a delay and measures how long it took to process
-     * @param delayMilliseconds - how long to run the task after
-     * @param feature - feature to add cpu usage to
-     * @param type - usage type to add cpu usage to
-     * @param task - the task
-     * @return future allowing to cancel the task
-     */
-    Future<?> runTaskLater(int delayMilliseconds, TabFeature feature, String type, Runnable task);
-
-    Future<?> runTaskLater(int delayMilliseconds, Runnable task);
-}

api/src/main/java/me/neznamy/tab/api/team/TeamManager.java

@@ -1,136 +1,184 @@
 package me.neznamy.tab.api.team;
 
+import lombok.NonNull;
 import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
 
 public interface TeamManager {
 
     /**
      * Makes player's NameTag globally invisible
-     * @see #showNametag(TabPlayer)
-     * @see #hasHiddenNametag(TabPlayer)
+     *
+     * @param   player
+     *          player to hide nametag of
+     * @see     #showNametag(TabPlayer)
+     * @see     #hasHiddenNametag(TabPlayer)
      */
-    void hideNametag(TabPlayer player);
+    void hideNametag(@NonNull TabPlayer player);
 
     /**
      * Hides player's NameTag for specified player until it's shown again
-     * @param viewer - player to hide NameTag for
+     *
+     * @param   player
+     *          player to hide nametag of
+     * @param   viewer
+     *          player to hide NameTag for
      */
-    void hideNametag(TabPlayer player, TabPlayer viewer);
+    void hideNametag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
 
     /**
      * Makes player's NameTag visible again
-     * @see #hideNametag(TabPlayer)
-     * @see #hasHiddenNametag(TabPlayer)
+     *
+     * @param   player
+     *          player to show nametag of
+     * @see     #hideNametag(TabPlayer)
+     * @see     #hasHiddenNametag(TabPlayer)
      */
-    void showNametag(TabPlayer player);
+    void showNametag(@NonNull TabPlayer player);
 
     /**
      * Shows player's NameTag for specified viewer if it was hidden before
-     * @param viewer - player to show NameTag back for
+     *
+     * @param   player
+     *          player to show nametag of
+     * @param   viewer
+     *          player to show NameTag back for
      */
-    void showNametag(TabPlayer player, TabPlayer viewer);
+    void showNametag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
 
     /**
      * Return whether player has hidden NameTag or not
-     * @return Whether player has hidden NameTag or not
-     * @see #hideNametag(TabPlayer)
-     * @see #showNametag(TabPlayer)
+     *
+     * @param   player
+     *          player to check nametag visibility status of
+     * @return  Whether player has hidden NameTag or not
+     * @see     #hideNametag(TabPlayer)
+     * @see     #showNametag(TabPlayer)
      */
-    boolean hasHiddenNametag(TabPlayer player);
+    boolean hasHiddenNametag(@NonNull TabPlayer player);
 
     /**
      * Returns true if NameTag is hidden for specified viewer, false if not
-     * @param viewer - player to check visibility status for
-     * @return true if hidden, false if not
+     *
+     * @param   player
+     *          player to check visibility status of
+     * @param   viewer
+     *          player to check visibility status for
+     * @return  true if hidden, false if not
      */
-    boolean hasHiddenNametag(TabPlayer player, TabPlayer viewer);
+    boolean hasHiddenNametag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
 
     /**
      * Unregisters player's team and no longer handles it, as well as disables anti-override for teams.
      * This can be resumed using resumeTeamHandling(). If team handling was paused already, nothing happens.
+     *
+     * @param   player
+     *          player to pause team handling of
      */
-    void pauseTeamHandling(TabPlayer player);
+    void pauseTeamHandling(@NonNull TabPlayer player);
 
     /**
      * Resumes team handling if it was before paused using pauseTeamHandling(), if not, nothing happens
+     *
+     * @param   player
+     *          player to resume team handling of
      */
-    void resumeTeamHandling(TabPlayer player);
+    void resumeTeamHandling(@NonNull TabPlayer player);
 
     /**
      * Returns true if team handling is paused for this player using pauseTeamHandling(), false if not, or
      * it was resumed already using resumeTeamHandling
-     * @return true if paused, false if not
+     *
+     * @param   player
+     *          player to check handling status of
+     * @return  true if paused, false if not
      */
-    boolean hasTeamHandlingPaused(TabPlayer player);
+    boolean hasTeamHandlingPaused(@NonNull TabPlayer player);
 
     /**
      * Forces new team name for the player until this method is called again with null argument and
      * performs all actions to change player's team name
-     * @param teamName - forced team name
+     *
+     * @param   player
+     *          player to set team name of
+     * @param   teamName
+     *          forced team name
      */
-    void forceTeamName(TabPlayer player, String teamName);
+    void forceTeamName(@NonNull TabPlayer player, @Nullable String teamName);
 
     /**
      * Returns forced team name of player or null if not forced
-     * @return forced team name of player or null if not forced
+     *
+     * @param   player
+     *          player to check forced team name of
+     * @return  forced team name of player or null if not forced
      */
-    String getForcedTeamName(TabPlayer player);
+    @Nullable String getForcedTeamName(@NonNull TabPlayer player);
 
 
     /**
      * Forces collision rule for the player. Setting it to null will remove forced value
-     * @param collision - forced collision rule
+     *
+     * @param   player
+     *          player to set collision rule of
+     * @param   collision
+     *          forced collision rule
      */
-    void setCollisionRule(TabPlayer player, Boolean collision);
+    void setCollisionRule(@NonNull TabPlayer player, @Nullable Boolean collision);
 
     /**
      * Returns forced collision rule or null if collision is not forced using setCollisionRule
-     * @return forced value or null if not forced
+     *
+     * @param   player
+     *          player to get forced collision of
+     * @return  forced value or null if not forced
      */
-    Boolean getCollisionRule(TabPlayer player);
+    @Nullable Boolean getCollisionRule(@NonNull TabPlayer player);
 
     /**
      * Sends update team's properties packet of player's team to everyone
-     * @param player - player to update team data of
+     *
+     * @param   player
+     *          player to update team data of
      */
-    void updateTeamData(TabPlayer player);
+    void updateTeamData(@NonNull TabPlayer player);
 
-    void setPrefix(TabPlayer player, String prefix);
+    void setPrefix(@NonNull TabPlayer player, @Nullable String prefix);
 
-    void setSuffix(TabPlayer player, String suffix);
+    void setSuffix(@NonNull TabPlayer player, @Nullable String suffix);
 
-    void resetPrefix(TabPlayer player);
+    void resetPrefix(@NonNull TabPlayer player);
 
-    void resetSuffix(TabPlayer player);
+    void resetSuffix(@NonNull TabPlayer player);
 
-    String getCustomPrefix(TabPlayer player);
+    @Nullable String getCustomPrefix(@NonNull TabPlayer player);
 
-    String getCustomSuffix(TabPlayer player);
+    @Nullable String getCustomSuffix(@NonNull TabPlayer player);
 
-    String getOriginalPrefix(TabPlayer player);
+    @NonNull String getOriginalPrefix(@NonNull TabPlayer player);
 
-    String getOriginalSuffix(TabPlayer player);
+    @NonNull String getOriginalSuffix(@NonNull TabPlayer player);
 
     /**
      * Toggles nametag visibility view on all players for specified player.
      * On first call, nametags of all players will become invisible for specified
      * player. On second call, they will become visible again.
      *
-     * @param    player
-     *             player to toggle nametag visibility view for
-     * @param    sendToggleMessage
-     *             {@code true} if configured toggle message should be sent, {@code false} if not
+     * @param   player
+     *          player to toggle nametag visibility view for
+     * @param   sendToggleMessage
+     *          {@code true} if configured toggle message should be sent, {@code false} if not
      */
-    void toggleNameTagVisibilityView(TabPlayer player, boolean sendToggleMessage);
+    void toggleNameTagVisibilityView(@NonNull TabPlayer player, boolean sendToggleMessage);
 
     /**
      * Returns {@code true} if player has hidden nametags by either calling
      * {@link #toggleNameTagVisibilityView(TabPlayer, boolean)} or using a command,
      * {@code false} if not.
      *
-     * @param    player
-     *             player to check
-     * @return    {@code true} if hidden, {@code false} if not
+     * @param   player
+     *          player to check
+     * @return  {@code true} if hidden, {@code false} if not
      */
-    boolean hasHiddenNameTagVisibilityView(TabPlayer player);
+    boolean hasHiddenNameTagVisibilityView(@NonNull TabPlayer player);
 }

api/src/main/java/me/neznamy/tab/api/util/BiFunctionWithException.java

@@ -2,17 +2,25 @@ package me.neznamy.tab.api.util;
 
 /**
  * An interface for BiFunction which can throw an exception.
- * Used in {@link me.neznamy.tab.api.protocol.PacketBuilder} to 
- * call build method for packet classes, which may throw an
- * exception due to reflection.
- * @param    <A>
- *             First function argument
- * @param    <B>
- *             Second function argument
- * @param    <C>
- *             Function return type
+ * @param   <A>
+ *          First function argument
+ * @param   <B>
+ *          Second function argument
+ * @param   <C>
+ *          Function return type
  */
 public interface BiFunctionWithException<A, B, C> {
 
+    /**
+     * Runs the function and returns the result
+     *
+     * @param   a
+     *          First argument
+     * @param   b
+     *          Second argument
+     * @return  Output from function
+     * @throws  ReflectiveOperationException
+     *          If reflective operation fails
+     */
     C apply(A a, B b) throws ReflectiveOperationException;
 }

api/src/main/java/me/neznamy/tab/api/util/ComponentCache.java

@@ -0,0 +1,30 @@
+package me.neznamy.tab.api.util;
+
+import lombok.AllArgsConstructor;
+import me.neznamy.tab.api.ProtocolVersion;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@AllArgsConstructor
+public class ComponentCache<K, V> {
+
+    private final int cacheSize;
+    private final BiFunctionWithException<K, ProtocolVersion, V> function;
+    private final Map<K, V> cacheModern = new HashMap<>();
+    private final Map<K, V> cacheLegacy = new HashMap<>();
+
+    public V get(K key, ProtocolVersion clientVersion) {
+        try {
+            if (key == null) return null;
+            Map<K, V> cache = clientVersion == null || clientVersion.getMinorVersion() >= 16 ? cacheModern : cacheLegacy;
+            if (cache.containsKey(key)) return cache.get(key);
+            V value = function.apply(key, clientVersion);
+            if (cache.size() > cacheSize) cache.clear();
+            cache.put(key, value);
+            return value;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

api/src/main/java/me/neznamy/tab/api/util/Preconditions.java

@@ -1,20 +1,62 @@
 package me.neznamy.tab.api.util;
 
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Class with utility methods used in the plugin
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class Preconditions {
 
-    private Preconditions(){}
-
-    public static void checkNotNull(Object obj, String name){
-        if (obj == null) throw new IllegalArgumentException(name + " cannot be null");
-    }
-
-    public static void checkMaxLength(String string, int maxLength, String name) {
-        checkNotNull(string, name);
+    /**
+     * Checks length of String and throws {@code IllegalArgumentException} if it is
+     * longer than limit.
+     *
+     * @param   string
+     *          String to check
+     * @param   maxLength
+     *          Maximum length of the string
+     * @param   name
+     *          Name of the variable to use in exception message
+     * @throws  IllegalArgumentException
+     *          if {@code string} is {@code null} or longer than {@code maxLength} characters
+     */
+    public static void checkMaxLength(@NonNull String string, int maxLength, String name) {
         if (string.length() > maxLength) throw new IllegalArgumentException(name + " is longer than " + maxLength + " characters (" + string.length() + ")");
     }
 
-    public static void checkRange(Number number, Number min, Number max, String variable){
+    /**
+     * Checks number range and throws {@code IllegalArgumentException} if number
+     * is out of range.
+     *
+     * @param   number
+     *          Number to check
+     * @param   min
+     *          Minimum allowed value
+     * @param   max
+     *          Maximum allowed value
+     * @param   variable
+     *          Variable name to use in exception message
+     * @throws  IllegalArgumentException
+     *          if {@code number} is out of range ({@code number < min || number > max})
+     */
+    public static void checkRange(Number number, Number min, Number max, String variable) {
         if (number.doubleValue() < min.doubleValue() || number.doubleValue() > max.doubleValue())
-            throw new IllegalArgumentException(variable + " index out of range (" + min + " - " + max + ")");
+            throw new IllegalArgumentException(variable + " index out of range (" + min + " - " + max + "), was " + number);
+    }
+
+    /**
+     * Checks if player is loaded and throws {@code IllegalStateException} if not.
+     *
+     * @param   player
+     *          Player to check
+     * @throws  IllegalStateException
+     *          If player is not loaded
+     */
+    public static void checkLoaded(TabPlayer player) {
+        if (!player.isLoaded()) throw new IllegalStateException("Player is not loaded yet. Try again later.");
     }
 }

api/src/main/java/me/neznamy/tab/api/util/ReflectionUtils.java

@@ -0,0 +1,24 @@
+package me.neznamy.tab.api.util;
+
+/**
+ * Utility class storing methods working with reflection
+ */
+public class ReflectionUtils {
+
+    /**
+     * Returns {@code true} if class with given full name exists,
+     * {@code false} if not.
+     *
+     * @param   path
+     *          Full class path and name
+     * @return  {@code true} if exists, {@code false} if not
+     */
+    public static boolean classExists(String path) {
+        try {
+            Class.forName(path);
+            return true;
+        } catch (ClassNotFoundException | NullPointerException e) {
+            return false;
+        }
+    }
+}

build-logic/build.gradle.kts

@@ -2,11 +2,16 @@ plugins {
     `kotlin-dsl`
 }
 
-repositories {
-    gradlePluginPortal()
-    mavenCentral()
+dependencies {
+    implementation(libs.plugin.shadow)
+    implementation(libs.plugin.lombok)
 }
 
 dependencies {
-    implementation("gradle.plugin.com.github.johnrengelman", "shadow", "7.1.0")
+    compileOnly(files(libs::class.java.protectionDomain.codeSource.location))
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
 }

build-logic/settings.gradle.kts

@@ -0,0 +1,16 @@
+rootProject.name = "build-logic"
+
+dependencyResolutionManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+    // You're a great IDE IntelliJ, but sometimes you really annoy me. >:(
+//    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+
+    versionCatalogs {
+        register("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}

build-logic/src/main/kotlin/tab.base-conventions.gradle.kts

@@ -2,6 +2,7 @@ import org.apache.tools.ant.filters.ReplaceTokens
 
 plugins {
     `java-library`
+    id("io.freefair.lombok")
 }
 
 tasks {
@@ -9,10 +10,14 @@ tasks {
         filter<ReplaceTokens>("tokens" to mapOf(
             "name" to rootProject.name,
             "version" to project.version,
-            "description" to project.description
+            "description" to project.description,
+            "website" to rootProject.ext.get("website")!!.toString(),
+            "author" to rootProject.ext.get("author")!!.toString()
         ))
     }
     javadoc {
+        // This saves a decent bit of processing power on slow machines
+        enabled = false
         options.encoding = Charsets.UTF_8.name()
         (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:none", "-quiet")
     }

build-logic/src/main/kotlin/tab.platform-conventions.gradle.kts

@@ -9,5 +9,6 @@ tasks {
         relocate("org.bstats", "me.neznamy.tab.libs.org.bstats")
         relocate("org.json.simple", "me.neznamy.tab.libs.org.json.simple")
         relocate("net.kyori.event", "me.neznamy.tab.libs.net.kyori.event")
+        relocate("me.neznamy.yamlassist", "me.neznamy.tab.libs.yamlassist")
     }
 }