3.2.5

More abstraction of unlimited nametag mode (also a small fix from previous commit)
Unlimited NameTags - Make armor stands visible for spectators (#785 )
2023-02-13 16:40:36 +01:00 · 2023-02-13 14:25:38 +01:00 · 2023-02-13 13:57:49 +01:00 · 2023-02-13 12:54:05 +01:00 · 2023-02-12 12:51:37 +01:00 · 2023-02-12 12:29:06 +01:00
439 changed files with 30674 additions and 22682 deletions
@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: ['https://paypal.me/neznamy1'] # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
@@ -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, ...)
@@ -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
@@ -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
@@ -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
@@ -3,6 +3,7 @@ on:
  push:
    branches:
      - master
+      - v3
  pull_request:
    types: [opened, synchronize, reopened]
 jobs:
@@ -10,27 +11,35 @@ jobs:
    name: Build
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3.3.0 #https://github.com/actions/checkout/releases
        with:
          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
      - name: Set up JDK 11
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3.9.0 #https://github.com/actions/setup-java/releases
        with:
+          distribution: 'temurin'
          java-version: 11
      - name: Cache SonarCloud packages
-        uses: actions/cache@v1
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
        with:
          path: ~/.sonar/cache
          key: ${{ runner.os }}-sonar
          restore-keys: ${{ runner.os }}-sonar
-      - name: Cache Maven packages
-        uses: actions/cache@v1
+      - name: Cache Gradle
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
-          restore-keys: ${{ runner.os }}-m2
+          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
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        run: mvn -B verify org.sonarsource.scanner.maven:sonar-maven-plugin:sonar
+        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
@@ -35,3 +35,9 @@ hs_err_pid*
 # other
 .gitattributes
 *.iml
+run/
+
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar
@@ -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.
@@ -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.
@@ -1,41 +1,34 @@
-## 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. Or just get premium version for free.  
-  
-  
-## Compiling
-Plugin can be compiled using maven. Once you've purchased the premium version, you can enable premium features by setting [this line to return true](https://github.com/NEZNAMY/TAB/blob/master/shared/src/main/java/me/neznamy/tab/shared/TAB.java#L82) and apply your code improvements. Enabling it without purchasing the plugin may result in the features not working correctly.  
-**No support is provided for self-compiled jars, only for official compilations.** If you compiled it yourself, it is highly likely you modified something, which might be the reason why is the plugin not working. If you didn't modify anything, you can just get the plugin from official download locations.
-  
-  
-## Links
-Free version  
-    Spigot (releases): https://www.spigotmc.org/resources/57806/  
-    Pre-releases https://github.com/NEZNAMY/TAB/releases  
-Premium version  
-    Polymart (releases): https://polymart.org/resource/484  
-    MC-Market (releases): https://www.mc-market.org/resources/14009/  
-    Pre-releases on discord for verified buyers  
-Bukkit bridge https://www.spigotmc.org/resources/83966/  
-Wiki https://github.com/NEZNAMY/TAB/wiki  
-Discord invite link: https://discord.gg/EaSvdk6  
+# 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.

+# 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.  

