3.3.2

optimizations in CPUManager

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,28 +0,0 @@
----
-name: Bug report
-about: Report a bug
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Server version**
-
-
-**Plugin version** ("latest" is not a version)
-
-
-**Describe the bug**
-
-
-**How to reproduce**
-
-
-**Expected behavior**
-
-
-**Actual behavior**
-
-
-**Additional info** (errors, screenshots, ...)

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,63 @@
+name: Bug Report
+description: Plugin does not work as described.
+labels: ["Type: Bug"]
+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: Describe the bug
+      description: How the plugin behaves
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Expected behavior
+      description: How the plugin is supposed to behave instead with your configuration.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: What to do in order to reproduce this issue
+      placeholder: |
+        Step 1: ..
+        Step 2: ..
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      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
+    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 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

@@ -0,0 +1,57 @@
+name: Error
+description: Error message with a stack trace in console or error file.
+labels: ["Type: Error"]
+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: Stack trace
+      description: The error message and stack trace you received in console or errors.log file.
+    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 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

@@ -0,0 +1,29 @@
+name: Wiki change
+description: Change to text on a wiki page or adding a new section.
+labels: ["Type: Wiki change"]
+body:
+  - type: input
+    attributes:
+      label: Page link
+      description: Link to the page that should receive the change.
+      placeholder: https://github.com/NEZNAMY/TAB/wiki/Installation
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Current text (if applicable)
+      description: Current version of the text (if modifying), ignore in case of new section.
+      placeholder: |
+        Installation on Bukkit/Spigot/Paper is as simple as it can be. Just put the plugin into plugins folder and restart the server. You can also run `/plugman load tab` to load the plugin while server is running.
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: New text
+      description: What the text should be changed to / how should new section look
+      placeholder: |
+        Put the plugin into plugins folder and restart the server. In case you don't want to restart your server, loading with plugins like PlugMan is supported.
+    validations:
+      required: true

.github/workflows/build.yml

@@ -0,0 +1,44 @@
+name: Build
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened]
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - 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@v3.9.0 #https://github.com/actions/setup-java/releases
+        with:
+          distribution: 'temurin'
+          java-version: 11
+      - name: Cache SonarCloud packages
+        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@v3.2.3 #https://github.com/actions/cache/releases
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: "${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}"
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Build and analyze
+        env:
+          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@v3.1.2 #https://github.com/actions/upload-artifact/releases
+        with:
+          name: Jar
+          path: jar/build/libs/TAB-**.jar

.gitignore

@@ -1,8 +1,7 @@
 # Compiled class file
 *.class
-/bin/
-/target/
-/src/test/
+bin/
+target/
 
 # Log file
 *.log
@@ -31,8 +30,14 @@ hs_err_pid*
 .project
 
 # intellij
-/.idea/
+.idea/
 
 # other
 .gitattributes
-*.iml
+*.iml
+run/
+
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.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

@@ -1,4 +1,4 @@
-Apache License
+                                 Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 
@@ -172,30 +172,3 @@ Apache License
       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.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.md