-## Maven Repository
-```
-<repositories>
-  <repository>
-    <id>jitpack.io</id>
-    <url>https://jitpack.io</url>
-  </repository>
-</repositories>
+# 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.

-<dependencies>
-  <!-- TAB -->
-  <dependency>
-    <groupId>com.github.NEZNAMY</groupId>
-    <artifactId>TAB</artifactId>
-    <version>2.9.0</version>
-  </dependency>
-</dependencies>
- ```
+# 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)  
+Support my work & receive customer support: [BuiltByBit](https://builtbybit.com/resources/14009/), [Polymart](https://polymart.org/resource/484)  
+Other links: [Discord support for customers](https://discord.gg/EaSvdk6), [Wiki](https://github.com/NEZNAMY/TAB/wiki)  
+
+# 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)
@@ -0,0 +1,25 @@
+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.gson)
+    compileOnlyApi(libs.adventureMiniMessage)
+    compileOnlyApi(libs.adventureApi)
+    compileOnlyApi(libs.adventureLegacy)
+}
+
+blossom {
+    replaceToken("@plugin_version@", project.version)
+    replaceTokenIn("src/main/java/me/neznamy/tab/api/TabConstants.java")
+}
+
+tasks.javadoc {
+    enabled = project.hasProperty("enable-javadoc")
+}
@@ -0,0 +1,108 @@
+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();
+    
+    /**
+     * Teleports armor stand to owner's current location for everyone in range
+     */
+    void teleport();
+    
+    /**
+     * Teleports armor stand to owner's current location for specified player
+     *
+     * @param   viewer
+     *          player to send packet to
+     */
+    void teleport(TabPlayer viewer);
+    
+    /**
+     * Changes sneaking flag and sends packets to everyone in range
+     *
+     * @param   sneaking
+     *          new sneaking status
+     */
+    void sneak(boolean sneaking);
+    
+    /**
+     * DeSpawns armor stand for everyone
+     */
+    void destroy();
+    
+    /**
+     * DeSpawns armor stand for specified player
+     *
+     * @param   viewer
+     *          player to send packet to
+     */
+    void destroy(TabPlayer viewer);
+    
+    /**
+     * Updates armor stand's name if needed
+     */
+    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();
+    
+    /**
+     * Spawns armor stand for specified player
+     *
+     * @param   viewer
+     *          player to spawn for
+     */
+    void spawn(TabPlayer viewer);
+
+    /**
+     * Sends respawn packets to specified player to make position
+     * change instant instead of teleport animation
+     *
+     * @param   viewer
+     *          Player to send armor stand respawn packets to
+     */
+    void respawn(TabPlayer viewer);
+}
@@ -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);
+}
@@ -0,0 +1,116 @@
+package me.neznamy.tab.api;
+
+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);
+
+    /**
+     * Internal function that marks objective packet deserialization
+     * when at least 1 feature uses it.
+     * <p>
+     * Internal use only.
+     */
+    void markObjective();
+
+    /**
+     * Internal function that marks display objective packet deserialization
+     * when at least 1 feature uses it.
+     * <p>
+     * Internal use only.
+     */
+    void markDisplayObjective();
+
+    /**
+     * Returns array of all currently enabled features
+     *
+     * @return  array of all currently enabled features
+     */
+    TabFeature[] getValues();
+}
@@ -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);
+}
@@ -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);
+}
@@ -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;
+    }
+}
@@ -0,0 +1,140 @@
+package me.neznamy.tab.api;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * Enum class representing all possibly used protocol versions
+ */
+public enum ProtocolVersion {
+
+    UNKNOWN_SERVER_VERSION ("Unknown"),
+    UNKNOWN_CLIENT_VERSION ("Unknown"),
+    PROXY   ("Proxy"),
+    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;
+    }
+}
@@ -0,0 +1,213 @@
+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.task.ThreadManager;
+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("API instance is null. This likely means you shaded TAB's API into your project" +
+                " instead of only using it, which is not allowed.");
+        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 Thread manager, which allows task submitting
+     *
+     * @return  ThreadManager instance
+     */
+    public abstract ThreadManager getThreadManager();
+
+    /**
+     * Returns TAB's cache file used to store player toggle data
+     *
+     * @return  TAB's player cache file
+     */
+    public abstract ConfigurationFile getPlayerCache();
+
+    /**
+     * Returns TAB's config.yml file
+     *
+     * @return  config.yml file
+     */
+    public abstract ConfigurationFile getConfig();
+
+    /**
+     * Returns TAB's group configuration
+     *
+     * @return  TAB's group configuration
+     */
+    public abstract PropertyConfiguration getGroups();
+
+    /**
+     * Returns TAB's user configuration
+     *
+     * @return  TAB's user configuration
+     */
+    public abstract PropertyConfiguration getUsers();
+
+    /**
+     * Sends a debug message into console if the option
+     * is enabled in config.
+     *
+     * @param   message
+     *          Message to send
+     */
+    public abstract void debug(String message);
+
+    /**
+     * Logs an error into errors.log file
+     *
+     * @param   message
+     *          Error message
+     * @param   t
+     *          Thrown error
+     */
+    public abstract void logError(String message, Throwable t);
+
+    /**
+     * Sets name of file with syntax error, which prevented
+     * the plugin from enabling. Internal use only.
+     *
+     * @param   file
+     *          Name of file with syntax error
+     */
+    public abstract void setBrokenFile(String file);
+
+    /**
+     * Returns {@code true} if the plugin is currently disabled due to an error,
+     * either a yaml syntax error or an internal startup error. Returns {@code false}
+     * if the plugin is properly running.
+     *
+     * @return  {@code true} if disabled, {@code false} if running correctly
+     */
+    public abstract boolean isPluginDisabled();
+}
@@ -0,0 +1,383 @@
+package me.neznamy.tab.api;
+
+/**
+ * A class containing various constants used everywhere in the plugin
+ * to allow easier overview and modification to prevent inconsistencies.
+ */
+public class TabConstants {
+
+    public static final String PLUGIN_VERSION = "@plugin_version@";
+    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 = "TAB";
+
+    /**
+     * Private constructor to prevent the class from being instantiated
+     */
+    private TabConstants() {}
+
+    /**
+     * Feature sub-category explaining why / when a certain feature
+     * needed CPU time to process tasks.
+     */
+    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";
+
+        /**
+         * Private constructor to prevent the class from being instantiated
+         */
+        private CpuUsageCategory() {}
+    }
+
+    /**
+     * Information why a specific feature sent a packet
+     * and what the packet sent is supposed to do.
+     */
+    public static class PacketCategory {
+
+        public static final String BOSSBAR_COLOR_STYLE = "BossBar (Color and style)";
+        public static final String BOSSBAR_PROGRESS = "BossBar (Progress)";
+        public static final String BOSSBAR_TEXT = "BossBar (Text)";
+        public static final String BOSSBAR_WITHER_TELEPORT = "BossBar (Teleporting Wither)";
+
+        public static final String GLOBAL_PLAYERLIST_LATENCY = "Global PlayerList (Updating latency)";
+        public static final String GLOBAL_PLAYERLIST_VANISH = "Global PlayerList (Vanishing)";
+
+        public static final String LAYOUT_FIXED_SLOTS = "Layout (Fixed slots)";
+        public static final String LAYOUT_PLAYER_SLOTS = "Layout (Player slots)";
+        public static final String LAYOUT_LATENCY = "Layout (Updating latency)";
+
+        public static final String NAMETAGS_TEAM_REGISTER = "NameTags (Team register)";
+        public static final String NAMETAGS_TEAM_UNREGISTER = "NameTags (Team unregister)";
+        public static final String NAMETAGS_TEAM_UPDATE = "NameTags (Team update)";
+
+        public static final String SORTING_CHANGING_TEAM_NAME = "Sorting (Changing team name)";
+
+        public static final String SCOREBOARD_TITLE = "Scoreboard (Title)";
+        public static final String SCOREBOARD_LINES = "Scoreboard (Lines)";
+
+        public static final String UNLIMITED_NAMETAGS_OFFSET_CHANGE = "Unlimited NameTags (Changing offset)";
+        public static final String UNLIMITED_NAMETAGS_SPAWN = "Unlimited NameTags (Spawning)";
+        public static final String UNLIMITED_NAMETAGS_DESPAWN = "Unlimited NameTags (Despawning)";
+        public static final String UNLIMITED_NAMETAGS_TELEPORT = "Unlimited NameTags (Teleporting)";
+        public static final String UNLIMITED_NAMETAGS_SNEAK = "Unlimited NameTags (Sneaking)";
+        public static final String UNLIMITED_NAMETAGS_METADATA = "Unlimited NameTags (Metadata)";
+
+        /**
+         * Private constructor to prevent the class from being instantiated
+         */
+        private PacketCategory() {}
+    }
+
+    /**
+     * Permission nodes used by the plugin
+     */
+    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.";
+
+        /**
+         * Private constructor to prevent the class from being instantiated
+         */
+        private Permission(){}
+    }
+
+    /**
+     * Internal property names used to store text
+     * under a specific key
+     */
+    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";
+
+        /**
+         * Private constructor to prevent the class from being instantiated
+         */
+        private Property() {}
+
+        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.
+     */
+    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";
+
+        /**
+         * Private constructor to prevent the class from being instantiated
+         */
+        private Feature(){}
+
+        public static String scoreboardLine(String line) {
+            return "scoreboard-" + line;
+        }
+
+        public static String scoreboardLine(String scoreboard, int index) {
+            return "scoreboard-score-" + scoreboard + "-" + index;
+        }
+
+        public static String layout(String name) {
+            return "layout-" + name;
+        }
+
+        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 bossBarColorStyle(String name) {
+            return "BossBar-color-style-" + name;
+        }
+    }
+
+    /**
+     * All internal placeholders offered by the plugin
+     */
+    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
+     */
+    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 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
+     */
+    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";
+
+    }
+}
@@ -0,0 +1,391 @@
+package me.neznamy.tab.api;
+
+import java.util.*;
+
+import lombok.Getter;
+import me.neznamy.tab.api.protocol.PacketPlayOutPlayerInfo;
+import me.neznamy.tab.api.protocol.PacketPlayOutScoreboardDisplayObjective;
+import me.neznamy.tab.api.protocol.PacketPlayOutScoreboardObjective;
+
+/**
+ * Abstract class representing a core feature of the plugin.
+ * <p>
+ * It receives all kinds of events and can react to them.
+ */
+public abstract class TabFeature {
+
+    /** Feature's name displayed in /tab cpu */
+    @Getter private final String featureName;
+
+    /** Feature's function name displayed in place of refreshing in /tab cpu */
+    @Getter private final String refreshDisplayName;
+
+    /** 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<>());
+
+    /**
+     * List of methods overridden (implemented) by each feature.
+     * If a method is not overridden, it is not called at all.
+     * This avoids a massive spam for every single method
+     * in every single feature in /tab cpu output
+     */
+    private final List<String> methodOverrides = new ArrayList<>();
+
+    /**
+     * Constructs new instance with given parameters and loads method overrides
+     *
+     * @param   featureName
+     *          Feature's name in /tab cpu
+     * @param   refreshDisplayName
+     *          "refreshing" cpu display type name of the feature
+     */
+    protected TabFeature(String featureName, String refreshDisplayName) {
+        this.featureName = featureName;
+        this.refreshDisplayName = refreshDisplayName;
+        try {
+            if (getClass().getMethod("onCommand", TabPlayer.class, String.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onCommand");
+            if (getClass().getMethod("onJoin", TabPlayer.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onJoin");
+            if (getClass().getMethod("onQuit", TabPlayer.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onQuit");
+            if (getClass().getMethod("onWorldChange", TabPlayer.class, String.class, String.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onWorldChange");
+            if (getClass().getMethod("onServerChange", TabPlayer.class, String.class, String.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onServerChange");
+            if (getClass().getMethod("onDisplayObjective", TabPlayer.class, PacketPlayOutScoreboardDisplayObjective.class).getDeclaringClass() != TabFeature.class) {
+                methodOverrides.add("onDisplayObjective");
+                TabAPI.getInstance().getFeatureManager().markDisplayObjective();
+            }
+            if (getClass().getMethod("onLoginPacket", TabPlayer.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onLoginPacket");
+            if (getClass().getMethod("onObjective", TabPlayer.class, PacketPlayOutScoreboardObjective.class).getDeclaringClass() != TabFeature.class) {
+                methodOverrides.add("onObjective");
+                TabAPI.getInstance().getFeatureManager().markObjective();
+            }
+            if (getClass().getMethod("onPlayerInfo", TabPlayer.class, PacketPlayOutPlayerInfo.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onPlayerInfo");
+            if (getClass().getMethod("onPacketReceive", TabPlayer.class, Object.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onPacketReceive");
+            if (getClass().getMethod("onPacketSend", TabPlayer.class, Object.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onPacketSend");
+            if (getClass().getMethod("refresh", TabPlayer.class, boolean.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("refresh");
+            if (getClass().getMethod("onVanishStatusChange", TabPlayer.class).getDeclaringClass() != TabFeature.class)
+                methodOverrides.add("onVanishStatusChange");
+        } catch (NoSuchMethodException e) {
+            //this will never happen
+        }
+    }
+
+    /**
+     * 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   featureName
+     *          Feature's name in /tab cpu
+     * @param   refreshDisplayName
+     *          "refreshing" cpu display type name of the feature
+     * @param   configSection
+     *          Configuration section of the feature to load disabled
+     *          servers / worlds from
+     */
+    protected TabFeature(String featureName, String refreshDisplayName, String configSection) {
+        this(featureName, refreshDisplayName);
+        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");
+        }
+    }
+
+    /**
+     * Loads all online players and sends packets
+     */
+    public void load() {
+        //empty by default
+    }
+
+    /**
+     * Unloads all players and sends clear packets
+     */
+    public void unload() {
+        //empty by default
+    }
+
+    /**
+     * Processes command from player. This is typically a toggle command.
+     *
+     * @param   sender
+     *          command sender
+     * @param   message
+     *          command line
+     * @return  {@code true} if event should be cancelled, {@code true} if not
+     */
+    public boolean onCommand(TabPlayer sender, String message) {
+        return false;
+    }
+
+    /**
+     * Processes join event
+     *
+     * @param   connectedPlayer
+     *          player who connected
+     */
+    public void onJoin(TabPlayer connectedPlayer) {
+        //empty by default
+    }
+
+    /**
+     * Processes quit event
+     *
+     * @param   disconnectedPlayer
+     *          player who disconnected
+     */
+    public void onQuit(TabPlayer disconnectedPlayer) {
+        //empty by default
+    }
+
+    /**
+     * Processes world switch
+     *
+     * @param   changed
+     *          player who switched world
+     * @param   from
+     *          world player changed from
+     * @param   to
+     *          world player changed to
+     */
+    public void onWorldChange(TabPlayer changed, String from, String to) {
+        //empty by default
+    }
+
+    /**
+     * Processes server switch
+     *
+     * @param   changed
+     *          player who switched server
+     * @param   from
+     *          server player changed from
+     * @param   to
+     *          server player changed to
+     */
+    public void onServerChange(TabPlayer changed, String from, String to) {
+        //empty by default
+    }
+
+    /**
+     * Processes the packet send and returns true if packet should be cancelled
+     *
+     * @param   receiver
+     *          player receiving packet
+     * @param   packet
+     *          received packet
+     */
+    public void onDisplayObjective(TabPlayer receiver, PacketPlayOutScoreboardDisplayObjective packet) {
+        //empty by default
+    }
+
+    /**
+     * Processes login packet, only available on BungeeCord
+     *
+     * @param   packetReceiver
+     *          player receiving client reset packet
+     */
+    public void onLoginPacket(TabPlayer packetReceiver) {
+        //empty by default
+    }
+
+    /**
+     * Processes the packet send
+     *
+     * @param   receiver
+     *          player receiving packet
+     * @param   packet
+     *          received packet
+     */
+    public void onObjective(TabPlayer receiver, PacketPlayOutScoreboardObjective packet) {
+        //empty by default
+    }
+
+    /**
+     * Processes the packet send and possibly modifies it
+     *
+     * @param   receiver
+     *          player receiving packet
+     * @param   info
+     *          received packet
+     */
+    public void onPlayerInfo(TabPlayer receiver, PacketPlayOutPlayerInfo info) {
+        //empty by default
+    }
+
+    /**
+     * Processes raw packet sent by client
+     *
+     * @param   sender
+     *          packet sender
+     * @param   packet
+     *          packet received
+     * @return  true if false should be cancelled, false if not
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public boolean onPacketReceive(TabPlayer sender, Object packet) throws ReflectiveOperationException {
+        return false;
+    }
+
+    /**
+     * Processes raw packet sent to client
+     *
+     * @param   receiver
+     *          packet receiver
+     * @param   packet
+     *          the packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public void onPacketSend(TabPlayer receiver, Object packet) throws ReflectiveOperationException {
+        //empty by default
+    }
+
+    /**
+     * Performs refresh of specified player
+     *
+     * @param   refreshed
+     *          player to refresh
+     * @param   force
+     *          if refresh should be forced despite refresh seemingly not needed
+     */
+    public void refresh(TabPlayer refreshed, boolean force) {
+        //empty by default
+    }
+
+    /**
+     * Processes vanish status change of player
+     *
+     * @param   player
+     *          Player who changed vanish status
+     */
+    public void onVanishStatusChange(TabPlayer player){
+        //empty by default
+    }
+
+    /**
+     * Registers this feature as one using specified placeholders
+     *
+     * @param   placeholders
+     *          placeholders to add as used in this feature
+     */
+    public void addUsedPlaceholders(Collection<String> placeholders) {
+        if (placeholders.isEmpty()) return;
+        placeholders.forEach(p -> TabAPI.getInstance().getPlaceholderManager().addUsedPlaceholder(p, this));
+    }
+
+    /**
+     * Returns {@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 method with specified name is overridden
+     * in the implementation, {@code false} if not
+     *
+     * @param   method
+     *          Method to check
+     * @return  {@code true} if overridden, {@code false} if not
+     */
+    public boolean overridesMethod(String method) {
+        return methodOverrides.contains(method);
+    }
+
+    /**
+     * 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);
+    }
+}
@@ -0,0 +1,306 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import io.netty.channel.Channel;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import me.neznamy.tab.api.protocol.Skin;
+import me.neznamy.tab.api.protocol.TabPacket;
+
+/**
+ * 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 velocity with some specific velocity setup
+     *
+     * @return  player's uuid in TabList
+     */
+    UUID getTablistUUID();
+
+    /**
+     * 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 custom universal packet
+     *
+     * @param   packet
+     *          packet to send
+     */
+    void sendCustomPacket(TabPacket packet);
+
+    /**
+     * Sends the player a custom universal packet and adds that packet into counter that
+     * is displayed in /tab cpu
+     *
+     * @param   packet
+     *          packet to send
+     * @param   feature
+     *          feature to increment sent packet counter of
+     */
+    void sendCustomPacket(TabPacket packet, TabFeature feature);
+    
+    /**
+     * Sends the player a custom universal packet and adds that packet into counter that
+     * is displayed in /tab cpu
+     *
+     * @param   packet
+     *          packet to send
+     * @param   feature
+     *          feature to increment sent packet counter of
+     */
+    void sendCustomPacket(TabPacket packet, String feature);
+
+    /**
+     * Sends the player a platform-specific packet
+     *
+     * @param   packet
+     *          an instance of packet depending on platform
+     */
+    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 netty channel. On servers running version 1.7 or older returns {@code null}.
+     *
+     * @return  player's channel
+     */
+    Channel getChannel();
+
+    /**
+     * 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(TabFeature 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(TabFeature 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(TabFeature 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();
+}
@@ -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);
+}
@@ -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
+}
@@ -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;
+}
@@ -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();
+}
@@ -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();
+}
@@ -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
+    }
+}
@@ -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");
+    }
+}
@@ -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;
+    }
+}
@@ -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();
+    }
+}
@@ -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);
+    }
+}
@@ -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 '&amp;' 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();
+    }
+}
@@ -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);
+    }
+}
@@ -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()));
+    }
+}
@@ -0,0 +1,69 @@
+package me.neznamy.tab.api.chat;
+
+import lombok.AllArgsConstructor;
+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 */
+    private final Object originalComponent;
+
+    /**
+     * Returns the original NMS component
+     * @return  the original NMS component
+     */
+    public Object get() {
+        return 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());
+    }
+}
@@ -0,0 +1,198 @@
+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.TextColor;
+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
+     *
+     * @param   text
+     *          text to convert
+     * @return  translated text
+     */
+    public String convertRGBtoLegacy(String text) {
+        if (text == null) return null;
+        if (!text.contains("#")) return EnumChatFormat.color(text);
+        String applied = applyFormats(text);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < applied.length(); i++){
+            char c = applied.charAt(i);
+            if (c == '#' && applied.length() > i+6) {
+                String hexCode = applied.substring(i+1, i+7);
+                if (isHexCode(hexCode)) {
+                    if (containsLegacyCode(applied, i)) {
+                        sb.append(new TextColor(hexCode, EnumChatFormat.getByChar(applied.charAt(i+8))).getLegacyColor().getFormat());
+                        i += 8;
+                    } else {
+                        sb.append(new TextColor(hexCode).getLegacyColor().getFormat());
+                        i += 6;
+                    }
+                } else {
+                    sb.append(c);
+                }
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Returns true if text contains legacy color request at defined RGB index start
+     *
+     * @param   text
+     *          text to check
+     * @param   i
+     *          current index start
+     * @return  {@code true} if legacy color is defined and valid, {@code false} otherwise
+     */
+    private static boolean containsLegacyCode(String text, int i) {
+        if (text.length() - i < 9 || text.charAt(i+7) != '|') return false;
+        return EnumChatFormat.getByChar(text.charAt(i+8)) != null;
+    }
+}
@@ -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 &amp;x&amp;R&amp;R&amp;G&amp;G&amp;B&amp;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;
+    }
+}
@@ -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;
+    }
+}
@@ -0,0 +1,25 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Formatter for #&lt;RRGGBB&gt;
+ */
+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;
+    }
+}
@@ -0,0 +1,25 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Formatter for &lt;#RRGGBB&gt;
+ */
+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;
+    }
+}
@@ -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 &amp;x&amp;R&amp;R&amp;G&amp;G&amp;B&amp;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;
+        }
+    }
+}
@@ -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);
+}
@@ -0,0 +1,12 @@
+package me.neznamy.tab.api.chat.rgb.format;
+
+/**
+ * Formatter for &amp;#RRGGBB
+ */
+public class UnnamedFormat1 implements RGBFormatter {
+
+    @Override
+    public String reformat(String text) {
+        return text.contains("&#") ? text.replace("&#", "#") : text;
+    }
+}
@@ -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);
+    }
+}
@@ -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;
+    }
+}
@@ -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();
+    }
+}
@@ -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 &lt;gradient:#RRGGBB:#RRGGBB&gt;Text&lt;/gradient&gt;
+ * and &lt;gradient:#RRGGBB|L:#RRGGBB&gt;Text&lt;/gradient&gt;
+ */
+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;
+    }
+}
@@ -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);
+        }
+    }
+}
@@ -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);
+        }
+    }
+}
@@ -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);
+}
@@ -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);
+}
@@ -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 {
+}
@@ -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 {
+}
@@ -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();
+}
@@ -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);
+}
@@ -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 {
+}
@@ -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();
+}
@@ -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.TabFeature;
+import me.neznamy.tab.api.TabPlayer;
+
+public interface PlaceholderManager {
+
+    /**
+     * 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, TabFeature feature);
+
+    String findReplacement(String placeholder, String output);
+
+    List<String> getUsedPlaceholders();
+
+    Placeholder getPlaceholder(String identifier);
+}
@@ -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);
+}
@@ -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);
+}
@@ -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();
+}
@@ -0,0 +1,267 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.ProtocolVersion;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
+import me.neznamy.tab.api.util.BiFunctionWithException;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A class for packet building, methods are overridden in
+ * platform-specific builders which extend this class to build actual packets.
+ * Packets which don't have a method override are forwarded into
+ * sendPacket method, where they are handled using platform's API instead.
+ */
+public class PacketBuilder {
+
+    /** Function map turning custom packet class into platform-specific packets */
+    protected final Map<Class<? extends TabPacket>, BiFunctionWithException<TabPacket, ProtocolVersion, Object>> buildMap = new HashMap<>();
+
+    /**
+     * Constructs new instance and fills {@link #buildMap} with abstract build methods
+     * of packets present on all platforms.
+     */
+    public PacketBuilder() {
+        buildMap.put(PacketPlayOutBoss.class, (packet, version) -> build((PacketPlayOutBoss)packet, version));
+        buildMap.put(PacketPlayOutChat.class, (packet, version) -> build((PacketPlayOutChat)packet, version));
+        buildMap.put(PacketPlayOutPlayerInfo.class, (packet, version) -> build((PacketPlayOutPlayerInfo)packet, version));
+        buildMap.put(PacketPlayOutPlayerListHeaderFooter.class, (packet, version) -> build((PacketPlayOutPlayerListHeaderFooter)packet, version));
+        buildMap.put(PacketPlayOutScoreboardDisplayObjective.class, (packet, version) -> build((PacketPlayOutScoreboardDisplayObjective)packet, version));
+        buildMap.put(PacketPlayOutScoreboardObjective.class, (packet, version) -> build((PacketPlayOutScoreboardObjective)packet, version));
+        buildMap.put(PacketPlayOutScoreboardScore.class, (packet, version) -> build((PacketPlayOutScoreboardScore)packet, version));
+        buildMap.put(PacketPlayOutScoreboardTeam.class, (packet, version) -> build((PacketPlayOutScoreboardTeam)packet, version));
+    }
+
+    /**
+     * Converts custom packet into platform-specific packet by calling a function from
+     * {@link #buildMap}.
+     *
+     * @param   packet
+     *          Packet to build
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if reflection fails
+     */
+    public Object build(@NonNull TabPacket packet, @NonNull ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return buildMap.get(packet.getClass()).apply(packet, clientVersion);
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutBoss class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutBoss packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutChat class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutChat packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutPlayerInfo class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutPlayerInfo packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutPlayerListHeaderFooter class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutPlayerListHeaderFooter packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutScoreboardDisplayObjective class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutScoreboardDisplayObjective packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutScoreboardObjective class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutScoreboardObjective packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutScoreboardScore class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutScoreboardScore packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Constructs platform-specific PacketPlayOutScoreboardTeam class based on custom packet class
+     *
+     * @param   packet
+     *          Custom packet to be built
+     * @param   clientVersion
+     *          Protocol version of player to build the packet for
+     * @return  Platform-specific packet
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public Object build(PacketPlayOutScoreboardTeam packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return packet;
+    }
+
+    /**
+     * Cuts given string to specified character length (or length-1 if last character is a color character)
+     * and translates RGB to legacy colors. If string is not that long, the original string is returned.
+     * RGB codes are converted into legacy, since cutting is only needed for &lt;1.13.
+     * If {@code string} is {@code null}, empty string is returned.
+     *
+     * @param   string
+     *          String to cut
+     * @param   length
+     *          Length to cut to
+     * @return  string cut to {@code length} characters
+     */
+    public String cutTo(String string, int length) {
+        if (string == null) return "";
+        String legacyText = string;
+        if (string.contains("#")) {
+            //converting RGB to legacy colors
+            legacyText = RGBUtils.getInstance().convertRGBtoLegacy(string);
+        }
+        if (legacyText.length() <= length) return legacyText;
+        if (legacyText.charAt(length-1) == EnumChatFormat.COLOR_CHAR) {
+            return legacyText.substring(0, length-1); //cutting one extra character to prevent prefix ending with "&"
+        } else {
+            return legacyText.substring(0, length);
+        }
+    }
+
+    /**
+     * If {@code clientVersion} is &gt;= 1.13, creates a component from given text and returns
+     * it as a serialized component, which BungeeCord uses.
+     * <p>
+     * If {@code clientVersion} is &lt; 1.12, the text is cut to {@code length} characters if
+     * needed and returned.
+     *
+     * @param   text
+     *          Text to convert
+     * @param   clientVersion
+     *          Version of player to convert text for
+     * @return  serialized component for 1.13+ clients, cut string for 1.12-
+     */
+    public String jsonOrCut(String text, ProtocolVersion clientVersion, int length) {
+        if (text == null) return null;
+        if (clientVersion.getMinorVersion() >= 13) {
+            return IChatBaseComponent.optimizedComponent(text).toString(clientVersion);
+        } else {
+            return cutTo(text, length);
+        }
+    }
+
+    /**
+     * Converts platform-specific instance of player info packet into
+     * {@link PacketPlayOutPlayerInfo} object.
+     *
+     * @param   packet
+     *          platform-specific info packet
+     * @param   clientVersion
+     *          Version of client receiving the packet
+     * @return  The packet converted into {@link PacketPlayOutPlayerInfo}
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public PacketPlayOutPlayerInfo readPlayerInfo(Object packet, ProtocolVersion clientVersion) throws ReflectiveOperationException {
+        return null;
+    }
+
+    /**
+     * Converts platform-specific instance of objective packet into
+     * {@link PacketPlayOutScoreboardObjective} object.
+     *
+     * @param   packet
+     *          platform-specific objective packet
+     * @return  The packet converted into {@link PacketPlayOutScoreboardObjective}
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public PacketPlayOutScoreboardObjective readObjective(Object packet) throws ReflectiveOperationException {
+        return null;
+    }
+
+    /**
+     * Converts platform-specific instance of display objective packet into
+     * {@link PacketPlayOutScoreboardDisplayObjective} object.
+     *
+     * @param   packet
+     *          platform-specific display objective packet
+     * @return  The packet converted into {@link PacketPlayOutScoreboardDisplayObjective}
+     * @throws  ReflectiveOperationException
+     *          if thrown by reflective operation
+     */
+    public PacketPlayOutScoreboardDisplayObjective readDisplayObjective(Object packet) throws ReflectiveOperationException {
+        return null;
+    }
+}
@@ -0,0 +1,175 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.Data;
+import lombok.NonNull;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+
+import java.util.UUID;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data
+public class PacketPlayOutBoss implements TabPacket {
+
+    /** UUID of the BossBar */
+    private final UUID id;
+
+    /** Action of this packet */
+    private Action action;
+
+    /** BossBar title */
+    private String name;
+
+    /** BossBar progress (0-1)*/
+    private float pct;
+
+    /** BossBar color */
+    private BarColor color;
+
+    /** BossBar style */
+    private BarStyle overlay;
+
+    /** Darken screen flag */
+    private boolean darkenScreen;
+
+    /** Play music flag */
+    private boolean playMusic;
+
+    /** Create fog flag */
+    private boolean createWorldFog;
+
+    /**
+     * Constructs new instance with given parameters and
+     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action}.ADD action
+     *
+     * @param   id
+     *          BossBar uuid
+     * @param   name
+     *          BossBar title
+     * @param   pct
+     *          BossBar progress
+     * @param   color
+     *          BossBar color
+     * @param   overlay
+     *          BossBar style
+     */
+    public PacketPlayOutBoss(@NonNull UUID id, @NonNull String name, float pct, @NonNull BarColor color, @NonNull BarStyle overlay) {
+        this.action = Action.ADD;
+        this.id = id;
+        this.name = name;
+        this.pct = pct;
+        this.color = color;
+        this.overlay = overlay;
+    }
+
+    /**
+     * Constructs new instance with given parameters and
+     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action#REMOVE} action
+     *
+     * @param   id
+     *          BossBar uuid
+     */
+    public PacketPlayOutBoss(@NonNull UUID id) {
+        this.action = Action.REMOVE;
+        this.id = id;
+    }
+
+    /**
+     * Constructs new instance with given parameters and
+     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action#UPDATE_PCT} action
+     *
+     * @param   id
+     *          BossBar uuid
+     * @param   pct
+     *          BossBar progress
+     */
+    public PacketPlayOutBoss(@NonNull UUID id, float pct) {
+        this.action = Action.UPDATE_PCT;
+        this.id = id;
+        this.pct = pct;
+    }
+
+    /**
+     * Constructs new instance with given parameters and
+     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action#UPDATE_NAME} action
+     *
+     * @param   id
+     *          BossBar uuid
+     * @param   name
+     *          BossBar title
+     */
+    public PacketPlayOutBoss(@NonNull UUID id, @NonNull String name) {
+        this.action = Action.UPDATE_NAME;
+        this.id = id;
+        this.name = name;
+    }
+
+    /**
+     * Constructs new instance with given parameters and
+     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action#UPDATE_STYLE} action
+     *
+     * @param   id
+     *          BossBar uuid
+     * @param   color
+     *          BossBar color
+     * @param   overlay
+     *          BossBar style
+     */
+    public PacketPlayOutBoss(@NonNull UUID id, @NonNull BarColor color, @NonNull BarStyle overlay) {
+        this.action = Action.UPDATE_STYLE;
+        this.id = id;
+        this.color = color;
+        this.overlay = overlay;
+    }
+
+    /**
+     * Constructs new instance with given parameters and
+     * {@link me.neznamy.tab.api.protocol.PacketPlayOutBoss.Action#UPDATE_PROPERTIES} action
+     *
+     * @param   darkenScreen
+     *          Darken screen flag
+     * @param   playMusic
+     *          Play music flag
+     * @param   createWorldFog
+     *          Create fog flag
+     */
+    public PacketPlayOutBoss(@NonNull UUID id, boolean darkenScreen, boolean playMusic, boolean createWorldFog) {
+        this.action = Action.UPDATE_PROPERTIES;
+        this.id = id;
+        this.darkenScreen = darkenScreen;
+        this.playMusic = playMusic;
+        this.createWorldFog = createWorldFog;
+    }
+
+    /**
+     * Returns bitmask based on {@link #darkenScreen}, {@link #playMusic} and {@link #darkenScreen} values.
+     * <p>
+     * {@link #darkenScreen} adds {@code 1}, {@link #playMusic} {@code 2} and {@link #darkenScreen} {@code 4}
+     * to the final value.
+     *
+     * @return  the bitmask
+     */
+    public byte getFlags(){
+        byte value = 0;
+        if (darkenScreen) value += 1;
+        if (playMusic) value += 2;
+        if (createWorldFog) value += 4;
+        return value;
+    }
+
+    /**
+     * An enum representing all valid boss packet actions.
+     * Calling ordinal() will return action's network ID.
+     */
+    public enum Action {
+
+        ADD,
+        REMOVE,
+        UPDATE_PCT,
+        UPDATE_NAME,
+        UPDATE_STYLE,
+        UPDATE_PROPERTIES
+    }
+}
@@ -0,0 +1,29 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.Data;
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data
+public class PacketPlayOutChat implements TabPacket {
+
+    /** Message to be sent */
+    @NonNull private final IChatBaseComponent message;
+
+    /** Message position */
+    @NonNull private final ChatMessageType type;
+
+    /**
+     * An enum representing positions of a chat message
+     * Calling ordinal() will return type's network ID.
+     */
+    public enum ChatMessageType {
+
+        CHAT,
+        SYSTEM,
+        GAME_INFO
+    }
+}
@@ -0,0 +1,190 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data @AllArgsConstructor
+public class PacketPlayOutPlayerInfo implements TabPacket {
+
+    /** Packet actions */
+    private final EnumSet<EnumPlayerInfoAction> actions;
+
+    /** List of affected entries */
+    private final List<PlayerInfoData> entries;
+
+    /**
+     * Constructs new instance with given parameters.
+     * 
+     * @param   action
+     *          Packet action
+     * @param   entries
+     *          Affected entries
+     */
+    public PacketPlayOutPlayerInfo(EnumPlayerInfoAction action, PlayerInfoData... entries) {
+        this(action, Arrays.asList(entries));
+    }
+
+    /**
+     * Constructs new instance with given parameters.
+     * 
+     * @param   action
+     *          Packet action
+     * @param   entries
+     *          Affected entries
+     */
+    public PacketPlayOutPlayerInfo(@NonNull EnumPlayerInfoAction action, @NonNull List<PlayerInfoData> entries) {
+        if (action == EnumPlayerInfoAction.ADD_PLAYER) {
+            actions = EnumSet.of(EnumPlayerInfoAction.ADD_PLAYER,
+                    EnumPlayerInfoAction.INITIALIZE_CHAT,
+                    EnumPlayerInfoAction.UPDATE_GAME_MODE,
+                    EnumPlayerInfoAction.UPDATE_LISTED,
+                    EnumPlayerInfoAction.UPDATE_LATENCY,
+                    EnumPlayerInfoAction.UPDATE_DISPLAY_NAME);
+        } else {
+            this.actions = EnumSet.of(action);
+        }
+        this.entries = entries;
+    }
+
+    /**
+     * Constructs new instance with given parameters.
+     *
+     * @param   actions
+     *          Packet actions
+     * @param   entries
+     *          Affected entries
+     */
+    public PacketPlayOutPlayerInfo(@NonNull EnumSet<EnumPlayerInfoAction> actions, @NonNull PlayerInfoData... entries) {
+        this.actions = actions;
+        this.entries = Arrays.asList(entries);
+    }
+
+    /**
+     * A subclass representing player list entry
+     */
+    @Data @AllArgsConstructor
+    public static class PlayerInfoData {
+
+        /** Real name of affected player */
+        private String name;
+
+        /** Player UUID */
+        @NonNull private UUID uniqueId;
+
+        /** Player's skin, null for empty skin */
+        private Skin skin;
+
+        /** I have no idea what this is */
+        private boolean listed;
+
+        /** Latency */
+        private int latency;
+
+        /** GameMode */
+        private EnumGamemode gameMode = EnumGamemode.SURVIVAL; //ProtocolLib causes NPE even when action does not use GameMode
+
+        /** 
+         * Display name displayed in TabList. Using {@code null} results in no display name
+         * and scoreboard team prefix/suffix being visible in TabList instead.
+         */
+        private IChatBaseComponent displayName;
+
+        /** Chat session ID */
+        private UUID chatSessionId;
+
+        /** Player's chat signing key */
+        private Object profilePublicKey;
+
+        /**
+         * Constructs new instance with given parameters. Suitable for 
+         * {@link EnumPlayerInfoAction#UPDATE_GAME_MODE} action
+         * 
+         * @param   uniqueId
+         *          Player's uuid
+         * @param   gameMode
+         *          Player's GameMode
+         */
+        public PlayerInfoData(@NonNull UUID uniqueId, EnumGamemode gameMode) {
+            this.uniqueId = uniqueId;
+            this.gameMode = gameMode;
+        }
+
+        /**
+         * Constructs new instance with given parameters. Suitable for 
+         * {@link EnumPlayerInfoAction#UPDATE_LATENCY} action
+         * 
+         * @param   uniqueId
+         *          Player's uuid
+         * @param   latency
+         *          Player's ping
+         */
+        public PlayerInfoData(@NonNull UUID uniqueId, int latency) {
+            this.uniqueId = uniqueId;
+            this.latency = latency;
+        }
+
+        /**
+         * Constructs new instance with given parameters. Suitable for 
+         * {@link EnumPlayerInfoAction#UPDATE_DISPLAY_NAME} action
+         * 
+         * @param   uniqueId
+         *          Player's uuid
+         * @param   displayName
+         *          Player's display name
+         */
+        public PlayerInfoData(@NonNull UUID uniqueId, IChatBaseComponent displayName) {
+            this.uniqueId = uniqueId;
+            this.displayName = displayName;
+        }
+
+        /**
+         * Constructs new instance with given parameter. Suitable for 
+         * {@link EnumPlayerInfoAction#REMOVE_PLAYER} action
+         * 
+         * @param   uniqueId
+         *          Player's uuid
+         */
+        public PlayerInfoData(@NonNull UUID uniqueId) {
+            this.uniqueId = uniqueId;
+        }
+    }
+
+    /**
+     * En enum representing packet action
+     */
+    public enum EnumPlayerInfoAction {
+
+        ADD_PLAYER,
+        INITIALIZE_CHAT,
+        UPDATE_GAME_MODE,
+        UPDATE_LISTED,
+        UPDATE_LATENCY,
+        UPDATE_DISPLAY_NAME,
+        REMOVE_PLAYER
+    }
+
+    /**
+     * An enum representing GameMode
+     */
+    public enum EnumGamemode {
+
+        NOT_SET,
+        SURVIVAL,
+        CREATIVE,
+        ADVENTURE,
+        SPECTATOR;
+
+        /** Value array to iterate over to avoid array creations on each call */
+        public static final EnumGamemode[] VALUES = values();
+    }
+}
@@ -0,0 +1,33 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data @AllArgsConstructor
+public class PacketPlayOutPlayerListHeaderFooter implements TabPacket {
+
+    /** TabList header */
+    @NonNull private final IChatBaseComponent header;
+
+    /** TabList footer */
+    @NonNull private final IChatBaseComponent footer;
+
+    /**
+     * Constructs new instance with given parameters. They are converted to {@link IChatBaseComponent}
+     * using {@link IChatBaseComponent#optimizedComponent(String)} method.
+     * 
+     * @param   header
+     *          TabList header
+     * @param   footer
+     *          TabList footer
+     */
+    public PacketPlayOutPlayerListHeaderFooter(@NonNull String header, @NonNull String footer) {
+        this.header = IChatBaseComponent.optimizedComponent(header);
+        this.footer = IChatBaseComponent.optimizedComponent(footer);
+    }
+}
@@ -0,0 +1,22 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.Data;
+import lombok.NonNull;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data
+public class PacketPlayOutScoreboardDisplayObjective implements TabPacket {
+
+    /**
+     * Display slot.
+     * 0 = PlayerList,
+     * 1 = SideBar,
+     * 2 = BelowName.
+     */
+    private final int slot;
+
+    /** Up to 16 characters long objective name */
+    @NonNull private final String objectiveName;
+}
@@ -0,0 +1,55 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+import me.neznamy.tab.api.util.Preconditions;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data @AllArgsConstructor
+public class PacketPlayOutScoreboardObjective implements TabPacket {
+
+    /**
+     * Packet action.
+     * 0 = register,
+     * 1 = unregister,
+     * 2 = update title
+     */
+    private final int action;
+
+    /** Up to 16 characters long objective name */
+    @NonNull private final String objectiveName;
+
+    /** Display name */
+    private final String displayName;
+
+    /** Display type, only takes effect in PlayerList */
+    private final EnumScoreboardHealthDisplay renderType;
+
+    /**
+     * Constructs new packet with given objective name and 1 (unregister) action.
+     *
+     * @param   objectiveName
+     *          objective name, up to 16 characters long
+     * @throws  IllegalArgumentException
+     *          if {@code objectiveName} is null or longer than 16 characters
+     */
+    public PacketPlayOutScoreboardObjective(@NonNull String objectiveName) {
+        Preconditions.checkMaxLength(objectiveName, 16, "objective name");
+        this.objectiveName = objectiveName;
+        this.displayName = ""; //avoiding NPE on <1.7
+        this.action = 1;
+        this.renderType = null;
+    }
+
+    /**
+     * An enum representing available display types.
+     * They only take effect in PlayerList position.
+     */
+    public enum EnumScoreboardHealthDisplay {
+
+        INTEGER, HEARTS
+    }
+}
@@ -0,0 +1,32 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.Data;
+import lombok.NonNull;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data
+public class PacketPlayOutScoreboardScore implements TabPacket {
+
+    /** Packet action */
+    @NonNull private final Action action;
+
+    /** Objective name */
+    @NonNull private final String objectiveName;
+
+    /** Affected player */
+    @NonNull private final String player;
+
+    /** Player's score */
+    private final int score;
+
+    /**
+     * An enum representing action types
+     */
+    public enum Action {
+
+        CHANGE,
+        REMOVE
+    }
+}
@@ -0,0 +1,180 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.Data;
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.util.Preconditions;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * A class representing platform specific packet class
+ */
+@Data
+public class PacketPlayOutScoreboardTeam implements TabPacket {
+
+    /**
+     * Up to 16 characters long team name.
+     * It is used to sort players alphabetically in TabList by team names.
+     * Team-less players appear on top, sorted by usernames.
+     * Players with teams are below them, players of the same team are
+     * sorted alphabetically by usernames.
+     */
+    @NonNull private final String name;
+
+    /** Team prefix, limited to 16 characters, on &lt;1.13 */
+    private String playerPrefix;
+
+    /** Team suffix, limited to 16 characters, on &lt;1.13 */
+    private String playerSuffix;
+
+    /** 
+     * NameTag visibility rule since 1.8. Possible options are:
+     * {@code always}, {@code hideForOtherTeams}, {@code hideForOwnTeam}, {@code never}
+     */
+    private String nameTagVisibility;
+
+    /**
+     * Collision rule added in 1.9. Possible options are:
+     * {@code always}, {@code pushOtherTeams}, {@code pushOwnTeam}, {@code never}
+     */
+    private String collisionRule;
+
+    /**
+     * Team color field added in 1.13. It determines name color,
+     * prefix and suffix color start.
+     */
+    private EnumChatFormat color;
+
+    /** 
+     * Affected entities. For players, it is their name, for other entities their UUID
+     * Player name length is limited to 16 characters for &lt;1.8, 40 characters since 1.8.
+     * Entity UUID option was added in 1.8.
+     */
+    @NonNull private Collection<String> players = Collections.emptyList();
+
+    /**
+     * Packet action.
+     * 0 = create team,
+     * 1 = remove team,
+     * 2 = update team info,
+     * 3 = add entries,
+     * 4 = remove entries
+     */
+    private final int action;
+
+    /**
+     * Bit mask.
+     * 0x01: Allow friendly fire,
+     * 0x02: Can see invisible players on the same team.
+     */
+    private int options;
+
+    /**
+     * Constructs new instance with given parameters. Private constructor used
+     * internally to validate team name and set action.
+     * 
+     * @param   action
+     *          Packet action (0 = create team, 1 = remove team, 2 = update team info,
+     *          3 = add entries, 4 = remove entries)
+     * @param   name
+     *          Team name, up to 16 characters long
+     * @throws  IllegalArgumentException
+     *          if {@code name} is null, empty or longer than 16 characters
+     */
+    private PacketPlayOutScoreboardTeam(int action, @NonNull String name) {
+        Preconditions.checkMaxLength(name, 16, "team name");
+        this.action = action;
+        this.name = name;
+    }
+
+    /**
+     * Constructs new instance with given parameters and 0 (CREATE) action
+     * 
+     * @param   team
+     *          Team name, up to 16 characters long
+     * @param   prefix
+     *          Prefix of players in team
+     * @param   suffix
+     *          Suffix of players in team
+     * @param   visibility
+     *          NameTag visibility rule
+     * @param   collision
+     *          Collision rule
+     * @param   players
+     *          Affected entities
+     * @param   options
+     *          bitmask of team options
+     * @throws  IllegalArgumentException
+     *          if {@code name} is null, empty or longer than 16 characters
+     */
+    public PacketPlayOutScoreboardTeam(String team, @NonNull String prefix, @NonNull String suffix, String visibility,
+                                       String collision, @NonNull Collection<String> players, int options) {
+        this(0, team);
+        this.playerPrefix = prefix;
+        this.playerSuffix = suffix;
+        this.nameTagVisibility = visibility;
+        this.collisionRule = collision;
+        this.players = players;
+        this.options = options;
+    }
+
+    /**
+     * Constructs new instance with given parameters and 1 (REMOVE) action
+     * 
+     * @param   team
+     *          Team name, up to 16 characters long
+     * @throws  IllegalArgumentException
+     *          if {@code name} is null, empty or longer than 16 characters
+     */
+    public PacketPlayOutScoreboardTeam(String team) {
+        this(1, team);
+    }
+
+    /**
+     * Constructs new instance with given parameters and 2 (UPDATE_TEAM_INFO) action
+     * 
+     * @param   team
+     *          Team name, up to 16 characters long
+     * @param   prefix
+     *          Prefix of players in team
+     * @param   suffix
+     *          Suffix of players in team
+     * @param   visibility
+     *          NameTag visibility rule
+     * @param   collision
+     *          Collision rule
+     * @param   options
+     *          bitmask of team options
+     * @throws  IllegalArgumentException
+     *          if {@code name} is null, empty or longer than 16 characters
+     */
+    public PacketPlayOutScoreboardTeam(String team, @NonNull String prefix, @NonNull String suffix,
+                                       String visibility, String collision, int options) {
+        this(2, team);
+        this.playerPrefix = prefix;
+        this.playerSuffix = suffix;
+        this.nameTagVisibility = visibility;
+        this.collisionRule = collision;
+        this.options = options;
+    }
+
+    /**
+     * Constructs new instance with given parameters and 3 (ADD_PLAYERS) if {@code add} is {@code true}, 
+     * 4 (REMOVE_PLAYERS) if {@code add} is {@code false} action.
+     * 
+     * @param   team
+     *          Team name, up to 16 characters long
+     * @param   players
+     *          Affected entities
+     * @param   add
+     *          {@code true} if players should be added, {@code false} if removed from team
+     * @throws  IllegalArgumentException
+     *          if {@code name} is null, empty or longer than 16 characters
+     */
+    public PacketPlayOutScoreboardTeam(String team, @NonNull Collection<String> players, boolean add) {
+        this(add ? 3 : 4, team);
+        this.players = players;
+    }
+}
@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.protocol;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+
+/**
+ * Class representing a minecraft skin as a value - signature pair.
+ */
+@Data @AllArgsConstructor
+public class Skin {
+
+    /** Skin value */
+    @NonNull private final String value;
+
+    /** Skin signature, can be null */
+    private final String signature;
+}
@@ -0,0 +1,17 @@
+package me.neznamy.tab.api.protocol;
+
+/**
+ * Interface representing a packet that can be sent to client independently of platform.
+ * It is technically empty, existence is only present to restrict type access
+ * when sending packets to player, so {@link me.neznamy.tab.api.TabPlayer#sendCustomPacket(TabPacket)} cannot
+ * be called with an actual packet.
+ */
+public interface TabPacket {
+
+    /**
+     * Returns user-friendly string representation of the packet
+     *
+     * @return  user-friendly string representation of the packet
+     */
+    String toString();
+}
@@ -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);
+}
@@ -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();
+}
@@ -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);
+}
@@ -0,0 +1,96 @@
+package me.neznamy.tab.api.task;
+
+import java.util.concurrent.Future;
+
+import me.neznamy.tab.api.TabFeature;
+
+/**
+ * Manager for scheduling and executing tasks in TAB's
+ * main thread to avoid concurrency issues.
+ */
+public interface ThreadManager {
+
+    /**
+     * Starts a task in new thread and measures how long it took to process
+     *
+     * @param   feature
+     *          feature to add cpu usage to
+     * @param   type
+     *          usage type to add cpu usage to
+     * @param   task
+     *          the task
+     */
+    Future<Void> runMeasuredTask(TabFeature feature, String type, Runnable task);
+
+    /**
+     * Starts a task in new thread and measures how long it took to process
+     *
+     * @param   feature
+     *          feature to add cpu usage to
+     * @param   type
+     *          usage type to add cpu usage to
+     * @param   task
+     *          the task
+     */
+    Future<Void> runMeasuredTask(String feature, String type, Runnable task);
+
+    /**
+     * Runs task in a new thread
+     *
+     * @param   task
+     *          the task
+     */
+    Future<Void> runTask(Runnable task);
+
+    /**
+     * Starts a new task with defined repeat interval that measures cpu usage
+     *
+     * @param   intervalMilliseconds
+     *          task interval
+     * @param   feature
+     *          feature to add cpu usage to
+     * @param   type
+     *          usage type to add cpu usage to
+     * @param   task
+     *          the task
+     * @return  Future representing the submitted task
+     */
+    Future<?> startRepeatingMeasuredTask(int intervalMilliseconds, TabFeature feature, String type, Runnable task);
+
+    /**
+     * Starts a new task with defined repeat interval
+     *
+     * @param   intervalMilliseconds
+     *          task interval
+     * @param   task
+     *          the task
+     * @return  Future representing the submitted task
+     */
+    Future<?> startRepeatingTask(int intervalMilliseconds, Runnable task);
+
+    /**
+     * Runs task with a delay and measures how long it took to process
+     *
+     * @param   delayMilliseconds
+     *          how long to run the task after
+     * @param   feature
+     *          feature to add cpu usage to
+     * @param   type
+     *          usage type to add cpu usage to
+     * @param   task
+     *          the task
+     * @return  Future representing the submitted task
+     */
+    Future<?> runTaskLater(int delayMilliseconds, TabFeature feature, String type, Runnable task);
+
+    /**
+     * Runs task with a delay
+     *
+     * @param   delayMilliseconds
+     *          how long to run the task after
+     * @param   task
+     *          the task
+     * @return  Future representing the submitted task
+     */
+    Future<?> runTaskLater(int delayMilliseconds, Runnable task);
+}
@@ -0,0 +1,182 @@
+package me.neznamy.tab.api.team;
+
+import me.neznamy.tab.api.TabPlayer;
+
+public interface TeamManager {
+
+    /**
+     * Makes player's NameTag globally invisible
+     *
+     * @param   player
+     *          player to hide nametag of
+     * @see     #showNametag(TabPlayer)
+     * @see     #hasHiddenNametag(TabPlayer)
+     */
+    void hideNametag(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(TabPlayer player, TabPlayer viewer);
+
+    /**
+     * Makes player's NameTag visible again
+     *
+     * @param   player
+     *          player to show nametag of
+     * @see     #hideNametag(TabPlayer)
+     * @see     #hasHiddenNametag(TabPlayer)
+     */
+    void showNametag(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(TabPlayer player, 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(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(TabPlayer player, TabPlayer viewer);
+
+    /**
+     * Unregisters player's team and no longer handles it, as well as disables anti-override for teams.
+     * This can be resumed using resumeTeamHandling(). If team handling was paused already, nothing happens.
+     *
+     * @param   player
+     *          player to pause team handling of
+     */
+    void pauseTeamHandling(TabPlayer player);
+
+    /**
+     * Resumes team handling if it was before paused using pauseTeamHandling(), if not, nothing happens
+     *
+     * @param   player
+     *          player to resume team handling of
+     */
+    void resumeTeamHandling(TabPlayer player);
+
+    /**
+     * 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(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(TabPlayer player, 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
+     */
+    String getForcedTeamName(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(TabPlayer player, 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
+     */
+    Boolean getCollisionRule(TabPlayer player);
+
+    /**
+     * Sends update team's properties packet of player's team to everyone
+     *
+     * @param   player
+     *          player to update team data of
+     */
+    void updateTeamData(TabPlayer player);
+
+    void setPrefix(TabPlayer player, String prefix);
+
+    void setSuffix(TabPlayer player, String suffix);
+
+    void resetPrefix(TabPlayer player);
+
+    void resetSuffix(TabPlayer player);
+
+    String getCustomPrefix(TabPlayer player);
+
+    String getCustomSuffix(TabPlayer player);
+
+    String getOriginalPrefix(TabPlayer player);
+
+    String getOriginalSuffix(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(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(TabPlayer player);
+}
@@ -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();
+}
@@ -0,0 +1,29 @@
+package me.neznamy.tab.api.util;
+
+/**
+ * An interface for BiFunction which can throw an exception.
+ * Used in {@link me.neznamy.tab.api.protocol.PacketBuilder} to
+ * call build method for packet classes, which may throw an
+ * exception due to reflection.
+ * @param   <A>
+ *          First function argument
+ * @param   <B>
+ *          Second function argument
+ * @param   <C>
+ *          Function return type
+ */
+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;
+}
@@ -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);
+        }
+    }
+}
@@ -0,0 +1,64 @@
+package me.neznamy.tab.api.util;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Class with utility methods used in the plugin
+ */
+public class Preconditions {
+
+    /**
+     * Private constructor preventing the class from being instantiated
+     */
+    private 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.");
+    }
+}
@@ -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;
+        }
+    }
+}
@@ -0,0 +1,12 @@
+package me.neznamy.tab.api.util;
+
+/**
+ * Supplier that can throw an exception
+ *
+ * @param   <T>
+ *          Return class type
+ */
+public interface SupplierWithException<T> {
+
+    T get() throws Exception;
+}
@@ -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
+}
@@ -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"))
+        }
+    }
+}
@@ -0,0 +1,33 @@
+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
+        ))
+    }
+    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))
+    }
+}
@@ -0,0 +1,13 @@
+plugins {
+    id("tab.standard-conventions")
+    id("com.github.johnrengelman.shadow")
+}
+
+tasks {
+    shadowJar {
+        archiveFileName.set("TAB-${project.name}-${project.version}.jar")
+        relocate("org.bstats", "me.neznamy.tab.libs.org.bstats")
+        relocate("org.json.simple", "me.neznamy.tab.libs.org.json.simple")
+        relocate("net.kyori.event", "me.neznamy.tab.libs.net.kyori.event")
+    }
+}
@@ -0,0 +1,25 @@
+plugins {
+    id("tab.base-conventions")
+    `maven-publish`
+}
+
+java {
+    withSourcesJar()
+    withJavadocJar()
+}
+
+publishing {
+    repositories {
+        maven {
+            name = "krypton"
+            url = uri("https://repo.kryptonmc.org/releases")
+            credentials(PasswordCredentials::class)
+        }
+    }
+    publications.create<MavenPublication>("mavenJava") {
+        groupId = rootProject.group as String
+        artifactId = "tab-${project.name}"
+        version = rootProject.version as String
+        from(components["java"])
+    }
+}
@@ -0,0 +1,30 @@
+plugins {
+    id("tab.parent")
+}
+
+allprojects {
+    group = "me.neznamy"
+    version = property("projectVersion") as String // from gradle.properties
+    description = "An all-in-one solution that works"
+}
+
+val platforms = setOf(
+    projects.bukkit,
+    projects.bungeecord,
+    projects.krypton,
+    projects.velocity,
+    //projects.sponge
+).map { it.dependencyProject }
+
+val special = setOf(
+    projects.api,
+    projects.shared
+).map { it.dependencyProject }
+
+subprojects {
+    when (this) {
+        in platforms -> plugins.apply("tab.platform-conventions")
+        in special -> plugins.apply("tab.standard-conventions")
+        else -> plugins.apply("tab.base-conventions")
+    }
+}
@@ -0,0 +1,9 @@
+dependencies {
+    implementation(projects.shared)
+    implementation(libs.bstats.bukkit)
+    compileOnly(libs.bukkit)
+    compileOnly(libs.placeholderapi)
+    compileOnly(libs.vault)
+    compileOnly(libs.via)
+    compileOnly(libs.authlib)
+}
@@ -1,150 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<parent>
-		<groupId>me.neznamy</groupId>
-		<artifactId>TAB</artifactId>
-		<version>2.9.2-pre2</version>
-	</parent>
-	<artifactId>bukkit</artifactId>
-
-	<repositories>
-
-		<!-- Spigot API -->
-		<repository>
-			<id>spigot-repo</id>
-			<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-		</repository>
-
-		<!-- PlaceholderAPI -->
-		<repository>
-			<id>placeholderapi</id>
-			<url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
-		</repository>
-
-		<!-- Vault -->
-		<repository>
-			<id>jitpack.io</id>
-			<url>https://jitpack.io</url>
-		</repository>
-
-		<!-- ViaVersion -->
-		<repository>
-			<id>viaversion</id>
-			<url>https://repo.viaversion.com/</url>
-		</repository>
-
-		<repository>
-			<id>aikar</id>
-			<url>https://repo.aikar.co/content/groups/aikar/</url>
-		</repository>
-	</repositories>
-
-	<dependencies>
-
-		<!-- TAB Core -->
-		<dependency>
-			<groupId>me.neznamy</groupId>
-			<artifactId>shared</artifactId>
-			<version>${project.version}</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>com.github.NEZNAMY</groupId>
-					<artifactId>YamlAssist</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.googlecode.json-simple</groupId>
-					<artifactId>json-simple</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Spigot API -->
-		<dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot-api</artifactId>
-			<version>1.17-R0.1-SNAPSHOT</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-lang</groupId>
-					<artifactId>commons-lang</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.md-5</groupId>
-					<artifactId>bungeecord-chat</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.code.gson</groupId>
-					<artifactId>gson</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.yaml</groupId>
-					<artifactId>snakeyaml</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- PlaceholderAPI -->
-		<dependency>
-			<groupId>me.clip</groupId>
-			<artifactId>placeholderapi</artifactId>
-			<version>2.10.9</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>org.jetbrains</groupId>
-					<artifactId>annotations</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Vault -->
-		<dependency>
-			<groupId>com.github.MilkBowl</groupId>
-			<artifactId>VaultAPI</artifactId>
-			<version>1.7</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-lang</groupId>
-					<artifactId>commons-lang</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.code.gson</groupId>
-					<artifactId>gson</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.bukkit</groupId>
-					<artifactId>bukkit</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- ViaVersion -->
-		<dependency>
-			<groupId>com.viaversion</groupId>
-			<artifactId>viaversion-api</artifactId>
-			<version>4.0.0</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>com.mojang</groupId>
-			<artifactId>authlib</artifactId>
-			<version>1.11</version>
-			<scope>provided</scope>
-		</dependency>
-		
-		
-		<!-- Bukkit Metrics -->
-		<dependency>
-			<groupId>org.bstats</groupId>
-			<artifactId>bstats-bukkit</artifactId>
-			<version>2.2.1</version>
-			<scope>compile</scope>
-		</dependency>
-	</dependencies>
-</project>
@@ -1,5 +1,7 @@
 package me.neznamy.tab.platforms.bukkit;

+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.api.TabAPI;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -8,65 +10,63 @@ import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;

-import me.neznamy.tab.shared.TAB;
-
 /**
 * The core for bukkit forwarding events into all enabled features
 */
+@RequiredArgsConstructor
 public class BukkitEventListener implements Listener {

-	/**
-	 * Listener to PlayerQuitEvent to remove player data and forward the event to features
-	 * @param e quit event
-	 */
-	@EventHandler(priority = EventPriority.HIGHEST)
-	public void onQuit(PlayerQuitEvent e){
-		if (TAB.getInstance().isDisabled()) return;
-		TAB.getInstance().getCPUManager().runTask("processing PlayerQuitEvent", () -> TAB.getInstance().getFeatureManager().onQuit(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId())));
-	}
-	
-	/**
-	 * Listener to PlayerJoinEvent to create player data and forward the event to features
-	 * @param e join event
-	 */
-	@EventHandler(priority = EventPriority.LOWEST)
-	public void onJoin(PlayerJoinEvent e) {
-		if (TAB.getInstance().isDisabled()) return;
-		TAB.getInstance().getCPUManager().runTask("processing PlayerJoinEvent", () -> {
-			try {
-				int i = 0;
-				int version;
-				while ((version = Main.getProtocolVersion(e.getPlayer())) == -1 && ++i < 100) {
-					Thread.sleep(2);
-				}
-				if (!e.getPlayer().isOnline()) return;
-				if (i == 50) {
-					TAB.getInstance().getErrorManager().printError("Failed to get protocol version of " + e.getPlayer().getName() + " after 50 retries");
-				}
-				TAB.getInstance().getFeatureManager().onJoin(new BukkitTabPlayer(e.getPlayer(), version));
-			} catch (InterruptedException pluginDisabled) {
-				Thread.currentThread().interrupt();
-			}
-		});
-	}
+    /** Platform instance */
+    private final BukkitPlatform platform;
+    
+    /**
+     * Listener to PlayerQuitEvent to remove player data and forward the event to features
+     *
+     * @param   e
+     *          quit event
+     */
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onQuit(PlayerQuitEvent e){
+        if (TabAPI.getInstance().isPluginDisabled()) return;
+        TabAPI.getInstance().getThreadManager().runTask(() -> TabAPI.getInstance().getFeatureManager().onQuit(TabAPI.getInstance().getPlayer(e.getPlayer().getUniqueId())));
+    }
+    
+    /**
+     * Listener to PlayerJoinEvent to create player data and forward the event to features
+     *
+     * @param   e
+     *          join event
+     */
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onJoin(PlayerJoinEvent e) {
+        if (TabAPI.getInstance().isPluginDisabled()) return;
+        TabAPI.getInstance().getThreadManager().runTask(() ->
+                TabAPI.getInstance().getFeatureManager().onJoin(new BukkitTabPlayer(e.getPlayer(), platform.getProtocolVersion(e.getPlayer()))));
+    }