@@ -1,36 +1,86 @@
-## Introduction  
-Here it is. After countless requests to go opensource, I did it to make those people quiet. It worked.  
-It's already been a year and I still can't see any positives of it. This way I just made it easier for everyone to make a plugin as good, so people can stop using it and switch to something better. 
-  
-  
-## Compiling
-Plugin can be compiled using maven.
+# About
+TAB aims to be a superior all-in-one minecraft plugin for displaying information that outperforms all 
+similar plugins in terms of features, performance, compatibility and support.  
+More information can be found at [Why TAB?](https://github.com/NEZNAMY/TAB/wiki/Why-TAB%3F) wiki page.
 
-  
-## Premium code
-The source contains content of premium version as well. However, this must be activated by setting [this line to return true](https://github.com/NEZNAMY/TAB/blob/master/src/main/java/me/neznamy/tab/shared/TAB.java#L79).  
-  
-  
-## Maven Repository
-```
-<repositories>
-  <repository>
-    <id>jitpack.io</id>
-    <url>https://jitpack.io</url>
-  </repository>
-</repositories>
+# 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, customer support is only provided to 
+customers who have purchased the plugin (see [Customer support](#customer-support)).  
 
-<dependencies>
-  <!-- TAB -->
-  <dependency>
-    <groupId>com.github.NEZNAMY</groupId>
-    <artifactId>TAB-API</artifactId>
-    <version>2.8.10</version>
-  </dependency>
-</dependencies>
- ```
-## Links
-Discord: https://discord.gg/EaSvdk6  
-SpigotMC (free): https://www.spigotmc.org/resources/57806/  
-MC-Market (paid): https://www.mc-market.org/resources/14009/  
-Wiki: https://github.com/NEZNAMY/TAB/wiki  
+# 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.  
+The universal jar contains all modules for all supported platforms.
+
+# 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.
+
+# 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.
+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
+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

@@ -0,0 +1,30 @@
+plugins {
+    id("net.kyori.blossom") version "1.2.0"
+}
+
+dependencies {
+    compileOnlyApi(libs.netty)
+    api(libs.jsonSimple) {
+        exclude("junit", "junit")
+    }
+    compileOnlyApi(libs.snakeyaml)
+    api(libs.yamlAssist)
+    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

@@ -0,0 +1,57 @@
+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
+     */
+    boolean isStaticOffset();
+    
+    /**
+     * Changes offset of the armor stand
+     *
+     * @param   offset
+     *          new offset
+     */
+    void setOffset(double offset);
+
+    /**
+     * Returns offset of the armor stand
+     *
+     * @return  offset from base
+     */
+    double getOffset();
+    
+    /**
+     * Returns property for armor stand's name
+     *
+     * @return  property for armor stand's name
+     */
+    Property getProperty();
+
+    /**
+     * Updates armor stand's name if needed
+     */
+    void refresh();
+    
+    /**
+     * Updates visibility if needed
+     *
+     * @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
+     */
+    int getEntityId();
+}

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

@@ -0,0 +1,20 @@
+package me.neznamy.tab.api;
+
+/**
+ * A helper class for easy management of armor stands of a player
+ */
+public interface ArmorStandManager {
+
+    /**
+     * Sends destroy packet of all armor stands to everyone and clears nearby players list
+     */
+    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

@@ -0,0 +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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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

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

@@ -0,0 +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
+     */
+    String getOriginalRawValue();
+
+    /**
+     * Temporarily overrides current raw value with an API call
+     *
+     * @param   temporaryValue
+     *          temporary value to be assigned
+     */
+    void setTemporaryValue(String temporaryValue);
+
+    /**
+     * Returns current temporary value
+     *
+     * @return  temporary value or null if not set
+     */
+    String getTemporaryValue();
+
+    /**
+     * Returns temporary value (via API) if present, raw value otherwise
+     *
+     * @return  current raw value
+     */
+    String getCurrentRawValue();
+
+    /**
+     * Returns 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
+     */
+    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
+     */
+    String updateAndGet();
+
+    /**
+     * Returns value for defined viewer by applying relational placeholders to last known value
+     *
+     * @param   viewer
+     *          the viewer
+     * @return  format for the viewer
+     */
+    String getFormat(TabPlayer viewer);
+}

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

@@ -0,0 +1,147 @@
+package me.neznamy.tab.api;
+
+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 {
+
+    /**
+     * 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);
+
+    /**
+     * 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);
+
+    /**
+     * 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);
+
+    /**
+     * 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);
+
+    /**
+     * 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);
+
+    /**
+     * 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();
+
+    /**
+     * 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

@@ -0,0 +1,159 @@
+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
+ */
+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),
+    V1_17_1 (756),
+    V1_17   (755),
+    V1_16_5 (754),
+    V1_16_4 (754),
+    V1_16_3 (753),
+    V1_16_2 (751),
+    V1_16_1 (736),
+    V1_16   (735),
+    V1_15_2 (578),
+    V1_15_1 (575),
+    V1_15   (573),
+    V1_14_4 (498),
+    V1_14_3 (490),
+    V1_14_2 (485),
+    V1_14_1 (480),
+    V1_14   (477),
+    V1_13_2 (404),
+    V1_13_1 (401),
+    V1_13   (393),
+    V1_12_2 (340),
+    V1_12_1 (338),
+    V1_12   (335),
+    V1_11_2 (316),
+    V1_11_1 (316),
+    V1_11   (315),
+    V1_10_2 (210),
+    V1_10_1 (210),
+    V1_10   (210),
+    V1_9_4  (110),
+    V1_9_3  (110),
+    V1_9_2  (109),
+    V1_9_1  (108),
+    V1_9    (107),
+    V1_8    (47),
+    V1_7_10 (5),
+    V1_7_9  (5),
+    V1_7_8  (5),
+    V1_7_7  (5),
+    V1_7_6  (5),
+    V1_7_5  (4),
+    V1_7_4  (4),
+    V1_7_2  (4),
+    V1_6_4  (78),
+    V1_6_2  (74),
+    V1_6_1  (73),
+    V1_5_2  (61),
+    V1_5_1  (60),
+    V1_5    (60),
+    V1_4_7  (51),
+    V1_4_6  (51);
+
+    /** 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 */
+    @Getter private final int networkId;
+
+    /** 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;
+
+    /** 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
+     */
+    ProtocolVersion(int networkId) {
+        this.networkId = networkId;
+        this.minorVersion = Integer.parseInt(toString().split("_")[1]);
+        this.friendlyName = toString().substring(1).replace("_", ".");
+    }
+
+    /**
+     * Constructs new instance with given friendly name
+     *
+     * @param   friendlyName
+     *          friendly name to display
+     */
+    ProtocolVersion(String friendlyName) {
+        this.networkId = 999;
+        this.minorVersion = 18;
+        this.friendlyName = friendlyName;
+    }
+
+    /**
+     * 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
+     */
+    public static ProtocolVersion fromFriendlyName(String friendlyName) {
+        if (friendlyName.startsWith("1.8")) return V1_8;
+        try {
+            return valueOf("V" + friendlyName.replace(".", "_"));
+        } catch (IllegalArgumentException e) {
+            return UNKNOWN_SERVER_VERSION;
+        }
+    }
+
+    /**
+     * Returns 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) {
+            if (networkId == v.getNetworkId()) return v;
+        }
+        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

@@ -0,0 +1,209 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import me.neznamy.tab.api.bossbar.BossBarManager;
+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.team.TeamManager;
+
+/**
+ * The primary API class to get instances of other API classes
+ */
+public abstract class TabAPI {
+
+    /** Instance of the API */
+    private static TabAPI instance;
+
+    /**
+     * Constructs new instance and sets it as new API instance
+     */
+    public TabAPI() {
+        instance = this;
+    }
+
+    /**
+     * 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
+     *
+     * @param   id
+     *          Player UUID
+     * @return  player object from given UUID
+     */
+    public abstract TabPlayer getPlayer(UUID id);
+
+    /**
+     * Returns player object from given 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
+     */
+    public abstract TabPlayer[] getOnlinePlayers();
+
+    /**
+     * 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. If not, returns {@code null}.
+     *
+     * @return  scoreboard manager
+     */
+    public abstract ScoreboardManager getScoreboardManager();
+
+    /**
+     * 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
+     */
+    public abstract PlaceholderManager getPlaceholderManager();
+
+    /**
+     * Returns 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
+     */
+    public abstract EventBus getEventBus();
+
+    /**
+     * Returns server version. On proxy installation returns PROXY.
+     *
+     * @return  server version
+     */
+    public abstract ProtocolVersion getServerVersion();
+
+    /**
+     * Prints message into console
+     *
+     * @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);
+
+    /**
+     * 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

@@ -0,0 +1,340 @@
+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_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@";
+
+    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";
+        public static final String PLAYER_QUIT = "Player Quit";
+        public static final String WORLD_SWITCH = "World Switch";
+        public static final String SERVER_SWITCH = "Server Switch";
+        public static final String COMMAND_PREPROCESS = "Command Preprocess";
+        public static final String PLAYER_SNEAK = "Player Sneak";
+        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 VANISH_CHANGE = "Vanish status change";
+        public static final String ANTI_OVERRIDE = "Anti override";
+
+        public static final String BYTE_BUF = "ByteBuf";
+        public static final String PACKET_PLAYER_INFO = "PacketPlayOutPlayerInfo";
+        public static final String PACKET_DISPLAY_OBJECTIVE = "PacketPlayOutScoreboardDisplayObjective";
+        public static final String PACKET_OBJECTIVE = "PacketPlayOutScoreboardObjective";
+        public static final String PACKET_JOIN_GAME = "Login Packet";
+        public static final String PACKET_ENTITY_MOVE = "PacketPlayOutEntity";
+        public static final String PACKET_ENTITY_MOVE_PASSENGER = "PacketPlayOutEntity (passenger)";
+        public static final String PACKET_ENTITY_SPAWN = "PacketPlayOutNamedEntitySpawn";
+        public static final String PACKET_ENTITY_DESTROY = "PacketPlayOutEntityDestroy";
+        public static final String RAW_PACKET_IN = "Packet reading (in)";
+        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 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";
+    }
+
+    /**
+     * Permission nodes used by the plugin
+     */
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class Permission {
+
+        public static final String COMMAND_ALL = "tab.admin";
+        public static final String COMMAND_RELOAD = "tab.reload";
+        public static final String COMMAND_BOSSBAR_ANNOUNCE = "tab.announce.bar";
+        public static final String COMMAND_BOSSBAR_TOGGLE = "tab.bossbar.toggle";
+        public static final String COMMAND_BOSSBAR_SEND = "tab.send.bar";
+        public static final String COMMAND_CPU = "tab.cpu";
+        public static final String COMMAND_DEBUG = "tab.debug";
+        public static final String COMMAND_GROUP_INFO = "tab.groupinfo";
+        public static final String COMMAND_GROUP_LIST = "tab.grouplist";
+        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";
+        public static final String COMMAND_SCOREBOARD_TOGGLE_OTHER = "tab.scoreboard.toggle.other";
+        public static final String COMMAND_SCOREBOARD_SHOW = "tab.scoreboard.show";
+        public static final String COMMAND_SCOREBOARD_SHOW_OTHER = "tab.scoreboard.show.other";
+        public static final String COMMAND_SETCOLLISION = "tab.setcollision";
+        public static final String COMMAND_AUTOCOMPLETE = "tab.tabcomplete";
+        public static final String COMMAND_DATA_REMOVE = "tab.remove";
+        public static final String COMMAND_PROPERTY_CHANGE_PREFIX = "tab.change.";
+        public static final String COMMAND_WIDTH = "tab.width";
+
+        public static final String STAFF = "tab.staff";
+
+        public static final String PER_WORLD_PLAYERLIST_BYPASS = "tab.bypass";
+        public static final String SEE_VANISHED = "tab.seevanished";
+        public static final String SPECTATOR_BYPASS = "tab.spectatorbypass";
+
+        public static final String TEST_PERMISSION = "tab.testpermission";
+
+        public static final String GROUP_PREFIX = "tab.group.";
+    }
+
+    /**
+     * 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";
+        public static final String FOOTER = "footer";
+
+        public static final String TABPREFIX = "tabprefix";
+        public static final String CUSTOMTABNAME = "customtabname";
+        public static final String TABSUFFIX = "tabsuffix";
+
+        public static final String TAGPREFIX = "tagprefix";
+        public static final String CUSTOMTAGNAME = "customtagname";
+        public static final String TAGSUFFIX = "tagsuffix";
+
+        public static final String ABOVENAME = "abovename";
+        public static final String NAMETAG = "nametag";
+        public static final String BELOWNAME = "belowname";
+
+        public static final String SCOREBOARD_TITLE = "scoreboard-title";
+
+        public static final String BELOWNAME_NUMBER = "belowname-number";
+        public static final String BELOWNAME_TEXT = "belowname-text";
+
+        public static final String YELLOW_NUMBER = "yellow-number";
+
+        public static String bossbarTitle(String name) {
+            return "bossbar-title-" + name;
+        }
+
+        public static String bossbarProgress(String name) {
+            return "bossbar-progress-" + name;
+        }
+
+        public static String bossbarColor(String name) {
+            return "bossbar-color-" + name;
+        }
+
+        public static String bossbarStyle(String name) {
+            return "bossbar-style-" + name;
+        }
+
+        public static String scoreboardPrefix(String scoreboard, int lineNumber) {
+            return scoreboard + "-" + lineNumber + "-prefix";
+        }
+
+        public static String scoreboardName(String scoreboard, int lineNumber) {
+            return scoreboard + "-" + lineNumber + "-name";
+        }
+
+        public static String scoreboardSuffix(String scoreboard, int lineNumber) {
+            return scoreboard + "-" + lineNumber + "-suffix";
+        }
+    }
+
+    /**
+     * 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
+        public static final String HEADER_FOOTER = "HeaderFooter";
+        public static final String GHOST_PLAYER_FIX = "GhostPlayerFix";
+        public static final String PLAYER_LIST = "PlayerList";
+        public static final String SPECTATOR_FIX = "SpectatorFix";
+        public static final String YELLOW_NUMBER = "YellowNumber";
+        public static final String BELOW_NAME = "BelowName";
+        public static final String BELOW_NAME_TEXT = "BelowNameText";
+        public static final String SCOREBOARD = "ScoreBoard";
+        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";
+        public static final String NAME_TAGS = "NameTag16";
+        public static final String NAME_TAGS_COLLISION = "NameTagCollision";
+        public static final String NAME_TAGS_VISIBILITY = "NameTagVisibility";
+        public static final String GROUP_MANAGER = "GroupManager";
+        public static final String PLACEHOLDER_MANAGER = "PlaceholderManager";
+        public static final String PET_FIX = "PetFix";
+        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";
+
+        //BungeeCord only
+        public static final String REDIS_BUNGEE = "RedisBungee";
+        public static final String GLOBAL_PLAYER_LIST = "GlobalPlayerList";
+        public static final String GLOBAL_PLAYER_LIST_LATENCY = "GlobalPlayerList-Latency";
+
+        //additional info displayed in cpu command
+        public static final String PACKET_SERIALIZING = "Packet serializing";
+        public static final String PACKET_DESERIALIZING = "Packet deserializing";
+
+        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;
+        }
+
+        public static String layoutSlot(String layout, int slot) {
+            return "layout-" + layout + "-slot-" + slot;
+        }
+
+        public static String bossBarTitle(String name) {
+            return "BossBar-title-" + name;
+        }
+
+        public static String bossBarProgress(String name) {
+            return "BossBar-progress-" + name;
+        }
+
+        public static String bossBarColor(String color) {
+            return "BossBar-color-" + color;
+        }
+
+        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/TabPlayer.java

@@ -0,0 +1,299 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+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
+ */
+public interface TabPlayer {
+
+    /**
+     * Refreshes all visuals on the player
+     */
+    void forceRefresh();
+
+    /**
+     * Returns player's name
+     *
+     * @return  Player's name
+     */
+    String getName();
+
+    /**
+     * Returns 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 a proxy which does not rewrite UUIDs.
+     *
+     * @return  player's uuid in TabList
+     */
+    UUID getTablistId();
+
+    /**
+     * Returns 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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    boolean hasPermission(String permission);
+
+    /**
+     * Sends the player a platform-specific packet
+     *
+     * @param   packet
+     *          an instance of packet depending on platform
+     */
+    void sendPacket(Object packet);
+
+    /**
+     * Returns player's property by name
+     *
+     * @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
+     */
+    void sendMessage(String message, boolean translateColors);
+
+    /**
+     * Sends specified component as a chat message
+     *
+     * @param   message
+     *          message to send
+     */
+    void sendMessage(IChatBaseComponent message);
+
+    /**
+     * Returns player's ping calculated by server
+     *
+     * @return  player's ping
+     */
+    int getPing();
+
+    /**
+     * Returns player's skin data
+     *
+     * @return  player's skin
+     */
+    Skin getSkin();
+
+    /**
+     * Returns true once the player is successfully loaded (onJoin method ran through all methods)
+     *
+     * @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 {@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(Refreshable feature, String identifier, String rawValue);
+
+    /**
+     * Loads property from config using standard property loading algorithm
+     *
+     * @param   property
+     *          property name to load
+     * @return  {@code true} if value did not exist or changed, {@code false} otherwise
+     */
+    boolean loadPropertyFromConfig(Refreshable feature, String property);
+
+    /**
+     * Loads property from config using standard property loading algorithm. If the property is
+     * 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(Refreshable feature, String property, String ifNotSet);
+
+    /**
+     * Returns name of player's scoreboard team or {@code null} if NameTag feature is disabled
+     *
+     * @return  name of player's team
+     */
+    String getTeamName();
+
+    /**
+     * 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 {@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();
+
+    /**
+     * 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();
+
+    /**
+     * 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
+     */
+    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

@@ -0,0 +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/BarColor.java

@@ -0,0 +1,16 @@
+package me.neznamy.tab.api.bossbar;
+
+/**
+ * An enum representing all available BossBar colors.
+ * Calling ordinal() will return color's network ID.
+ */
+public enum BarColor {
+
+    PINK,
+    BLUE,
+    RED,
+    GREEN,
+    YELLOW,
+    PURPLE,
+    WHITE
+}

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

@@ -0,0 +1,22 @@
+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"),
+    NOTCHED_6("SEGMENTED_6"),
+    NOTCHED_10("SEGMENTED_10"),
+    NOTCHED_12("SEGMENTED_12"),
+    NOTCHED_20("SEGMENTED_20");
+
+    /** Style's name used in Bukkit API */
+    @Getter private final String bukkitName;
+}

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

@@ -0,0 +1,210 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.UUID;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * An interface representing a BossBar line.
+ * <p>
+ * For clients 1.8 and lower it uses wither, which only allows 1 bar 
+ * to be displayed at a time. Entity packets are not available on BungeeCord,
+ * where nothing will be displayed for these players.
+ * <p>
+ * For 1.9+ it uses the new BossBar feature, allowing configurable styles
+ * and colors, as well as display several bars at once. Limit of maximum 
+ * displayed BossBars depends on client resolution and GUI scale, up to
+ * 9 concurrent BossBars displayed at once.
+ */
+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
+     */
+    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
+     */
+    UUID getUniqueId();
+
+    /**
+     * Changes BossBar title to specified string, supporting placeholders.
+     * <p>
+     * If title contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified title is equal to the current one, nothing happens.
+     *
+     * @param   title
+     *          New title to display in this BossBar
+     */
+    void setTitle(String title);
+
+    /**
+     * Changes BossBar progress to specified string, supporting placeholders.
+     * The string must be a string version of a float value, or a placeholder that
+     * outputs a float value with range 0-100.
+     * <p>
+     * If progress contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified progress is equal to the current one, nothing happens.
+     *
+     * @param   progress
+     *          New progress to use in this BossBar
+     */
+    void setProgress(String progress);
+
+    /**
+     * 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
+     */
+    void setProgress(float progress);
+
+    /**
+     * Changes BossBar color to specified string, supporting placeholders.
+     * The string must be a string version of one of the supported values,
+     * or a placeholder that outputs one of them.
+     * <p>
+     * If color contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified color is equal to the current one, nothing happens.
+     *
+     * @param   color
+     *          New color to use in this BossBar
+     */
+    void setColor(String color);
+
+    /**
+     * Changes BossBar color to specified enum constant.
+     * <p>
+     * If specified color is equal to the current one, nothing happens.
+     *
+     * @param   color
+     *          New color to use in this BossBar
+     */
+    void setColor(BarColor color);
+
+    /**
+     * Changes BossBar style to specified string, supporting placeholders.
+     * The string must be a string version of one of the supported values,
+     * or a placeholder that outputs one of them.
+     * <p>
+     * If style contains new placeholders not used before, they are registered using
+     * standard registration logic and refreshed periodically. No need to call
+     * this method to try to keep placeholder values up to date.
+     * <p>
+     * If specified style is equal to the current one, nothing happens.
+     *
+     * @param   style
+     *          New style to use in this BossBar
+     */
+    void setStyle(String style);
+
+    /**
+     * Changes BossBar style to specified enum constant.
+     * <p>
+     * If specified style is equal to the current one, nothing happens.
+     *
+     * @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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    String getStyle();
+
+    /**
+     * Registers this BossBar to specified player.
+     * <p>
+     * If the player already sees this BossBar, nothing happens.
+     *
+     * @param   player
+     *          Player to register this BossBar to
+     */
+    void addPlayer(TabPlayer player);
+
+    /**
+     * Unregisters this BossBar from specified player.
+     * <p>
+     * If the player does not see this BossBar, nothing happens.
+     *
+     * @param   player
+     *          Player to unregister this BossBar from
+     */
+    void removePlayer(TabPlayer player);
+
+    /**
+     * Returns list of players who can see this BossBar.
+     * <p>
+     * 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
+     */
+    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
+     */
+    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

@@ -0,0 +1,165 @@
+package me.neznamy.tab.api.bossbar;
+
+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 TabAPI#getBossBarManager()}.
+ * This requires the BossBar feature to be enabled in config, otherwise the method will
+ * return {@code null}.
+ */
+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
+     */
+    BossBar createBossBar(String title, float progress, BarColor color, BarStyle style);
+
+    /**
+     * 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
+     */
+    BossBar createBossBar(String title, String progress, String color, String style);
+
+    /**
+     * Returns registered BossBar with given name. For BossBars from config it is the name
+     * they were created with, for API BossBars their randomly generated name, which can be
+     * 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
+     */
+    BossBar getBossBar(String name);
+
+    /**
+     * Returns registered BossBar with specified UUID. This UUID is randomly generated when
+     * 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
+     */
+    BossBar getBossBar(UUID id);
+
+    /**
+     * Returns a map of all registered BossBars. This includes both BossBars from config
+     * and those registered via API.
+     * <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
+     */
+    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)
+     */
+    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)
+     */
+    boolean hasBossBarVisible(TabPlayer player);
+
+    /**
+     * 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
+     * @see #toggleBossBar(TabPlayer, boolean)
+     * @see #hasBossBarVisible(TabPlayer)
+     */
+    void setBossBarVisible(TabPlayer player, boolean visible, boolean sendToggleMessage);
+
+    /**
+     * 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()
+     */
+    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()
+     */
+    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)
+     */
+    List<BossBar> getAnnouncedBossBars();
+}

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