-	/**
-	 * Listener to PlayerChangedWorldEvent to forward the event to features
-	 * @param e world changed event
-	 */
-	@EventHandler(priority = EventPriority.LOWEST)
-	public void onWorldChange(PlayerChangedWorldEvent e){
-		if (TAB.getInstance().isDisabled()) return;
-		TAB.getInstance().getCPUManager().runTask("processing PlayerChangedWorldEvent", () -> TAB.getInstance().getFeatureManager().onWorldChange(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName()));
-	}
+    /**
+     * Listener to PlayerChangedWorldEvent to forward the event to features
+     *
+     * @param   e
+     *          world changed event
+     */
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onWorldChange(PlayerChangedWorldEvent e){
+        if (TabAPI.getInstance().isPluginDisabled()) return;
+        TabAPI.getInstance().getThreadManager().runTask(() ->
+                TabAPI.getInstance().getFeatureManager().onWorldChange(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName()));
+    }

-	/**
-	 * Listener to PlayerChangedWorldEvent to forward the event to features
-	 * @param e command preprocess event
-	 */
-	@EventHandler
-	public void onCommand(PlayerCommandPreprocessEvent e) {
-		if (TAB.getInstance().isDisabled()) return;
-		if (TAB.getInstance().getFeatureManager().onCommand(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId()), e.getMessage())) e.setCancelled(true);
-	}
+    /**
+     * Listener to PlayerChangedWorldEvent to forward the event to features
+     *
+     * @param   e
+     *          command preprocess event
+     */
+    @EventHandler
+    public void onCommand(PlayerCommandPreprocessEvent e) {
+        if (TabAPI.getInstance().isPluginDisabled()) return;
+        if (TabAPI.getInstance().getFeatureManager().onCommand(
+                TabAPI.getInstance().getPlayer(e.getPlayer().getUniqueId()), e.getMessage())) e.setCancelled(true);
+    }
 }
@@ -2,143 +2,140 @@ package me.neznamy.tab.platforms.bukkit;

 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.NoSuchElementException;
+import java.util.function.Function;

 import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPromise;
+import lombok.AllArgsConstructor;
+import me.neznamy.tab.api.TabFeature;
 import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.NMSStorage;
+import me.neznamy.tab.api.TabConstants;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
 import me.neznamy.tab.shared.features.PipelineInjector;
+import me.neznamy.tab.shared.features.sorting.Sorting;
+import org.jetbrains.annotations.NotNull;

+/**
+ * Pipeline injection for bukkit
+ */
 public class BukkitPipelineInjector extends PipelineInjector {

-	//handler to inject before
-	private static final String INJECT_POSITION = "packet_handler";
-	
-	//nms storage
-	private NMSStorage nms;
+    /** NMS data storage */
+    private final NMSStorage nms = NMSStorage.getInstance();

-	/**
-	 * Constructs new instance with given parameters
-	 * @param tab - tab instance
-	 * @param nms - nms storage
-	 */
-	public BukkitPipelineInjector(TAB tab, NMSStorage nms){
-		super(tab);
-		this.nms = nms;
-	}
-	
-	@Override
-	public void inject(TabPlayer player) {
-		if (!player.getChannel().pipeline().names().contains(INJECT_POSITION)) {
-			//fake player or waterfall bug
-			return;
-		}
-		uninject(player);
-		try {
-			player.getChannel().pipeline().addBefore(INJECT_POSITION, DECODER_NAME, new BukkitChannelDuplexHandler(player));
-		} catch (NoSuchElementException | IllegalArgumentException e) {
-			//idk how does this keep happening but whatever
-		}
-	}
+    /**
+     * Constructs new instance
+     */
+    public BukkitPipelineInjector(){
+        super("packet_handler");
+    }

-	@Override
-	public void uninject(TabPlayer player) {
-		try {
-			if (player.getChannel().pipeline().names().contains(DECODER_NAME)) player.getChannel().pipeline().remove(DECODER_NAME);
-		} catch (NoSuchElementException e) {
-			//for whatever reason this rarely throws
-			//java.util.NoSuchElementException: TABReader
-		}
-	}
-	
-	/**
-	 * Custom channel duplex handler override
-	 */
-	public class BukkitChannelDuplexHandler extends ChannelDuplexHandler {
-		
-		//injected player
-		private TabPlayer player;
-		
-		/**
-		 * Constructs new instance with given player
-		 * @param player - player to inject
-		 */
-		public BukkitChannelDuplexHandler(TabPlayer player) {
-			this.player = player;
-		}
+    @Override
+    public Function<TabPlayer, ChannelDuplexHandler> getChannelFunction() {
+        return BukkitChannelDuplexHandler::new;
+    }

-		@Override
-		public void channelRead(ChannelHandlerContext context, Object packet) {
-			try {
-				Object modifiedPacket = tab.getFeatureManager().onPacketReceive(player, packet);
-				if (modifiedPacket != null) super.channelRead(context, modifiedPacket);
-			} catch (Exception e){
-				tab.getErrorManager().printError("An error occurred when reading packets", e);
-			}
-		}
+    /**
+     * Custom channel duplex handler override
+     */
+    @AllArgsConstructor
+    public class BukkitChannelDuplexHandler extends ChannelDuplexHandler {

-		@Override
-		public void write(ChannelHandlerContext context, Object packet, ChannelPromise channelPromise) {
-			try {
-				if (nms.getClass("PacketPlayOutPlayerInfo").isInstance(packet)) {
-					super.write(context, tab.getFeatureManager().onPacketPlayOutPlayerInfo(player, packet), channelPromise);
-					return;
-				}
-				if (tab.getFeatureManager().getNameTagFeature() != null && antiOverrideTeams && nms.getClass("PacketPlayOutScoreboardTeam").isInstance(packet)) {
-					modifyPlayers(packet);
-					super.write(context, packet, channelPromise);
-					return;
-				}
-				if (nms.getClass("PacketPlayOutScoreboardDisplayObjective").isInstance(packet) && antiOverrideObjectives && tab.getFeatureManager().onDisplayObjective(player, packet)) {
-					return;
-				}
-				if (antiOverrideObjectives && nms.getClass("PacketPlayOutScoreboardObjective").isInstance(packet)) {
-					tab.getFeatureManager().onObjective(player, packet);
-				}
-				tab.getFeatureManager().onPacketSend(player, packet);
-			} catch (Exception e){
-				tab.getErrorManager().printError("An error occurred when reading packets", e);
-			}
-			try {
-				super.write(context, packet, channelPromise);
-			} catch (Exception e) {
-				tab.getErrorManager().printError("Failed to forward packet " + packet.getClass().getSimpleName() + " to " + player.getName(), e);
-			}
-		}
-		
-		/**
-		 * Removes all real players from team if packet does not come from TAB and reports this to override log
-		 * @param packetPlayOutScoreboardTeam - team packet
-		 * @throws IllegalAccessException 
-		 */
-		@SuppressWarnings("unchecked")
-		private void modifyPlayers(Object packetPlayOutScoreboardTeam) throws IllegalAccessException {
-			long time = System.nanoTime();
-			Collection<String> players = (Collection<String>) nms.getField("PacketPlayOutScoreboardTeam_PLAYERS").get(packetPlayOutScoreboardTeam);
-			String teamName = (String) nms.getField("PacketPlayOutScoreboardTeam_NAME").get(packetPlayOutScoreboardTeam);
-			if (players == null) return;
-			//creating a new list to prevent NoSuchFieldException in minecraft packet encoder when a player is removed
-			Collection<String> newList = new ArrayList<>();
-			for (String entry : players) {
-				TabPlayer p = tab.getPlayer(entry);
-				if (p == null) {
-					newList.add(entry);
-					continue;
-				}
-				if (!tab.getFeatureManager().getNameTagFeature().getPlayersInDisabledWorlds().contains(p) && !p.hasTeamHandlingPaused() && 
-						!p.getTeamName().equals(teamName)) {
-					logTeamOverride(teamName, entry);
-				} else {
-					newList.add(entry);
-				}
-			}
-			nms.setField(packetPlayOutScoreboardTeam, "PacketPlayOutScoreboardTeam_PLAYERS", newList);
-			tab.getCPUManager().addTime(TabFeature.NAMETAGS, UsageType.ANTI_OVERRIDE, System.nanoTime()-time);
-		}
-	}
+        /** Injected player */
+        private final TabPlayer player;
+
+        @Override
+        public void channelRead(@NotNull ChannelHandlerContext context, @NotNull Object packet) {
+            try {
+                if (TAB.getInstance().getFeatureManager().onPacketReceive(player, packet)) return;
+                super.channelRead(context, packet);
+            } catch (Exception e){
+                TAB.getInstance().getErrorManager().printError("An error occurred when reading packets", e);
+            }
+        }
+
+        @Override
+        public void write(ChannelHandlerContext context, Object packet, ChannelPromise channelPromise) {
+            try {
+                if (nms.PacketPlayOutPlayerInfo.isInstance(packet) ||
+                        (nms.ClientboundPlayerInfoRemovePacket != null && nms.ClientboundPlayerInfoRemovePacket.isInstance(packet))) {
+                    super.write(context, TAB.getInstance().getFeatureManager().onPacketPlayOutPlayerInfo(player, packet), channelPromise);
+                    return;
+                }
+                if (antiOverrideTeams && nms.PacketPlayOutScoreboardTeam.isInstance(packet)) {
+                    long time = System.nanoTime();
+                    modifyPlayers(packet);
+                    TAB.getInstance().getCPUManager().addTime("NameTags", TabConstants.CpuUsageCategory.ANTI_OVERRIDE, System.nanoTime()-time);
+                    super.write(context, packet, channelPromise);
+                    return;
+                }
+                if (nms.PacketPlayOutScoreboardDisplayObjective.isInstance(packet)){
+                    TAB.getInstance().getFeatureManager().onDisplayObjective(player, packet);
+                }
+                if (nms.PacketPlayOutScoreboardObjective.isInstance(packet)) {
+                    TAB.getInstance().getFeatureManager().onObjective(player, packet);
+                }
+                TAB.getInstance().getFeatureManager().onPacketSend(player, packet);
+            } catch (Exception e){
+                TAB.getInstance().getErrorManager().printError("An error occurred when reading packets", e);
+            }
+            try {
+                super.write(context, packet, channelPromise);
+            } catch (Exception e) {
+                TAB.getInstance().getErrorManager().printError("Failed to forward packet " + packet.getClass().getSimpleName() + " to " + player.getName(), e);
+            }
+        }
+
+        /**
+         * Removes all real players from team if packet does not come from TAB and reports this to override log
+         *
+         * @param   packetPlayOutScoreboardTeam
+         *          team packet
+         * @throws  ReflectiveOperationException
+         *          nmsGameMode
+         */
+        @SuppressWarnings("unchecked")
+        private void modifyPlayers(Object packetPlayOutScoreboardTeam) throws ReflectiveOperationException {
+            int action = nms.PacketPlayOutScoreboardTeam_ACTION.getInt(packetPlayOutScoreboardTeam);
+            if (action == 1 || action == 2 || action == 4) return;
+            Collection<String> players = (Collection<String>) nms.PacketPlayOutScoreboardTeam_PLAYERS.get(packetPlayOutScoreboardTeam);
+            String teamName = (String) nms.PacketPlayOutScoreboardTeam_NAME.get(packetPlayOutScoreboardTeam);
+            if (players == null) return;
+            //creating a new list to prevent NoSuchFieldException in minecraft packet encoder when a player is removed
+            Collection<String> newList = new ArrayList<>();
+            for (String entry : players) {
+                TabPlayer p = getPlayer(entry);
+                if (p == null) {
+                    newList.add(entry);
+                    continue;
+                }
+                Sorting sorting = (Sorting) TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.SORTING);
+                if (!((TabFeature)TAB.getInstance().getTeamManager()).isDisabledPlayer(p) &&
+                        !TAB.getInstance().getTeamManager().hasTeamHandlingPaused(p) && !teamName.equals(sorting.getShortTeamName(p))) {
+                    logTeamOverride(teamName, p.getName(), sorting.getShortTeamName(p));
+                } else {
+                    newList.add(entry);
+                }
+            }
+            nms.setField(packetPlayOutScoreboardTeam, nms.PacketPlayOutScoreboardTeam_PLAYERS, newList);
+        }
+
+        /**
+         * Returns player with matching game profile name. This is different from
+         * real name when a nick plugin changing names of players is used. If no
+         * player was found, returns {@code null}.
+         *
+         * @param   name
+         *          Game profile name
+         * @return  Player with matching game profile name
+         */
+        private TabPlayer getPlayer(String name) {
+            for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+                if (p.getNickname().equals(name)) return p;
+            }
+            return null;
+        }
+    }
 }
@@ -1,305 +1,122 @@
 package me.neznamy.tab.platforms.bukkit;

-import java.lang.reflect.Method;
-import java.text.DecimalFormat;
-import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.UUID;
-
+import me.neznamy.tab.api.TabConstants;
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.placeholders.UniversalPlaceholderRegistry;
+import net.milkbowl.vault.chat.Chat;
 import org.bukkit.Bukkit;
-import org.bukkit.Statistic;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.java.JavaPlugin;

-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.features.PlaceholderManager;
-import me.neznamy.tab.shared.placeholders.Placeholder;
-import me.neznamy.tab.shared.placeholders.PlaceholderRegistry;
-import me.neznamy.tab.shared.placeholders.PlayerPlaceholder;
-import me.neznamy.tab.shared.placeholders.ServerPlaceholder;
-import net.milkbowl.vault.chat.Chat;
-import net.milkbowl.vault.economy.Economy;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.text.NumberFormat;
+import java.util.Locale;
+import java.util.UUID;

 /**
- * Bukkit registry to register bukkit-only placeholders
+ * Bukkit registry to register bukkit-only and universal placeholders
 */
-public class BukkitPlaceholderRegistry implements PlaceholderRegistry {
+public class BukkitPlaceholderRegistry extends UniversalPlaceholderRegistry {

-	//formatter for 2 decimal places
-	public final DecimalFormat decimal2 = ((DecimalFormat)NumberFormat.getNumberInstance(Locale.US));
+    /** Number formatter for 2 decimal places */
+    private final NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.US);

-	//plugin instance
-	private JavaPlugin plugin;
+    /** Vault Chat hook */
+    private Chat chat;

-	//vault economy
-	private Economy economy;
+    /** NMS server to get TPS from on spigot */
+    private Object server;

-	//vault chat
-	private Chat chat;
+    /** TPS field*/
+    private Field recentTps;

-	//placeholder registry buffer
-	private List<Placeholder> placeholders;
+    /** Detection for presence of Paper's TPS getter */
+    private Method paperTps;

-	private Object essentials;
-	
-	//essentials methods
-	private Method essGetUser;
-	private Method essGetNickname;
-	private Method essIsAfk;
-	
-	private Method purpurIsAfk;
+    /** Detection for presence of Paper's MSPT getter */
+    private Method paperMspt;

-	/**
-	 * Constructs new instance with given parameter
-	 * @param plugin - plugin instance
-	 */
-	public BukkitPlaceholderRegistry(JavaPlugin plugin) {
-		decimal2.applyPattern("#.##");
-		this.plugin = plugin;
-		essentials = Bukkit.getPluginManager().getPlugin("Essentials");
-		if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
-			RegisteredServiceProvider<Economy> rspEconomy = Bukkit.getServicesManager().getRegistration(Economy.class);
-			if (rspEconomy != null) economy = rspEconomy.getProvider();
-			RegisteredServiceProvider<Chat> rspChat = Bukkit.getServicesManager().getRegistration(Chat.class);
-			if (rspChat != null) chat = rspChat.getProvider();
-		}
-		if (essentials != null) {
-			try {
-				essGetUser = Class.forName("com.earth2me.essentials.Essentials").getMethod("getUser", Player.class);
-				essGetNickname = Class.forName("com.earth2me.essentials.User").getMethod("getNickname");
-				essIsAfk = Class.forName("com.earth2me.essentials.User").getMethod("isAfk");
-			} catch (Exception e) {
-				TAB.getInstance().getErrorManager().printError("Failed to load essentials methods", e);
-			}
-		}
-	}
+    /** Detection for presence of Purpur's AFK getter */
+    private Method purpurIsAfk;

-	@Override
-	public List<Placeholder> registerPlaceholders() {
-		placeholders = new ArrayList<>();
-		placeholders.add(new PlayerPlaceholder("%money%", 1000) {
-			public String get(TabPlayer p) {
-				if (economy != null) return decimal2.format(economy.getBalance((Player) p.getPlayer()));
-				return "-";
-			}
-		});
+    /**
+     * Constructs new instance and loads hooks
+     */
+    public BukkitPlaceholderRegistry() {
+        numberFormat.setMaximumFractionDigits(2);
+        if (Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.VAULT)) {
+            RegisteredServiceProvider<Chat> rspChat = Bukkit.getServicesManager().getRegistration(Chat.class);
+            if (rspChat != null) chat = rspChat.getProvider();
+        }
+        try {
+            server = Bukkit.getServer().getClass().getMethod("getServer").invoke(Bukkit.getServer());
+            recentTps = server.getClass().getField("recentTps");
+        } catch (ReflectiveOperationException e) {
+            //not spigot
+        }
+        try { paperTps = Bukkit.class.getMethod("getTPS"); } catch (NoSuchMethodException ignored) {}
+        try { paperMspt = Bukkit.class.getMethod("getAverageTickTime"); } catch (NoSuchMethodException ignored) {}
+        try { purpurIsAfk = Player.class.getMethod("isAfk"); } catch (NoSuchMethodException ignored) {}
+    }

-		placeholders.add(new PlayerPlaceholder("%displayname%", 500) {
-			public String get(TabPlayer p) {
-				return ((Player) p.getPlayer()).getDisplayName();
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%deaths%", 1000) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getStatistic(Statistic.DEATHS));
-			}
-		});
-		placeholders.add(new ServerPlaceholder("%tps%", 1000) {
-			public String get() {
-				try {
-					Object nmsServer = Bukkit.getServer().getClass().getMethod("getServer").invoke(Bukkit.getServer());
-					double value = ((double[]) nmsServer.getClass().getField("recentTps").get(nmsServer))[0];
-					return decimal2.format(Math.min(20, value));
-				} catch (Exception t) {
-					return "-1";
-				}
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%canseeonline%", 2000) {
-			public String get(TabPlayer p) {
-				int count = 0;
-				for (TabPlayer all : TAB.getInstance().getPlayers()){
-					if (((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
-				}
-				return String.valueOf(count);
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%canseestaffonline%", 2000) {
-			public String get(TabPlayer p) {
-				int count = 0;
-				for (TabPlayer all : TAB.getInstance().getPlayers()){
-					if (all.isStaff() && ((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
-				}
-				return String.valueOf(count);
-			}
-		});
-		if (NMSStorage.getInstance().getMinorVersion() >= 6) {
-			placeholders.add(new PlayerPlaceholder("%health%", 100) {
-				public String get(TabPlayer p) {
-					return String.valueOf((int) Math.ceil(((Player) p.getPlayer()).getHealth()));
-				}
-			});
-		}
-		registerAFKPlaceholder();
-		registerVaultPlaceholders();
-		registerPositionPlaceholders();
-		registerEssentialsPlaceholders();
-		registerSyncPlaceholders();
-		return placeholders;
-	}
+    @SuppressWarnings("deprecation")
+    @Override
+    public void registerPlaceholders(PlaceholderManager manager) {
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.DISPLAY_NAME, 500, p -> ((Player) p.getPlayer()).getDisplayName());
+        if (paperTps != null) {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.TPS, 1000, () -> formatTPS(Bukkit.getTPS()[0]));
+        } else if (recentTps != null) {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.TPS, 1000, () -> {
+                try {
+                    return formatTPS(((double[]) recentTps.get(server))[0]);
+                } catch (IllegalAccessException e) {
+                    return -1;
+                }
+            });
+        } else {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.TPS, -1, () -> -1);
+        }
+        if (paperMspt != null) {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.MSPT, 1000, () -> numberFormat.format(Bukkit.getAverageTickTime()));
+        }
+        Plugin essentials = Bukkit.getPluginManager().getPlugin(TabConstants.Plugin.ESSENTIALS);
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.AFK, 500, p -> {
+            if (essentials != null) {
+                try {
+                    Object user = essentials.getClass().getMethod("getUser", UUID.class).invoke(essentials, p.getUniqueId());
+                    if ((boolean) user.getClass().getMethod("isAfk").invoke(user)) return true;
+                } catch (ReflectiveOperationException e) {
+                    TAB.getInstance().getErrorManager().printError("Failed to get AFK status of " + p.getName() + " using Essentials", e);
+                }
+            }
+            return purpurIsAfk != null && ((Player)p.getPlayer()).isAfk();
+        });
+        // Removed placeholder, keeping the implementation to avoid placeholder breaking for users on update
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.ESSENTIALS_NICK, -1, TabPlayer::getName);

-	/**
-	 * Registers AFK placeholder
-	 */
-	private void registerAFKPlaceholder() {
-		Plugin afkplus = Bukkit.getPluginManager().getPlugin("AFKPlus");
-		boolean antiafkplus = Bukkit.getPluginManager().isPluginEnabled("AntiAFKPlus");
-		try {
-			purpurIsAfk = Player.class.getMethod("isAfk");
-		} catch (NoSuchMethodException | SecurityException e1) {
-			//not purpur
-		}
-		String noAfk = TAB.getInstance().getConfiguration().getConfig().getString("placeholders.afk-no", "");
-		String yesAfk = TAB.getInstance().getConfiguration().getConfig().getString("placeholders.afk-yes", " &4*&4&lAFK&4*&r");
-		placeholders.add(new PlayerPlaceholder("%afk%", 500) {
-			public String get(TabPlayer p) {
-				try {
-					if (essentials != null) {
-						Object user = essGetUser.invoke(Bukkit.getPluginManager().getPlugin("Essentials"), p.getPlayer());
-						if ((boolean) essIsAfk.invoke(user)) return yesAfk;
-					}
-					if (afkplus != null) {
-						Object afkplusplayer = afkplus.getClass().getMethod("getPlayer", UUID.class).invoke(afkplus, p.getUniqueId());
-						if ((boolean) afkplusplayer.getClass().getMethod("isAFK").invoke(afkplusplayer)) return yesAfk;
-					}
-					if (antiafkplus) {
-						Object api = Class.forName("de.kinglol12345.AntiAFKPlus.api.AntiAFKPlusAPI").getDeclaredMethod("getAPI").invoke(null);
-						if ((boolean) api.getClass().getMethod("isAFK", Player.class).invoke(api, p.getPlayer())) return yesAfk;
-					}
-				} catch (Exception e) {
-					return TAB.getInstance().getErrorManager().printError("", "Failed to check AFK status of " + p.getName(), e);
-				}
-				try {
-					if (purpurIsAfk != null && (boolean) purpurIsAfk.invoke(p.getPlayer())) return yesAfk;
-				} catch (Exception e) {
-					//not purpur
-				}
-				return noAfk;
-			}
-			@Override
-			public String[] getNestedStrings(){
-				return new String[] {yesAfk, noAfk};
-			}
-		});
-	}
+        if (chat != null) {
+            manager.registerPlayerPlaceholder(TabConstants.Placeholder.VAULT_PREFIX, 1000, p -> chat.getPlayerPrefix((Player) p.getPlayer()));
+            manager.registerPlayerPlaceholder(TabConstants.Placeholder.VAULT_SUFFIX, 1000, p -> chat.getPlayerSuffix((Player) p.getPlayer()));
+        } else {
+            manager.registerServerPlaceholder(TabConstants.Placeholder.VAULT_PREFIX, -1, () -> "");
+            manager.registerServerPlaceholder(TabConstants.Placeholder.VAULT_SUFFIX, -1, () -> "");
+        }
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.HEALTH, 100, p -> (int) Math.ceil(((Player) p.getPlayer()).getHealth()));
+        super.registerPlaceholders(manager);
+    }

-	/**
-	 * Registers vault placeholders
-	 */
-	private void registerVaultPlaceholders() {
-		if (Bukkit.getPluginManager().isPluginEnabled("Vault") && chat != null) {
-			placeholders.add(new PlayerPlaceholder("%vault-prefix%", 500) {
-
-				public String get(TabPlayer p) {
-					return chat.getPlayerPrefix((Player) p.getPlayer());
-				}
-			});
-			placeholders.add(new PlayerPlaceholder("%vault-suffix%", 500) {
-
-				public String get(TabPlayer p) {
-					return chat.getPlayerSuffix((Player) p.getPlayer());
-				}
-			});
-		} else {
-			placeholders.add(new ServerPlaceholder("%vault-prefix%", 1000000) {
-				public String get() {
-					return "";
-				}
-			});
-			placeholders.add(new ServerPlaceholder("%vault-suffix%", 1000000) {
-				public String get() {
-					return "";
-				}
-			});
-		}
-	}
-
-	/**
-	 * Registers position placeholders
-	 */
-	private void registerPositionPlaceholders() {
-		placeholders.add(new PlayerPlaceholder("%xPos%", 100) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getLocation().getBlockX());
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%yPos%", 100) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getLocation().getBlockY());
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%zPos%", 100) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getLocation().getBlockZ());
-			}
-		});
-	}
-
-	/**
-	 * Registers essentials placeholders
-	 */
-	private void registerEssentialsPlaceholders() {
-		if (essentials != null) {
-			placeholders.add(new PlayerPlaceholder("%essentialsnick%", 1000) {
-				public String get(TabPlayer p) {
-					if (essGetNickname == null) return "<Internal plugin error>";
-					String name = null;
-					try {
-						name = (String) essGetNickname.invoke(essGetUser.invoke(essentials, p.getPlayer()));
-					} catch (Exception e) {
-						TAB.getInstance().getErrorManager().printError("Failed to get Essentials nickname of " + p.getName(), e);
-					}
-					if (name == null || name.length() == 0) return p.getName();
-					return TAB.getInstance().getConfiguration().getEssentialsNickPrefix() + name;
-				}
-			});
-		} else {
-			placeholders.add(new PlayerPlaceholder("%essentialsnick%", 100000000) {
-				public String get(TabPlayer p) {
-					return p.getName();
-				}
-			});
-		}
-	}
-
-	/**
-	 * Registers synchronous placeholders
-	 */
-	private void registerSyncPlaceholders() {
-		PlaceholderManager pl = TAB.getInstance().getPlaceholderManager();
-		for (String identifier : pl.getAllUsedPlaceholderIdentifiers()) {
-			if (identifier.startsWith("%sync:")) {
-				int refresh;
-				if (pl.getServerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					refresh = pl.getServerPlaceholderRefreshIntervals().get(identifier);
-				} else if (pl.getPlayerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					refresh = pl.getPlayerPlaceholderRefreshIntervals().get(identifier);
-				} else {
-					refresh = pl.getDefaultRefresh();
-				}
-				placeholders.add(new PlayerPlaceholder(identifier, refresh) {
-
-					@Override
-					public String get(TabPlayer p) {
-						Bukkit.getScheduler().runTask(plugin, () -> {
-
-							long time = System.nanoTime();
-							String syncedPlaceholder = identifier.substring(6, identifier.length()-1);
-							String value = ((BukkitPlatform) TAB.getInstance().getPlatform()).setPlaceholders((Player) p.getPlayer(), "%" + syncedPlaceholder + "%");
-							getLastValues().put(p.getName(), value);
-							if (!getForceUpdate().contains(p.getName())) getForceUpdate().add(p.getName());
-							TAB.getInstance().getCPUManager().addPlaceholderTime(getIdentifier(), System.nanoTime()-time);
-						});
-						return getLastValues().get(p.getName());
-					}
-				});
-			}
-		}
-	}
-}
+    /**
+     * Formats TPS using number formatter with 2 decimal places.
+     *
+     * @param   tps
+     *          TPS to format
+     * @return  Formatted TPS as a String
+     */
+    private String formatTPS(double tps) {
+        return numberFormat.format(Math.min(20, tps));
+    }
+}
@@ -1,312 +1,284 @@
 package me.neznamy.tab.platforms.bukkit;