@@ -0,0 +1,29 @@
+package me.neznamy.tab.api.chat;
+
+import lombok.Data;
+import lombok.NonNull;
+
+/**
+ * Class for click event action in chat component
+ */
+@Data
+public class ChatClickable {
+
+    /** Click action */
+    @NonNull private final EnumClickAction action;
+
+    /** Click value */
+    @NonNull private final String value;
+
+    /**
+     * Enum for all possible click actions
+     */
+    public enum EnumClickAction {
+
+        OPEN_URL,
+        RUN_COMMAND,
+        CHANGE_PAGE, //since 1.8
+        SUGGEST_COMMAND,
+        COPY_TO_CLIPBOARD //since 1.15
+    }
+}

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

@@ -0,0 +1,35 @@
+package me.neznamy.tab.api.chat;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+
+import java.util.UUID;
+
+public class ChatComponentEntity extends IChatBaseComponent {
+
+    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
+    public String toRawText() {
+        return toString();
+    }
+    
+    @Override
+    public String toString() {
+        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

@@ -0,0 +1,32 @@
+package me.neznamy.tab.api.chat;
+
+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 */
+    @NonNull private final EnumHoverAction action;
+
+    /** Hover value */
+    @NonNull private final IChatBaseComponent value;
+
+    /**
+     * Enum for all possible hover actions
+     */
+    @AllArgsConstructor
+    public enum EnumHoverAction {
+
+        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

@@ -0,0 +1,219 @@
+package me.neznamy.tab.api.chat;
+
+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(@NonNull ChatModifier modifier) {
+        this.color = modifier.color == null ? null : new TextColor(modifier.color);
+        this.bold = modifier.bold;
+        this.italic = modifier.italic;
+        this.underlined = modifier.underlined;
+        this.strikethrough = modifier.strikethrough;
+        this.obfuscated = modifier.obfuscated;
+        this.clickEvent = modifier.clickEvent == null ? null : new ChatClickable(modifier.clickEvent.getAction(), modifier.clickEvent.getValue());
+        this.hoverEvent = modifier.hoverEvent == null ? null : new ChatHoverable(modifier.hoverEvent.getAction(), modifier.hoverEvent.getValue());
+        this.font = modifier.font;
+        this.targetVersion = modifier.targetVersion;
+    }
+
+
+    /**
+     * Returns 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() {
+        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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    public boolean isObfuscated() {
+        return Boolean.TRUE.equals(obfuscated);
+    }
+
+    /**
+     * Sets click action to OPEN_URL and url to given value
+     *
+     * @param   url
+     *          url to open
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    public void onClickChangePage(int newPage) {
+        if (TabAPI.getInstance().getServerVersion().getMinorVersion() < 8) throw new UnsupportedOperationException("change_page click action is not supported on <1.8");
+        clickEvent = new ChatClickable(EnumClickAction.CHANGE_PAGE, String.valueOf(newPage));
+    }
+
+    /**
+     * Sets click action to COPY_TO_CLIPBOARD and text to provided value
+     *
+     * @param   text
+     *          text to copy to clipboard on click
+     */
+    public void onClickCopyToClipBoard(@NonNull String text) {
+        clickEvent = new ChatClickable(EnumClickAction.COPY_TO_CLIPBOARD, text);
+    }
+
+    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
+     */
+    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
+     */
+    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
+     */
+    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(@NonNull EnumHoverAction action, @NonNull IChatBaseComponent value) {
+        hoverEvent = new ChatHoverable(action, value);
+    }
+
+    @SuppressWarnings("unchecked")
+    public JSONObject serialize() {
+        JSONObject json = new JSONObject();
+        if (color != null) json.put("color", targetVersion.getMinorVersion() >= 16 ? color.toString() : color.getLegacyColor().toString().toLowerCase());
+        if (bold != null) json.put("bold", bold);
+        if (italic != null) json.put("italic", italic);
+        if (underlined != null) json.put("underlined", underlined);
+        if (strikethrough != null) json.put("strikethrough", strikethrough);
+        if (obfuscated != null) json.put("obfuscated", obfuscated);
+        if (clickEvent != null) {
+            JSONObject click = new JSONObject();
+            click.put("action", clickEvent.getAction().toString().toLowerCase());
+            click.put("value", clickEvent.getValue());
+            json.put("clickEvent", click);
+        }
+        if (hoverEvent != null) {
+            JSONObject hover = new JSONObject();
+            hover.put("action", hoverEvent.getAction().toString().toLowerCase());
+            if (TabAPI.getInstance().getServerVersion().getMinorVersion() >= 16) {
+                hover.put(hoverEvent.getAction().getPreferredKey(), hoverEvent.getValue());
+            } else {
+                hover.put("value", TabAPI.getInstance().getServerVersion().getMinorVersion() >= 9 ?
+                        hoverEvent.getValue() : hoverEvent.getValue().toRawText());
+            }
+            json.put("hoverEvent", hover);
+        }
+        if (font != null) json.put("font", font);
+        return json;
+    }
+
+    public String getMagicCodes() {
+        StringBuilder builder = new StringBuilder();
+        if (isBold()) builder.append(EnumChatFormat.BOLD.getFormat());
+        if (isItalic()) builder.append(EnumChatFormat.ITALIC.getFormat());
+        if (isUnderlined()) builder.append(EnumChatFormat.UNDERLINE.getFormat());
+        if (isStrikethrough()) builder.append(EnumChatFormat.STRIKETHROUGH.getFormat());
+        if (isObfuscated()) builder.append(EnumChatFormat.OBFUSCATED.getFormat());
+        return builder.toString();
+    }
+}

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

@@ -0,0 +1,161 @@
+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 org.jetbrains.annotations.NotNull;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+import java.util.List;
+
+/**
+ * A class representing a chat component that was serialized before,
+ * but deserialize was requested in PacketPlayOutPlayerInfo packet.
+ * This is used to read and modify the packet and then rewrite it.
+ * However, display name components must be deserialized to properly
+ * forward them in the new packet, but its value is not actually
+ * used anywhere.
+ * <p>
+ * To avoid this heavy and completely unnecessary operation, the original
+ * string is saved and returned during serialization. If any read/write
+ * operation is performed, the string is fully deserialized and this object
+ * will act like a normal chat component.
+ */
+@SuppressWarnings("unchecked")
+@RequiredArgsConstructor
+public class DeserializedChatComponent extends IChatBaseComponent {
+
+    /** The original serialized component string */
+    @NonNull private final String json;
+
+    /**
+     * Flag tracking whether this component was fully deserialized
+     * in case of a read operation to avoid repeating the deserialization
+     * process on every request.
+     */
+    private boolean deserialized;
+
+    /**
+     * Flag tracking whether this component was modified, which means
+     * a new string has to be created instead of returning the input one.
+     */
+    private boolean modified;
+
+    @Override
+    public String toString() {
+        if (modified) return super.toString();
+        return json;
+    }
+
+    @Override
+    public String toString(ProtocolVersion clientVersion) {
+        if (modified) return super.toString(clientVersion);
+        return json;
+    }
+
+    @Override
+    public List<IChatBaseComponent> getExtra() {
+        if (!deserialized) deserialize();
+        return super.getExtra();
+    }
+
+    @Override
+    public String getText() {
+        if (!deserialized) deserialize();
+        return super.getText();
+    }
+
+    @Override
+    public @NotNull ChatModifier getModifier() {
+        if (!deserialized) deserialize();
+        return super.getModifier();
+    }
+
+    @Override
+    public IChatBaseComponent setExtra(List<IChatBaseComponent> components) {
+        if (!deserialized) deserialize();
+        modified = true;
+        return super.setExtra(components);
+    }
+
+    @Override
+    public void addExtra(@NotNull IChatBaseComponent child) {
+        if (!deserialized) deserialize();
+        modified = true;
+        super.addExtra(child);
+    }
+
+    @Override
+    public void setModifier(@NotNull ChatModifier modifier) {
+        if (!deserialized) deserialize();
+        modified = true;
+        super.setModifier(modifier);
+    }
+
+    /**
+     * Performs a full deserialization process on this component.
+     */
+    void deserialize() {
+        deserialized = true;
+        if (json.startsWith("\"") && json.endsWith("\"") && json.length() > 1) {
+            //simple component with only text used, minecraft serializer outputs the text in quotes instead of full json
+            setText(json.substring(1, json.length()-1));
+            return;
+        }
+        JSONObject jsonObject;
+        try {
+            jsonObject = (JSONObject) new JSONParser().parse(json);
+        } catch (ParseException e) {
+            TabAPI.getInstance().logError("Failed to deserialize json component " + json, e);
+            return;
+        }
+ /*       if (jsonObject.containsKey("type")) {
+            return new ChatComponentEntity((String) jsonObject.get("type"), UUID.fromString((String) jsonObject.get("id")), IChatBaseComponent.deserialize(jsonObject.get("name").toString()).toFlatText());
+        }*/
+        setText((String) jsonObject.get("text"));
+        getModifier().setBold(getBoolean(jsonObject, "bold"));
+        getModifier().setItalic(getBoolean(jsonObject, "italic"));
+        getModifier().setUnderlined(getBoolean(jsonObject, "underlined"));
+        getModifier().setStrikethrough(getBoolean(jsonObject, "strikethrough"));
+        getModifier().setObfuscated(getBoolean(jsonObject, "obfuscated"));
+        getModifier().setColor(TextColor.fromString(((String) jsonObject.get("color"))));
+        if (jsonObject.containsKey("clickEvent")) {
+            JSONObject clickEvent = (JSONObject) jsonObject.get("clickEvent");
+            String action = (String) clickEvent.get("action");
+            String value = clickEvent.get("value").toString();
+            getModifier().onClick(ChatClickable.EnumClickAction.valueOf(action.toUpperCase()), value);
+        }
+        if (jsonObject.containsKey("hoverEvent")) {
+            JSONObject hoverEvent = (JSONObject) jsonObject.get("hoverEvent");
+            String action = (String) hoverEvent.get("action");
+            String value = (String) hoverEvent.get("value");
+            getModifier().onHover(ChatHoverable.EnumHoverAction.valueOf(action.toUpperCase()), deserialize(value));
+        }
+        if (jsonObject.containsKey("extra")) {
+            List<Object> list = (List<Object>) jsonObject.get("extra");
+            for (Object extra : list) {
+                String string = extra.toString();
+                //reverting .toString() removing "" for simple text
+                if (!string.startsWith("{")) string = "\"" + string + "\"";
+                addExtra(IChatBaseComponent.deserialize(string));
+            }
+        }
+    }
+
+    /**
+     * 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
+     */
+    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

@@ -0,0 +1,207 @@
+package me.neznamy.tab.api.chat;
+
+import lombok.Getter;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
+
+/**
+ * An enum containing all possible legacy color codes and magic codes. Also contains handy color-related methods.
+ */
+public enum EnumChatFormat {
+
+    BLACK('0', "000000"),
+    DARK_BLUE('1', "0000AA"),
+    DARK_GREEN('2', "00AA00"),
+    DARK_AQUA('3', "00AAAA"),
+    DARK_RED('4', "AA0000"),
+    DARK_PURPLE('5', "AA00AA"),
+    GOLD('6', "FFAA00"),
+    GRAY('7', "AAAAAA"),
+    DARK_GRAY('8', "555555"),
+    BLUE('9', "5555FF"),
+    GREEN('a', "55FF55"),
+    AQUA('b', "55FFFF"),
+    RED('c', "FF5555"),
+    LIGHT_PURPLE('d', "FF55FF"),
+    YELLOW('e', "FFFF55"),
+    WHITE('f', "FFFFFF"),
+    OBFUSCATED('k'),
+    BOLD('l'),
+    STRIKETHROUGH('m'),
+    UNDERLINE('n'),
+    ITALIC('o'),
+    RESET('r');
+
+    /** Creating a constant to avoid memory allocations on each request */
+    public static final EnumChatFormat[] VALUES = values();
+
+    /** The symbol minecraft uses to colorize text */
+    public static final char COLOR_CHAR = 0x00a7;
+
+    /** The color symbol in form of a string */
+    public static final String COLOR_STRING = String.valueOf(COLOR_CHAR);
+
+    /** Character representing the color or magic code */
+    @Getter private final char character;
+
+    /** Red value of this constant, 0 for magic codes */
+    @Getter private final short red;
+
+    /** Green value of this constant, 0 for magic codes */
+    @Getter private final short green;
+
+    /** Blue value of this constant, 0 for magic codes */
+    @Getter private final short blue;
+
+    /** Color as 6-digit hex code, null for magic codes */
+    @Getter private final String hexCode;
+
+    /** Color symbol followed by constant's character */
+    @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
+     */
+    EnumChatFormat(char character, String hexCode) {
+        this.character = character;
+        this.format = String.valueOf(COLOR_CHAR) + character;
+        this.hexCode = hexCode;
+        int hexColor = Integer.parseInt(hexCode, 16);
+        red = (short) ((hexColor >> 16) & 0xFF);
+        green = (short) ((hexColor >> 8) & 0xFF);
+        blue = (short) (hexColor & 0xFF);
+    }
+
+    /**
+     * Constructs new magic code instance with given character
+     *
+     * @param   character
+     *          character representing the magic code
+     */
+    EnumChatFormat(char character) {
+        this.character = character;
+        this.format = String.valueOf(COLOR_CHAR) + character;
+        red = 0;
+        green = 0;
+        blue = 0;
+        hexCode = null;
+    }
+
+    /**
+     * 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
+     */
+    public static EnumChatFormat getByChar(char c) {
+        for (EnumChatFormat format : VALUES) {
+            if (format.character == c) return format;
+        }
+        return null;
+    }
+
+    /**
+     * 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
+     */
+    public static EnumChatFormat lastColorsOf(String string) {
+        if (string == null || string.length() == 0) return EnumChatFormat.WHITE;
+        String legacyText = RGBUtils.getInstance().convertRGBtoLegacy(string);
+        String last = getLastColors(legacyText);
+        if (last.length() > 0) {
+            char c = last.toCharArray()[1];
+            for (EnumChatFormat e : VALUES) {
+                if (e.character == c) return e;
+            }
+        }
+        return EnumChatFormat.WHITE;
+    }
+
+    /**
+     * 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
+     */
+    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;
+        }
+        return null;
+    }
+
+    /**
+     * 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
+     */
+    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)) {
+                b[i] = COLOR_CHAR;
+                b[(i + 1)] = Character.toLowerCase(b[(i + 1)]);
+            }
+        }
+        return new String(b);
+    }
+
+    /**
+     * Turns back the color symbol into '&amp;' symbol in provided text.
+     *
+     * @param   text
+     *          text to revert colors in
+     * @return  reverted text
+     */
+    public static String decolor(String text) {
+        if (text == null) return null;
+        if (!text.contains(COLOR_STRING)) return text;
+        return text.replace(COLOR_CHAR, '&');
+    }
+
+    /**
+     * 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
+     */
+    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--) {
+            char section = input.charAt(index);
+            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);
+                    result.insert(1, c);
+                    if ("0123456789AaBbCcDdEeFfRr".contains(String.valueOf(c))) {
+                        break;
+                    }
+                }
+            }
+        }
+        return result.toString();
+    }
+}

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