-import java.io.File;
-import java.util.Collection;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.java.JavaPlugin;
-
+import com.viaversion.viaversion.api.Via;
+import lombok.Getter;
+import lombok.Setter;
 import me.clip.placeholderapi.PlaceholderAPI;
+import me.neznamy.tab.api.TabConstants;
+import me.neznamy.tab.api.TabFeature;
 import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.api.event.BukkitTABLoadEvent;
-import me.neznamy.tab.platforms.bukkit.features.WitherBossBar;
-import me.neznamy.tab.platforms.bukkit.features.PerWorldPlayerlist;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
+import me.neznamy.tab.api.util.ReflectionUtils;
+import me.neznamy.tab.platforms.bukkit.features.BukkitTabExpansion;
+import me.neznamy.tab.platforms.bukkit.features.PerWorldPlayerList;
 import me.neznamy.tab.platforms.bukkit.features.PetFix;
-import me.neznamy.tab.platforms.bukkit.features.TabExpansion;
-import me.neznamy.tab.platforms.bukkit.features.unlimitedtags.NameTagX;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import me.neznamy.tab.platforms.bukkit.features.WitherBossBar;
+import me.neznamy.tab.platforms.bukkit.features.unlimitedtags.BukkitNameTagX;
 import me.neznamy.tab.platforms.bukkit.permission.Vault;
-import me.neznamy.tab.shared.Platform;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.features.BelowName;
-import me.neznamy.tab.shared.features.NameTag;
-import me.neznamy.tab.shared.features.PingSpoof;
-import me.neznamy.tab.shared.features.PlaceholderManager;
-import me.neznamy.tab.shared.features.SpectatorFix;
-import me.neznamy.tab.shared.features.TabObjective;
-import me.neznamy.tab.shared.features.scoreboard.ScoreboardManager;
+import me.neznamy.tab.shared.backend.BackendPlatform;
+import me.neznamy.tab.shared.features.PipelineInjector;
+import me.neznamy.tab.shared.features.PlaceholderManagerImpl;
+import me.neznamy.tab.shared.features.TabExpansion;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
+import me.neznamy.tab.shared.features.nametags.NameTag;
 import me.neznamy.tab.shared.permission.LuckPerms;
 import me.neznamy.tab.shared.permission.None;
 import me.neznamy.tab.shared.permission.PermissionPlugin;
-import me.neznamy.tab.shared.permission.UltraPermissions;
-import me.neznamy.tab.shared.placeholders.Placeholder;
-import me.neznamy.tab.shared.placeholders.PlayerPlaceholder;
-import me.neznamy.tab.shared.placeholders.RelationalPlaceholder;
-import me.neznamy.tab.shared.placeholders.ServerPlaceholder;
-import me.neznamy.tab.shared.placeholders.UniversalPlaceholderRegistry;
+import me.neznamy.tab.shared.placeholders.PlayerPlaceholderImpl;
 import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;

 /**
- * Bukkit implementation of Platform
+ * Implementation of Platform interface for Bukkit platform
 */
-public class BukkitPlatform implements Platform {
-	
-	//plugin instance
-	private JavaPlugin plugin;
-	
-	//nms storage
-	private NMSStorage nms;
-	
-	//booleans to check plugin presence
-	private Plugin placeholderAPI;
-	private boolean viaversion;
-	private boolean idisguise;
-	private boolean libsdisguises;
-	private boolean essentials;
+public class BukkitPlatform extends BackendPlatform {

-	/**
-	 * Constructs new instance with given parameters
-	 * @param plugin - plugin instance
-	 * @param nms - nms storage
-	 */
-	public BukkitPlatform(JavaPlugin plugin, NMSStorage nms) {
-		this.plugin = plugin;
-		this.nms = nms;
-	}
+    /** Plugin instance for registering tasks and events */
+    private final JavaPlugin plugin;

-	@Override
-	public PermissionPlugin detectPermissionPlugin() {
-		if (Bukkit.getPluginManager().isPluginEnabled("LuckPerms")) {
-			return new LuckPerms(Bukkit.getPluginManager().getPlugin("LuckPerms").getDescription().getVersion());
-		} else if (Bukkit.getPluginManager().isPluginEnabled("UltraPermissions")) {
-			return new UltraPermissions(Bukkit.getPluginManager().getPlugin("UltraPermissions").getDescription().getVersion());
-		} else if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
-			return new Vault(Bukkit.getServicesManager().getRegistration(Permission.class).getProvider(), Bukkit.getPluginManager().getPlugin("Vault").getDescription().getVersion());
-		} else {
-			return new None();
-		}
-	}
+    /** Variables checking presence of other plugins to hook into */
+    private final boolean placeholderAPI = Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.PLACEHOLDER_API);
+    @Getter @Setter private boolean libsDisguisesEnabled = Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.LIBS_DISGUISES);
+    private Plugin viaVersion;
+    private final boolean protocolSupport = Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.PROTOCOL_SUPPORT);

-	@Override
-	public void loadFeatures() {
-		placeholderAPI = Bukkit.getPluginManager().getPlugin("PlaceholderAPI");
-		viaversion = Bukkit.getPluginManager().isPluginEnabled("ViaVersion");
-		idisguise = Bukkit.getPluginManager().isPluginEnabled("iDisguise");
-		libsdisguises = Bukkit.getPluginManager().isPluginEnabled("LibsDisguises");
-		essentials = Bukkit.getPluginManager().isPluginEnabled("Essentials");
-		TAB tab = TAB.getInstance();
-		tab.getPlaceholderManager().addRegistry(new BukkitPlaceholderRegistry(plugin));
-		tab.getPlaceholderManager().addRegistry(new UniversalPlaceholderRegistry());
-		tab.getPlaceholderManager().registerPlaceholders();
-		if (nms.getMinorVersion() >= 8 && tab.getConfiguration().isPipelineInjection()) {
-			tab.getFeatureManager().registerFeature("injection", new BukkitPipelineInjector(tab, nms));
-		}
-		loadNametagFeature(tab);
-		loadUniversalFeatures();
-		if (tab.getConfiguration().getConfig().getBoolean("ping-spoof.enabled", false)) tab.getFeatureManager().registerFeature("pingspoof", new PingSpoof());
-		if (tab.getConfiguration().getConfig().getString("yellow-number-in-tablist", "%ping%").length() > 0) tab.getFeatureManager().registerFeature("tabobjective", new TabObjective(tab));
-		if (tab.getConfiguration().getConfig().getBoolean("do-not-move-spectators", false)) tab.getFeatureManager().registerFeature("spectatorfix", new SpectatorFix());
-		if (tab.getConfiguration().getConfig().getBoolean("classic-vanilla-belowname.enabled", true)) tab.getFeatureManager().registerFeature("belowname", new BelowName(tab));
-		if (tab.getConfiguration().getPremiumConfig() != null && tab.getConfiguration().getPremiumConfig().getBoolean("scoreboard.enabled", false)) tab.getFeatureManager().registerFeature("scoreboard", new ScoreboardManager(tab));
-		if (tab.getConfiguration().getBossbarConfig().getBoolean("bossbar-enabled", false) && nms.getMinorVersion() < 9) tab.getFeatureManager().registerFeature("bossbar1.8", new WitherBossBar(tab, plugin));
-		if (nms.getMinorVersion() >= 9 && tab.getConfiguration().getConfig().getBoolean("fix-pet-names", false)) tab.getFeatureManager().registerFeature("petfix", new PetFix(nms));
-		if (tab.getConfiguration().getConfig().getBoolean("per-world-playerlist.enabled", false)) tab.getFeatureManager().registerFeature("pwp", new PerWorldPlayerlist(plugin, tab));
-		if (placeholderAPI != null) {
-			new TabExpansion(plugin);
-		}
-		for (Player p : getOnlinePlayers()) {
-			tab.addPlayer(new BukkitTabPlayer(p, Main.getProtocolVersion(p)));
-		}
-	}
-	
-	/**
-	 * Loads nametag feature from config
-	 * @param tab - tab instance
-	 */
-	private void loadNametagFeature(TAB tab) {
-		if (tab.getConfiguration().getConfig().getBoolean("change-nametag-prefix-suffix", true)) {
-			if (tab.getConfiguration().getConfig().getBoolean("unlimited-nametag-prefix-suffix-mode.enabled", false) && nms.getMinorVersion() >= 8) {
-				tab.getFeatureManager().registerFeature("nametagx", new NameTagX(plugin, nms, tab));
-			} else {
-				tab.getFeatureManager().registerFeature("nametag16", new NameTag(tab));
-			}
-		}
-	}
+    /**
+     * Constructs new instance with given plugin parameter
+     *
+     * @param   plugin
+     *          plugin instance
+     */
+    public BukkitPlatform(JavaPlugin plugin) {
+        super(new BukkitPacketBuilder());
+        this.plugin = plugin;
+        if (Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.VIAVERSION)) {
+            if (ReflectionUtils.classExists("com.viaversion.viaversion.api.Via")) {
+                viaVersion = Bukkit.getPluginManager().getPlugin(TabConstants.Plugin.VIAVERSION);
+            } else {
+                TAB.getInstance().sendConsoleMessage("&cAn outdated version of ViaVersion (" + getPluginVersion(TabConstants.Plugin.VIAVERSION) + ") was detected.", true);
+                TAB.getInstance().sendConsoleMessage("&cTAB only supports ViaVersion 4.0.0 and above. Disabling ViaVersion hook.", true);
+                TAB.getInstance().sendConsoleMessage("&cThis might cause problems, such as limitations still being present for latest MC clients as well as RGB not working.", true);
+            }
+        }
+    }

-	/**
-	 * Returns list of online players from Bukkit API
-	 * @return list of online players from Bukkit API
-	 */
-	@SuppressWarnings("unchecked")
-	private Player[] getOnlinePlayers() {
-		try {
-			Object players = Bukkit.class.getMethod("getOnlinePlayers").invoke(null);
-			if (players instanceof Player[]) {
-				//1.7.x
-				return (Player[]) players;
-			} else {
-				//1.8+
-				return ((Collection<Player>)players).toArray(new Player[0]); 
-			}
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get online players", e);
-			return new Player[0];
-		}
-	}
+    @Override
+    public PermissionPlugin detectPermissionPlugin() {
+        if (Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.LUCKPERMS)) {
+            return new LuckPerms(getPluginVersion(TabConstants.Plugin.LUCKPERMS));
+        } else if (Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.VAULT)) {
+            RegisteredServiceProvider<Permission> provider = Bukkit.getServicesManager().getRegistration(Permission.class);
+            if (provider == null) return new None();
+            return new Vault(provider.getProvider(), getPluginVersion(TabConstants.Plugin.VAULT));
+        } else {
+            return new None();
+        }
+    }

-	@Override
-	public void sendConsoleMessage(String message, boolean translateColors) {
-		Bukkit.getConsoleSender().sendMessage(translateColors ? message.replace('&', '\u00a7') : message);
-	}
+    public BossBarManagerImpl getLegacyBossBar() {
+        return new WitherBossBar(plugin);
+    }

-	@Override
-	public void registerUnknownPlaceholder(String identifier) {
-		if (identifier.contains("_")) {
-			PlaceholderManager pl = TAB.getInstance().getPlaceholderManager();
-			if (identifier.startsWith("%rel_")) {
-				//relational placeholder
-				registerRelationalPlaceholder(identifier, pl.getRelationalRefresh(identifier));
-			} else {
-				//normal placeholder
-				String expansion = identifier.split("_")[0].substring(1).toLowerCase();
-				if (expansion.equals("some")) return;
-				if (pl.getServerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					registerServerPlaceholder(identifier, pl.getServerPlaceholderRefreshIntervals().get(identifier));
-					return;
-				}
-				if (pl.getPlayerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					registerPlayerPlaceholder(identifier, pl.getPlayerPlaceholderRefreshIntervals().get(identifier));
-					return;
-				}
-				registerPlayerPlaceholder(identifier, pl.getDefaultRefresh());
-			}
-		}
-	}
-	
-	/**
-	 * Registers server placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerServerPlaceholder(String identifier, int refresh) {
-		BukkitPlatform pl = this;
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new ServerPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)){
-			
-			@Override
-			public String get() {
-				return pl.setPlaceholders(null, identifier);
-			}
-		});
-	}
-	
-	/**
-	 * Registers player placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerPlayerPlaceholder(String identifier, int refresh) {
-		BukkitPlatform pl = this;
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new PlayerPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)) {
+    @Override
+    public String getPluginVersion(String plugin) {
+        Plugin pl = Bukkit.getPluginManager().getPlugin(plugin);
+        return pl == null ? null : pl.getDescription().getVersion();
+    }

-			@Override
-			public String get(TabPlayer p) {
-				return pl.setPlaceholders((Player) p.getPlayer(), identifier);
-			}
-		});
-	}
-	
-	/**
-	 * Registers relational placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerRelationalPlaceholder(String identifier, int refresh) {
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new RelationalPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)) {
+    @Override
+    public void loadPlayers() {
+        for (Player p : getOnlinePlayers()) {
+            TAB.getInstance().addPlayer(new BukkitTabPlayer(p, getProtocolVersion(p)));
+        }
+    }

-			@Override
-			public String get(TabPlayer viewer, TabPlayer target) {
-				if (placeholderAPI == null) return identifier;
-				try {
-					return PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier);
-				} catch (Exception t) {
-					TAB.getInstance().getErrorManager().printError("PlaceholderAPI v" + placeholderAPI.getDescription().getVersion() + " generated an error when setting relational placeholder " + identifier + " for viewer " + viewer.getName() + " and target " + target.getName(), t, false, TAB.getInstance().getErrorManager().getPapiErrorLog());
-				}
-				return identifier;
-			}
-		});
-	}
-	
-	/**
-	 * Runs PlaceholderAPI call and returns the output. If the task fails, error is logged and "ERROR" returned instead
-	 * @param player - player to set placeholder for
-	 * @param placeholder - placeholder
-	 * @return result from PlaceholderAPI
-	 */
-	public String setPlaceholders(Player player, String placeholder) {
-		if (placeholderAPI == null) return placeholder;
-		try {
-			return PlaceholderAPI.setPlaceholders(player, placeholder);
-		} catch (Exception t) {
-			String playername = (player == null ? "<null>" : player.getName());
-			TAB.getInstance().getErrorManager().printError("PlaceholderAPI v" + placeholderAPI.getDescription().getVersion() + " generated an error when setting placeholder " + placeholder + " for player " + playername, t, false, TAB.getInstance().getErrorManager().getPapiErrorLog());
-			return "ERROR";
-		}
-	}
+    @Override
+    public void registerPlaceholders() {
+        new BukkitPlaceholderRegistry().registerPlaceholders(TAB.getInstance().getPlaceholderManager());
+    }

-	@Override
-	public String getServerVersion() {
-		return Bukkit.getBukkitVersion().split("-")[0] + " (" + Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3] + ")";
-	}
+    @Override
+    public @Nullable PipelineInjector getPipelineInjector() {
+        return new BukkitPipelineInjector();
+    }

-	@Override
-	public String getSeparatorType() {
-		return "world";
-	}
+    @Override
+    public NameTag getUnlimitedNametags() {
+        return new BukkitNameTagX(plugin);
+    }

-	@Override
-	public File getDataFolder() {
-		return plugin.getDataFolder();
-	}
-	
-	@Override
-	public String replaceAllPlaceholders(String string, TabPlayer sender) {
-		if (string == null) return null;
-		String replaced = string;
-		for (Placeholder p : TAB.getInstance().getPlaceholderManager().getAllPlaceholders()) {
-			if (replaced.contains(p.getIdentifier())) {
-				if (p instanceof ServerPlaceholder) {
-					((ServerPlaceholder)p).update();
-				}
-				if (p instanceof PlayerPlaceholder) {
-					((PlayerPlaceholder)p).update(sender);
-				}
-				replaced = p.set(replaced, sender);
-			}
-		}
-		replaced = setPlaceholders(sender == null ? null : (Player) sender.getPlayer(), replaced);
-		return replaced;
-	}
+    @Override
+    public TabExpansion getTabExpansion() {
+        if (placeholderAPI) {
+            BukkitTabExpansion expansion = new BukkitTabExpansion();
+            expansion.register();
+            return expansion;
+        }
+        return null;
+    }

-	@Override
-	public void callLoadEvent() {
-		Bukkit.getPluginManager().callEvent(new BukkitTABLoadEvent());
-	}
+    @Override
+    public TabFeature getPetFix() {
+        return new PetFix();
+    }

-	@Override
-	public int getMaxPlayers() {
-		return Bukkit.getMaxPlayers();
-	}
+    @Override
+    public @Nullable TabFeature getPerWorldPlayerlist() {
+        return new PerWorldPlayerList(plugin);
+    }

-	@Override
-	public String getConfigName() {
-		return "bukkitconfig.yml";
-	}
+    /**
+     * Returns online players from Bukkit API
+     *
+     * @return  online players from Bukkit API
+     */
+    @SuppressWarnings("unchecked")
+    private Player[] getOnlinePlayers() {
+        try {
+            Object players = Bukkit.class.getMethod("getOnlinePlayers").invoke(null);
+            if (players instanceof Player[]) {
+                //1.7-
+                return (Player[]) players;
+            } else {
+                //1.8+
+                return ((Collection<Player>)players).toArray(new Player[0]); 
+            }
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().printError("Failed to get online players", e);
+            return new Player[0];
+        }
+    }

-	public boolean isViaversionEnabled() {
-		return viaversion;
-	}
+    @Override
+    public void registerUnknownPlaceholder(String identifier) {
+        PlaceholderManagerImpl pl = TAB.getInstance().getPlaceholderManager();
+        if (identifier.startsWith("%rel_")) {
+            //relational placeholder
+            TAB.getInstance().getPlaceholderManager().registerRelationalPlaceholder(identifier, pl.getRelationalRefresh(identifier), (viewer, target) -> 
+                placeholderAPI ? PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier) : identifier);
+        } else {
+            //normal placeholder
+            if (identifier.startsWith("%sync:")) {
+                int refresh = pl.getServerPlaceholderRefreshIntervals().getOrDefault(identifier,
+                        pl.getPlayerPlaceholderRefreshIntervals().getOrDefault(identifier, pl.getDefaultRefresh()));
+                String syncedPlaceholder = "%" + identifier.substring(6, identifier.length()-1) + "%";
+                pl.registerPlaceholder(new PlayerPlaceholderImpl(identifier, refresh, null) {
+                    
+                    @Override
+                    public Object request(TabPlayer p) {
+                        Bukkit.getScheduler().runTask(plugin, () -> {
+                            long time = System.nanoTime();
+                            updateValue(p, placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), syncedPlaceholder) : identifier);
+                            TAB.getInstance().getCPUManager().addPlaceholderTime(getIdentifier(), System.nanoTime()-time);
+                        });
+                        return null;
+                    }
+                });
+                return;
+            }
+            if (pl.getServerPlaceholderRefreshIntervals().containsKey(identifier)) {
+                TAB.getInstance().getPlaceholderManager().registerServerPlaceholder(identifier, pl.getServerPlaceholderRefreshIntervals().get(identifier), () ->
+                        placeholderAPI ? PlaceholderAPI.setPlaceholders(null, identifier) : identifier);
+            } else {
+                int refresh = pl.getPlayerPlaceholderRefreshIntervals().getOrDefault(identifier, pl.getDefaultRefresh());
+                TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p -> 
+                    placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), identifier) : identifier);
+            }
+        }
+    }

-	public boolean isLibsdisguisesEnabled() {
-		return libsdisguises;
-	}
+    /**
+     * Gets protocol version of requested player and returns it.
+     *
+     * @param   player
+     *          Player to get protocol version of
+     * @return  protocol version of the player
+     */
+    public int getProtocolVersion(Player player) {
+        if (protocolSupport){
+            int version = getProtocolVersionPS(player);
+            //some PS versions return -1 on unsupported server versions instead of throwing exception
+            if (version != -1 && version < TAB.getInstance().getServerVersion().getNetworkId()) return version;
+        }
+        if (viaVersion != null) {
+            return getProtocolVersionVia(player, 0);
+        }
+        return TAB.getInstance().getServerVersion().getNetworkId();
+    }

-	public boolean isIdisguiseEnabled() {
-		return idisguise;
-	}
+    /**
+     * Returns protocol version of requested player using ProtocolSupport
+     *
+     * @param   player
+     *          Player to get protocol version of
+     * @return  protocol version of the player using ProtocolSupport
+     */
+    private int getProtocolVersionPS(Player player){
+        try {
+            Object protocolVersion = Class.forName("protocolsupport.api.ProtocolSupportAPI").getMethod("getProtocolVersion", Player.class).invoke(null, player);
+            int version = (int) protocolVersion.getClass().getMethod("getId").invoke(protocolVersion);
+            TAB.getInstance().debug("ProtocolSupport returned protocol version " + version + " for " + player.getName() + " (online=" + player.isOnline() + ")");
+            return version;
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().printError(String.format("Failed to get protocol version of %s using ProtocolSupport", player.getName()), e);
+            return TAB.getInstance().getServerVersion().getNetworkId();
+        }
+    }

-	public boolean isEssentialsEnabled() {
-		return essentials;
-	}
+    /**
+     * Returns protocol version of requested player using ViaVersion
+     *
+     * @param   player
+     *          Player to get protocol version of
+     * @return  protocol version of the player using ViaVersion
+     */
+    private int getProtocolVersionVia(Player player, int retryLevel){
+        try {
+            if (retryLevel == 10) {
+                TAB.getInstance().debug("Failed to get protocol version of " + player.getName() + " after 10 retries");
+                return TAB.getInstance().getServerVersion().getNetworkId();
+            }
+            int version = Via.getAPI().getPlayerVersion(player.getUniqueId());
+            if (version == -1) {
+                if (!player.isOnline()) return TAB.getInstance().getServerVersion().getNetworkId();
+                Thread.sleep(5);
+                return getProtocolVersionVia(player, retryLevel + 1);
+            }
+            TAB.getInstance().debug("ViaVersion returned protocol version " + version + " for " + player.getName() + " (online=" + player.isOnline() + ")");
+            return version;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return -1;
+        } catch (Exception | LinkageError e) {
+            TAB.getInstance().getErrorManager().printError(String.format("Failed to get protocol version of %s using ViaVersion v%s", player.getName(), viaVersion.getDescription().getVersion()), e);
+            return TAB.getInstance().getServerVersion().getNetworkId();
+        }
+    }
+
+    /**
+     * Sends console message using ConsoleCommandSender, due to
+     * Paper not translating colors correctly in Logger messages
+     * and to allow RGB (at least on Paper, doesn't work on spigot)
+     *
+     * @param   message
+     *          Message to send
+     * @param   translateColors
+     *          Whether color codes should be translated or not
+     */
+    @Override
+    public void sendConsoleMessage(String message, boolean translateColors) {
+        Bukkit.getConsoleSender().sendMessage("[TAB] " + (translateColors ?
+                EnumChatFormat.color(RGBUtils.getInstance().convertToBukkitFormat(message,
+                        TAB.getInstance().getServerVersion().getMinorVersion() >= 16))
+                : message));
+    }
 }
@@ -1,12 +1,20 @@
 package me.neznamy.tab.platforms.bukkit;

-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.legacy.bossbar.BossColor;
+import com.viaversion.viaversion.api.legacy.bossbar.BossFlag;
+import com.viaversion.viaversion.api.legacy.bossbar.BossStyle;
+import io.netty.channel.Channel;
+import lombok.NonNull;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
+import me.neznamy.tab.api.protocol.PacketPlayOutBoss;
+import me.neznamy.tab.api.protocol.PacketPlayOutChat;
+import me.neznamy.tab.api.protocol.Skin;
+import me.neznamy.tab.platforms.bukkit.nms.storage.NMSStorage;
+import me.neznamy.tab.shared.ITabPlayer;
+import me.neznamy.tab.shared.TAB;
 import org.bukkit.Bukkit;
 import org.bukkit.boss.BarColor;
 import org.bukkit.boss.BarFlag;
@@ -17,203 +25,274 @@ import org.bukkit.entity.Player;
 import org.bukkit.metadata.MetadataValue;
 import org.bukkit.potion.PotionEffectType;

-import com.viaversion.viaversion.api.Via;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.Channel;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.ITabPlayer;
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.packets.PacketPlayOutBoss;
-import me.neznamy.tab.shared.rgb.RGBUtils;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;

 /**
- * TabPlayer for Bukkit
+ * TabPlayer implementation for Bukkit platform
 */
 public class BukkitTabPlayer extends ITabPlayer {

-	//bukkit player
-	private Player player;
+    /** Player's NMS handle (EntityPlayer), preloading for speed */
+    private Object handle;

-	//nms handle
-	private Object handle;
+    /** Player's connection for sending packets, preloading for speed */
+    private Object playerConnection;
+    
+    /** Bukkit BossBars the player can currently see */
+    private final Map<UUID, BossBar> bossBars = new HashMap<>();

-	//nms player connection
-	private Object playerConnection;
-	
-	//player's visible boss bars
-	private Map<UUID, BossBar> bossbars = new HashMap<>();
+    /** ViaVersion BossBars this 1.9+ player can see on 1.8 server */
+    private final Map<UUID, com.viaversion.viaversion.api.legacy.bossbar.BossBar> viaBossBars = new HashMap<>();

-	/**
-	 * Constructs new instance with given parameter
-	 * @param p - bukkit player
-	 */
-	public BukkitTabPlayer(Player p, int protocolVersion){
-		player = p;
-		world = p.getWorld().getName();
-		try {
-			handle = NMSStorage.getInstance().getMethod("getHandle").invoke(player);
-			playerConnection = NMSStorage.getInstance().getField("PLAYER_CONNECTION").get(handle);
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get playerConnection of " + p.getName(), e);
-		}
-		try {
-			if (NMSStorage.getInstance().getField("CHANNEL") != null)
-				channel = (Channel) NMSStorage.getInstance().getField("CHANNEL").get(NMSStorage.getInstance().getField("NETWORK_MANAGER").get(playerConnection));
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get channel of " + p.getName(), e);
-		}
-		uniqueId = p.getUniqueId();
-		name = p.getName();
-		version = ProtocolVersion.fromNetworkId(protocolVersion);
-		init();
-	}
+    /**
+     * Constructs new instance with given bukkit player and protocol version
+     *
+     * @param   p
+     *          bukkit player
+     * @param   protocolVersion
+     *          Player's protocol network id
+     */
+    public BukkitTabPlayer(Player p, int protocolVersion){
+        super(p, p.getUniqueId(), p.getName(), TAB.getInstance().getConfiguration().getServerName(), p.getWorld().getName(), protocolVersion, true);
+        try {
+            handle = NMSStorage.getInstance().getHandle.invoke(player);
+            playerConnection = NMSStorage.getInstance().PLAYER_CONNECTION.get(handle);
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().printError("Failed to get playerConnection of " + p.getName(), e);
+        }
+    }

-	@Override
-	public boolean hasPermission(String permission) {
-		return player.hasPermission(permission);
-	}
+    @Override
+    public boolean hasPermission(@NonNull String permission) {
+        long time = System.nanoTime();
+        boolean value = getPlayer().hasPermission(permission);
+        TAB.getInstance().getCPUManager().addMethodTime("hasPermission", System.nanoTime()-time);
+        return value;
+    }

-	@Override
-	public long getPing() {
-		try {
-			int ping = NMSStorage.getInstance().getField("PING").getInt(handle);
-			if (ping > 10000 || ping < 0) ping = -1;
-			return ping;
-		} catch (Exception e) {
-			return -1;
-		}
-	}
+    @Override
+    public int getPing() {
+        try {
+            int ping = NMSStorage.getInstance().PING.getInt(handle);
+            if (ping > 10000 || ping < 0) ping = -1;
+            return ping;
+        } catch (IllegalAccessException e) {
+            return -1;
+        }
+    }

-	@Override
-	public void sendPacket(Object nmsPacket) {
-		if (nmsPacket == null || !player.isOnline()) return;
-		try {
-			if (((BukkitPlatform)TAB.getInstance().getPlatform()).isViaversionEnabled() && nmsPacket instanceof ByteBuf) {
-				Via.getAPI().sendRawPacket(uniqueId, (ByteBuf) nmsPacket);
-				return;
-			}
-			if (nmsPacket instanceof PacketPlayOutBoss) {
-				handle((PacketPlayOutBoss) nmsPacket);
-				return;
-			}
-			NMSStorage.getInstance().getMethod("sendPacket").invoke(playerConnection, nmsPacket);
-		} catch (IllegalArgumentException e) {
-			//java.lang.IllegalArgumentException: This player is not controlled by ViaVersion!
-			//this is only used to send 1.9 bossbar packets on 1.8 servers, no idea why it does this sometimes
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("An error occurred when sending " + nmsPacket.getClass().getSimpleName(), e);
-		}
-	}
-	
-	private void handle(PacketPlayOutBoss packet) {
-		Set<BarFlag> flags = new HashSet<>();
-		BossBar bar;
-		switch (packet.getOperation()) {
-		case ADD:
-			if (packet.isCreateWorldFog()) flags.add(BarFlag.CREATE_FOG);
-			if (packet.isDarkenScreen()) flags.add(BarFlag.DARKEN_SKY);
-			if (packet.isPlayMusic()) flags.add(BarFlag.PLAY_BOSS_MUSIC);
-			bar = Bukkit.createBossBar(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && NMSStorage.getInstance().getMinorVersion() >= 16), 
-					BarColor.valueOf(packet.getColor().name()), 
-					BarStyle.valueOf(packet.getOverlay().name().replace("PROGRESS", "SOLID").replace("NOTCHED", "SEGMENTED")),
-					flags.toArray(new BarFlag[0]));
-			bar.setProgress(packet.getPct());
-			bossbars.put(packet.getId(), bar);
-			bar.addPlayer(player);
-			break;
-		case REMOVE:
-			bossbars.get(packet.getId()).removePlayer(player);
-			bossbars.remove(packet.getId());
-			break;
-		case UPDATE_PCT:
-			bossbars.get(packet.getId()).setProgress(packet.getPct());
-			break;
-		case UPDATE_NAME:
-			bossbars.get(packet.getId()).setTitle(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && NMSStorage.getInstance().getMinorVersion() >= 16));
-			break;
-		case UPDATE_STYLE:
-			bossbars.get(packet.getId()).setColor(BarColor.valueOf(packet.getColor().name()));
-			bossbars.get(packet.getId()).setStyle(BarStyle.valueOf(packet.getOverlay().name().replace("PROGRESS", "SOLID").replace("NOTCHED", "SEGMENTED")));
-			break;
-		case UPDATE_PROPERTIES:
-			bar = bossbars.get(packet.getId());
-			processFlag(bar, packet.isCreateWorldFog(), BarFlag.CREATE_FOG);
-			processFlag(bar, packet.isDarkenScreen(), BarFlag.DARKEN_SKY);
-			processFlag(bar, packet.isPlayMusic(), BarFlag.PLAY_BOSS_MUSIC);
-			break;
-		default:
-			break;
-		}
-	}
-	
-	private void processFlag(BossBar bar, boolean targetValue, BarFlag flag) {
-		if (targetValue) {
-			if (!bar.hasFlag(flag)) {
-				bar.addFlag(flag);
-			}
-		} else {
-			if (bar.hasFlag(flag)) {
-				bar.removeFlag(flag);
-			}
-		}
-	}
+    @Override
+    public void sendPacket(Object nmsPacket) {
+        if (nmsPacket == null || !getPlayer().isOnline()) return;
+        long time = System.nanoTime();
+        try {
+            if (nmsPacket instanceof PacketPlayOutBoss) {
+                if (TAB.getInstance().getServerVersion().getMinorVersion() >= 9) {
+                    handle((PacketPlayOutBoss) nmsPacket);
+                } else {
+                    handleVia((PacketPlayOutBoss) nmsPacket);
+                }
+            } else if (nmsPacket instanceof PacketPlayOutChat) {
+                getPlayer().sendMessage(((PacketPlayOutChat) nmsPacket).getMessage().toLegacyText());
+            } else {
+                NMSStorage.getInstance().sendPacket.invoke(playerConnection, nmsPacket);
+            }
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().printError("An error occurred when sending " + nmsPacket.getClass().getSimpleName(), e);
+        }
+        TAB.getInstance().getCPUManager().addMethodTime("sendPacket", System.nanoTime()-time);
+    }

-	@Override
-	public boolean hasInvisibilityPotion() {
-		return player.hasPotionEffect(PotionEffectType.INVISIBILITY);
-	}
+    /**
+     * Handles PacketPlayOutBoss packet send request using Bukkit API,
+     * since the API offers everything we need and makes us not need to
+     * deal with NMS code at all.
+     *
+     * @param   packet
+     *          packet request to handle using Bukkit API
+     */
+    private void handle(PacketPlayOutBoss packet) {
+        BossBar bar = bossBars.get(packet.getId());
+        if (packet.getAction() == PacketPlayOutBoss.Action.ADD) {
+            if (bossBars.containsKey(packet.getId())) return;
+            bar = Bukkit.createBossBar(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16),
+                    BarColor.valueOf(packet.getColor().name()),
+                    BarStyle.valueOf(packet.getOverlay().getBukkitName()));
+            if (packet.isCreateWorldFog()) bar.addFlag(BarFlag.CREATE_FOG);
+            if (packet.isDarkenScreen()) bar.addFlag(BarFlag.DARKEN_SKY);
+            if (packet.isPlayMusic()) bar.addFlag(BarFlag.PLAY_BOSS_MUSIC);
+            bar.setProgress(packet.getPct());
+            bossBars.put(packet.getId(), bar);
+            bar.addPlayer(getPlayer());
+            return;
+        }
+        if (bar == null) return; //no idea how
+        switch (packet.getAction()) {
+        case REMOVE:
+            bar.removePlayer(getPlayer());
+            bossBars.remove(packet.getId());
+            break;
+        case UPDATE_PCT:
+            bar.setProgress(packet.getPct());
+            break;
+        case UPDATE_NAME:
+            bar.setTitle(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+            break;
+        case UPDATE_STYLE:
+            bar.setColor(BarColor.valueOf(packet.getColor().name()));
+            bar.setStyle(BarStyle.valueOf(packet.getOverlay().getBukkitName()));
+            break;
+        case UPDATE_PROPERTIES:
+            bar = bossBars.get(packet.getId());
+            processFlag(bar, packet.isCreateWorldFog(), BarFlag.CREATE_FOG);
+            processFlag(bar, packet.isDarkenScreen(), BarFlag.DARKEN_SKY);
+            processFlag(bar, packet.isPlayMusic(), BarFlag.PLAY_BOSS_MUSIC);
+            break;
+        default:
+            break;
+        }
+    }

-	@Override
-	public boolean isDisguised() {
-		try {
-			if (!((BukkitPlatform)TAB.getInstance().getPlatform()).isLibsdisguisesEnabled()) return false;
-			return (boolean) Class.forName("me.libraryaddict.disguise.DisguiseAPI").getMethod("isDisguised", Entity.class).invoke(null, player);
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(false, "Failed to check disguise status using LibsDisguises", e);
-		}
-	}
+    /**
+     * Handles PacketPlayOutBoss packet request for 1.9+ clients on
+     * 1.8 servers using ViaVersion API instead of using Wither.
+     *
+     * @param   packet
+     *          packet request to handle using ViaVersion API
+     */
+    private void handleVia(PacketPlayOutBoss packet) {
+        com.viaversion.viaversion.api.legacy.bossbar.BossBar bar;
+        switch (packet.getAction()) {
+        case ADD:
+            if (viaBossBars.containsKey(packet.getId())) return;
+            bar = Via.getAPI().legacyAPI().createLegacyBossBar(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16), 
+                    packet.getPct(),
+                    BossColor.valueOf(packet.getColor().name()), 
+                    BossStyle.valueOf(packet.getOverlay().getBukkitName()));
+            //fog missing from via API
+            if (packet.isDarkenScreen()) bar.addFlag(BossFlag.DARKEN_SKY);
+            if (packet.isPlayMusic()) bar.addFlag(BossFlag.PLAY_BOSS_MUSIC);
+            viaBossBars.put(packet.getId(), bar);
+            bar.addPlayer(getPlayer().getUniqueId());
+            break;
+        case REMOVE:
+            viaBossBars.get(packet.getId()).removePlayer(getPlayer().getUniqueId());
+            viaBossBars.remove(packet.getId());
+            break;
+        case UPDATE_PCT:
+            viaBossBars.get(packet.getId()).setHealth(packet.getPct());
+            break;
+        case UPDATE_NAME:
+            viaBossBars.get(packet.getId()).setTitle(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16));
+            break;
+        case UPDATE_STYLE:
+            viaBossBars.get(packet.getId()).setColor(BossColor.valueOf(packet.getColor().name()));
+            viaBossBars.get(packet.getId()).setStyle(BossStyle.valueOf(packet.getOverlay().getBukkitName()));
+            break;
+        case UPDATE_PROPERTIES:
+            bar = viaBossBars.get(packet.getId());
+            //fog missing from via API
+            processFlagVia(bar, packet.isDarkenScreen(), BossFlag.DARKEN_SKY);
+            processFlagVia(bar, packet.isPlayMusic(), BossFlag.PLAY_BOSS_MUSIC);
+            break;
+        default:
+            break;
+        }
+    }