@@ -0,0 +1,373 @@
+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.ComponentCache;
+import org.json.simple.JSONObject;
+
+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 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 */
+    @Getter @Setter private String text;
+
+    /** Chat modifier containing color, magic codes, hover and click event */
+    @Getter @Setter @NonNull private ChatModifier modifier = new ChatModifier();
+
+    /** Extra components used in "extra" field */
+    private List<IChatBaseComponent> extra;
+
+    /**
+     * Constructs a new component which is a clone of provided component
+     *
+     * @param   component
+     *          component to clone
+     */
+    public IChatBaseComponent(@NonNull IChatBaseComponent component) {
+        this.text = component.text;
+        this.modifier = new ChatModifier(component.modifier);
+        for (IChatBaseComponent child : component.getExtra()) {
+            addExtra(new IChatBaseComponent(child));
+        }
+    }
+
+    /**
+     * Constructs new instance with given text
+     *
+     * @param   text
+     *          text to display
+     */
+    public IChatBaseComponent(String text) {
+        this.text = text;
+    }
+
+    /**
+     * Returns list of extra components. If no extra components are defined, returns empty list.
+     *
+     * @return  list of extra components
+     */
+    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
+     */
+    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;
+    }
+
+    /**
+     * Appends provided component as extra component
+     *
+     * @param   child
+     *          component to append
+     */
+    public void addExtra(@NonNull IChatBaseComponent child) {
+        if (extra == null) extra = new ArrayList<>();
+        extra.add(child);
+    }
+
+    /**
+     * 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
+     */
+    public static IChatBaseComponent deserialize(String json) {
+        if (json == null) return null;
+        return new DeserializedChatComponent(json);
+    }
+
+    /**
+     * 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)
+     */
+    @Override
+    public String toString() {
+        JSONObject json = new JSONObject();
+        if (text != null) json.put("text", text);
+        if (modifier.getTargetVersion() == null) modifier.setTargetVersion(TabAPI.getInstance().getServerVersion()); //packet.toString() was called as a part of a debug message
+        json.putAll(modifier.serialize());
+        if (extra != null) json.put("extra", extra);
+        return json.toString();
+    }
+
+    /**
+     * 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
+     */
+    public String toString(ProtocolVersion clientVersion) {
+        return toString(clientVersion, false);
+    }
+
+    /**
+     * 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
+     */
+    public String toString(ProtocolVersion clientVersion, boolean sendTranslatableIfEmpty) {
+        if (extra == null) {
+            if (text == null) return null;
+            if (text.length() == 0) {
+                if (sendTranslatableIfEmpty) {
+                    return "{\"translate\":\"\"}";
+                } else {
+                    return "{\"text\":\"\"}";
+                }
+            }
+        }
+        modifier.setTargetVersion(clientVersion);
+        for (IChatBaseComponent child : getExtra()) {
+            child.modifier.setTargetVersion(clientVersion);
+        }
+        return serializeCache.get(this, clientVersion);
+    }
+
+    /**
+     * Returns organized component from colored text
+     *
+     * @param   originalText
+     *          text to convert
+     * @return  organized component from colored text
+     */
+    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++) {
+            char c = text.charAt(i);
+            if (c == EnumChatFormat.COLOR_CHAR) {
+                i++;
+                if (i >= text.length()) {
+                    break;
+                }
+                c = text.charAt(i);
+                if ((c >= 'A') && (c <= 'Z')) {
+                    c = (char)(c + ' ');
+                }
+                EnumChatFormat format = EnumChatFormat.getByChar(c);
+                if (format != null) {
+                    if (builder.length() > 0) {
+                        component.setText(builder.toString());
+                        components.add(component);
+                        component = new IChatBaseComponent(component);
+                        component.text = null;
+                        builder = new StringBuilder();
+                    }
+                    switch (format) {
+                    case BOLD: 
+                        component.modifier.setBold(true);
+                        break;
+                    case ITALIC: 
+                        component.modifier.setItalic(true);
+                        break;
+                    case UNDERLINE: 
+                        component.modifier.setUnderlined(true);
+                        break;
+                    case STRIKETHROUGH: 
+                        component.modifier.setStrikethrough(true);
+                        break;
+                    case OBFUSCATED: 
+                        component.modifier.setObfuscated(true);
+                        break;
+                    case RESET: 
+                        component = new IChatBaseComponent();
+                        component.modifier.setColor(new TextColor(EnumChatFormat.WHITE));
+                        break;
+                    default:
+                        component = new IChatBaseComponent();
+                        component.modifier.setColor(new TextColor(format));
+                        break;
+                    }
+                }
+            } else if (c == '#' && text.length() > i+6) {
+                String hex = text.substring(i+1, i+7);
+                if (RGBUtils.getInstance().isHexCode(hex)) {
+                    TextColor color;
+                    if (containsLegacyCode(text, i)) {
+                        color = new TextColor(hex, EnumChatFormat.getByChar(text.charAt(i+8)));
+                        i += 8;
+                    } else {
+                        color = new TextColor(hex);
+                        i += 6;
+                    }
+                    if (builder.length() > 0) {
+                        component.setText(builder.toString());
+                        components.add(component);
+                        builder = new StringBuilder();
+                    }
+                    component = new IChatBaseComponent();
+                    component.modifier.setColor(color);
+                } else {
+                    builder.append(c);
+                }
+            } else {
+                builder.append(c);
+            }
+        }
+        component.setText(builder.toString());
+        components.add(component);
+        return new IChatBaseComponent("").setExtra(components);
+    }
+
+    /**
+     * 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
+     */
+    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;
+    }
+
+    /**
+     * Converts this component into a simple text with legacy colors (the closest match if color is set to RGB)
+     *
+     * @return  The simple text format
+     */
+    public String toLegacyText() {
+        StringBuilder builder = new StringBuilder();
+        append(builder, "");
+        return builder.toString();
+    }
+
+    /**
+     * 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  new formatting, might be identical to previous one
+     */
+    private String append(StringBuilder builder, String previousFormatting) {
+        String formatting = previousFormatting;
+        if (text != null) {
+            formatting = getFormatting();
+            if (!formatting.equals(previousFormatting)) {
+                builder.append(formatting);
+            }
+            builder.append(text);
+
+        }
+        for (IChatBaseComponent component : getExtra()) {
+            formatting = component.append(builder, formatting);
+        }
+        return formatting;
+    }
+
+    /**
+     * Returns colors and magic codes of this component
+     *
+     * @return  used colors and magic codes
+     */
+    private String getFormatting() {
+        StringBuilder builder = new StringBuilder();
+        if (modifier.getColor() != null) {
+            if (modifier.getColor().getLegacyColor() == EnumChatFormat.WHITE) {
+                //preventing unwanted &r -> &f conversion and stopping the <1.13 client bug fix from working
+                builder.append(EnumChatFormat.RESET.getFormat());
+            } else {
+                builder.append(modifier.getColor().getLegacyColor().getFormat());
+            }
+        }
+        builder.append(modifier.getMagicCodes());
+        return builder.toString();
+    }
+
+    /**
+     * Returns raw text without colors, only works correctly when component is organized
+     *
+     * @return  raw text in this component and all child components
+     */
+    public String toRawText() {
+        StringBuilder builder = new StringBuilder();
+        if (text != null) builder.append(text);
+        for (IChatBaseComponent child : getExtra()) {
+            if (child.text != null) builder.append(child.text);
+        }
+        return builder.toString();
+    }
+
+    /**
+     * Converts the component into flat text with used colors (including rgb) and magic codes
+     *
+     * @return  converted text
+     */
+    public String toFlatText() {
+        StringBuilder builder = new StringBuilder();
+        if (modifier.getColor() != null) builder.append("#").append(modifier.getColor().getHexCode());
+        builder.append(modifier.getMagicCodes());
+        if (text != null) builder.append(text);
+        for (IChatBaseComponent child : getExtra()) {
+            builder.append(child.toFlatText());
+        }
+        return builder.toString();
+    }
+
+    /**
+     * 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
+     */
+    public static IChatBaseComponent optimizedComponent(String text) {
+        return stringCache.get(text, null);
+    }
+}

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