-	@Override
-	public Object getSkin() {
-		try {
-			return Class.forName("com.mojang.authlib.GameProfile").getMethod("getProperties").invoke(NMSStorage.getInstance().getMethod("getProfile").invoke(handle));
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to get skin of " + getName(), e);
-		}
-	}
+    /**
+     * Sets BossBar flag to requested target value.
+     *
+     * @param   bar
+     *          BossBar to set flag of
+     * @param   targetValue
+     *          Target value of the flag
+     * @param   flag
+     *          Flag to set value of
+     */
+    private void processFlag(BossBar bar, boolean targetValue, BarFlag flag) {
+        if (targetValue && !bar.hasFlag(flag)) bar.addFlag(flag);
+        if (!targetValue && bar.hasFlag(flag)) bar.removeFlag(flag);
+    }

-	@Override
-	public Player getPlayer() {
-		return player;
-	}
+    /**
+     * Sets BossBar flag to requested target value.
+     *
+     * @param   bar
+     *          BossBar to set flag of
+     * @param   targetValue
+     *          Target value of the flag
+     * @param   flag
+     *          Flag to set value of
+     */
+    private void processFlagVia(com.viaversion.viaversion.api.legacy.bossbar.BossBar bar, boolean targetValue, BossFlag flag) {
+        if (targetValue && !bar.hasFlag(flag)) bar.addFlag(flag);
+        if (!targetValue && bar.hasFlag(flag)) bar.removeFlag(flag);
+    }

-	@Override
-	public boolean isOnline() {
-		return player.isOnline();
-	}
+    @Override
+    public boolean hasInvisibilityPotion() {
+        return getPlayer().hasPotionEffect(PotionEffectType.INVISIBILITY);
+    }

-	@Override
-	public boolean isVanished() {
-		try {
-			if (((BukkitPlatform)TAB.getInstance().getPlatform()).isEssentialsEnabled()) {
-				Object essentials = Bukkit.getPluginManager().getPlugin("Essentials");
-				Object user = essentials.getClass().getMethod("getUser", Player.class).invoke(essentials, player);
-				boolean vanished = (boolean) user.getClass().getMethod("isVanished").invoke(user);
-				if (vanished) return true;
-			}
-			List<MetadataValue> metadata = player.getMetadata("vanished");
-			return !metadata.isEmpty() && metadata.get(0).asBoolean();
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to check vanish status of " + player.getName(), e);
-		}
-		return false;
-	}
+    @Override
+    public boolean isDisguised() {
+        try {
+            if (!((BukkitPlatform)TAB.getInstance().getPlatform()).isLibsDisguisesEnabled()) return false;
+            return (boolean) Class.forName("me.libraryaddict.disguise.DisguiseAPI").getMethod("isDisguised", Entity.class).invoke(null, getPlayer());
+        } catch (LinkageError | ReflectiveOperationException e) {
+            //java.lang.NoClassDefFoundError: Could not initialize class me.libraryaddict.disguise.DisguiseAPI
+            TAB.getInstance().getErrorManager().printError("Failed to check disguise status using LibsDisguises", e);
+            ((BukkitPlatform)TAB.getInstance().getPlatform()).setLibsDisguisesEnabled(false);
+            return false;
+        }
+    }

-	@SuppressWarnings("deprecation")
-	@Override
-	public int getGamemode() {
-		return player.getGameMode().getValue();
-	}
-}
+    @Override
+    public Skin getSkin() {
+        try {
+            Collection<Property> col = ((GameProfile)NMSStorage.getInstance().getProfile.invoke(handle)).getProperties().get("textures");
+            if (col.isEmpty()) return null; //offline mode
+            Property property = col.iterator().next();
+            return new Skin(property.getValue(), property.getSignature());
+        } catch (ReflectiveOperationException e) {
+            TAB.getInstance().getErrorManager().printError("Failed to get skin of " + getName(), e);
+            return null;
+        }
+    }
+
+    @Override
+    public Player getPlayer() {
+        return (Player) player;
+    }
+
+    @Override
+    public boolean isOnline() {
+        return getPlayer().isOnline();
+    }
+
+    @Override
+    public boolean isVanished() {
+        return getPlayer().getMetadata("vanished").stream().anyMatch(MetadataValue::asBoolean);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public int getGamemode() {
+        return getPlayer().getGameMode().getValue();
+    }
+
+    @Override
+    public Channel getChannel() {
+        try {
+            if (NMSStorage.getInstance().CHANNEL != null)
+                return (Channel) NMSStorage.getInstance().CHANNEL.get(NMSStorage.getInstance().NETWORK_MANAGER.get(playerConnection));
+        } catch (IllegalAccessException e) {
+            TAB.getInstance().getErrorManager().printError("Failed to get channel of " + getName(), e);
+        }
+        return null;
+    }
+}
@@ -1,167 +1,143 @@
 package me.neznamy.tab.platforms.bukkit;

+import me.neznamy.tab.api.ProtocolVersion;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabConstants;
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.util.SupplierWithException;
+import me.neznamy.tab.platforms.bukkit.nms.storage.*;
+import me.neznamy.tab.shared.TAB;
+import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bukkit.Bukkit;
+import org.bukkit.command.*;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

-import org.bstats.bukkit.Metrics;
-import org.bstats.charts.SimplePie;
-import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabCompleter;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import com.viaversion.viaversion.api.Via;
-
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.TAB;
-
 /**
 * Main class for Bukkit platform
 */
 public class Main extends JavaPlugin {
-	
-	@Override
-	public void onEnable(){
-		Bukkit.getConsoleSender().sendMessage("\u00a77[TAB] Server version: " + Bukkit.getBukkitVersion().split("-")[0] + " (" + Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3] + ")");
-		if (!isVersionSupported()){
-			Bukkit.getPluginManager().disablePlugin(this);
-			return;
-		}
-		TAB.setInstance(new TAB(new BukkitPlatform(this, NMSStorage.getInstance()), new BukkitPacketBuilder(NMSStorage.getInstance()), ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0])));
-		if (TAB.getInstance().getServerVersion() == ProtocolVersion.UNKNOWN) {
-			Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Unknown server version: " + Bukkit.getBukkitVersion() + "! Plugin may not work correctly.");
-		}
-		Bukkit.getPluginManager().registerEvents(new BukkitEventListener(), this);
-		TABCommand command = new TABCommand();
-		Bukkit.getPluginCommand("tab").setExecutor(command);
-		Bukkit.getPluginCommand("tab").setTabCompleter(command);
-		TAB.getInstance().load();
-		Metrics metrics = new Metrics(this, 5304);
-		metrics.addCustomChart(new SimplePie("unlimited_nametag_mode_enabled", () -> TAB.getInstance().getFeatureManager().isFeatureEnabled("nametagx") ? "Yes" : "No"));
-		metrics.addCustomChart(new SimplePie("placeholderapi", () -> Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI") ? "Yes" : "No"));
-		metrics.addCustomChart(new SimplePie("permission_system", () -> TAB.getInstance().getPermissionPlugin().getName()));
-		metrics.addCustomChart(new SimplePie("server_version", () -> "1." + NMSStorage.getInstance().getMinorVersion() + ".x"));
-		metrics.addCustomChart(new SimplePie("using_premium_version", () -> TAB.getInstance().isPremium() ? "Yes" : "No"));
-	}

-	@Override
-	public void onDisable() {
-		//null check due to L23 return making L30 not run
-		if (TAB.getInstance() != null) TAB.getInstance().unload();
-	}
-	
-	/**
-	 * Initializes all used NMS classes, constructors, fields and methods and returns true if everything went successfully and version is marked as compatible
-	 * @return true if compatible, false if not
-	 */
-	private boolean isVersionSupported(){
-		List<String> supportedVersions = Arrays.asList(
-				"v1_5_R1", "v1_5_R2", "v1_5_R3", "v1_6_R1", "v1_6_R2", "v1_6_R3",
-				"v1_7_R1", "v1_7_R2", "v1_7_R3", "v1_7_R4", "v1_8_R1", "v1_8_R2", "v1_8_R3",
-				"v1_9_R1", "v1_9_R2", "v1_10_R1", "v1_11_R1", "v1_12_R1", "v1_13_R1", "v1_13_R2",
-				"v1_14_R1", "v1_15_R1", "v1_16_R1", "v1_16_R2", "v1_16_R3", "v1_17_R1");
-		String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-		try {
-			NMSStorage.setInstance(new NMSStorage());
-			if (supportedVersions.contains(serverPackage)) {
-				return true;
-			} else {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] No compatibility issue was found, but this plugin version does not claim to support your server version. This jar has only been tested on 1.5.x - 1.17. Disabling just to stay safe.");
-			}
-		} catch (Exception ex) {
-			if (supportedVersions.contains(serverPackage)) {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Your server version is marked as compatible, but a compatibility issue was found. Please report the error below (include your server version & fork too)");
-				Bukkit.getConsoleSender().sendMessage(ex.getClass().getName() + ": " + ex.getMessage());
-				for (StackTraceElement e : ex.getStackTrace()) {
-					Bukkit.getConsoleSender().sendMessage(e.toString());
-				}
-			} else {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Your server version is completely unsupported. This plugin version only supports 1.5.x - 1.17. Disabling.");
-			}
-		}
-		return false;
-	}
-	
-	/**
-	 * Gets protocol version and returns it
-	 * @return protocol version of this player
-	 */
-	public static int getProtocolVersion(Player player) {
-		if (Bukkit.getPluginManager().isPluginEnabled("ProtocolSupport")){
-			int version = getProtocolVersionPS(player);
-			//some PS versions return -1 on unsupported server versions instead of throwing exception
-			if (version != -1 && version < TAB.getInstance().getServerVersion().getNetworkId()) return version;
-		}
-		if (Bukkit.getPluginManager().isPluginEnabled("ViaVersion")) {
-			return getProtocolVersionVia(player);
-		}
-		return TAB.getInstance().getServerVersion().getNetworkId();
-	}
+    @Override
+    public void onEnable(){
+        String version = Bukkit.getBukkitVersion().split("-")[0];
+        String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+        Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("[TAB] Server version: " + version + " (" + serverPackage + ")"));
+        if (!isVersionSupported()){
+            Bukkit.getPluginManager().disablePlugin(this);
+            return;
+        }
+        BukkitPlatform platform = new BukkitPlatform(this);
+        TAB.setInstance(new TAB(platform, ProtocolVersion.fromFriendlyName(version), version + " (" + serverPackage + ")", getDataFolder(), getLogger()));
+        if (TAB.getInstance().getServerVersion() == ProtocolVersion.UNKNOWN_SERVER_VERSION) {
+            Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Unknown server version: " + Bukkit.getBukkitVersion() + "! Plugin may not work correctly."));
+        }
+        Bukkit.getPluginManager().registerEvents(new BukkitEventListener(platform), this);
+        TAB.getInstance().load();
+        Metrics metrics = new Metrics(this, 5304);
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.UNLIMITED_NAME_TAG_MODE_ENABLED, () -> TAB.getInstance().getFeatureManager().isFeatureEnabled(TabConstants.Feature.UNLIMITED_NAME_TAGS) ? "Yes" : "No"));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.PLACEHOLDER_API, () -> Bukkit.getPluginManager().isPluginEnabled(TabConstants.Plugin.PLACEHOLDER_API) ? "Yes" : "No"));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.PERMISSION_SYSTEM, () -> TAB.getInstance().getGroupManager().getPlugin().getName()));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.SERVER_VERSION, () -> "1." + TAB.getInstance().getServerVersion().getMinorVersion() + ".x"));
+        PluginCommand cmd = Bukkit.getPluginCommand("tab");
+        if (cmd == null) return;
+        TABCommand command = new TABCommand();
+        cmd.setExecutor(command);
+        cmd.setTabCompleter(command);
+    }

-	/**
-	 * Returns protocol version of this player using ProtocolSupport
-	 * @return protocol version of this player using ProtocolSupport
-	 */
-	private static int getProtocolVersionPS(Player player){
-		try {
-			Object protocolVersion = Class.forName("protocolsupport.api.ProtocolSupportAPI").getMethod("getProtocolVersion", Player.class).invoke(null, player);
-			int version = (int) protocolVersion.getClass().getMethod("getId").invoke(protocolVersion);
-			TAB.getInstance().debug("ProtocolSupport returned protocol version " + version + " for " + player.getName() + "(online=" + player.isOnline() + ")");
-			return version;
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get protocol version of " + player.getName() + " using ProtocolSupport", e);
-			return TAB.getInstance().getServerVersion().getNetworkId();
-		}
-	}
+    @Override
+    public void onDisable() {
+        //null check due to compatibility check making instance not get set on unsupported versions
+        if (TAB.getInstance() != null) TAB.getInstance().unload();
+    }
+    
+    /**
+     * Initializes all used NMS classes, constructors, fields and methods.
+     * Returns {@code true} if everything went successfully and version is marked as compatible,
+     * {@code false} if anything went wrong or version is not marked as compatible.
+     *
+     * @return  {@code true} if server version is compatible, {@code false} if not
+     */
+    private boolean isVersionSupported(){
+        List<String> supportedVersions = Arrays.asList(
+                "v1_5_R1", "v1_5_R2", "v1_5_R3", "v1_6_R1", "v1_6_R2", "v1_6_R3",
+                "v1_7_R1", "v1_7_R2", "v1_7_R3", "v1_7_R4", "v1_8_R1", "v1_8_R2", "v1_8_R3",
+                "v1_9_R1", "v1_9_R2", "v1_10_R1", "v1_11_R1", "v1_12_R1", "v1_13_R1", "v1_13_R2",
+                "v1_14_R1", "v1_15_R1", "v1_16_R1", "v1_16_R2", "v1_16_R3", "v1_17_R1", "v1_18_R1",
+                "v1_18_R2", "v1_19_R1", "v1_19_R2");
+        String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+        try {
+            long time = System.currentTimeMillis();
+            int minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
+            NMSStorage.setInstance(getNMSLoader());
+            if (supportedVersions.contains(serverPackage)) {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("[TAB] Loaded NMS hook in " + (System.currentTimeMillis()-time) + "ms"));
+                return true;
+            } else {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] No compatibility issue was found, but this plugin version does not claim to support your server package (" + serverPackage + "). This jar has only been tested on 1.5.2 - 1.19.3. Disabling just to stay safe."));
+            }
+        } catch (IllegalStateException ex) {
+            if (supportedVersions.contains(serverPackage)) {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Your server version is marked as compatible, but a compatibility issue was found. Please report this issue (include your server version & fork too)"));
+            } else {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Your server version is completely unsupported. This plugin version only supports 1.5.2 - 1.19.3. Disabling."));
+            }
+        }
+        return false;
+    }

-	/**
-	 * Returns protocol version of this player using ViaVersion
-	 * @return protocol version of this player using ViaVersion
-	 */
-	private static int getProtocolVersionVia(Player player){
-		try {
-			int version = Via.getAPI().getPlayerVersion(player.getUniqueId());
-			TAB.getInstance().debug("ViaVersion returned protocol version " + version + " for " + player.getName() + "(online=" + player.isOnline() + ")");
-			return version;
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get protocol version of " + player.getName() + " using ViaVersion v" + Bukkit.getPluginManager().getPlugin("ViaVersion").getDescription().getVersion(), e);
-			return TAB.getInstance().getServerVersion().getNetworkId();
-		}
-	}
-	
-	public class TABCommand implements CommandExecutor, TabCompleter {
+    private NMSStorage getNMSLoader() {
+        List<SupplierWithException<NMSStorage>> loaders = new ArrayList<>();
+        loaders.add(BukkitLegacyNMSStorage::new);
+        loaders.add(BukkitModernNMSStorage::new);
+        loaders.add(MojangModernNMSStorage::new);
+        loaders.add(ThermosNMSStorage::new);
+        for (SupplierWithException<NMSStorage> loader : loaders) {
+            try {
+                return loader.get();
+            } catch (Exception ignored){}
+        }
+        throw new IllegalStateException("Unsupported server version");
+    }

-		@Override
-		public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-			if (TAB.getInstance().isDisabled()) {
-				for (String message : TAB.getInstance().getDisabledCommand().execute(args, sender.hasPermission("tab.reload"), sender.hasPermission("tab.admin"))) {
-					sender.sendMessage(message.replace('&', '\u00a7'));
-				}
-			} else {
-				TabPlayer p = null;
-				if (sender instanceof Player) {
-					p = TAB.getInstance().getPlayer(((Player)sender).getUniqueId());
-					if (p == null) return true; //player not loaded correctly
-				}
-				TAB.getInstance().getCommand().execute(p, args);
-			}
-			return false;
-		}
+    /**
+     * Command handler for /tab command
+     */
+    private static class TABCommand implements CommandExecutor, TabCompleter {

-		@Override
-		public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
-			TabPlayer p = null;
-			if (sender instanceof Player) {
-				p = TAB.getInstance().getPlayer(((Player)sender).getUniqueId());
-				if (p == null) return new ArrayList<>(); //player not loaded correctly
-			}
-			return TAB.getInstance().getCommand().complete(p, args);
-		}
-	}
+        @Override
+        public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+            if (TabAPI.getInstance().isPluginDisabled()) {
+                for (String message : TAB.getInstance().getDisabledCommand().execute(args, sender.hasPermission(TabConstants.Permission.COMMAND_RELOAD), sender.hasPermission(TabConstants.Permission.COMMAND_ALL))) {
+                    sender.sendMessage(EnumChatFormat.color(message));
+                }
+            } else {
+                TabPlayer p = null;
+                if (sender instanceof Player) {
+                    p = TAB.getInstance().getPlayer(((Player)sender).getUniqueId());
+                    if (p == null) return true; //player not loaded correctly
+                }
+                TAB.getInstance().getCommand().execute(p, args);
+            }
+            return false;
+        }
+
+        @Override
+        public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, String[] args) {
+            TabPlayer p = null;
+            if (sender instanceof Player) {
+                p = TAB.getInstance().getPlayer(((Player)sender).getUniqueId());
+                if (p == null) return new ArrayList<>(); //player not loaded correctly
+            }
+            return TAB.getInstance().getCommand().complete(p, args);
+        }
+    }
 }