@@ -0,0 +1,210 @@
+package me.neznamy.tab.api.chat;
+
+import lombok.Getter;
+import lombok.NonNull;
+import me.neznamy.tab.api.util.Preconditions;
+
+/**
+ * A class representing a component color, which can be either RGB or legacy code.
+ */
+public class TextColor {
+
+    /**
+     * RGB values as a single number of 3 8-bit numbers (0-255).
+     * It is only initialized if colors are actually used to avoid
+     * unnecessary memory allocations with string operations.
+     */
+    private int rgb = -1;
+
+    /** Closest legacy color to this color object. */
+    private EnumChatFormat legacyColor;
+
+    /** HEX code of this color as a 6-digit hexadecimal string without "#" prefix. */
+    private String hexCode;
+
+    /**
+     * 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. */
+    @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}
+     */
+    public TextColor(@NonNull TextColor color) {
+        rgb = color.rgb;
+        legacyColor = color.legacyColor;
+        hexCode = color.hexCode;
+        legacyColorForced = color.legacyColorForced;
+    }
+
+    /**
+     * 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}
+     */
+    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}
+     */
+    public TextColor(@NonNull String hexCode, EnumChatFormat legacyColor) {
+        this.hexCode = hexCode;
+        this.legacyColorForced = true;
+        this.legacyColor = legacyColor;
+    }
+
+    /**
+     * Constructs new instance from provided legacy color
+     *
+     * @param   legacyColor
+     *          legacy color to construct the instance from
+     * @throws  IllegalArgumentException
+     *          if {@code legacyColor} is {@code null}
+     */
+    public TextColor(@NonNull EnumChatFormat legacyColor) {
+        this.rgb = (legacyColor.getRed() << 16) + (legacyColor.getGreen() << 8) + legacyColor.getBlue();
+        this.hexCode = legacyColor.getHexCode();
+    }
+
+    /**
+     * 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})
+     */
+    public TextColor(int red, int green, int blue) {
+        Preconditions.checkRange(red, 0, 255, "red");
+        Preconditions.checkRange(green, 0, 255, "green");
+        Preconditions.checkRange(blue, 0, 255, "blue");
+        this.rgb = (red << 16) + (green << 8) + blue;
+    }
+
+    /**
+     * Loads the closest legacy color based currently provided values
+     */
+    private EnumChatFormat loadClosestColor() {
+        double minMaxDist = 9999;
+        double maxDist;
+        EnumChatFormat closestColor = EnumChatFormat.WHITE;
+        for (EnumChatFormat color : EnumChatFormat.VALUES) {
+            int rDiff = Math.abs(color.getRed() - getRed());
+            int gDiff = Math.abs(color.getGreen() - getGreen());
+            int bDiff = Math.abs(color.getBlue() - getBlue());
+            maxDist = rDiff;
+            if (gDiff > maxDist) maxDist = gDiff;
+            if (bDiff > maxDist) maxDist = bDiff;
+            if (maxDist < minMaxDist) {
+                minMaxDist = maxDist;
+                closestColor = color;
+            }
+        }
+        return closestColor;
+    }
+
+    /**
+     * Returns {@code red} value
+     *
+     * @return  red value
+     */
+    public int getRed() {
+        if (rgb == -1) rgb = Integer.parseInt(hexCode, 16);
+        return (rgb >> 16) & 0xFF;
+    }
+
+    /**
+     * Returns {@code green} value
+     *
+     * @return  green value
+     */
+    public int getGreen() {
+        if (rgb == -1) rgb = Integer.parseInt(hexCode, 16);
+        return (rgb >> 8) & 0xFF;
+    }
+
+    /**
+     * Returns {@code blue} value
+     *
+     * @return  blue value
+     */
+    public int getBlue() {
+        if (rgb == -1) rgb = Integer.parseInt(hexCode, 16);
+        return rgb & 0xFF;
+    }
+
+    /**
+     * 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
+     */
+    public EnumChatFormat getLegacyColor() {
+        if (legacyColor == null) legacyColor = loadClosestColor();
+        return legacyColor;
+    }
+
+    /**
+     * Returns 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);
+        return hexCode;
+    }
+
+    /**
+     * 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
+     */
+    public String toString() {
+        EnumChatFormat legacyEquivalent = EnumChatFormat.fromRGBExact(getRed(), getGreen(), getBlue());
+        if (legacyEquivalent != null) {
+            //not sending old colors as RGB to 1.16 clients if not needed as <1.16 servers will fail to apply color
+            return legacyEquivalent.toString().toLowerCase();
+        }
+        return "#" + getHexCode();
+    }
+
+    /**
+     * 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
+     */
+    public static TextColor fromString(String string) {
+        if (string == null) return null;
+        if (string.startsWith("#")) return new TextColor(string.substring(1));
+        return new TextColor(EnumChatFormat.valueOf(string.toUpperCase()));
+    }
+}

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

@@ -0,0 +1,164 @@
+package me.neznamy.tab.api.chat.rgb;
+
+import lombok.Getter;
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+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.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
+ */
+public class RGBUtils {
+
+    /** Instance of the class */
+    @Getter private static final RGBUtils instance = new RGBUtils();
+
+    /** Registered RGB formatters */
+    private final RGBFormatter[] formats;
+
+    /** Registered gradient patterns */
+    private final GradientPattern[] gradients;
+
+    /** TAB's RGB pattern, used to convert text to bukkit format for boss bar */
+    private final Pattern tabPattern = Pattern.compile("#[0-9a-fA-F]{6}");
+
+    /** RGB pattern for legacy codes */
+    private final Pattern tabPatternLegacy = Pattern.compile("#[0-9a-fA-F]{6}\\|.");
+
+    /**
+     * Constructs new instance and loads all RGB patterns and gradients
+     */
+    public RGBUtils() {
+        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(),
+                //<#RRGGBB>Text</#RRGGBB>
+                new CommonGradient(Pattern.compile("<#[0-9a-fA-F]{6}>[^<]*</#[0-9a-fA-F]{6}>"),
+                        Pattern.compile("<#[0-9a-fA-F]{6}\\|.>[^<]*</#[0-9a-fA-F]{6}>"),
+                        "<#", 9, 2, 9, 7),
+                //<$#RRGGBB>Text<$#RRGGBB>
+                new CommonGradient(Pattern.compile("<\\$#[0-9a-fA-F]{6}>[^<]*<\\$#[0-9a-fA-F]{6}>"),
+                        Pattern.compile("<\\$#[0-9a-fA-F]{6}\\|.>[^<]*<\\$#[0-9a-fA-F]{6}>"),
+                        "<$", 10, 3, 10, 7),
+                new KyoriGradient()
+        };
+    }
+
+    /**
+     * Applies all RGB formats and gradients to text and returns it.
+     *
+     * @param   text
+     *          original text
+     * @return  text where everything is converted to #RRGGBB
+     */
+    public String applyFormats(@NonNull String text) {
+        String replaced = text;
+        for (GradientPattern pattern : gradients) {
+            replaced = pattern.applyPattern(replaced, false);
+        }
+        for (RGBFormatter formatter : formats) {
+            replaced = formatter.reformat(replaced);
+        }
+        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
+     */
+    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);
+            for (Pattern p : new Pattern[]{tabPatternLegacy, tabPattern}) {
+                Matcher m = p.matcher(replaced);
+                while (m.find()) {
+                    String hexCode = m.group();
+                    String fixed = "&x&" + hexCode.charAt(1) + "&" + hexCode.charAt(2) + "&" + hexCode.charAt(3) + "&" + hexCode.charAt(4) + "&" + hexCode.charAt(5) + "&" + hexCode.charAt(6);
+                    replaced = replaced.replace(hexCode, EnumChatFormat.color(fixed));
+                }
+            }
+            return replaced;
+        } else {
+            return convertRGBtoLegacy(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;
+        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
+     */
+    public boolean isHexCode(@NonNull String string) {
+        if (string.length() != 6) return false;
+        for (int i=0; i<6; i++) {
+            char c = string.charAt(i);
+            if (c < 48 || (c > 57 && c < 65) || (c > 70 && c < 97) || c > 102) return false;
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,27 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import me.neznamy.tab.api.chat.EnumChatFormat;
+
+/**
+ * Formatter for &x&R&R&G&G&B&B
+ */
+public class BukkitFormat implements RGBFormatter {
+
+    private final Pattern pattern = Pattern.compile("[" + EnumChatFormat.COLOR_CHAR + "&]x[" + EnumChatFormat.COLOR_CHAR + "&\\p{XDigit}]{12}");
+    
+    @Override
+    public String reformat(String text) {
+        if (!text.contains("&x") && !text.contains(EnumChatFormat.COLOR_CHAR + "x")) return text;
+        String replaced = text;
+        Matcher m = pattern.matcher(replaced);
+        while (m.find()) {
+            String hexCode = m.group();
+            String fixed = new String(new char[] {'#', hexCode.charAt(3), hexCode.charAt(5), hexCode.charAt(7), hexCode.charAt(9), hexCode.charAt(11), hexCode.charAt(13)});
+            replaced = replaced.replace(hexCode, fixed);
+        }
+        return replaced;
+    }
+}

api/src/main/java/me/neznamy/tab/api/chat/rgb/format/CMIFormat.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 CMIFormat 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/HtmlFormat.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 HtmlFormat implements RGBFormatter {
+
+    private final Pattern pattern = Pattern.compile("#<[0-9a-fA-F]{6}>");
+
+    @Override
+    public String reformat(String text) {
+        if (!text.contains("#<")) return text;
+        Matcher m = pattern.matcher(text);
+        String replaced = text;
+        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/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

@@ -0,0 +1,16 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+/**
+ * Abstract class for different RGB patterns
+ */
+public interface RGBFormatter {
+
+    /**
+     * Reformats RGB codes in provided text into #RRGGBB format
+     *
+     * @param   text
+     *          text to format
+     * @return  reformatted text
+     */
+    String reformat(String text);
+}

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

@@ -0,0 +1,12 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+/**
+ * Formatter for &#RRGGBB
+ */
+public class UnnamedFormat1 implements RGBFormatter {
+
+    @Override
+    public String reformat(String text) {
+        return text.contains("&#") ? text.replace("&#", "#") : text;
+    }
+}

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

@@ -0,0 +1,30 @@
+package me.neznamy.tab.api.chat.rgb.gradient;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class CMIGradient extends CommonGradient {
+
+    //pattern for {#RRGGBB<>}
+    private final Pattern shortcutPattern = Pattern.compile("\\{#[0-9a-fA-F]{6}<>}");
+    
+    public CMIGradient() {
+        super(Pattern.compile("\\{#[0-9a-fA-F]{6}>}[^{]*\\{#[0-9a-fA-F]{6}<}"),
+                Pattern.compile("\\{#[0-9a-fA-F]{6}\\|.>}[^{]*\\{#[0-9a-fA-F]{6}<}"),
+                "{#", 9, 2, 10, 8);
+    }
+    
+    @Override
+    public String applyPattern(String text, boolean ignorePlaceholders) {
+        String replaced = text;
+        if (replaced.contains("<>}")) {
+            Matcher m = shortcutPattern.matcher(replaced);
+            while (m.find()) {
+                String format = m.group();
+                String code = format.substring(2, 8);
+                replaced = replaced.replace(format, "{#" + code + "<}{#" + code + ">}");
+            }
+        }
+        return super.applyPattern(replaced, ignorePlaceholders);
+    }
+}

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

@@ -0,0 +1,48 @@
+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;
+    private final Pattern legacyPattern;
+    private final String containCheck;
+    private final int legacyCharPosition;
+    private final int startColorStart;
+    private final int messageStart;
+    private final int endColorStartSub;
+
+    @Override
+    public String applyPattern(String text, boolean ignorePlaceholders) {
+        if (!text.contains(containCheck)) return text;
+        String replaced = text;
+        Matcher m = legacyPattern.matcher(replaced);
+        while (m.find()) {
+            String format = m.group();
+            EnumChatFormat legacyColor = EnumChatFormat.getByChar(format.charAt(legacyCharPosition));
+            if ((ignorePlaceholders && format.contains("%")) || legacyColor == null) continue;
+            TextColor start = new TextColor(format.substring(startColorStart, startColorStart+6), legacyColor);
+            String message = format.substring(messageStart+2, format.length()-10);
+            TextColor end = new TextColor(format.substring(format.length()-endColorStartSub, format.length()-endColorStartSub+6));
+            String applied = asGradient(start, message, end);
+            replaced = replaced.replace(format, applied);
+        }
+        m = pattern.matcher(replaced);
+        while (m.find()) {
+            String format = m.group();
+            if (ignorePlaceholders && format.contains("%")) continue;
+            TextColor start = new TextColor(format.substring(startColorStart, startColorStart+6));
+            String message = format.substring(messageStart, format.length()-10);
+            TextColor end = new TextColor(format.substring(format.length()-endColorStartSub, format.length()-endColorStartSub+6));
+            String applied = asGradient(start, message, end);
+            replaced = replaced.replace(format, applied);
+        }
+        return replaced;
+    }
+}

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

@@ -0,0 +1,57 @@
+package me.neznamy.tab.api.chat.rgb.gradient;
+
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.TextColor;
+
+/**
+ * Abstract class for applying different gradient patterns
+ */
+public interface GradientPattern {
+
+    /**
+     * Applies gradients in provided text and returns text using only #RRGGBB
+     *
+     * @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
+     */
+    default String asGradient(TextColor start, String text, TextColor end) {
+        //lazy support for magic codes in gradients
+        String magicCodes = EnumChatFormat.getLastColors(text);
+        String deColorized = text.substring(magicCodes.length());
+        StringBuilder sb = new StringBuilder();
+        int length = deColorized.length();
+        if (length == 1) {
+            sb.append("#");
+            sb.append(new TextColor(start.getRed(), start.getGreen(), start.getBlue()).getHexCode());
+            if (start.isLegacyColorForced()) sb.append("|").append(start.getLegacyColor().getCharacter());
+            sb.append(magicCodes);
+            sb.append(deColorized);
+            return sb.toString();
+        }
+        for (int i=0; i<length; i++) {
+            int red = (int) (start.getRed() + (float)(end.getRed() - start.getRed())/(length-1)*i);
+            int green = (int) (start.getGreen() + (float)(end.getGreen() - start.getGreen())/(length-1)*i);
+            int blue = (int) (start.getBlue() + (float)(end.getBlue() - start.getBlue())/(length-1)*i);
+            sb.append("#");
+            sb.append(new TextColor(red, green, blue).getHexCode());
+            if (start.isLegacyColorForced()) sb.append("|").append(start.getLegacyColor().getCharacter());
+            sb.append(magicCodes);
+            sb.append(deColorized.charAt(i));
+        }
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,46 @@
+package me.neznamy.tab.api.chat.rgb.gradient;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+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>
+ */
+public class KyoriGradient implements GradientPattern {
+
+    private final Pattern pattern = Pattern.compile("<gradient:#[0-9a-fA-F]{6}:#[0-9a-fA-F]{6}>[^<]*</gradient>");
+
+    private final Pattern patternLegacy = Pattern.compile("<gradient:#[0-9a-fA-F]{6}\\|.:#[0-9a-fA-F]{6}>[^<]*</gradient>");
+    
+    @Override
+    public String applyPattern(String text, boolean ignorePlaceholders) {
+        if (!text.contains("<grad")) return text;
+        String replaced = text;
+        Matcher m = patternLegacy.matcher(replaced);
+        while (m.find()) {
+            String format = m.group();
+            EnumChatFormat legacyColor = EnumChatFormat.getByChar(format.charAt(18));
+            if ((ignorePlaceholders && format.contains("%")) || legacyColor == null) continue;
+            TextColor start = new TextColor(format.substring(11, 17), legacyColor);
+            String message = format.substring(28, format.length()-11);
+            TextColor end = new TextColor(format.substring(21, 27));
+            String applied = asGradient(start, message, end);
+            replaced = replaced.replace(format, applied);
+        }
+        m = pattern.matcher(replaced);
+        while (m.find()) {
+            String format = m.group();
+            if (ignorePlaceholders && format.contains("%")) continue;
+            TextColor start = new TextColor(format.substring(11, 17));
+            String message = format.substring(26, format.length()-11);
+            TextColor end = new TextColor(format.substring(19, 25));
+            String applied = asGradient(start, message, end);
+            replaced = replaced.replace(format, applied);
+        }
+        return replaced;
+    }
+}

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

@@ -0,0 +1,399 @@
+package me.neznamy.tab.api.config;
+
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+import me.neznamy.tab.api.TabAPI;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Abstract class for configuration file
+ */
+@SuppressWarnings("unchecked")
+public abstract class ConfigurationFile {
+
+    /** Comments on top of the file */
+    protected List<String> header;
+
+    /** Configuration file content */
+    @Getter @Setter protected Map<String, Object> values;
+
+    /** File to use */
+    @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
+     */
+    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()) {
+            if (source == null) throw new IllegalStateException("File does not exist and source is null");
+            Files.copy(source, file.toPath());
+        }
+        detectHeader();
+    }
+
+    /**
+     * Saves values from map to the file
+     */
+    public abstract void save();
+
+    /**
+     * Returns simple name of the file
+     *
+     * @return  simple name of the file
+     */
+    public String getName() {
+        return file.getName();
+    }
+
+    /**
+     * 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
+     */
+    public Object getObject(String path, Object defaultValue) {
+        Object value = values;
+        for (String section : path.contains(".") ? path.split("\\.") : new String[] {path}) {
+            if (!(value instanceof Map)) {
+                if (defaultValue != null) set(path, defaultValue);
+                return defaultValue;
+            }
+            value = getIgnoreCase((Map<Object, Object>) value, section);
+        }
+        if (value == null && defaultValue != null) {
+            TabAPI.getInstance().debug("Inserting missing config option \"" + path + "\" with value \"" + defaultValue + "\" into " + file.getName());
+            set(path, defaultValue);
+            return defaultValue;
+        }
+        return value;
+    }
+
+    /**
+     * 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
+     */
+    public Object getObject(String path) {
+        return getObject(path, null);
+    }
+
+    public Object getObject(String[] path) {
+        Object value = values;
+        for (String section : path) {
+            if (!(value instanceof Map)) {
+                return null;
+            }
+            value = getIgnoreCase((Map<Object, Object>) value, section);
+        }
+        return value;
+    }
+
+    /**
+     * 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
+     */
+    private Object getIgnoreCase(Map<Object, Object> map, String key) {
+        for (Entry<Object, Object> entry : map.entrySet()) {
+            if (entry.getKey().toString().equalsIgnoreCase(key)) return entry.getValue();
+        }
+        return map.get(key);
+    }
+
+    /**
+     * 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
+     */
+    public String getString(String path) {
+        return getString(path, null);
+    }
+
+    /**
+     * Returns config option with specified path as {@code String}. 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 as {@code String}
+     */
+    public String getString(String path, String defaultValue) {
+        Object value = getObject(path, defaultValue);
+        if (value == null) return defaultValue;
+        return String.valueOf(value);
+    }
+
+    /**
+     * 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
+     */
+    public List<String> getStringList(String path) {
+        return getStringList(path, null);
+    }
+
+    /**
+     * Returns config option with specified path as {@code List<String>}. 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 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);
+        if (value == null) return defaultValue;
+        if (!(value instanceof List)) {
+            return new ArrayList<>();
+        }
+        List<String> fixedList = new ArrayList<>();
+        for (Object key : (List<Object>)value) {
+            fixedList.add(String.valueOf(key));
+        }
+        return fixedList;
+    }
+
+    /**
+     * 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
+     */
+    public Integer getInt(String path) {
+        return getInt(path, null);
+    }
+
+    /**
+     * Returns config option with specified path as {@code Integer}. 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 as {@code Integer}
+     */
+    public Integer getInt(String path, Integer defaultValue) {
+        Object value = getObject(path, defaultValue);
+        if (value == null) return defaultValue;
+        try{
+            return Integer.parseInt(value.toString());
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * Returns config option with specified path as {@code Boolean}. 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 as {@code Boolean}
+     */
+    public boolean getBoolean(String path, boolean defaultValue) {
+        Object value = getObject(path, defaultValue);
+        if (value == null) return defaultValue;
+        return Boolean.parseBoolean(value.toString());
+    }
+
+    /**
+     * Returns config option with specified path as {@code Double}. 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 as {@code Double}
+     */
+    public Double getDouble(String path, double defaultValue) {
+        Object value = getObject(path, defaultValue);
+        if (value == null) return defaultValue;
+        try {
+            return Double.parseDouble(value.toString());
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 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>}
+     */
+    public <K, V> Map<K, V> getConfigurationSection(String path) {
+        if (path == null || path.length() == 0) return (Map<K, V>) values;
+        Object value = getObject(path, null);
+        if (value instanceof Map) {
+            return (Map<K, V>) value;
+        } else {
+            return new LinkedHashMap<>();
+        }
+    }
+
+    /**
+     * 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
+     */
+    public boolean hasConfigOption(String path) {
+        return getObject(path) != null;
+    }
+
+    /**
+     * 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
+     */
+    public void set(String path, Object value) {
+        set(values, path, value);
+        save();
+    }
+
+    /**
+     * 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
+     */
+    private Map<String, Object> set(Map<String, Object> map, String path, Object value) {
+        if (path.contains(".")) {
+            String keyWord = getRealKey(map, path.split("\\.")[0]);
+            Object subMap = map.get(keyWord);
+            if (!(subMap instanceof Map)) {
+                subMap = new LinkedHashMap<>();
+            }
+            map.put(keyWord, set((Map<String, Object>) subMap, path.substring(keyWord.length()+1), value));
+        } else {
+            if (value == null) {
+                map.remove(getRealKey(map, path));
+            } else {
+                map.put(path, value);
+            }
+        }
+        return map;
+    }
+
+    /**
+     * 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
+     */
+    private String getRealKey(Map<?, ?> map, String key) {
+        for (Object mapKey : map.keySet()) {
+            if (mapKey.toString().equalsIgnoreCase(key)) return mapKey.toString();
+        }
+        return key;
+    }
+
+    /**
+     * Detects header of a file (first lines of file starting with #).
+     *
+     * @throws  IOException
+     *          if I/O operation fails
+     */
+    private void detectHeader() throws IOException {
+        header = new ArrayList<>();
+        for (String line : Files.readAllLines(file.toPath())) {
+            if (line.startsWith("#")) {
+                header.add(line);
+            } else {
+                break;
+            }
+        }
+    }
+
+    /**
+     * Inserts header back into file. This is required after calling {@link #save()}, because
+     * it destroys the header.
+     *
+     * @throws  IOException
+     *          if I/O operation fails
+     */
+    public void fixHeader() throws IOException {
+        if (header == null) return;
+        List<String> content = new ArrayList<>(header);
+        content.addAll(Files.readAllLines(file.toPath()));
+        Files.delete(file.toPath());
+        if (file.createNewFile()) {
+            Files.write(file.toPath(), content);
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+package me.neznamy.tab.api.config;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.error.YAMLException;
+
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.yamlassist.YamlAssist;
+
+/**
+ * YAML implementation of ConfigurationFile
+ */
+public class YamlConfigurationFile extends ConfigurationFile {
+
+    /** SnakeYAML instance */
+    private static final Yaml yaml;
+
+    static {
+        DumperOptions options = new DumperOptions();
+        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        yaml = new Yaml(options);
+    }
+
+    /**
+     * 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
+     */
+    public YamlConfigurationFile(InputStream source, File destination) throws YAMLException, IOException {
+        super(source, destination);
+        FileInputStream input = null;
+        try {
+            input = new FileInputStream(file);
+            values = yaml.load(input);
+            if (values == null) values = new LinkedHashMap<>();
+            input.close();
+        } catch (YAMLException e) {
+            if (input != null) input.close();
+            TabAPI tab = TabAPI.getInstance();
+            tab.setBrokenFile(destination.getName());
+            tab.sendConsoleMessage("&cFile " + destination + " has broken syntax.", true);
+            tab.sendConsoleMessage("&6Error message from yaml parser: " + e.getMessage(), true);
+            List<String> suggestions = YamlAssist.getSuggestions(file);
+            if (!suggestions.isEmpty()) {
+                tab.sendConsoleMessage("&dSuggestions to fix yaml syntax:", true);
+                for (String suggestion : suggestions) {
+                    tab.sendConsoleMessage("&d- " + suggestion, true);
+                }
+            }
+            throw e;
+        }
+    }
+
+    @Override
+    public void save() {
+        try {
+            Writer writer = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8);
+            yaml.dump(values, writer);
+            writer.close();
+            fixHeader();
+        } catch (IOException e) {
+            TabAPI.getInstance().sendConsoleMessage("&cFailed to save yaml file " + file.getPath() + " with content " + values.toString(), true);
+        }
+    }
+}

api/src/main/java/me/neznamy/tab/api/event/EventBus.java

@@ -0,0 +1,53 @@
+package me.neznamy.tab.api.event;
+
+/**
+ * The event bus. This is used to register event listeners/handlers for
+ * handling events that may be fired by TAB.
+ */
+public interface EventBus {
+
+    /**
+     * Scans the given listener for any method that is annotated with
+     * {@link Subscribe} and registers it as a listener to this event bus.
+     *
+     * All methods in this class that are annotated with {@link Subscribe}
+     * must meet the following criteria:
+     * <ul>
+     *     <li>It must be <strong>public</strong>.</li>
+     *     <li>It must <strong>not</strong> be abstract.</li>
+     *     <li>It must have exactly <strong>one</strong> parameter.</li>
+     *     <li>Its single parameter must be <strong>an event</strong>.</li>
+     * </ul>
+     * If a method does not meet the above criteria, an exception <strong>will</strong>
+     * be thrown.
+     *
+     * @param listener the listener to register
+     * @throws RuntimeException if a method does not meet the criteria
+     */
+    void register(Object listener);
+
+    /**
+     * Registers the given handler to this event bus.
+     *
+     * @param type the class type of the event
+     * @param handler the handler to register
+     * @param <E> the type of the event
+     */
+    <E extends TabEvent> void register(Class<E> type, EventHandler<E> handler);
+
+    /**
+     * Scans the given listener for any method that is annotated with
+     * {@link Subscribe} and unregisters it from this event bus.
+     *
+     * @param listener the listener to unregister
+     */
+    void unregister(Object listener);
+
+    /**
+     * Unregisters the given handler from this event bus.
+     *
+     * @param handler the handler to unregister
+     * @param <E> the type of the event
+     */
+    <E extends TabEvent> void unregister(EventHandler<E> handler);
+}

api/src/main/java/me/neznamy/tab/api/event/EventHandler.java

@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.event;
+
+/**
+ * A handler for an event. This allows listening for events in a more
+ * functional style.
+ *
+ * @param <E> the type of event this handler handles
+ */
+@FunctionalInterface
+public interface EventHandler<E> {
+
+    /**
+     * Called when the given event is fired from an event bus.
+     *
+     * @param event the event to handle
+     */
+    void handle(E event);
+}

api/src/main/java/me/neznamy/tab/api/event/Subscribe.java

@@ -0,0 +1,14 @@
+package me.neznamy.tab.api.event;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Subscribes to a {@link TabEvent}.
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Subscribe {
+}

api/src/main/java/me/neznamy/tab/api/event/TabEvent.java

@@ -0,0 +1,10 @@
+package me.neznamy.tab.api.event;
+
+/**
+ * An event that may be fired by TAB when something occurs.
+ *
+ * This is a marker interface. All events <strong>must</strong> implement this
+ * interface.
+ */
+public interface TabEvent {
+}

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

@@ -0,0 +1,25 @@
+package me.neznamy.tab.api.event.player;
+
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.event.TabEvent;
+
+/**
+ * Called when the player has been fully loaded by TAB.
+ */
+public interface PlayerLoadEvent extends TabEvent {
+
+    /**
+     * Gets 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
+     */
+    boolean isJoin();
+}

api/src/main/java/me/neznamy/tab/api/event/plugin/PlaceholderRegisterEvent.java

@@ -0,0 +1,11 @@
+package me.neznamy.tab.api.event.plugin;
+
+import me.neznamy.tab.api.event.TabEvent;
+import me.neznamy.tab.api.placeholder.Placeholder;
+
+public interface PlaceholderRegisterEvent extends TabEvent {
+
+    String getIdentifier();
+
+    void setPlaceholder(Placeholder placeholder);
+}

api/src/main/java/me/neznamy/tab/api/event/plugin/TabLoadEvent.java

@@ -0,0 +1,9 @@
+package me.neznamy.tab.api.event.plugin;
+
+import me.neznamy.tab.api.event.TabEvent;
+
+/**
+ * Called when TAB is fully loaded.
+ */
+public interface TabLoadEvent extends TabEvent {
+}

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

@@ -0,0 +1,14 @@
+package me.neznamy.tab.api.placeholder;
+
+public interface Placeholder {
+
+    int getRefresh();
+
+    String getIdentifier();
+
+    void enableTriggerMode(Runnable onActivation, Runnable onDisable);
+
+    void unload();
+
+    boolean isUsed();
+}

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

@@ -0,0 +1,53 @@
+package me.neznamy.tab.api.placeholder;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import me.neznamy.tab.api.feature.Refreshable;
+import me.neznamy.tab.api.TabPlayer;
+
+public interface PlaceholderManager extends Refreshable {
+
+    /**
+     * Registers a server placeholder (placeholder with same output for all players)
+     */
+    ServerPlaceholder registerServerPlaceholder(String identifier, int refresh, Supplier<Object> supplier);
+
+    /**
+     * Registers a player placeholder (placeholder with player-specific output)
+     */
+    PlayerPlaceholder registerPlayerPlaceholder(String identifier, int refresh, Function<TabPlayer, Object> function);
+
+    /**
+     * Registers a relational placeholder (different output for each player pair)
+     */
+    RelationalPlaceholder registerRelationalPlaceholder(String identifier, int refresh, BiFunction<TabPlayer, TabPlayer, Object> function);
+
+    /**
+     * 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
+     */
+    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
+     */
+    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

@@ -0,0 +1,28 @@
+package me.neznamy.tab.api.placeholder;
+
+import me.neznamy.tab.api.TabPlayer;
+
+public interface PlayerPlaceholder extends Placeholder {
+
+    void updateValue(TabPlayer player, 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   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

@@ -0,0 +1,33 @@
+package me.neznamy.tab.api.placeholder;
+
+import me.neznamy.tab.api.TabPlayer;
+
+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

@@ -0,0 +1,22 @@
+package me.neznamy.tab.api.placeholder;
+
+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/scoreboard/Line.java

@@ -0,0 +1,29 @@
+package me.neznamy.tab.api.scoreboard;
+
+/**
+ * An interface allowing to work with a line of
+ * text in scoreboard.
+ *
+ */
+public interface Line {
+
+    /**
+     * Returns configured raw text of this line. Placeholders
+     * remain in raw format.
+     * 
+     * @return  raw text of this line
+     */
+    String getText();
+    
+    /**
+     * Changes text to new value. Supports placeholders, which are
+     * automatically registered if needed and refreshed periodically
+     * based on configuration. No need to call this method to try to
+     * keep placeholders up to date. If value is identical to previous 
+     * one, nothing happens.
+     * 
+     * @param   text
+     *          Raw text to display in the line
+     */
+    void setText(String text);
+}

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

@@ -0,0 +1,87 @@
+package me.neznamy.tab.api.scoreboard;
+
+import java.util.List;
+
+/**
+ * An interface allowing to work with scoreboard, such as adding players,
+ * removing players and changing lines. New instance can be created using
+ * {@link ScoreboardManager#createScoreboard(String, String, List)},
+ * for scoreboards from config {@link ScoreboardManager#getRegisteredScoreboards()}.
+ */
+public interface Scoreboard {
+
+    /**
+     * Returns internal name of this scoreboard. Name is defined in registration,
+     * 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
+     */
+    String getName();
+
+    /**
+     * Returns raw title of this scoreboard. Placeholders stay in their
+     * raw format.
+     * 
+     * @return  scoreboard title
+     * @see     #setTitle(String)
+     */
+    String getTitle();
+
+    /**
+     * Sets title to specified value. Placeholders are refreshed automatically
+     * with refresh intervals defined in config. No need to call this method
+     * to try to keep placeholders up to date. Supports RGB codes using any of 
+     * the supported formats.
+     * <p>
+     * Length is limited to 32 characters on &lt;1.13. If the limit is exceeded,
+     * text will be cut to 32 characters.
+     * <p>
+     * Calling this method with same title as before will not do anything.
+     * 
+     * @param   title
+     *          New title to use with placeholder support
+     * @see     #getTitle()
+     */
+    void setTitle(String title);
+
+    /**
+     * Returns list of lines in this scoreboard in the order they appear
+     * 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)
+     */
+    List<Line> getLines();
+
+    /**
+     * 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)
+     */
+    void addLine(String text);
+
+    /**
+     * 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 &gt;= {@link #getLines()}.size())
+     * @see     #getLines()
+     * @see     #addLine(String)
+     */
+    void removeLine(int index);
+
+    /**
+     * Unregisters this scoreboard from all players who can see it.
+     */
+    void unregister();
+}

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

@@ -0,0 +1,166 @@
+package me.neznamy.tab.api.scoreboard;
+
+import java.util.List;
+import java.util.Map;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface allowing work with scoreboards, such as creating,
+ * sending, toggling and modifying.
+ * <p>
+ * Instance can be obtained using {@link me.neznamy.tab.api.TabAPI#getScoreboardManager()}.
+ * This requires the scoreboard feature to be enabled in config,
+ * the method will return null otherwise.
+ */
+public interface ScoreboardManager {
+
+    /**
+     * Creates new scoreboard, registers and returns it. {@code name}
+     * is internal name of the scoreboard, which it will be registered
+     * with and further work where scoreboard name is used allowed.
+     * <p>
+     * Scoreboard {@code title} is limited to 32 characters on &lt;1.13. If needed,
+     * it will be cut to 32 character for those players (after replacing 
+     * placeholders). RGB is supported using any of the supported formats.
+     * Placeholders are supported.
+     * <p>
+     * {@code lines} will display in the same order as contained in the list.
+     * 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}
+     */
+    Scoreboard createScoreboard(String name, String title, List<String> lines);
+    
+    /**
+     * Returns map of registered scoreboards via config and API.
+     * Map key is name of scoreboard, which is defined either in config
+     * or using {@link #createScoreboard(String, String, List)}.
+     * Map value is reference to the actual scoreboard.
+     * 
+     * @return  map of registered scoreboards
+     */
+    Map<String, Scoreboard> getRegisteredScoreboards();
+    
+    /**
+     * Displays scoreboard to defined player. This will disable all display
+     * condition checks until the scoreboard is unregistered using 
+     * {@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)
+     */
+    void showScoreboard(TabPlayer player, Scoreboard scoreboard);
+    
+    /**
+     * 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)
+     */
+    boolean hasCustomScoreboard(TabPlayer player);
+    
+    /**
+     * Hides custom scoreboard sent using {@link #showScoreboard(TabPlayer, Scoreboard)}
+     * 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)
+     */
+    void resetScoreboard(TabPlayer player);
+    
+    /**
+     * Returns {@code true} if player has scoreboard enabled, {@code false} 
+     * if disabled (toggled) using either toggle command, 
+     * {@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)
+     */
+    boolean hasScoreboardVisible(TabPlayer player);
+    
+    /**
+     * Sets scoreboard visibility of player to defined value. If visibility status
+     * is same as player had before, nothing happens. If this call changes
+     * 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)
+     */
+    void setScoreboardVisible(TabPlayer player, boolean visible, boolean sendToggleMessage);
+    
+    /**
+     * Toggles scoreboard for specified player. If player had scoreboard visible,
+     * 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)
+     */
+    void toggleScoreboard(TabPlayer player, boolean sendToggleMessage);
+    
+    /**
+     * Temporarily displays scoreboard to all players for specified amount of 
+     * 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.
+     */
+    void announceScoreboard(String scoreboard, int duration);
+
+    /**
+     * 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
+     */
+    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/team/TeamManager.java

@@ -0,0 +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
+     *
+     * @param   player
+     *          player to hide nametag of
+     * @see     #showNametag(TabPlayer)
+     * @see     #hasHiddenNametag(TabPlayer)
+     */
+    void hideNametag(@NonNull TabPlayer player);
+
+    /**
+     * Hides player's NameTag for specified player until it's shown again
+     *
+     * @param   player
+     *          player to hide nametag of
+     * @param   viewer
+     *          player to hide NameTag for
+     */
+    void hideNametag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Makes player's NameTag visible again
+     *
+     * @param   player
+     *          player to show nametag of
+     * @see     #hideNametag(TabPlayer)
+     * @see     #hasHiddenNametag(TabPlayer)
+     */
+    void showNametag(@NonNull TabPlayer player);
+
+    /**
+     * Shows player's NameTag for specified viewer if it was hidden before
+     *
+     * @param   player
+     *          player to show nametag of
+     * @param   viewer
+     *          player to show NameTag back for
+     */
+    void showNametag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Return whether player has hidden NameTag or not
+     *
+     * @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(@NonNull TabPlayer player);
+
+    /**
+     * Returns true if NameTag is hidden for specified viewer, 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(@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(@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(@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
+     *
+     * @param   player
+     *          player to check handling status of
+     * @return  true if paused, false if not
+     */
+    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   player
+     *          player to set team name of
+     * @param   teamName
+     *          forced team name
+     */
+    void forceTeamName(@NonNull TabPlayer player, @Nullable String teamName);
+
+    /**
+     * Returns 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
+     */
+    @Nullable String getForcedTeamName(@NonNull TabPlayer player);
+
+
+    /**
+     * Forces collision rule for the player. Setting it to null will remove forced value
+     *
+     * @param   player
+     *          player to set collision rule of
+     * @param   collision
+     *          forced collision rule
+     */
+    void setCollisionRule(@NonNull TabPlayer player, @Nullable Boolean collision);
+
+    /**
+     * Returns forced collision rule or null if collision is not forced using setCollisionRule
+     *
+     * @param   player
+     *          player to get forced collision of
+     * @return  forced value or null if not forced
+     */
+    @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
+     */
+    void updateTeamData(@NonNull TabPlayer player);
+
+    void setPrefix(@NonNull TabPlayer player, @Nullable String prefix);
+
+    void setSuffix(@NonNull TabPlayer player, @Nullable String suffix);
+
+    void resetPrefix(@NonNull TabPlayer player);
+
+    void resetSuffix(@NonNull TabPlayer player);
+
+    @Nullable String getCustomPrefix(@NonNull TabPlayer player);
+
+    @Nullable String getCustomSuffix(@NonNull TabPlayer player);
+
+    @NonNull String getOriginalPrefix(@NonNull 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
+     */
+    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
+     */
+    boolean hasHiddenNameTagVisibilityView(@NonNull TabPlayer player);
+}

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

@@ -0,0 +1,32 @@
+package me.neznamy.tab.api.team;
+
+import java.util.List;
+
+import me.neznamy.tab.api.TabPlayer;
+
+public interface UnlimitedNametagManager extends TeamManager {
+
+    void disableArmorStands(TabPlayer player);
+    
+    void enableArmorStands(TabPlayer player);
+    
+    boolean hasDisabledArmorStands(TabPlayer player);
+
+    void setName(TabPlayer player, String customName);
+    
+    void setLine(TabPlayer player, String line, String value);
+
+    void resetName(TabPlayer player);
+    
+    void resetLine(TabPlayer player, String line);
+
+    String getCustomName(TabPlayer player);
+    
+    String getCustomLineValue(TabPlayer player, String line);
+
+    String getOriginalName(TabPlayer player);
+    
+    String getOriginalLineValue(TabPlayer player, String line);
+    
+    List<String> getDefinedLines();
+}

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

@@ -0,0 +1,26 @@
+package me.neznamy.tab.api.util;
+
+/**
+ * An interface for BiFunction which can throw an exception.
+ * @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

@@ -0,0 +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 {
+
+    /**
+     * 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() + ")");
+    }
+
+    /**
+     * 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 + "), 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

@@ -0,0 +1,17 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation(libs.plugin.shadow)
+    implementation(libs.plugin.lombok)
+}
+
+dependencies {
+    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

@@ -0,0 +1,35 @@
+import org.apache.tools.ant.filters.ReplaceTokens
+
+plugins {
+    `java-library`
+    id("io.freefair.lombok")
+}
+
+tasks {
+    processResources {
+        filter<ReplaceTokens>("tokens" to mapOf(
+            "name" to rootProject.name,
+            "version" to project.version,
+            "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")
+    }
+    compileJava {
+        options.encoding = Charsets.UTF_8.name()
+        options.release.set(8)
+        options.compilerArgs.addAll(listOf("-nowarn", "-Xlint:-unchecked", "-Xlint:-deprecation"))
+    }
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+}