Define decimal separator in one more way to make sure it works properly (#967 )

Send warn if using debug command on player who is not loaded (#959 )
Send warn if both per world playerlist and layout are enabled
2026-11-13 12:42:06 -05:00 · 2023-07-07 15:25:11 +02:00 · 2023-07-06 20:55:16 +02:00 · 2023-07-06 15:12:28 +02:00 · 2023-07-06 12:37:24 +02:00 · 2023-07-06 12:33:47 +02:00
525 changed files with 95266 additions and 90810 deletions
@@ -0,0 +1,7 @@
+* text=auto
+
+*.sh text eol=lf
+gradlew text eol=lf
+*.bat text eol=crlf
+
+*.jar binary
@@ -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,56 @@
+name: Memory leak
+description: Memory leak caused by TAB.
+labels: ["Type: Memory leak"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Heap dump
+      description: Link to uploaded memory dump which I can look into.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Uncleared object(s)
+      description: Objects you believe should have been removed from the memory but are not
+      placeholder: |
+        There is only 1 player online, but heap dump has 100 instances of TabPlayer
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included download link of my heap dump
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
+        - label: I have explained what I believe is wrong with the heap dump
+          required: true
@@ -0,0 +1,55 @@
+name: Performance issue
+description: Performance issue in TAB or in server caused by TAB
+labels: ["Type: Performance"]
+body:
+  - type: input
+    attributes:
+      label: Server version
+      description: Version and type of used server software where TAB is installed.
+      placeholder: Spigot 1.18.1
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: TAB version
+      description: Full version in numbers, "latest" is not a version.
+      placeholder: 3.0.2
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Evidence
+      description: Any evidence proving the performance issue, such as output of /tab cpu or timings.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce (if known)
+      description: What to do in order to reproduce this issue
+      placeholder: |
+        Step 1: ..
+        Step 2: ..
+    validations:
+      required: false
+
+  - type: textarea
+    attributes:
+      label: Additional info
+      description: Any other info you want to provide.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Let's make sure this report is valid
+      options:
+        - label: I am running latest version of the plugin
+          required: true
+        - label: I have included sufficient evidence of the issue
+          required: true
+        - label: I ticked all of the boxes without actually reading them
+          required: false
@@ -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
@@ -0,0 +1,45 @@
+name: Build
+on:
+  push:
+    branches:
+      - master
+      - v4
+  pull_request:
+    types: [opened, synchronize, reopened]
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3.3.0 #https://github.com/actions/checkout/releases
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3.9.0 #https://github.com/actions/setup-java/releases
+        with:
+          distribution: 'temurin'
+          java-version: 17
+      - name: Cache SonarCloud packages
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
+        with:
+          path: ~/.sonar/cache
+          key: ${{ runner.os }}-sonar
+          restore-keys: ${{ runner.os }}-sonar
+      - name: Cache Gradle
+        uses: actions/cache@v3.2.3 #https://github.com/actions/cache/releases
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: "${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}"
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Build and analyze
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
+        run: ./gradlew clean build
+      - name: Upload a Build Artifact
+        uses: actions/upload-artifact@v3.1.2 #https://github.com/actions/upload-artifact/releases
+        with:
+          name: Jar
+          path: jar/build/libs/TAB-**.jar
@@ -33,5 +33,10 @@ hs_err_pid*
 .idea/

 # other
-.gitattributes
 *.iml
+run/
+
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar
@@ -0,0 +1,9 @@
+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.
@@ -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,47 +1,23 @@
-## 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.  
-If you have a great argument why was making this open-source worth not only for those looking for premium features for free, please take your time and explain it to: Lionel#5648 (more names coming soon).  
-  
-  
-## 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#L78) 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 places.
-  
-  
-## 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  
-  
-  
-## Downloads
-Official release: https://www.spigotmc.org/resources/57806/  
-Pre-releases: https://github.com/NEZNAMY/TAB/releases  
-  
-  
-## Maven Repository
-```
-<repositories>
-  <repository>
-    <id>jitpack.io</id>
-    <url>https://jitpack.io</url>
-  </repository>
-</repositories>
+# 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 and compatibility.  
+More information can be found at [Why TAB?](https://github.com/NEZNAMY/TAB/wiki/Why-TAB%3F) wiki page.

-<dependencies>
-  <!-- TAB -->
-  <dependency>
-    <groupId>com.github.NEZNAMY</groupId>
-    <artifactId>TAB-API</artifactId>
-    <version>2.8.10</version>
-  </dependency>
-</dependencies>
- ```
+# Compiling
+Compilation requires JDK 17 and up.  
+To compile the plugin, run `./gradlew build` from the terminal.  
+Once the plugin compiles, grab the jar from `/jar/build/libs/` folder.  
+The universal jar contains all modules for all supported platforms.
+
+# Documentation
+You can find everything about the plugin on the [Wiki](https://github.com/NEZNAMY/TAB/wiki). This includes a detailed description
+of all features, as well as information regarding compatibility or limitations of each feature.  
+
+# Issues
+The [Issues](https://github.com/NEZNAMY/TAB/issues) section is an issue tracker for all the kind of problems covered in issue templates.
+Please refrain from attempting to use it to receive help with your server, such issues will be closed immediately.  
+When opening an issue, provide as much information as possible. The difference between a bug getting fixed in 1 week vs 1 hour
+is in quality of the report. Bug reports where steps to reproduce are "idk" have no value and will not help to get the bug fixed at all.  
+
+# Contributing
+See [CONTRIBUTING.md](https://github.com/NEZNAMY/TAB/blob/master/CONTRIBUTING.md)
@@ -0,0 +1,2 @@
+# Security Policy
+If you found a security issue, send me a private message anywhere.
@@ -0,0 +1,7 @@
+dependencies {
+    compileOnlyApi("org.jetbrains:annotations:24.0.1")
+}
+
+tasks.javadoc {
+    enabled = project.hasProperty("enable-javadoc")
+}
@@ -0,0 +1,135 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import lombok.NonNull;
+import lombok.Setter;
+import me.neznamy.tab.api.bossbar.BossBarManager;
+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.tablist.SortingManager;
+import me.neznamy.tab.api.tablist.HeaderFooterManager;
+import me.neznamy.tab.api.tablist.TabListFormatManager;
+import me.neznamy.tab.api.nametag.NameTagManager;
+import me.neznamy.tab.api.tablist.layout.LayoutManager;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * The primary API class to get instances of other API classes
+ */
+public abstract class TabAPI {
+
+    /** Instance of the API */
+    @Setter private static TabAPI instance;
+
+    /**
+     * Returns API instance. If instance was not set by the plugin, throws
+     * {@code IllegalStateException}. This is usually caused by shading the API
+     * into own project, which is not allowed. Another option is calling the method
+     * before plugin was able to load.
+     *
+     * @return  API instance
+     * @throws  IllegalStateException
+     *          If instance is {@code null}
+     */
+    public static @NotNull TabAPI getInstance() {
+        if (instance == null) throw new IllegalStateException("The API instance is null. This can have 2 possible causes: \n" +
+                "#1 - API was called before TAB was loaded. This means your plugin was loaded before TAB was. To make sure your " +
+                "plugin loads after TAB, add it as a depend or soft depend of your plugin.\n" +
+                "#2 - You shaded TAB's classes into your plugin, instead of only using them. This is not allowed. To verify this " +
+                "is your case, unzip your plugin and check for TAB's classes. If they are there, you will need to fix your compiler " +
+                "to not include them, such as scope provided for maven compilation.");
+        return instance;
+    }
+
+    /**
+     * Returns player object from given UUID
+     *
+     * @param   id
+     *          Player UUID
+     * @return  player object from given UUID
+     */
+    public abstract @Nullable TabPlayer getPlayer(@NonNull UUID id);
+
+    /**
+     * Returns player object from given name
+     *
+     * @param   name
+     *          Player name
+     * @return  player object from given name
+     */
+    public abstract @Nullable TabPlayer getPlayer(@NonNull 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 @NotNull TabPlayer[] getOnlinePlayers();
+
+    /**
+     * Return BossBar manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  BossBar manager
+     */
+    public abstract @Nullable BossBarManager getBossBarManager();
+
+    /**
+     * Returns scoreboard manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  scoreboard manager
+     */
+    public abstract @Nullable ScoreboardManager getScoreboardManager();
+
+    /**
+     * Returns team manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  team manager
+     */
+    public abstract @Nullable NameTagManager getNameTagManager();
+
+    /**
+     * Returns header/footer manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  Header/footer manager
+     */
+    public abstract @Nullable HeaderFooterManager getHeaderFooterManager();
+
+    /**
+     * Returns PlaceholderManager instance
+     *
+     * @return  PlaceholderManager instance
+     */
+    public abstract @NotNull PlaceholderManager getPlaceholderManager();
+
+    /**
+     * Returns TabList name format manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  TabList name format manager
+     */
+    public abstract @Nullable TabListFormatManager getTabListFormatManager();
+
+    /**
+     * Returns Layout manager instance if the feature is enabled. If not, returns {@code null}.
+     *
+     * @return  Layout manager
+     */
+    public abstract @Nullable LayoutManager getLayoutManager();
+
+    /**
+     * Returns Sorting manager instance if at least one feature capable of sorting players is enabled.
+     * If not, returns {@code null}.
+     *
+     * @return  Sorting manager
+     */
+    public abstract @Nullable SortingManager getSortingManager();
+
+    /**
+     * Gets the event bus for registering listeners for TAB events.
+     *
+     * @return  the event bus
+     */
+    public abstract @Nullable EventBus getEventBus();
+}
@@ -0,0 +1,69 @@
+package me.neznamy.tab.api;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+/**
+ * An interface representing a player
+ */
+public interface TabPlayer {
+
+    /**
+     * Returns player's name
+     *
+     * @return  Player's name
+     */
+    @NotNull String getName();
+
+    /**
+     * Returns player's UUID
+     *
+     * @return  Player's UUID
+     */
+    @NotNull UUID getUniqueId();
+
+    /**
+     * Returns platform-specific entity
+     *
+     * @return  an instance of bukkit/bungee player depending on platform
+     */
+    @NotNull Object getPlayer();
+
+    /**
+     * 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();
+
+    /**
+     * 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
+     */
+    @NotNull String getGroup();
+
+    /**
+     * Temporarily overrides player's group and applies all changes coming from new group.
+     * This includes all properties and sorting, if used.
+     * Set to {@code null} to reset back.
+     *
+     * @param   group
+     *          New group to use
+     * @see     #hasTemporaryGroup()
+     */
+    void setTemporaryGroup(@Nullable String group);
+
+    /**
+     * Returns {@code true} if a temporary group was applied to the player using {@link #setTemporaryGroup(String)}.
+     * If no group was set, returns {@code false}
+     *
+     * @return  {@code true} if group is set, {@code false} if not
+     * @see     #setTemporaryGroup(String)
+     */
+    boolean hasTemporaryGroup();
+}
@@ -0,0 +1,9 @@
+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,203 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.UUID;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * 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
+     */
+    @NotNull 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
+     */
+    @NotNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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
+     */
+    @NotNull 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
+     */
+    @NotNull 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
+     */
+    @NotNull 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
+     */
+    @NotNull 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(@NonNull 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(@NonNull 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
+     */
+    @NotNull List<TabPlayer> getPlayers();
+
+    /**
+     * Returns {@code true} if this boss bar is 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,156 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.Map;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * 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
+     */
+    @NotNull BossBar createBossBar(@NonNull String title, float progress, @NonNull BarColor color, @NonNull 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
+     */
+    @NotNull BossBar createBossBar(@NonNull String title, @NonNull String progress, @NonNull String color, @NonNull 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 {@code null} if no such BossBar exists.
+     * 
+     * @param   name
+     *          Name of registered BossBar
+     * @return  BossBar with specified name
+     */
+    @Nullable BossBar getBossBar(@NonNull String name);
+
+    /**
+     * 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
+     */
+    @NotNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull TabPlayer player, @NonNull 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(@NonNull 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)
+     */
+    @NotNull List<BossBar> getAnnouncedBossBars();
+}
@@ -0,0 +1,55 @@
+package me.neznamy.tab.api.event;
+
+import lombok.NonNull;
+
+/**
+ * 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.
+     *
+     * <p>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(@NonNull 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(@NonNull Class<E> type, @NonNull 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(@NonNull 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(@NonNull 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.
+ *
+ * <p>This is a marker interface. All events <strong>must</strong> implement this
+ * interface.
+ */
+public interface TabEvent {
+}
@@ -0,0 +1,26 @@
+package me.neznamy.tab.api.event.player;
+
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.event.TabEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * 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
+     */
+    @NotNull TabPlayer getPlayer();
+
+    /**
+     * Returns {@code true} if player was loaded because they joined,
+     * {@code false} if the player was loaded because tab reload command was executed
+     *
+     * @return  {@code true} if player joined, {@code false} if plugin was reloaded
+     */
+    boolean isJoin();
+}
@@ -0,0 +1,48 @@
+package me.neznamy.tab.api.event.plugin;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.event.TabEvent;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * Called when an unknown placeholder is about to be registered.
+ * It defaults to a PlaceholderAPI implementation, but can be overridden.
+ */
+public interface PlaceholderRegisterEvent extends TabEvent {
+
+    /**
+     * Returns placeholder identifier starting and ending with {@code %}
+     *
+     * @return  placeholder identifier starting and ending with {@code %}
+     */
+    @NotNull String getIdentifier();
+
+    /**
+     * Sets placeholder to specified server placeholder implementation.
+     *
+     * @param   supplier
+     *          Placeholder replacer
+     */
+    void setServerPlaceholder(@NonNull Supplier<Object> supplier);
+
+    /**
+     * Sets placeholder to specified player placeholder implementation.
+     *
+     * @param   function
+     *          Placeholder replacer
+     */
+    void setPlayerPlaceholder(@NonNull Function<TabPlayer, Object> function);
+
+    /**
+     * Sets placeholder to specified relational placeholder implementation.
+     *
+     * @param   function
+     *          Placeholder replacer
+     */
+    void setRelationalPlaceholder(@NonNull BiFunction<TabPlayer, TabPlayer, Object> function);
+}
@@ -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,183 @@
+package me.neznamy.tab.api.nametag;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for manipulating player name tags.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getNameTagManager()}.
+ * This requires the Team feature to be enabled in config, otherwise the method will
+ * return {@code null}.
+ */
+public interface NameTagManager {
+
+    /**
+     * Makes player's NameTag globally invisible
+     *
+     * @param   player
+     *          player to hide name tag of
+     * @see     #showNameTag(TabPlayer)
+     * @see     #hasHiddenNameTag(TabPlayer)
+     */
+    void hideNameTag(@NonNull TabPlayer player);
+
+    /**
+     * Hides player's NameTag for specified player until it's shown again
+     *
+     * @param   player
+     *          player to hide name tag of
+     * @param   viewer
+     *          player to hide name tag for
+     */
+    void hideNameTag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Makes player's NameTag visible again
+     *
+     * @param   player
+     *          player to show name tag of
+     * @see     #hideNameTag(TabPlayer)
+     * @see     #hasHiddenNameTag(TabPlayer)
+     */
+    void showNameTag(@NonNull TabPlayer player);
+
+    /**
+     * Shows player's NameTag for specified viewer if it was hidden before
+     *
+     * @param   player
+     *          player to show name tag of
+     * @param   viewer
+     *          player to show NameTag back for
+     */
+    void showNameTag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Return whether player has hidden NameTag or not
+     *
+     * @param   player
+     *          player to check name tag visibility status of
+     * @return  Whether player has hidden NameTag or not
+     * @see     #hideNameTag(TabPlayer)
+     * @see     #showNameTag(TabPlayer)
+     */
+    boolean hasHiddenNameTag(@NonNull TabPlayer player);
+
+    /**
+     * Returns true if NameTag is hidden for specified viewer, false if not
+     *
+     * @param   player
+     *          player to check visibility status of
+     * @param   viewer
+     *          player to check visibility status for
+     * @return  true if hidden, false if not
+     */
+    boolean hasHiddenNameTag(@NonNull TabPlayer player, @NonNull TabPlayer viewer);
+
+    /**
+     * Unregisters player's team and no longer handles it, as well as disables anti-override for teams.
+     * This can be resumed using resumeTeamHandling(). If team handling was paused already, nothing happens.
+     *
+     * @param   player
+     *          player to pause team handling of
+     */
+    void pauseTeamHandling(@NonNull TabPlayer player);
+
+    /**
+     * Resumes team handling if it was before paused using pauseTeamHandling(), if not, nothing happens
+     *
+     * @param   player
+     *          player to resume team handling of
+     */
+    void resumeTeamHandling(@NonNull TabPlayer player);
+
+    /**
+     * Returns true if team handling is paused for this player using pauseTeamHandling(), false if not, or
+     * it was resumed already using resumeTeamHandling
+     *
+     * @param   player
+     *          player to check handling status of
+     * @return  true if paused, false if not
+     */
+    boolean hasTeamHandlingPaused(@NonNull TabPlayer player);
+
+    /**
+     * Forces collision rule for the player. Setting it to null will remove forced value
+     *
+     * @param   player
+     *          player to set collision rule of
+     * @param   collision
+     *          forced collision rule
+     */
+    void setCollisionRule(@NonNull TabPlayer player, @Nullable Boolean collision);
+
+    /**
+     * Returns forced collision rule or null if collision is not forced using setCollisionRule
+     *
+     * @param   player
+     *          player to get forced collision of
+     * @return  forced value or null if not forced
+     */
+    @Nullable Boolean getCollisionRule(@NonNull TabPlayer player);
+
+    /**
+     * Changes player's prefix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   prefix
+     *          new prefix value
+     * @see     #getCustomPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
+    void setPrefix(@NonNull TabPlayer player, @Nullable String prefix);
+
+    /**
+     * Changes player's suffix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   suffix
+     *          new suffix value
+     * @see     #getCustomSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
+    void setSuffix(@NonNull TabPlayer player, @Nullable String suffix);
+
+    @Nullable String getCustomPrefix(@NonNull TabPlayer player);
+
+    @Nullable String getCustomSuffix(@NonNull TabPlayer player);
+
+    @NonNull String getOriginalPrefix(@NonNull TabPlayer player);
+
+    @NonNull String getOriginalSuffix(@NonNull TabPlayer player);
+
+    /**
+     * Toggles name tag visibility view on all players for specified player.
+     * On first call, name tags of all players will become invisible for specified
+     * player. On second call, they will become visible again.
+     *
+     * @param   player
+     *          player to toggle name tag visibility view for
+     * @param   sendToggleMessage
+     *          {@code true} if configured toggle message should be sent, {@code false} if not
+     */
+    void toggleNameTagVisibilityView(@NonNull TabPlayer player, boolean sendToggleMessage);
+
+    /**
+     * Returns {@code true} if player has hidden name tags by either calling
+     * {@link #toggleNameTagVisibilityView(TabPlayer, boolean)} or using a command,
+     * {@code false} if not.
+     *
+     * @param   player
+     *          player to check
+     * @return  {@code true} if hidden, {@code false} if not
+     */
+    boolean hasHiddenNameTagVisibilityView(@NonNull TabPlayer player);
+}
@@ -0,0 +1,128 @@
+package me.neznamy.tab.api.nametag;
+
+import java.util.List;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for manipulating player name tags.
+ * <p>
+ * Instance can be obtained using {@link TabAPI#getNameTagManager()} and then casting it.
+ * This requires both Team and Unlimited name tag features to be enabled in config, otherwise the method will
+ * return {@code null} or not be an instance of this class.
+ */
+public interface UnlimitedNameTagManager extends NameTagManager {
+
+    /**
+     * Disables armor stands of specified player and displays vanilla name tags instead.
+     *
+     * @param   player
+     *          Player to disable armor stands of
+     * @see     #enableArmorStands(TabPlayer)
+     * @see     #hasDisabledArmorStands(TabPlayer)
+     */
+    void disableArmorStands(@NonNull TabPlayer player);
+
+    /**
+     * Enabled back armor stands of player, who was disabled previously using
+     * {@link #disableArmorStands(TabPlayer)}.
+     *
+     * @param   player
+     *          Player to enable back
+     * @see     #disableArmorStands(TabPlayer)
+     * @see     #hasDisabledArmorStands(TabPlayer)
+     */
+    void enableArmorStands(@NonNull TabPlayer player);
+
+    /**
+     * Returns {@code true} if player has armor stands disabled using
+     * {@link #disableArmorStands(TabPlayer)}, {@code false} otherwise.
+     *
+     * @param   player
+     *          Player to check
+     * @return  {@code true} if disabled, {@code false} if not.
+     * @see     #disableArmorStands(TabPlayer)
+     * @see     #enableArmorStands(TabPlayer)
+     */
+    boolean hasDisabledArmorStands(@NonNull TabPlayer player);
+
+    /**
+     * Changes name to specified value. Set to {@code null} to
+     * reset back to original value.
+     *
+     * @param   player
+     *          Player to change name of
+     * @param   customName
+     *          New name, or {@code null} to reset to original value
+     */
+    void setName(@NonNull TabPlayer player, @Nullable String customName);
+
+    /**
+     * Changes line to specified value. Set to {@code null} to reset back to original value.
+     *
+     * @param   player
+     *          Player to change line of
+     * @param   line
+     *          Name of defined line
+     * @param   value
+     *          Value to use, or {@code null} to reset back to original value
+     * @see     #getDefinedLines()
+     */
+    void setLine(@NonNull TabPlayer player, @NonNull String line, @Nullable String value);
+
+    /**
+     * Returns custom name value set using {@link #setName(TabPlayer, String)}.
+     *
+     * @param   player
+     *          Player to check
+     * @return  Custom name set previously or {@code null} if not set
+     * @see     #setName(TabPlayer, String)
+     */
+    @Nullable String getCustomName(@NonNull TabPlayer player);
+
+    /**
+     * Returns custom line value set using {@link #setLine(TabPlayer, String, String)}.
+     *
+     * @param   player
+     *          Player to check
+     * @param   line
+     *          Defined line
+     * @return  Custom name set previously or {@code null} if not set
+     * @see     #setName(TabPlayer, String)
+     * @see     #getDefinedLines()
+     */
+    @Nullable String getCustomLineValue(@NonNull TabPlayer player, @NonNull String line);
+
+    /**
+     * Returns original name value configured in files.
+     *
+     * @param   player
+     *          Player to check
+     * @return  Original configured name
+     * @see     #setName(TabPlayer, String)
+     */
+    @NotNull String getOriginalName(@NonNull TabPlayer player);
+
+    /**
+     * Returns original line value configured in files.
+     *
+     * @param   player
+     *          Player to check
+     * @param   line
+     *          Line name
+     * @return  Original configured line
+     * @see     #setLine(TabPlayer, String, String)
+     */
+    @NotNull String getOriginalLineValue(@NonNull TabPlayer player, @NonNull String line);
+
+    /**
+     * Returns list of all defined lines in config, both static and dynamic lines.
+     *
+     * @return  List of all defined lines in config
+     */
+    @NotNull List<String> getDefinedLines();
+}
@@ -0,0 +1,23 @@
+package me.neznamy.tab.api.placeholder;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An interface representing some kind of placeholder
+ */
+public interface Placeholder {
+
+    /**
+     * Returns refresh interval of this placeholder
+     *
+     * @return  refresh interval of this placeholder
+     */
+    int getRefresh();
+
+    /**
+     * Returns placeholder's identifier
+     *
+     * @return  placeholder's identifier
+     */
+    @NotNull String getIdentifier();
+}
@@ -0,0 +1,92 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * An interface allowing placeholder registration. Instance can be
+ * obtained using {@link TabAPI#getPlaceholderManager()}
+ */
+public interface PlaceholderManager {
+
+    /**
+     * Registers a server placeholder (placeholder with same output for all players)
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @param   refresh
+     *          Refresh interval
+     * @param   supplier
+     *          Supplier for placeholder output
+     * @return  Registered placeholder for further use
+     * @throws  IllegalArgumentException
+     *          If {@code identifier} does not start and end with {@code %} or
+     *          {@code refresh} is not divisible by 50
+     */
+    @NotNull ServerPlaceholder registerServerPlaceholder(@NonNull String identifier, int refresh, @NonNull Supplier<Object> supplier);
+
+    /**
+     * Registers a player placeholder (placeholder different output per player)
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @param   refresh
+     *          Refresh interval
+     * @param   function
+     *          Function for placeholder output
+     * @return  Registered placeholder for further use
+     * @throws  IllegalArgumentException
+     *          If {@code identifier} does not start and end with {@code %} or
+     *          {@code refresh} is not divisible by 50
+     */
+    @NotNull PlayerPlaceholder registerPlayerPlaceholder(@NonNull String identifier, int refresh, @NonNull Function<TabPlayer, Object> function);
+
+    /**
+     * Registers a relational placeholder (placeholder with output different for each player duo)
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @param   refresh
+     *          Refresh interval
+     * @param   function
+     *          Function for placeholder output
+     * @return  Registered placeholder for further use
+     * @throws  IllegalArgumentException
+     *          If {@code identifier} does not start and end with {@code %},
+     *          does not start with {@code %rel_} or
+     *          {@code refresh} is not divisible by 50
+     */
+    @NotNull RelationalPlaceholder registerRelationalPlaceholder(@NonNull String identifier, int refresh, @NonNull BiFunction<TabPlayer, TabPlayer, Object> function);
+
+    /**
+     * Returns placeholder from specified identifier. If it does not exist, it is registered
+     * as a PlaceholderAPI placeholder and returned.
+     *
+     * @param   identifier
+     *          Placeholder identifier
+     * @return  Placeholder with specified identifier
+     */
+    @NotNull Placeholder getPlaceholder(@NonNull String identifier);
+
+    /**
+     * Unregisters placeholder and makes plugin no longer refresh it.
+     *
+     * @param   placeholder
+     *          Placeholder to unregister
+     */
+    void unregisterPlaceholder(@NonNull Placeholder placeholder);
+
+    /**
+     * Unregisters placeholder and makes plugin no longer refresh it.
+     *
+     * @param   identifier
+     *          identifier of placeholder to unregister
+     */
+    void unregisterPlaceholder(@NonNull String identifier);
+}
@@ -0,0 +1,30 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface for player placeholders (placeholders returning different value for each player)
+ */
+public interface PlayerPlaceholder extends Placeholder {
+
+    /**
+     * Force-updates placeholder value. It will still be overridden by periodic refresh later,
+     * so this is (only) useful for force an update when value is supposed to change, and you have
+     * a high refresh interval set.
+     *
+     * @param   player
+     *          Player to update value for
+     * @param   value
+     *          New value
+     */
+    void updateValue(@NonNull TabPlayer player, @NonNull Object value);
+
+    /**
+     * Force-updates placeholder value using previously provided update function.
+     *
+     * @param   player
+     *          Player to update value for
+     */
+    void update(@NonNull TabPlayer player);
+}
@@ -0,0 +1,34 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * An interface for relational placeholders (returning different value for each player duo)
+ */
+public interface RelationalPlaceholder extends Placeholder {
+
+    /**
+     * Force-updates placeholder value. It will still be overridden by periodic refresh later,
+     * so this is (only) useful for force an update when value is supposed to change, and you have
+     * a high refresh interval set.
+     *
+     * @param   viewer
+     *          Placeholder viewer
+     * @param   target
+     *          Placeholder target
+     * @param   value
+     *          New value
+     */
+    void updateValue(@NonNull TabPlayer viewer, @NonNull TabPlayer target, @NonNull Object value);
+
+    /**
+     * Force-updates placeholder value using previously provided update function.
+     *
+     * @param   viewer
+     *          Placeholder viewer
+     * @param   target
+     *          Placeholder target
+     */
+    void update(@NonNull TabPlayer viewer, @NonNull TabPlayer target);
+}
@@ -0,0 +1,24 @@
+package me.neznamy.tab.api.placeholder;
+
+import lombok.NonNull;
+
+/**
+ * An interface for server placeholders (returning same value for all players)
+ */
+public interface ServerPlaceholder extends Placeholder {
+
+    /**
+     * Force-updates placeholder value. It will still be overridden by periodic refresh later,
+     * so this is (only) useful for force an update when value is supposed to change, and you have
+     * a high refresh interval set.
+     *
+     * @param   value
+     *          New value
+     */
+    void updateValue(@NonNull Object value);
+
+    /**
+     * Force-updates placeholder value using previously provided update function.
+     */
+    void update();
+}
@@ -0,0 +1,32 @@
+package me.neznamy.tab.api.scoreboard;
+
+import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * 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
+     */
+    @NotNull 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(@NonNull String text);
+}
@@ -0,0 +1,90 @@
+package me.neznamy.tab.api.scoreboard;
+
+import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
+
+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
+     */
+    @NotNull String getName();
+
+    /**
+     * Returns raw title of this scoreboard. Placeholders stay in their
+     * raw format.
+     * 
+     * @return  scoreboard title
+     * @see     #setTitle(String)
+     */
+    @NotNull 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(@NonNull 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)
+     */
+    @NotNull 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(@NonNull 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,168 @@
+package me.neznamy.tab.api.scoreboard;
+
+import java.util.List;
+import java.util.Map;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * 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 {@code 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}
+     */
+    @NotNull Scoreboard createScoreboard(@NonNull String name, @NonNull String title, @NonNull 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
+     */
+    @NotNull 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(@NonNull TabPlayer player, @NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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(@NonNull 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
+     */
+    @NotNull Scoreboard getActiveScoreboard(@NonNull TabPlayer player);
+}
@@ -0,0 +1,57 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * 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. Use {@code null} to reset value back to original.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   header
+     *          Raw header value
+     */
+    void setHeader(@NonNull TabPlayer player, @Nullable 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. Use {@code null} to reset value back to original.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   footer
+     *          Raw footer value
+     */
+    void setFooter(@NonNull TabPlayer player, @Nullable 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. Use {@code null} to reset value back to original.
+     *
+     * @param   player
+     *          Player to set header for
+     * @param   header
+     *          Raw header value
+     * @param   footer
+     *          Raw footer value
+     */
+    void setHeaderAndFooter(@NonNull TabPlayer player, @Nullable String header, @Nullable String footer);
+}
@@ -0,0 +1,38 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface SortingManager {
+
+    /**
+     * Forces new team name for the player until this method is called again with null argument and
+     * performs all actions to change player's team name
+     *
+     * @param   player
+     *          player to set team name of
+     * @param   teamName
+     *          forced team name
+     */
+    void forceTeamName(@NonNull TabPlayer player, @Nullable String teamName);
+
+    /**
+     * Returns forced team name of player or null if not forced
+     *
+     * @param   player
+     *          player to check forced team name of
+     * @return  forced team name of player or null if not forced
+     */
+    @Nullable String getForcedTeamName(@NonNull TabPlayer player);
+
+    /**
+     * Returns original team name of the player set by the plugin.
+     *
+     * @param   player
+     *          Player to get team name of
+     * @return  Player's team name based on configuration.
+     */
+    @NotNull String getOriginalTeamName(@NonNull TabPlayer player);
+}
@@ -0,0 +1,132 @@
+package me.neznamy.tab.api.tablist;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * 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. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   prefix
+     *          new prefix value
+     * @see     #getCustomPrefix(TabPlayer)
+     * @see     #getOriginalPrefix(TabPlayer)
+     */
+    void setPrefix(@NonNull TabPlayer player, @Nullable String prefix);
+
+    /**
+     * Changes player's name to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   customName
+     *          new customName value
+     * @see     #getCustomName(TabPlayer)
+     * @see     #getOriginalName(TabPlayer)
+     */
+    void setName(@NonNull TabPlayer player, @Nullable String customName);
+
+    /**
+     * Changes player's suffix to provided value. Supports placeholders,
+     * as well as any supported RGB formats. Use {@code null} to reset
+     * value back to original.
+     *
+     * @param   player
+     *          player to change prefix of
+     * @param   suffix
+     *          new suffix value
+     * @see     #getCustomSuffix(TabPlayer)
+     * @see     #getOriginalSuffix(TabPlayer)
+     */
+    void setSuffix(@NonNull TabPlayer player, @Nullable String suffix);
+
+    /**
+     * 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     #getOriginalPrefix(TabPlayer)
+     */
+    @Nullable String getCustomPrefix(@NonNull 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     #getOriginalName(TabPlayer)
+     */
+    @Nullable String getCustomName(@NonNull 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     #getOriginalSuffix(TabPlayer)
+     */
+    @Nullable String getCustomSuffix(@NonNull 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     #getCustomPrefix(TabPlayer)
+     */
+    @NotNull String getOriginalPrefix(@NonNull 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     #getCustomName(TabPlayer)
+     */
+    @NotNull String getOriginalName(@NonNull 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     #getCustomSuffix(TabPlayer)
+     */
+    @NotNull String getOriginalSuffix(@NonNull TabPlayer player);
+}
@@ -0,0 +1,78 @@
+package me.neznamy.tab.api.tablist.layout;
+
+import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface representing a layout.
+ */
+public interface Layout {
+
+    /**
+     * Returns name of the layout.
+     *
+     * @return  name of the layout
+     */
+    @NotNull String getName();
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     */
+    void addFixedSlot(int slot, @NonNull String text);
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     * @param   skin
+     *          Skin definition like in config
+     */
+    void addFixedSlot(int slot, @NonNull String text, @NonNull String skin);
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     * @param   ping
+     *          Slot's ping
+     */
+    void addFixedSlot(int slot, @NonNull String text, int ping);
+
+    /**
+     * Adds fixed slot with specified parameters
+     *
+     * @param   slot
+     *          Slot (1-80)
+     * @param   text
+     *          Text to display
+     * @param   skin
+     *          Skin definition like in config
+     * @param   ping
+     *          Slot's ping
+     */
+    void addFixedSlot(int slot, @NonNull String text, @NonNull String skin, int ping);
+
+    /**
+     * Adds a player group.
+     *
+     * @param   condition
+     *          Condition that must be met for player to appear in the group.
+     *          May be null for no requirement. Syntax is like in config -
+     *          either condition name or short format.
+     * @param   slots
+     *          Slots for this player group
+     */
+    void addGroup(@Nullable String condition, int[] slots);
+}
@@ -0,0 +1,44 @@
+package me.neznamy.tab.api.tablist.layout;
+
+import lombok.NonNull;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.TabPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for working with layouts. Instance can be obtained using
+ * {@link TabAPI#getLayoutManager()}. If the feature is disabled in
+ * config, it will return {@code null}.
+ */
+public interface LayoutManager {
+
+    /**
+     * Creates new layout
+     *
+     * @param   name
+     *          Unique layout name
+     * @return  Created layout
+     */
+    Layout createNewLayout(String name);
+
+    /**
+     * Sends layout to player. Set to {@code null} to make player not see
+     * any layout, but default TabList instead.
+     *
+     * @param   player
+     *          Player to send layout to
+     * @param   layout
+     *          Layout to send
+     * @see     #resetLayout(TabPlayer)
+     */
+    void sendLayout(@NonNull TabPlayer player, @Nullable Layout layout);
+
+    /**
+     * Reset layout back to original one based on configuration.
+     *
+     * @param   player
+     *          Player to reset layout for
+     * @see     #sendLayout(TabPlayer, Layout)
+     */
+    void resetLayout(@NonNull TabPlayer player);
+}
@@ -0,0 +1,9 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation("com.github.johnrengelman:shadow:8.1.1")
+    implementation("io.freefair.gradle:lombok-plugin:8.0.1")
+    implementation("fabric-loom:fabric-loom.gradle.plugin:1.1-SNAPSHOT")
+}
@@ -0,0 +1,9 @@
+rootProject.name = "build-logic"
+
+dependencyResolutionManagement {
+    repositories {
+        maven("https://maven.fabricmc.net/")
+        gradlePluginPortal()
+        mavenCentral()
+    }
+}
@@ -0,0 +1,36 @@
+import org.apache.tools.ant.filters.ReplaceTokens
+
+plugins {
+    `java-library`
+    id("io.freefair.lombok")
+}
+
+tasks {
+    processResources {
+        filter<ReplaceTokens>("tokens" to mapOf(
+            "id" to rootProject.ext.get("id")!!.toString(),
+            "name" to rootProject.name,
+            "version" to project.version,
+            "description" to project.description,
+            "website" to rootProject.ext.get("website")!!.toString(),
+            "author" to rootProject.ext.get("author")!!.toString()
+        ))
+    }
+    javadoc {
+        // This saves a decent bit of processing power on slow machines
+        enabled = false
+        options.encoding = Charsets.UTF_8.name()
+        (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:none", "-quiet")
+    }
+    compileJava {
+        options.encoding = Charsets.UTF_8.name()
+        options.release.set(8)
+        options.compilerArgs.addAll(listOf("-nowarn", "-Xlint:-unchecked", "-Xlint:-deprecation"))
+    }
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+}
@@ -0,0 +1,15 @@
+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")
+        relocate("me.neznamy.yamlassist", "me.neznamy.tab.libs.me.neznamy.yamlassist")
+        relocate("org.yaml.snakeyaml", "me.neznamy.tab.libs.org.yaml.snakeyaml")
+    }
+}
@@ -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,36 @@
+plugins {
+    id("tab.parent")
+}
+
+allprojects {
+    group = "me.neznamy"
+    version = "4.0.3-SNAPSHOT"
+    description = "An all-in-one solution that works"
+
+    ext.set("id", "tab")
+    ext.set("website", "https://github.com/NEZNAMY/TAB")
+    ext.set("author", "NEZNAMY")
+}
+
+val platforms = setOf(
+    projects.bukkit,
+    projects.bungeecord,
+    projects.krypton,
+    projects.velocity,
+    projects.sponge7,
+    projects.sponge8,
+    projects.fabric
+).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,8 @@
+dependencies {
+    implementation(projects.shared)
+    implementation("org.bstats:bstats-bukkit:3.0.1")
+    compileOnly("org.purpurmc.purpur:purpur-api:1.16.5-R0.1-SNAPSHOT")
+    compileOnly("me.clip:placeholderapi:2.11.2")
+    compileOnly("com.mojang:authlib:1.5.25")
+    compileOnly("com.github.MilkBowl:VaultAPI:1.7")
+}
@@ -1,172 +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.8.11-pre13</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>
-
-	</repositories>
-
-	<dependencies>
-
-		<!-- TAB Core -->
-		<dependency>
-			<groupId>me.neznamy</groupId>
-			<artifactId>shared</artifactId>
-			<version>${project.version}</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>com.google.guava</groupId>
-					<artifactId>guava</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.github.NEZNAMY</groupId>
-					<artifactId>YamlAssist</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.yaml</groupId>
-					<artifactId>snakeyaml</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Spigot API -->
-		<dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot-api</artifactId>
-			<version>1.16.5-R0.1-SNAPSHOT</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-lang</groupId>
-					<artifactId>commons-lang</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.guava</groupId>
-					<artifactId>guava</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.guava</groupId>
-					<artifactId>guava</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>us.myles</groupId>
-			<artifactId>viaversion</artifactId>
-			<version>3.2.0</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>us.myles</groupId>
-					<artifactId>viaversion-common</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>us.myles</groupId>
-					<artifactId>viaversion-bukkit</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>us.myles</groupId>
-					<artifactId>viaversion-bungee</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>us.myles</groupId>
-					<artifactId>viaversion-fabric</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>us.myles</groupId>
-					<artifactId>viaversion-sponge</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>us.myles</groupId>
-					<artifactId>viaversion-velocity</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.md-5</groupId>
-					<artifactId>bungeecord-chat</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-	</dependencies>
-</project>
@@ -1,90 +1,43 @@
 package me.neznamy.tab.platforms.bukkit;

+import me.neznamy.tab.shared.platform.EventListener;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.AsyncPlayerChatEvent;
 import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.player.PlayerRespawnEvent;
-import org.bukkit.event.player.PlayerToggleSneakEvent;
-
-import me.neznamy.tab.shared.TAB;

 /**
 * The core for bukkit forwarding events into all enabled features
 */
-public class BukkitEventListener implements Listener {
+public class BukkitEventListener extends EventListener<Player> 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", () -> TAB.getInstance().getFeatureManager().onJoin(new BukkitTabPlayer(e.getPlayer())));
-	}
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onQuit(PlayerQuitEvent e) {
+        quit(e.getPlayer().getUniqueId());
+    }

-	/**
-	 * 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()));
-	}
+    @EventHandler(priority = EventPriority.LOW)
+    public void onJoin(PlayerJoinEvent e) {
+        join(e.getPlayer());
+    }

-	/**
-	 * 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 AsyncPlayerChatEvent to forward the event to features
-	 * @param e chat event
-	 */
-	@EventHandler
-	public void onChat(AsyncPlayerChatEvent e) {
-		if (TAB.getInstance().isDisabled()) return;
-		if (TAB.getInstance().getFeatureManager().onChat(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId()), e.getMessage(), e.isCancelled())) e.setCancelled(true);
-	}
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        worldChange(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
+    }

-	/**
-	 * Listener to PlayerRespawnEvent to forward the event to features
-	 * @param e respawn event
-	 */
-	@EventHandler
-	public void onRespawn(PlayerRespawnEvent e) {
-		if (TAB.getInstance().isDisabled()) return;
-		TAB.getInstance().getCPUManager().runTask("processing PlayerRespawnEvent", () -> TAB.getInstance().getFeatureManager().onRespawn(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId())));
-	}
-	
-	/**
-	 * Listener to PlayerToggleSneakEvent to forward the event to features
-	 * @param e sneak event
-	 */
-	@EventHandler
-	public void onSneak(PlayerToggleSneakEvent e) {
-		if (TAB.getInstance().isDisabled()) return;
-		TAB.getInstance().getCPUManager().runTask("processing PlayerToggleSneakEvent", () -> TAB.getInstance().getFeatureManager().onSneak(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId()), e.isSneaking()));
-	}
-}
+    @EventHandler
+    public void onCommand(PlayerCommandPreprocessEvent e) {
+        if (command(e.getPlayer().getUniqueId(), e.getMessage())) e.setCancelled(true);
+    }
+
+    @Override
+    public TabPlayer createPlayer(Player player) {
+        return new BukkitTabPlayer(player);
+    }
+}
@@ -1,193 +0,0 @@
-package me.neznamy.tab.platforms.bukkit;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Timer;
-import java.util.TimerTask;
-import java.util.UUID;
-import java.util.concurrent.Callable;
-import java.util.logging.Level;
-
-import org.bukkit.Bukkit;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.ServicePriority;
-import org.json.simple.JSONArray;
-import org.json.simple.JSONObject;
-
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.features.Metrics;
-
-/**
- * bStats metrics for bukkit
- */
-@SuppressWarnings("unchecked")
-public class BukkitMetrics extends Metrics {
-
-	private Main plugin;
-	
-	public BukkitMetrics(Main plugin) {
-		super("https://bStats.org/submitData/bukkit");
-		if (plugin == null) {
-			throw new IllegalArgumentException("Plugin cannot be null!");
-		}
-		this.plugin = plugin;
-
-		// Get the config file
-		File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
-		File configFile = new File(bStatsFolder, "config.yml");
-		YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
-		if (!config.isSet("serverUuid")) {
-			config.addDefault("enabled", true);
-			config.addDefault("serverUuid", UUID.randomUUID().toString());
-			config.addDefault("logFailedRequests", false);
-			config.addDefault("logSentData", false);
-			config.addDefault("logResponseStatusText", false);
-			config.options().header(
-					"bStats collects some data for plugin authors like how many servers are using their plugins.\n" +
-							"To honor their work, you should not disable it.\n" +
-							"This has nearly no effect on the server performance!\n" +
-							"Check out https://bStats.org/ to learn more :)"
-					).copyDefaults(true);
-			try {
-				config.save(configFile);
-			} catch (IOException ignored) { }
-		}
-
-		// Load the data
-		enabled = config.getBoolean("enabled", true);
-		serverUUID = config.getString("serverUuid");
-		logFailedRequests = config.getBoolean("logFailedRequests", false);
-		logSentData = config.getBoolean("logSentData", false);
-		logResponseStatusText = config.getBoolean("logResponseStatusText", false);
-
-		if (enabled) {
-			boolean found = false;
-			// Search for all other bStats Metrics classes to see if we are the first one
-			for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
-				try {
-					service.getField("B_STATS_VERSION"); // Our identifier :)
-					found = true; // We aren't the first
-					break;
-				} catch (NoSuchFieldException ignored) { }
-			}
-			// Register our service
-			Bukkit.getServicesManager().register(BukkitMetrics.class, this, plugin, ServicePriority.Normal);
-			if (!found) {
-				// We are the first!
-				startSubmitting();
-			}
-		}
-		addCustomChart(new SimplePie("unlimited_nametag_mode_enabled", new Callable<String>() {
-			public String call() {
-				return TAB.getInstance().getFeatureManager().isFeatureEnabled("nametagx") ? "Yes" : "No";
-			}
-		}));
-		addCustomChart(new SimplePie("placeholderapi", new Callable<String>() {
-			public String call() {
-				return Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI") ? "Yes" : "No";
-			}
-		}));
-		addCustomChart(new SimplePie("permission_system", new Callable<String>() {
-			public String call() {
-				return TAB.getInstance().getPermissionPlugin().getName();
-			}
-		}));
-		addCustomChart(new SimplePie("server_version", new Callable<String>() {
-			public String call() {
-				return "1." + ProtocolVersion.SERVER_VERSION.getMinorVersion() + ".x";
-			}
-		}));
-	}
-
-	private void startSubmitting() {
-		Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags
-		timer.scheduleAtFixedRate(new TimerTask() {
-			@Override
-			public void run() {
-				if (!plugin.isEnabled()) { // Plugin was disabled
-					timer.cancel();
-					return;
-				}
-				// Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler
-				// Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
-				Bukkit.getScheduler().runTask(plugin, () -> submitData());
-			}
-		}, 1000*60*5, 1000*60*30);
-		// Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
-		// WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
-		// WARNING: Just don't do it!
-	}
-
-	private JSONObject getServerData() {
-		// Minecraft specific data
-		int playerAmount = TAB.getInstance().getPlayers().size();
-		int onlineMode = Bukkit.getOnlineMode() ? 1 : 0;
-		String bukkitVersion = Bukkit.getVersion();
-
-		// OS/Java specific data
-		String javaVersion = System.getProperty("java.version");
-		String osName = System.getProperty("os.name");
-		String osArch = System.getProperty("os.arch");
-		String osVersion = System.getProperty("os.version");
-		int coreCount = Runtime.getRuntime().availableProcessors();
-
-		JSONObject data = new JSONObject();
-
-		data.put("serverUUID", serverUUID);
-
-		data.put("playerAmount", playerAmount);
-		data.put("onlineMode", onlineMode);
-		data.put("bukkitVersion", bukkitVersion);
-
-		data.put("javaVersion", javaVersion);
-		data.put("osName", osName);
-		data.put("osArch", osArch);
-		data.put("osVersion", osVersion);
-		data.put("coreCount", coreCount);
-
-		return data;
-	}
-
-	private void submitData() {
-		JSONObject data = getServerData();
-
-		JSONArray pluginData = new JSONArray();
-		// Search for all other bStats Metrics classes to get their plugin data
-		for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
-			try {
-				service.getField("B_STATS_VERSION"); // Our identifier :)
-
-				for (RegisteredServiceProvider<?> provider : Bukkit.getServicesManager().getRegistrations(service)) {
-					try {
-						pluginData.add(provider.getService().getMethod("getPluginData").invoke(provider.getProvider()));
-					} catch (NullPointerException ignored) {
-					} catch (NoSuchMethodException ignored) { 
-					} catch (IllegalAccessException ignored) { 
-					} catch (InvocationTargetException ignored) {
-					}
-				}
-			} catch (NoSuchFieldException ignored) { }
-		}
-
-		data.put("plugins", pluginData);
-
-		// Create a new thread for the connection to the bStats server
-		new Thread(new Runnable() {
-
-			public void run() {
-				try {
-					// Send the data
-					sendData(data, logResponseStatusText);
-				} catch (Throwable e) {
-					// Something went wrong! :(
-					if (logFailedRequests) {
-						plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e);
-					}
-				}
-			}
-		}).start();
-	}
-}
@@ -1,564 +0,0 @@
-package me.neznamy.tab.platforms.bukkit;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.EntityType;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.packets.EnumChatFormat;
-import me.neznamy.tab.shared.packets.IChatBaseComponent;
-import me.neznamy.tab.shared.packets.PacketBuilder;
-import me.neznamy.tab.shared.packets.PacketPlayOutBoss;
-import me.neznamy.tab.shared.packets.PacketPlayOutBoss.Action;
-import me.neznamy.tab.shared.packets.PacketPlayOutChat;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.EnumGamemode;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.EnumPlayerInfoAction;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.PlayerInfoData;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerListHeaderFooter;
-import me.neznamy.tab.shared.packets.PacketPlayOutScoreboardDisplayObjective;
-import me.neznamy.tab.shared.packets.PacketPlayOutScoreboardObjective;
-import me.neznamy.tab.shared.packets.PacketPlayOutScoreboardObjective.EnumScoreboardHealthDisplay;
-import me.neznamy.tab.shared.packets.PacketPlayOutScoreboardScore;
-import me.neznamy.tab.shared.packets.PacketPlayOutScoreboardTeam;
-import me.neznamy.tab.shared.packets.PacketPlayOutTitle;
-import me.neznamy.tab.shared.packets.IChatBaseComponent.ClickAction;
-import me.neznamy.tab.shared.rgb.TextColor;
-import us.myles.ViaVersion.api.type.Type;
-import us.myles.viaversion.libs.gson.JsonParser;
-
-@SuppressWarnings("unchecked")
-public class BukkitPacketBuilder implements PacketBuilder {
-
-	//nms storage
-	private NMSStorage nms;
-	
-	//entity type ids
-	private Map<EntityType, Integer> entityIds = new HashMap<EntityType, Integer>();
-
-	/**
-	 * Constructs new instance with given parameter
-	 * @param nms - nms storage
-	 */
-	public BukkitPacketBuilder(NMSStorage nms) {
-		this.nms = nms;
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 13) {
-			entityIds.put(EntityType.ARMOR_STAND, 1);
-			entityIds.put(EntityType.WITHER, 83);
-		} else {
-			entityIds.put(EntityType.WITHER, 64);
-			if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 8){
-				entityIds.put(EntityType.ARMOR_STAND, 30);
-			}
-		}
-	}
-	
-	@Override
-	public Object build(PacketPlayOutBoss packet, ProtocolVersion clientVersion) throws Exception {
-		if (nms.minorVersion >= 9) {
-			//1.9+ server
-			return buildBossPacket19(packet, clientVersion);
-		}
-		if (clientVersion.getMinorVersion() >= 9 && Bukkit.getPluginManager().isPluginEnabled("ViaVersion")) {
-			//1.9+ client on 1.8 server
-			//technically redundant VV check as there is no other way to get 1.9 client on 1.8 server
-			return buildBossPacketVia(packet, clientVersion);
-		}
-
-		//<1.9 client and server
-		return buildBossPacketEntity(packet, clientVersion);
-	}
-
-	/**
-	 * Build 1.9 boss packet
-	 * @param packet - packet to build
-	 * @param clientVersion - client version
-	 * @return 1.9 bossbar packet
-	 * @throws Exception - if something fails
-	 */
-	private Object buildBossPacket19(PacketPlayOutBoss packet, ProtocolVersion clientVersion) throws Exception {
-		Object nmsPacket = nms.newPacketPlayOutBoss.newInstance();
-		nms.PacketPlayOutBoss_UUID.set(nmsPacket, packet.id);
-		nms.PacketPlayOutBoss_ACTION.set(nmsPacket, Enum.valueOf(nms.PacketPlayOutBoss_Action, packet.operation.toString()));
-		nms.PacketPlayOutBoss_PROGRESS.set(nmsPacket, packet.pct);
-		nms.PacketPlayOutBoss_NAME.set(nmsPacket, packet.name == null ? null : toNMSComponent(IChatBaseComponent.optimizedComponent(packet.name), clientVersion));
-		nms.PacketPlayOutBoss_COLOR.set(nmsPacket, packet.color == null ? null : Enum.valueOf(nms.BarColor, packet.color.toString()));
-		nms.PacketPlayOutBoss_STYLE.set(nmsPacket, packet.overlay == null ? null : Enum.valueOf(nms.BarStyle, packet.overlay.toString()));
-		nms.PacketPlayOutBoss_DARKEN_SKY.set(nmsPacket, packet.darkenScreen);
-		nms.PacketPlayOutBoss_PLAY_MUSIC.set(nmsPacket, packet.playMusic);
-		nms.PacketPlayOutBoss_CREATE_FOG.set(nmsPacket, packet.createWorldFog);
-		return nmsPacket;
-	}
-
-	/**
-	 * Builds 1.9 bossbar packet bytebuf using viaversion
-	 * @param packet - packet to build
-	 * @param clientVersion - client version
-	 * @return bytebuf with 1.9 bossbar packet content
-	 * @throws Exception - if something fails
-	 */
-	private ByteBuf buildBossPacketVia(PacketPlayOutBoss packet, ProtocolVersion clientVersion) throws Exception {
-		if (clientVersion == ProtocolVersion.UNKNOWN) return null; //preventing disconnect if packet ID changes and users do not update
-		try {
-			ByteBuf buf = Unpooled.buffer();
-			Type.VAR_INT.writePrimitive(buf, clientVersion.getMinorVersion() == 15 ? 0x0D : 0x0C);
-			Type.UUID.write(buf, packet.id);
-			Type.VAR_INT.writePrimitive(buf, packet.operation.ordinal());
-			switch (packet.operation) {
-			case ADD:
-				Type.COMPONENT.write(buf, JsonParser.parseString(IChatBaseComponent.optimizedComponent(packet.name).toString(clientVersion)));
-				Type.FLOAT.writePrimitive(buf, packet.pct);
-				Type.VAR_INT.writePrimitive(buf, packet.color.ordinal());
-				Type.VAR_INT.writePrimitive(buf, packet.overlay.ordinal());
-				Type.BYTE.write(buf, packet.getFlags());
-				break;
-			case REMOVE:
-				break;
-			case UPDATE_PCT:
-				Type.FLOAT.writePrimitive(buf, packet.pct);
-				break;
-			case UPDATE_NAME:
-				Type.COMPONENT.write(buf, JsonParser.parseString(IChatBaseComponent.optimizedComponent(packet.name).toString(clientVersion)));
-				break;
-			case UPDATE_STYLE:
-				Type.VAR_INT.writePrimitive(buf, packet.color.ordinal());
-				Type.VAR_INT.writePrimitive(buf, packet.overlay.ordinal());
-				break;
-			case UPDATE_PROPERTIES:
-				Type.BYTE.write(buf, packet.getFlags());
-				break;
-			default:
-				break;
-			}
-			return buf;
-		} catch (Throwable t) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to create 1.9 bossbar packet using ViaVersion v" + Bukkit.getPluginManager().getPlugin("ViaVersion").getDescription().getVersion() + ". Is it the latest version?", t);
-		}
-	}
-
-	/**
-	 * Builds entity bossbar packet
-	 * @param packet - packet to build
-	 * @param clientVersion - client version
-	 * @return entity bossbar packet
-	 * @throws Exception - if something fails
-	 */
-	private Object buildBossPacketEntity(PacketPlayOutBoss packet, ProtocolVersion clientVersion) throws Exception {
-		if (packet.operation == Action.UPDATE_STYLE) return null; //nothing to do here
-
-		int entityId = Math.abs(packet.id.hashCode());
-		if (packet.operation == Action.REMOVE) {
-			return buildEntityDestroyPacket(entityId);
-		}
-		DataWatcher w = new DataWatcher();
-		if (packet.operation == Action.UPDATE_PCT || packet.operation == Action.ADD) {
-			float health = (float)300*packet.pct;
-			if (health == 0) health = 1;
-			w.helper().setHealth(health);
-		}
-		if (packet.operation == Action.UPDATE_NAME || packet.operation == Action.ADD) {
-			w.helper().setCustomName(packet.name, clientVersion);
-		}
-		if (packet.operation == Action.ADD) {
-			w.helper().setEntityFlags((byte) 32);
-			return buildEntitySpawnPacket(entityId, null, EntityType.WITHER, new Location(null, 0,0,0), w);
-		} else {
-			return buildEntityMetadataPacket(entityId, w);
-		}
-	}
-
-	@Override
-	public Object build(PacketPlayOutChat packet, ProtocolVersion clientVersion) throws Exception {
-		Object nmsPacket = nms.newPacketPlayOutChat.newInstance();
-		nms.PacketPlayOutChat_MESSAGE.set(nmsPacket, stringToComponent(packet.message.toString(clientVersion))); //using old method for chat packets due to broken item/entity deserializer
-		if (nms.minorVersion >= 12) {
-			nms.PacketPlayOutChat_POSITION.set(nmsPacket, Enum.valueOf(nms.ChatMessageType, packet.type.toString()));
-		} else if (nms.minorVersion >= 8) {
-			nms.PacketPlayOutChat_POSITION.set(nmsPacket, (byte)packet.type.ordinal());
-		}
-		if (nms.minorVersion >= 16) {
-			nms.PacketPlayOutChat_SENDER.set(nmsPacket, UUID.randomUUID());
-		}
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutPlayerInfo packet, ProtocolVersion clientVersion) throws Exception {
-		if (nms.minorVersion < 8) return null;
-		Object nmsPacket = nms.newPacketPlayOutPlayerInfo.newInstance();
-		nms.PacketPlayOutPlayerInfo_ACTION.set(nmsPacket, Enum.valueOf(nms.EnumPlayerInfoAction, packet.action.toString()));
-		List<Object> items = new ArrayList<Object>();
-		for (PlayerInfoData data : packet.entries) {
-			Object profile = nms.newGameProfile.newInstance(data.uniqueId, data.name);
-			if (data.skin != null) nms.PropertyMap_putAll.invoke(nms.GameProfile_PROPERTIES.get(profile), data.skin);
-			if (nms.newPlayerInfoData.getParameterCount() == 5) {
-				items.add(nms.newPlayerInfoData.newInstance(nms.newPacketPlayOutPlayerInfo.newInstance(), profile, data.latency, data.gameMode == null ? null : Enum.valueOf(nms.EnumGamemode, data.gameMode.toString()), 
-						data.displayName == null ? null : toNMSComponent(data.displayName, clientVersion)));
-			} else {
-				//1.8.8 paper
-				items.add(nms.newPlayerInfoData.newInstance(profile, data.latency, data.gameMode == null ? null : Enum.valueOf(nms.EnumGamemode, data.gameMode.toString()), 
-						data.displayName == null ? null : toNMSComponent(data.displayName, clientVersion)));
-			}
-		}
-		nms.PacketPlayOutPlayerInfo_PLAYERS.set(nmsPacket, items);
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutPlayerListHeaderFooter packet, ProtocolVersion clientVersion) throws Exception {
-		Object nmsPacket = nms.newPacketPlayOutPlayerListHeaderFooter.newInstance();
-		nms.PacketPlayOutPlayerListHeaderFooter_HEADER.set(nmsPacket, toNMSComponent(packet.header, clientVersion));
-		nms.PacketPlayOutPlayerListHeaderFooter_FOOTER.set(nmsPacket, toNMSComponent(packet.footer, clientVersion));
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutScoreboardDisplayObjective packet, ProtocolVersion clientVersion) throws Exception {
-		Object nmsPacket = nms.newPacketPlayOutScoreboardDisplayObjective.newInstance();
-		nms.PacketPlayOutScoreboardDisplayObjective_POSITION.set(nmsPacket, packet.slot);
-		nms.PacketPlayOutScoreboardDisplayObjective_OBJECTIVENAME.set(nmsPacket, packet.objectiveName);
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutScoreboardObjective packet, ProtocolVersion clientVersion) throws Exception {
-		String displayName = packet.displayName;
-		if (clientVersion.getMinorVersion() < 13) {
-			displayName = cutTo(displayName, 32);
-		}
-		Object nmsPacket = nms.newPacketPlayOutScoreboardObjective.newInstance();
-		nms.PacketPlayOutScoreboardObjective_OBJECTIVENAME.set(nmsPacket, packet.objectiveName);
-		if (nms.minorVersion >= 13) {
-			nms.PacketPlayOutScoreboardObjective_DISPLAYNAME.set(nmsPacket, toNMSComponent(IChatBaseComponent.optimizedComponent(displayName), clientVersion));
-		} else {
-			nms.PacketPlayOutScoreboardObjective_DISPLAYNAME.set(nmsPacket, displayName);
-		}
-		if (nms.PacketPlayOutScoreboardObjective_RENDERTYPE != null && packet.renderType != null) {
-			if (nms.minorVersion >= 8) {
-				nms.PacketPlayOutScoreboardObjective_RENDERTYPE.set(nmsPacket, Enum.valueOf(nms.EnumScoreboardHealthDisplay, packet.renderType.toString()));
-			} else {
-				nms.PacketPlayOutScoreboardObjective_RENDERTYPE.set(nmsPacket, packet.renderType.ordinal());
-			}
-		}
-		nms.PacketPlayOutScoreboardObjective_METHOD.set(nmsPacket, packet.method);
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutScoreboardScore packet, ProtocolVersion clientVersion) throws Exception {
-		if (nms.minorVersion >= 13) {
-			return nms.newPacketPlayOutScoreboardScore_1_13.newInstance(Enum.valueOf(nms.EnumScoreboardAction, packet.action.toString()), packet.objectiveName, packet.player, packet.score);
-		}
-		if (packet.action == PacketPlayOutScoreboardScore.Action.REMOVE) {
-			return nms.newPacketPlayOutScoreboardScore_String.newInstance(packet.player);
-		}
-		Object nmsPacket = nms.newPacketPlayOutScoreboardScore0.newInstance();
-		nms.PacketPlayOutScoreboardScore_PLAYER.set(nmsPacket, packet.player);
-		nms.PacketPlayOutScoreboardScore_OBJECTIVENAME.set(nmsPacket, packet.objectiveName);
-		nms.PacketPlayOutScoreboardScore_SCORE.set(nmsPacket, packet.score);
-		if (nms.minorVersion >= 8) {
-			nms.PacketPlayOutScoreboardScore_ACTION.set(nmsPacket, Enum.valueOf(nms.EnumScoreboardAction, packet.action.toString()));
-		} else {
-			nms.PacketPlayOutScoreboardScore_ACTION.set(nmsPacket, packet.action.ordinal());
-		}
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutScoreboardTeam packet, ProtocolVersion clientVersion) throws Exception {
-		String prefix = packet.playerPrefix;
-		String suffix = packet.playerSuffix;
-		if (clientVersion.getMinorVersion() < 13) {
-			prefix = cutTo(prefix, 16);
-			suffix = cutTo(suffix, 16);
-		}
-		Object nmsPacket = nms.newPacketPlayOutScoreboardTeam.newInstance();
-		nms.PacketPlayOutScoreboardTeam_NAME.set(nmsPacket, packet.name);
-		if (nms.minorVersion >= 13) {
-			nms.PacketPlayOutScoreboardTeam_DISPLAYNAME.set(nmsPacket, toNMSComponent(IChatBaseComponent.optimizedComponent(packet.name), clientVersion));
-			if (prefix != null && prefix.length() > 0) nms.PacketPlayOutScoreboardTeam_PREFIX.set(nmsPacket, toNMSComponent(IChatBaseComponent.optimizedComponent(prefix), clientVersion));
-			if (suffix != null && suffix.length() > 0) nms.PacketPlayOutScoreboardTeam_SUFFIX.set(nmsPacket, toNMSComponent(IChatBaseComponent.optimizedComponent(suffix), clientVersion));
-			EnumChatFormat format = packet.color != null ? packet.color : EnumChatFormat.lastColorsOf(prefix);
-			nms.PacketPlayOutScoreboardTeam_CHATFORMAT.set(nmsPacket, Enum.valueOf(nms.EnumChatFormat, format.toString()));
-		} else {
-			nms.PacketPlayOutScoreboardTeam_DISPLAYNAME.set(nmsPacket, packet.name);
-			nms.PacketPlayOutScoreboardTeam_PREFIX.set(nmsPacket, prefix);
-			nms.PacketPlayOutScoreboardTeam_SUFFIX.set(nmsPacket, suffix);
-		}
-		if (nms.PacketPlayOutScoreboardTeam_VISIBILITY != null) nms.PacketPlayOutScoreboardTeam_VISIBILITY.set(nmsPacket, packet.nametagVisibility);
-		if (nms.PacketPlayOutScoreboardTeam_COLLISION != null) nms.PacketPlayOutScoreboardTeam_COLLISION.set(nmsPacket, packet.collisionRule);
-		nms.PacketPlayOutScoreboardTeam_PLAYERS.set(nmsPacket, packet.players);
-		nms.PacketPlayOutScoreboardTeam_ACTION.set(nmsPacket, packet.method);
-		nms.PacketPlayOutScoreboardTeam_SIGNATURE.set(nmsPacket, packet.options);
-		return nmsPacket;
-	}
-
-	@Override
-	public Object build(PacketPlayOutTitle packet, ProtocolVersion clientVersion) throws Exception {
-		if (nms.minorVersion < 8) return null;
-		return nms.newPacketPlayOutTitle.newInstance(Enum.valueOf(nms.EnumTitleAction, packet.action.toString()), 
-				packet.text == null ? null : toNMSComponent(IChatBaseComponent.optimizedComponent(packet.text), clientVersion), packet.fadeIn, packet.stay, packet.fadeOut);
-	}
-	
-	/**
-	 * Builds entity destroy packet with given parameter
-	 * @param ids - entity ids to destroy
-	 * @return destroy packet
-	 * @throws Exception - if reflection fails
-	 */
-	public Object buildEntityDestroyPacket(int... ids) throws Exception {
-		return nms.newPacketPlayOutEntityDestroy.newInstance(ids);
-	}
-	
-	/**
-	 * Builds entity metadata packet with given parameters
-	 * @param entityId - entity id
-	 * @param dataWatcher - datawatcher
-	 * @return metadata packet
-	 * @throws Exception - if reflection fails
-	 */
-	public Object buildEntityMetadataPacket(int entityId, DataWatcher dataWatcher) throws Exception {
-		return nms.newPacketPlayOutEntityMetadata.newInstance(entityId, dataWatcher.toNMS(), true);
-	}
-	
-	/**
-	 * Builds entity spawn packet with given parameters
-	 * @param entityId - entity id
-	 * @param uuid - entity uuid
-	 * @param entityType - entity type
-	 * @param loc - location to spawn at
-	 * @param dataWatcher - datawatcher
-	 * @return entity spawn packet
-	 * @throws Exception - if reflection fails
-	 */
-	public Object buildEntitySpawnPacket(int entityId, UUID uuid, EntityType entityType, Location loc, DataWatcher dataWatcher) throws Exception {
-		Object nmsPacket = nms.newPacketPlayOutSpawnEntityLiving.newInstance();
-		nms.PacketPlayOutSpawnEntityLiving_ENTITYID.set(nmsPacket, entityId);
-		nms.PacketPlayOutSpawnEntityLiving_ENTITYTYPE.set(nmsPacket, entityIds.get(entityType));
-		nms.PacketPlayOutSpawnEntityLiving_YAW.set(nmsPacket, (byte)(loc.getYaw() * 256.0f / 360.0f));
-		nms.PacketPlayOutSpawnEntityLiving_PITCH.set(nmsPacket, (byte)(loc.getPitch() * 256.0f / 360.0f));
-		if (nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER != null) {
-			nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER.set(nmsPacket, dataWatcher.toNMS());
-		}
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-			nms.PacketPlayOutSpawnEntityLiving_UUID.set(nmsPacket, uuid);
-			nms.PacketPlayOutSpawnEntityLiving_X.set(nmsPacket, loc.getX());
-			nms.PacketPlayOutSpawnEntityLiving_Y.set(nmsPacket, loc.getY());
-			nms.PacketPlayOutSpawnEntityLiving_Z.set(nmsPacket, loc.getZ());
-		} else {
-			nms.PacketPlayOutSpawnEntityLiving_X.set(nmsPacket, floor((double)loc.getX()*32));
-			nms.PacketPlayOutSpawnEntityLiving_Y.set(nmsPacket, floor((double)loc.getY()*32));
-			nms.PacketPlayOutSpawnEntityLiving_Z.set(nmsPacket, floor((double)loc.getZ()*32));
-		}
-		return nmsPacket;
-	}
-	
-	/**
-	 * Builds entity teleport packet with given parameters
-	 * @param entityId - entity id
-	 * @param location - location to teleport to
-	 * @return entity teleport packet
-	 * @throws Exception - if reflection fails
-	 */
-	public Object buildEntityTeleportPacket(int entityId, Location location) throws Exception {
-		Object nmsPacket = nms.newPacketPlayOutEntityTeleport.newInstance();
-		nms.PacketPlayOutEntityTeleport_ENTITYID.set(nmsPacket, entityId);
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-			nms.PacketPlayOutEntityTeleport_X.set(nmsPacket, location.getX());
-			nms.PacketPlayOutEntityTeleport_Y.set(nmsPacket, location.getY());
-			nms.PacketPlayOutEntityTeleport_Z.set(nmsPacket, location.getZ());
-		} else {
-			nms.PacketPlayOutEntityTeleport_X.set(nmsPacket, floor((double)location.getX()*32));
-			nms.PacketPlayOutEntityTeleport_Y.set(nmsPacket, floor((double)location.getY()*32));
-			nms.PacketPlayOutEntityTeleport_Z.set(nmsPacket, floor((double)location.getZ()*32));
-		}
-		nms.PacketPlayOutEntityTeleport_YAW.set(nmsPacket, (byte)((float)location.getYaw()/360*256));
-		nms.PacketPlayOutEntityTeleport_PITCH.set(nmsPacket, (byte)((float)location.getPitch()/360*256));
-		return nmsPacket;
-	}
-
-	@Override
-	public PacketPlayOutPlayerInfo readPlayerInfo(Object nmsPacket, ProtocolVersion clientVersion) throws Exception {
-		if (nms.minorVersion < 8) return null;
-		EnumPlayerInfoAction action = EnumPlayerInfoAction.valueOf(nms.PacketPlayOutPlayerInfo_ACTION.get(nmsPacket).toString());
-		List<PlayerInfoData> listData = new ArrayList<PlayerInfoData>();
-		for (Object nmsData : (List<?>) nms.PacketPlayOutPlayerInfo_PLAYERS.get(nmsPacket)) {
-			Object nmsGamemode = nms.PlayerInfoData_GAMEMODE.get(nmsData);
-			EnumGamemode gamemode = nmsGamemode == null ? null : EnumGamemode.valueOf(nmsGamemode.toString());
-			Object profile = nms.PlayerInfoData_PROFILE.get(nmsData);
-			Object nmsComponent = nms.PlayerInfoData_LISTNAME.get(nmsData);
-			IChatBaseComponent listName = fromNMSComponent(nmsComponent);
-			listData.add(new PlayerInfoData((String) nms.GameProfile_NAME.get(profile), (UUID) nms.GameProfile_ID.get(profile), nms.GameProfile_PROPERTIES.get(profile), nms.PlayerInfoData_PING.getInt(nmsData), gamemode, listName));
-		}
-		return new PacketPlayOutPlayerInfo(action, listData);
-	}
-
-	@Override
-	public PacketPlayOutScoreboardObjective readObjective(Object nmsPacket, ProtocolVersion clientVersion) throws Exception {
-		String objective = (String) nms.PacketPlayOutScoreboardObjective_OBJECTIVENAME.get(nmsPacket);
-		String displayName;
-		if (nms.minorVersion >= 13) {
-			Object component = nms.PacketPlayOutScoreboardObjective_DISPLAYNAME.get(nmsPacket);
-			displayName = component == null ? null : fromNMSComponent(component).toLegacyText();
-		} else {
-			displayName = (String) nms.PacketPlayOutScoreboardObjective_DISPLAYNAME.get(nmsPacket);
-		}
-		EnumScoreboardHealthDisplay renderType = null;
-		if (nms.PacketPlayOutScoreboardObjective_RENDERTYPE != null) {
-			Object nmsRender = nms.PacketPlayOutScoreboardObjective_RENDERTYPE.get(nmsPacket);
-			if (nmsRender != null) {
-				if (nms.minorVersion >= 8) {
-					renderType = EnumScoreboardHealthDisplay.valueOf(nmsRender.toString());
-				} else {
-					renderType = EnumScoreboardHealthDisplay.values()[(int)nmsRender];
-				}
-			}
-		}
-		int method = nms.PacketPlayOutScoreboardObjective_METHOD.getInt(nmsPacket);
-		return new PacketPlayOutScoreboardObjective(method, objective, displayName, renderType);
-	}
-
-	@Override
-	public PacketPlayOutScoreboardDisplayObjective readDisplayObjective(Object nmsPacket, ProtocolVersion clientVersion) throws Exception {
-		return new PacketPlayOutScoreboardDisplayObjective(
-			nms.PacketPlayOutScoreboardDisplayObjective_POSITION.getInt(nmsPacket),
-			(String) nms.PacketPlayOutScoreboardDisplayObjective_OBJECTIVENAME.get(nmsPacket)
-		);
-	}
-	
-	/**
-	 * A method yoinked from minecraft code used to convert double to int
-	 * @param paramDouble double value
-	 * @return int value
-	 */
-	private int floor(double paramDouble){
-		int i = (int)paramDouble;
-		return paramDouble < i ? i - 1 : i;
-	}
-	
-	/**
-	 * Converts json string into a component
-	 * @param json json as string
-	 * @return NMS component
-	 * @throws Exception if something fails
-	 */
-	public Object stringToComponent(String json) throws Exception {
-		if (json == null) return null;
-		return nms.ChatSerializer_DESERIALIZE.invoke(null, json);
-	}
-	
-	/**
-	 * Converts minecraft IChatBaseComponent into TAB's component class. Currently does not support hover event.
-	 * @param component - component to convert
-	 * @return converted component
-	 * @throws Exception if something fails
-	 */
-	public IChatBaseComponent fromNMSComponent(Object component) throws Exception {
-		if (component == null) return null;
-		long time = System.nanoTime();
-		IChatBaseComponent chat = new IChatBaseComponent((String) nms.ChatComponentText_text.get(component));
-		Object modifier = nms.ChatBaseComponent_modifier.get(component);
-		if (modifier != null) {
-			Object color = nms.ChatModifier_color.get(modifier);
-			if (color != null) {
-				String name = (String) nms.ChatHexColor_name.get(color);
-				if (name != null) {
-					//legacy code
-					chat.setColor(new TextColor(EnumChatFormat.valueOf(name.toUpperCase())));
-				} else {
-					chat.setColor(new TextColor((int) nms.ChatHexColor_rgb.get(color)));
-				}
-			}
-			chat.setBold((Boolean) nms.ChatModifier_bold.get(modifier));
-			chat.setItalic((Boolean) nms.ChatModifier_italic.get(modifier));
-			chat.setObfuscated((Boolean) nms.ChatModifier_obfuscated.get(modifier));
-			chat.setStrikethrough((Boolean) nms.ChatModifier_strikethrough.get(modifier));
-			chat.setUnderlined((Boolean) nms.ChatModifier_underlined.get(modifier));
-			Object clickEvent = nms.ChatModifier_clickEvent.get(modifier);
-			if (clickEvent != null) {
-				chat.onClick(ClickAction.valueOf(nms.ChatClickable_action.get(clickEvent).toString().toUpperCase()), (String) nms.ChatClickable_value.get(clickEvent));
-			}
-	/*		Object hoverEvent = nms.ChatModifier_hoverEvent.get(modifier);
-			if (hoverEvent != null) {
-				chat.onHover(HoverAction.fromString(nms.ChatHoverable_action.get(hoverEvent).toString()), fromNMSComponent(nms.ChatHoverable_value.get(hoverEvent)));
-			}*/
-		}
-		for (Object extra : (List<Object>) nms.ChatBaseComponent_extra.get(component)) {
-			chat.addExtra(fromNMSComponent(extra));
-		}
-		TAB.getInstance().getCPUManager().addMethodTime("fromNMSComponent", System.nanoTime()-time);
-		return chat;
-	}
-	
-	/**
-	 * Converts TAB's IChatBaseComponent into minecraft's component. Currently does not support hover event.
-	 * @param component - component to convert
-	 * @param clientVersion - client version used to decide RGB conversion
-	 * @return converted component
-	 * @throws Exception if something fails
-	 */
-	public Object toNMSComponent(IChatBaseComponent component, ProtocolVersion clientVersion) throws Exception {
-		long time = System.nanoTime();
-		Object obj = toNMSComponent0(component, clientVersion);
-		TAB.getInstance().getCPUManager().addMethodTime("toNMSComponent", System.nanoTime()-time);
-		return obj;
-	}
-	
-	//separate method to prevent extras counting cpu again due to recursion and finally showing higher usage than real
-	private Object toNMSComponent0(IChatBaseComponent component, ProtocolVersion clientVersion) throws Exception {
-		if (component == null) return null;
-		Object chat = nms.newChatComponentText.newInstance(component.getText());
-		Object modifier;
-		if (nms.minorVersion >= 16) {
-			Object color = null;
-			if (component.getColor() != null) {
-				if (clientVersion.getMinorVersion() >= 16) {
-					color = nms.ChatHexColor_ofInt.invoke(null, (component.getColor().getRed() << 16) + (component.getColor().getGreen() << 8) + component.getColor().getBlue());
-				} else {
-					color = nms.ChatHexColor_ofString.invoke(null, component.getColor().getLegacyColor().toString().toLowerCase());
-				}
-			}
-			modifier = nms.newChatModifier.newInstance(
-					color,
-					component.isBold() ? true : null,
-					component.isItalic() ? true : null,
-					component.isUnderlined() ? true : null,
-					component.isStrikethrough() ? true : null,
-					component.isObfuscated() ? true : null,
-					component.getClickAction() == null ? null : nms.newChatClickable.newInstance(nms.EnumClickAction_a.invoke(null, component.getClickAction().toString().toLowerCase()), component.getClickValue().toString()), 
-					null, //component.getHoverAction() == null ? null : nms.newChatHoverable.newInstance(nms.EnumHoverAction_a.invoke(null, component.getHoverAction().toString().toLowerCase()), stringToComponent(component.getHoverValue().toString())), 
-					null, null
-			);
-		} else {
-			modifier = nms.newChatModifier.newInstance();
-			if (component.getClickAction() != null){
-				nms.ChatModifier_clickEvent.set(modifier, nms.newChatClickable.newInstance(nms.EnumClickAction_a.invoke(null, component.getClickAction().toString().toLowerCase()), component.getClickValue().toString()));
-			}
-/*			if (component.getHoverAction() != null) {
-				nms.ChatModifier_hoverEvent.set(modifier, nms.newChatHoverable.newInstance(nms.EnumHoverAction_a.invoke(null, (component.getHoverAction().toString().toLowerCase())), stringToComponent(component.getHoverValue().toString())));
-			}*/
-			if (component.getColor() != null) nms.ChatModifier_color.set(modifier, Enum.valueOf(nms.EnumChatFormat, component.getColor().getLegacyColor().toString()));
-			if (component.isBold()) nms.ChatModifier_bold.set(modifier, true);
-			if (component.isItalic()) nms.ChatModifier_italic.set(modifier, true);
-			if (component.isUnderlined()) nms.ChatModifier_underlined.set(modifier, true);
-			if (component.isStrikethrough()) nms.ChatModifier_strikethrough.set(modifier, true);
-			if (component.isObfuscated()) nms.ChatModifier_obfuscated.set(modifier, true);
-		}
-		nms.ChatBaseComponent_modifier.set(chat, modifier);
-		for (IChatBaseComponent extra : component.getExtra()) {
-			nms.ChatComponentText_addSibling.invoke(chat, toNMSComponent0(extra, clientVersion));
-		}
-		return chat;
-	}
-}
@@ -1,139 +1,153 @@
 package me.neznamy.tab.platforms.bukkit;

-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.NoSuchElementException;
-
-import io.netty.channel.ChannelDuplexHandler;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPromise;
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import com.mojang.authlib.GameProfile;
+import io.netty.channel.Channel;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.features.nametags.NameTag;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
 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.injection.NettyPipelineInjector;
+import me.neznamy.tab.shared.features.sorting.Sorting;
+import org.jetbrains.annotations.NotNull;

-public class BukkitPipelineInjector extends PipelineInjector {
+import java.util.*;
+import java.util.stream.Collectors;

-	//handler to inject before
-	private final String INJECT_POSITION = "packet_handler";
-	
-	//nms storage
-	private NMSStorage nms;
+/**
+ * Pipeline injection for bukkit
+ */
+public class BukkitPipelineInjector extends NettyPipelineInjector {

-	/**
-	 * 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
-		}
-	}
+    @Override
+    protected Channel getChannel(@NotNull TabPlayer player) {
+        BukkitTabPlayer bukkit = (BukkitTabPlayer) player;
+        NMSStorage nms = NMSStorage.getInstance();
+        try {
+            if (nms.CHANNEL != null) return (Channel) nms.CHANNEL.get(nms.NETWORK_MANAGER.get(bukkit.getPlayerConnection()));
+        } catch (IllegalAccessException exception) {
+            TAB.getInstance().getErrorManager().printError("Failed to get channel of " + bukkit.getName(), exception);
+        }
+        return null;
+    }

-	/**
-	 * Removes all real players from team if packet does not come from TAB and reports this to override log
-	 * @param packetPlayOutScoreboardTeam - team packet
-	 * @throws Exception - if reflection fails
-	 */
-	@SuppressWarnings("unchecked")
-	private void modifyPlayers(Object packetPlayOutScoreboardTeam) throws Exception {
-		long time = System.nanoTime();
-		if (nms.PacketPlayOutScoreboardTeam_SIGNATURE.getInt(packetPlayOutScoreboardTeam) != 69) {
-			Collection<String> players = (Collection<String>) nms.PacketPlayOutScoreboardTeam_PLAYERS.get(packetPlayOutScoreboardTeam);
-			//creating a new list to prevent NoSuchFieldException in minecraft packet encoder when a player is removed
-			Collection<String> newList = new ArrayList<String>();
-			for (String entry : players) {
-				TabPlayer p = tab.getPlayer(entry);
-				if (p == null) {
-					newList.add(entry);
-					continue;
-				}
-				if (tab.getFeatureManager().getNameTagFeature().isDisabledWorld(p.getWorldName())) {
-					newList.add(entry);
-				} else {
-					logTeamOverride((String) nms.PacketPlayOutScoreboardTeam_NAME.get(packetPlayOutScoreboardTeam), entry);
-				}
-			}
-			nms.PacketPlayOutScoreboardTeam_PLAYERS.set(packetPlayOutScoreboardTeam, newList);
-		}
-		tab.getCPUManager().addTime(TabFeature.NAMETAGS, UsageType.ANTI_OVERRIDE, System.nanoTime()-time);
-	}
-	
-	/**
-	 * 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
+    @SneakyThrows
+    public void onDisplayObjective(@NotNull TabPlayer player, @NotNull Object packet) {
+        TAB.getInstance().getFeatureManager().onDisplayObjective(player,
+                PacketScoreboard.DisplayObjective_POSITION.getInt(packet),
+                (String) PacketScoreboard.DisplayObjective_OBJECTIVE_NAME.get(packet));
+    }

-		@Override
-		public void channelRead(ChannelHandlerContext context, Object packet) throws Exception {
-			try {
-				Object modifiedPacket = tab.getFeatureManager().onPacketReceive(player, packet);
-				if (modifiedPacket != null) super.channelRead(context, modifiedPacket);
-			} catch (Throwable e){
-				tab.getErrorManager().printError("An error occurred when reading packets", e);
-			}
-		}
+    @Override
+    @SneakyThrows
+    public void onObjective(@NotNull TabPlayer player, @NotNull Object packet) {
+        TAB.getInstance().getFeatureManager().onObjective(player,
+                PacketScoreboard.Objective_METHOD.getInt(packet),
+                (String) PacketScoreboard.Objective_OBJECTIVE_NAME.get(packet));
+    }

-		@Override
-		public void write(ChannelHandlerContext context, Object packet, ChannelPromise channelPromise) throws Exception {
-			try {
-				if (nms.PacketPlayOutPlayerInfo.isInstance(packet)) {
-					super.write(context, tab.getFeatureManager().onPacketPlayOutPlayerInfo(player, packet), channelPromise);
-					return;
-				}
-				if (tab.getFeatureManager().getNameTagFeature() != null && antiOverrideTeams && nms.PacketPlayOutScoreboardTeam.isInstance(packet)) {
-					modifyPlayers(packet);
-					super.write(context, packet, channelPromise);
-					return;
-				}
-				if (nms.PacketPlayOutScoreboardDisplayObjective.isInstance(packet) && antiOverrideObjectives && tab.getFeatureManager().onDisplayObjective(player, packet)) {
-					return;
-				}
-				if (antiOverrideObjectives && nms.PacketPlayOutScoreboardObjective.isInstance(packet)) {
-					tab.getFeatureManager().onObjective(player, packet);
-				}
-				tab.getFeatureManager().onPacketSend(player, packet);
-			} catch (Throwable e){
-				tab.getErrorManager().printError("An error occurred when reading packets", e);
-			}
-			super.write(context, packet, channelPromise);
-		}
-	}
+    @Override
+    public boolean isDisplayObjective(@NotNull Object packet) {
+        return PacketScoreboard.DisplayObjectiveClass.isInstance(packet);
+    }
+
+    @Override
+    public boolean isObjective(@NotNull Object packet) {
+        return PacketScoreboard.ObjectivePacketClass.isInstance(packet);
+    }
+
+    @Override
+    public boolean isTeam(@NotNull Object packet) {
+        return PacketScoreboard.TeamPacketClass.isInstance(packet);
+    }
+
+    @Override
+    public boolean isPlayerInfo(@NotNull Object packet) {
+        return BukkitTabList.PacketPlayOutPlayerInfoClass.isInstance(packet);
+    }
+
+    @Override
+    @SneakyThrows
+    public void onPlayerInfo(@NotNull TabPlayer receiver, @NotNull Object packet) {
+        NMSStorage nms = NMSStorage.getInstance();
+        List<String> actions;
+        if (BukkitTabList.ClientboundPlayerInfoRemovePacket != null) {
+            //1.19.3+
+            actions = ((EnumSet<?>)BukkitTabList.ACTION.get(packet)).stream().map(Enum::name).collect(Collectors.toList());
+        } else {
+            //1.19.2-
+            actions = Collections.singletonList(BukkitTabList.ACTION.get(packet).toString());
+        }
+        List<Object> updatedList = new ArrayList<>();
+        for (Object nmsData : (List<?>) BukkitTabList.PLAYERS.get(packet)) {
+            GameProfile profile = (GameProfile) BukkitTabList.PlayerInfoData_getProfile.invoke(nmsData);
+            Object displayName = null;
+            if (actions.contains(TabList.Action.UPDATE_DISPLAY_NAME.name()) || actions.contains(TabList.Action.ADD_PLAYER.name())) {
+                displayName = BukkitTabList.PlayerInfoData_DisplayName.get(nmsData);
+                IChatBaseComponent newDisplayName = TAB.getInstance().getFeatureManager().onDisplayNameChange(receiver, profile.getId());
+                if (newDisplayName != null) displayName = nms.toNMSComponent(newDisplayName, receiver.getVersion());
+                if (!nms.is1_19_3Plus()) BukkitTabList.PlayerInfoData_DisplayName.set(nmsData, displayName);
+            }
+            if (nms.is1_19_3Plus()) {
+                // 1.19.3 is using records, which do not allow changing final fields, need to rewrite the list entirely
+                updatedList.add(BukkitTabList.newPlayerInfoData.newInstance(
+                        profile.getId(),
+                        profile,
+                        BukkitTabList.PlayerInfoData_Listed.getBoolean(nmsData),
+                        BukkitTabList.PlayerInfoData_Latency.getInt(nmsData),
+                        BukkitTabList.PlayerInfoData_GameMode.get(nmsData),
+                        displayName,
+                        BukkitTabList.PlayerInfoData_RemoteChatSession.get(nmsData)));
+            }
+        }
+        if (nms.is1_19_3Plus()) {
+            BukkitTabList.PLAYERS.set(packet, updatedList);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    @SneakyThrows
+    public void modifyPlayers(@NotNull Object packetPlayOutScoreboardTeam) {
+        if (TAB.getInstance().getNameTagManager() == null) return;
+        int action = PacketScoreboard.TeamPacket_ACTION.getInt(packetPlayOutScoreboardTeam);
+        if (action == 1 || action == 2 || action == 4) return;
+        Collection<String> players = (Collection<String>) PacketScoreboard.TeamPacket_PLAYERS.get(packetPlayOutScoreboardTeam);
+        String teamName = (String) PacketScoreboard.TeamPacket_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.getInstance().getPlayer(entry);
+            if (p == null) {
+                newList.add(entry);
+                continue;
+            }
+            Sorting sorting = TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.SORTING);
+            String expectedTeam = sorting.getShortTeamName(p);
+            if (expectedTeam == null) {
+                newList.add(entry);
+                continue;
+            }
+            if (!((NameTag)TAB.getInstance().getNameTagManager()).getDisableChecker().isDisabledPlayer(p) &&
+                    !TAB.getInstance().getNameTagManager().hasTeamHandlingPaused(p) && !teamName.equals(expectedTeam)) {
+                logTeamOverride(teamName, p.getName(), expectedTeam);
+            } else {
+                newList.add(entry);
+            }
+        }
+        PacketScoreboard.TeamPacket_PLAYERS.set(packetPlayOutScoreboardTeam, newList);
+    }
 }
@@ -1,308 +1,82 @@
 package me.neznamy.tab.platforms.bukkit;

+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.shared.placeholders.UniversalPlaceholderRegistry;
+import net.milkbowl.vault.chat.Chat;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.jetbrains.annotations.NotNull;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.text.DecimalFormat;
-import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Statistic;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import me.neznamy.tab.api.TabPlayer;
-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;

 /**
- * 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));
+    private Chat chat;

-	//plugin instance
-	private JavaPlugin plugin;
+    /** NMS server to get TPS from on spigot */
+    private Object server;

-	//vault economy
-	private Economy economy;
+    /** TPS field*/
+    private Field recentTps;

-	//vault chat
-	private Chat chat;
+    /** Detection for presence of Paper's TPS getter */
+    private Method paperTps;

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

-	//essentials methods
-	private Method getUser;
-	private Method getNickname;
+    /**
+     * Constructs new instance and loads hooks
+     */
+    public BukkitPlaceholderRegistry() {
+        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) {}
+        if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
+            RegisteredServiceProvider<Chat> rspChat = Bukkit.getServicesManager().getRegistration(Chat.class);
+            if (rspChat != null) chat = rspChat.getProvider();
+        }
+    }

-	/**
-	 * Constructs new instance with given parameter
-	 * @param plugin - plugin instance
-	 */
-	public BukkitPlaceholderRegistry(JavaPlugin plugin) {
-		decimal2.applyPattern("#.##");
-		this.plugin = plugin;
-		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 (Bukkit.getPluginManager().isPluginEnabled("Essentials")) {
-			try {
-				getUser = Class.forName("com.earth2me.essentials.Essentials").getMethod("getUser", Player.class);
-				getNickname = Class.forName("com.earth2me.essentials.User").getMethod("getNickname");
-			} catch (Exception e) {
-				TAB.getInstance().getErrorManager().printError("Failed to load essentials methods", e);
-			}
-		}
-	}
-
-	@Override
-	public List<Placeholder> registerPlaceholders() {
-		placeholders = new ArrayList<Placeholder>();
-		placeholders.add(new PlayerPlaceholder("%money%", 1000) {
-			public String get(TabPlayer p) {
-				if (economy != null) return decimal2.format(economy.getBalance((Player) p.getPlayer()));
-				return "-";
-			}
-		});
-
-		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 PlayerPlaceholder("%health%", 100) {
-			public String get(TabPlayer p) {
-				return String.valueOf((int) Math.ceil(((Player) p.getPlayer()).getHealth()));
-			}
-		});
-		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 (Throwable t) {
-					return "-1";
-				}
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%canseeonline%", 2000) {
-			public String get(TabPlayer p) {
-				int var = 0;
-				for (TabPlayer all : TAB.getInstance().getPlayers()){
-					if (((Player) p.getPlayer()).canSee((Player) all.getPlayer())) var++;
-				}
-				return String.valueOf(var);
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%canseestaffonline%", 2000) {
-			public String get(TabPlayer p) {
-				int var = 0;
-				for (TabPlayer all : TAB.getInstance().getPlayers()){
-					if (all.isStaff() && ((Player) p.getPlayer()).canSee((Player) all.getPlayer())) var++;
-				}
-				return String.valueOf(var);
-			}
-		});
-		registerAFKPlaceholder();
-		registerVaultPlaceholders();
-		registerPositionPlaceholders();
-		registerEssentialsPlaceholders();
-		registerSyncPlaceholders();
-		return placeholders;
-	}
-
-	/**
-	 * Registers AFK placeholder
-	 */
-	private void registerAFKPlaceholder() {
-		String noAfk = TAB.getInstance().getConfiguration().config.getString("placeholders.afk-no", "");
-		String yesAfk = TAB.getInstance().getConfiguration().config.getString("placeholders.afk-yes", " &4*&4&lAFK&4*&r");
-		placeholders.add(new PlayerPlaceholder("%afk%", 500) {
-			public String get(TabPlayer p) {
-				boolean afk = false;
-				try {
-					if (Bukkit.getPluginManager().isPluginEnabled("Essentials")) {
-						Object user = Bukkit.getPluginManager().getPlugin("Essentials").getClass().getMethod("getUser", Player.class).invoke(Bukkit.getPluginManager().getPlugin("Essentials"), p.getPlayer());
-						afk = (boolean) user.getClass().getMethod("isAfk").invoke(user);
-					}
-					if (Bukkit.getPluginManager().isPluginEnabled("AFKPlus")) {
-						Object AFKPlus = Bukkit.getPluginManager().getPlugin("AFKPlus");
-						Object AFKPlusPlayer = AFKPlus.getClass().getMethod("getPlayer", UUID.class).invoke(AFKPlus, p.getUniqueId());
-						afk = (boolean) AFKPlusPlayer.getClass().getMethod("isAFK").invoke(AFKPlusPlayer);
-					}
-					if (Bukkit.getPluginManager().isPluginEnabled("AntiAFKPlus")) {
-						Object api = Class.forName("de.kinglol12345.AntiAFKPlus.api.AntiAFKPlusAPI").getDeclaredMethod("getAPI").invoke(null);
-						afk = (boolean) api.getClass().getMethod("isAFK", Player.class).invoke(api, p.getPlayer());
-					}
-					if (Bukkit.getPluginManager().isPluginEnabled("xAntiAFK")) {
-						afk = (boolean) Class.forName("ch.soolz.xantiafk.xAntiAFKAPI").getMethod("isAfk", Player.class).invoke(null, p.getPlayer());
-					}
-					if (Bukkit.getPluginManager().isPluginEnabled("AutoAFK")) {
-						Object plugin = Bukkit.getPluginManager().getPlugin("AutoAFK");
-						Field f = plugin.getClass().getDeclaredField("afkList");
-						f.setAccessible(true);
-						HashMap<?, ?> map = (HashMap<?, ?>) f.get(plugin);
-						afk = map.containsKey(p.getPlayer());
-					}
-				} catch (Throwable t) {
-					return TAB.getInstance().getErrorManager().printError("", "Failed to check AFK status of " + p.getName(), t);
-				}
-				return afk ? yesAfk : noAfk;
-			}
-			@Override
-			public String[] getNestedStrings(){
-				return new String[] {yesAfk, noAfk};
-			}
-		});
-	}
-
-	/**
-	 * 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) {
-					try {
-						String prefix = chat.getPlayerPrefix((Player) p.getPlayer());
-						return prefix != null ? prefix : "";
-					} catch (Exception e) {
-						return TAB.getInstance().getErrorManager().printError("", "Placeholder %vault-prefix% threw an exception", e);
-					}
-				}
-			});
-			placeholders.add(new PlayerPlaceholder("%vault-suffix%", 500) {
-
-				public String get(TabPlayer p) {
-					try {
-						String suffix = chat.getPlayerSuffix((Player) p.getPlayer());
-						return suffix != null ? suffix : "";
-					} catch (Exception e) {
-						return TAB.getInstance().getErrorManager().printError("", "Placeholder %vault-suffix% threw an exception", e);
-					}
-				}
-			});
-		} 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 (Bukkit.getPluginManager().isPluginEnabled("Essentials")) {
-			placeholders.add(new PlayerPlaceholder("%essentialsnick%", 1000) {
-				public String get(TabPlayer p) {
-					String name = null;
-					try {
-						name = (String) getNickname.invoke(getUser.invoke(Bukkit.getPluginManager().getPlugin("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().essentialsNickPrefix + 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.allUsedPlaceholderIdentifiers) {
-			if (identifier.startsWith("%sync:")) {
-				int refresh;
-				if (pl.serverPlaceholderRefreshIntervals.containsKey(identifier)) {
-					refresh = pl.serverPlaceholderRefreshIntervals.get(identifier);
-				} else if (pl.playerPlaceholderRefreshIntervals.containsKey(identifier)) {
-					refresh = pl.playerPlaceholderRefreshIntervals.get(identifier);
-				} else {
-					refresh = pl.defaultRefresh;
-				}
-				placeholders.add(new PlayerPlaceholder(identifier, refresh) {
-
-					@Override
-					public String get(TabPlayer p) {
-						Bukkit.getScheduler().runTask(plugin, new Runnable() {
-
-							@Override
-							public void run() {
-								long time = System.nanoTime();
-								String syncedPlaceholder = identifier.substring(6, identifier.length()-1);
-								String value = ((BukkitPlatform) TAB.getInstance().getPlatform()).setPlaceholders((Player) p.getPlayer(), "%" + syncedPlaceholder + "%");
-								lastValue.put(p.getName(), value);
-								if (!forceUpdate.contains(p.getName())) forceUpdate.add(p.getName());
-								TAB.getInstance().getCPUManager().addPlaceholderTime(getIdentifier(), System.nanoTime()-time);
-							}
-						});
-						return getLastValue(p);
-					}
-				});
-			}
-		}
-	}
-}
+    @SuppressWarnings("deprecation")
+    @Override
+    public void registerPlaceholders(@NotNull 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, () -> format(Bukkit.getAverageTickTime()));
+        }
+        manager.registerPlayerPlaceholder(TabConstants.Placeholder.HEALTH, 100, p -> (int) Math.ceil(((Player) p.getPlayer()).getHealth()));
+        if (chat != null) {
+            manager.registerPlayerPlaceholder("%vault-prefix%", 1000, p -> chat.getPlayerPrefix((Player) p.getPlayer()));
+            manager.registerPlayerPlaceholder("%vault-suffix%", 1000, p -> chat.getPlayerSuffix((Player) p.getPlayer()));
+        } else {
+            manager.registerServerPlaceholder("%vault-prefix%", -1, () -> "");
+            manager.registerServerPlaceholder("%vault-suffix%", -1, () -> "");
+        }
+        super.registerPlaceholders(manager);
+    }
+}
@@ -1,340 +0,0 @@
-package me.neznamy.tab.platforms.bukkit;
-
-import java.io.File;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import me.clip.placeholderapi.PlaceholderAPI;
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.api.event.BukkitTABLoadEvent;
-import me.neznamy.tab.platforms.bukkit.features.BossBar_legacy;
-import me.neznamy.tab.platforms.bukkit.features.ExpansionDownloader;
-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.permission.Vault;
-import me.neznamy.tab.shared.Platform;
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.config.ConfigurationFile;
-import me.neznamy.tab.shared.features.NameTag;
-import me.neznamy.tab.shared.features.PlaceholderManager;
-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 net.milkbowl.vault.permission.Permission;
-
-/**
- * Bukkit implementation of Platform
- */
-public class BukkitPlatform implements Platform {
-
-	//list of used expansions
-	private Set<String> usedExpansions;
-	
-	//plugin instance
-	private JavaPlugin plugin;
-	
-	//nms storage
-	private NMSStorage nms;
-	
-	//booleans to check plugin presence
-	public boolean placeholderAPI;
-	public boolean viaversion;
-	public boolean idisguise;
-	public boolean libsdisguises;
-
-	/**
-	 * 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;
-	}
-
-	@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();
-		}
-	}
-
-	@Override
-	public void loadFeatures() throws Exception {
-		placeholderAPI = Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI");
-		viaversion = Bukkit.getPluginManager().isPluginEnabled("ViaVersion");
-		idisguise = Bukkit.getPluginManager().isPluginEnabled("iDisguise");
-		libsdisguises = Bukkit.getPluginManager().isPluginEnabled("LibsDisguises");
-		int version = ProtocolVersion.SERVER_VERSION.getMinorVersion();
-		TAB tab = TAB.getInstance();
-		usedExpansions = new HashSet<String>();
-		tab.getPlaceholderManager().addRegistry(new BukkitPlaceholderRegistry(plugin));
-		tab.getPlaceholderManager().addRegistry(new UniversalPlaceholderRegistry());
-		tab.getPlaceholderManager().registerPlaceholders();
-		if (version >= 8) {
-			tab.getFeatureManager().registerFeature("injection", new BukkitPipelineInjector(tab, nms));
-		}
-		loadNametagFeature(tab);
-		loadUniversalFeatures();
-		if (tab.getConfiguration().BossBarEnabled && version < 9) tab.getFeatureManager().registerFeature("bossbar1.8", new BossBar_legacy(tab));
-		if (version >= 9 && tab.getConfiguration().config.getBoolean("fix-pet-names", false)) tab.getFeatureManager().registerFeature("petfix", new PetFix(nms));
-		if (tab.getConfiguration().config.getBoolean("per-world-playerlist.enabled", false)) tab.getFeatureManager().registerFeature("pwp", new PerWorldPlayerlist(plugin, tab));
-		if (placeholderAPI) {
-			new TabExpansion(plugin);
-			new ExpansionDownloader(plugin).download(usedExpansions);
-		}
-
-		for (Player p : getOnlinePlayers()) {
-			tab.addPlayer(new BukkitTabPlayer(p));
-		}
-	}
-	
-	/**
-	 * Loads nametag feature from config
-	 * @param tab - tab instance
-	 */
-	private void loadNametagFeature(TAB tab) {
-		if (tab.getConfiguration().config.getBoolean("change-nametag-prefix-suffix", true)) {
-			if (tab.getConfiguration().config.getBoolean("unlimited-nametag-prefix-suffix-mode.enabled", false) && ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 8) {
-				tab.getFeatureManager().registerFeature("nametagx", new NameTagX(plugin, nms, tab));
-			} else {
-				tab.getFeatureManager().registerFeature("nametag16", new NameTag(tab));
-			}
-		}
-	}
-
-	/**
-	 * Returns list of online players from Bukkit API
-	 * @return list of online players from Bukkit API
-	 * @throws Exception - if reflection fails
-	 */
-	@SuppressWarnings("unchecked")
-	private Player[] getOnlinePlayers() throws Exception {
-		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]); 
-		}
-	}
-
-	@Override
-	public void sendConsoleMessage(String message, boolean translateColors) {
-		Bukkit.getConsoleSender().sendMessage(translateColors ? message.replace('&', '\u00a7') : message);
-	}
-
-	@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 plugin = identifier.split("_")[0].substring(1).toLowerCase();
-				if (plugin.equals("some")) return;
-				usedExpansions.add(plugin);
-				if (pl.serverPlaceholderRefreshIntervals.containsKey(identifier)) {
-					registerServerPlaceholder(identifier, pl.serverPlaceholderRefreshIntervals.get(identifier));
-					return;
-				}
-				if (pl.playerPlaceholderRefreshIntervals.containsKey(identifier)) {
-					registerPlayerPlaceholder(identifier, pl.playerPlaceholderRefreshIntervals.get(identifier));
-					return;
-				}
-				registerPlayerPlaceholder(identifier, pl.defaultRefresh);
-			}
-		}
-	}
-	
-	/**
-	 * Registers server placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerServerPlaceholder(String identifier, int refresh) {
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new ServerPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)){
-			
-			@Override
-			public String get() {
-				return setPlaceholders(null, identifier);
-			}
-		});
-	}
-	
-	/**
-	 * Registers player placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerPlayerPlaceholder(String identifier, int refresh) {
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new PlayerPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)) {
-
-			@Override
-			public String get(TabPlayer p) {
-				return 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 String get(TabPlayer viewer, TabPlayer target) {
-				if (!placeholderAPI) return identifier;
-				try {
-					return PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier);
-				} catch (Throwable t) {
-					TAB.getInstance().getErrorManager().printError("PlaceholderAPI v" + Bukkit.getPluginManager().getPlugin("PlaceholderAPI").getDescription().getVersion() + " generated an error when setting relational placeholder " + identifier + " for viewer " + viewer.getName() + " and target " + target.getName(), t, false, TAB.getInstance().getErrorManager().papiErrorLog);
-				}
-				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) return placeholder;
-		try {
-			return PlaceholderAPI.setPlaceholders(player, placeholder);
-		} catch (Throwable t) {
-			String playername = (player == null ? "<null>" : player.getName());
-			TAB.getInstance().getErrorManager().printError("PlaceholderAPI v" + Bukkit.getPluginManager().getPlugin("PlaceholderAPI").getDescription().getVersion() + " generated an error when setting placeholder " + placeholder + " for player " + playername, t, false, TAB.getInstance().getErrorManager().papiErrorLog);
-			return "ERROR";
-		}
-	}
-
-	@Override
-	public void convertConfig(ConfigurationFile config) {
-		convertUniversalOptions(config);
-		if (config.getName().equals("config.yml")) {
-			removeOld(config, "nametag-refresh-interval-ticks");
-			removeOld(config, "tablist-refresh-interval-ticks");
-			removeOld(config, "header-footer-refresh-interval-ticks");
-			removeOld(config, "belowname.refresh-interval-ticks");
-			removeOld(config, "placeholders.deluxetag-yes");
-			removeOld(config, "placeholders.deluxetag-no");
-			removeOld(config, "placeholders.faction-yes");
-			removeOld(config, "placeholders.faction-no");
-			removeOld(config, "staff-groups");
-			removeOld(config, "use-essentials-nickname");
-			removeOld(config, "deluxetag-empty-value");
-			removeOld(config, "factions-faction");
-			removeOld(config, "factions-nofaction");
-			removeOld(config, "date-format");
-			removeOld(config, "time-format");
-			removeOld(config, "relational-placeholders-refresh");
-			removeOld(config, "bukkit-bridge-mode");
-			if (config.hasConfigOption("tablist-objective")) {
-				String type = config.getString("tablist-objective");
-				String value;
-				if (type.equals("NONE")) {
-					value = "";
-				} else if (type.equals("PING")){
-					value = "%ping%";
-				} else if (type.equals("HEARTS")) {
-					value = "%health%";
-				} else {
-					value = config.getString("tablist-objective-custom-value");
-				}
-				config.set("tablist-objective", null);
-				config.set("tablist-objective-custom-value", null);
-				config.set("yellow-number-in-tablist", value);
-				TAB.getInstance().print('2', "Converted old tablist-objective config option to new yellow-number-in-tablist");
-			}
-			if (config.getObject("per-world-playerlist") instanceof Boolean) {
-				rename(config, "per-world-playerlist", "per-world-playerlist.enabled");
-				rename(config, "allow-pwp-bypass-permission", "per-world-playerlist.allow-bypass-permission");
-				rename(config, "ignore-pwp-in-worlds", "per-world-playerlist.ignore-effect-in-worlds");
-				Map<String, List<String>> sharedWorlds = new HashMap<String, List<String>>();
-				sharedWorlds.put("lobby", Arrays.asList("lobby1", "lobby2"));
-				sharedWorlds.put("minigames", Arrays.asList("paintball", "bedwars"));
-				config.set("per-world-playerlist.shared-playerlist-world-groups", sharedWorlds);
-				TAB.getInstance().print('2', "Converted old per-world-playerlist section to new one in advancedconfig.yml.");
-			}
-		}
-	}
-
-	@Override
-	public String getServerVersion() {
-		return Bukkit.getBukkitVersion().split("-")[0] + " (" + Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3] + ")";
-	}
-
-	@Override
-	public String getSeparatorType() {
-		return "world";
-	}
-
-	@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 void callLoadEvent() {
-		Bukkit.getPluginManager().callEvent(new BukkitTABLoadEvent());
-	}
-
-	@Override
-	public int getMaxPlayers() {
-		return Bukkit.getMaxPlayers();
-	}
-}
@@ -0,0 +1,84 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import me.neznamy.tab.platforms.bukkit.platform.BukkitPlatform;
+import me.neznamy.tab.platforms.bukkit.platform.FoliaPlatform;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.*;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bukkit.Bukkit;
+import org.bukkit.command.*;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/**
+ * Main class for Bukkit platform
+ */
+public class BukkitTAB extends JavaPlugin {
+
+    @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 = ReflectionUtils.classExists("io.papermc.paper.threadedregions.RegionizedServer") ?
+                new FoliaPlatform(this) : new BukkitPlatform(this);
+        TAB.setInstance(new TAB(platform, ProtocolVersion.fromFriendlyName(version), getDataFolder()));
+        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(), 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, () -> platform.isPlaceholderAPI() ? "Yes" : "No"));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.PERMISSION_SYSTEM, () -> TAB.getInstance().getGroupManager().getPermissionPlugin()));
+        metrics.addCustomChart(new SimplePie(TabConstants.MetricsChart.SERVER_VERSION, () -> "1." + TAB.getInstance().getServerVersion().getMinorVersion() + ".x"));
+        PluginCommand cmd = Bukkit.getPluginCommand(TabConstants.COMMAND_BACKEND);
+        if (cmd == null) return;
+        BukkitTabCommand command = new BukkitTabCommand();
+        cmd.setExecutor(command);
+        cmd.setTabCompleter(command);
+    }
+
+    @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,
+     * {@code false} if anything went wrong.
+     *
+     * @return  {@code true} if server version is compatible, {@code false} if not
+     */
+    private boolean isVersionSupported() {
+        try {
+            long time = System.currentTimeMillis();
+            String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+            int minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
+            NMSStorage.setInstance(minorVersion >= 17 ? new BukkitModernNMSStorage() : new BukkitLegacyNMSStorage());
+            Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("[TAB] Loaded NMS hook in " + (System.currentTimeMillis()-time) + "ms"));
+            return true;
+        } catch (Exception ex) {
+            if (ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0]) == ProtocolVersion.UNKNOWN_SERVER_VERSION) {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Your server version is not compatible. " +
+                        "This plugin version was made for " + ProtocolVersion.values()[ProtocolVersion.values().length-1].getFriendlyName() +
+                        " - " + ProtocolVersion.values()[3].getFriendlyName() + ". Disabling."));
+            } else {
+                Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] A compatibility issue " +
+                        "with your server was found. Unless you are running some really weird server software, this is a bug."));
+            }
+            return false;
+        }
+    }
+}
@@ -0,0 +1,48 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.platform.TabPlayer;
+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.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Command handler for /tab command
+ */
+public class BukkitTabCommand implements CommandExecutor, TabCompleter {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+        if (TAB.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);
+    }
+}
@@ -0,0 +1,201 @@
+package me.neznamy.tab.platforms.bukkit;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.*;
+
+/**
+ * TabList which support modifying many entries at once
+ * for significantly better performance. For 1.7 players,
+ * ViaVersion properly splits the packet into multiple, so
+ * we don't need to worry about that here.
+ * <p>
+ * This class does not support server versions of 1.7 and
+ * below, because of the massive differences in tab list
+ * and packet fields.
+ */
+@RequiredArgsConstructor
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class BukkitTabList implements TabList {
+
+    // NMS Fields
+    public static Class<?> PacketPlayOutPlayerListHeaderFooterClass;
+    public static Constructor<?> newPacketPlayOutPlayerListHeaderFooter;
+    public static Field HEADER;
+    public static Field FOOTER;
+
+    public static Class<?> PacketPlayOutPlayerInfoClass;
+    public static Constructor<?> newPacketPlayOutPlayerInfo;
+    public static Field ACTION;
+    public static Field PLAYERS;
+    public static Class<Enum> EnumPlayerInfoActionClass;
+    public static Class<Enum> EnumGamemodeClass;
+    public static Class<?> ClientboundPlayerInfoRemovePacket;
+    public static Class<?> RemoteChatSession$Data;
+    public static Constructor<?> newClientboundPlayerInfoRemovePacket;
+
+    public static Class<?> PlayerInfoDataClass;
+    public static Constructor<?> newPlayerInfoData;
+    public static Method PlayerInfoData_getProfile;
+    public static Field PlayerInfoData_Latency;
+    public static Field PlayerInfoData_GameMode;
+    public static Field PlayerInfoData_DisplayName;
+    public static Field PlayerInfoData_Listed;
+    public static Field PlayerInfoData_RemoteChatSession;
+
+    /** Player this TabList belongs to */
+    private final BukkitTabPlayer player;
+
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        if (nms.getMinorVersion() >= 17) {
+            newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooterClass.getConstructor(nms.IChatBaseComponent, nms.IChatBaseComponent);
+        } else {
+            newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooterClass.getConstructor();
+            HEADER = ReflectionUtils.getFields(PacketPlayOutPlayerListHeaderFooterClass, nms.IChatBaseComponent).get(0);
+            FOOTER = ReflectionUtils.getFields(PacketPlayOutPlayerListHeaderFooterClass, nms.IChatBaseComponent).get(1);
+        }
+        if (nms.is1_19_3Plus()) {
+            newClientboundPlayerInfoRemovePacket = ClientboundPlayerInfoRemovePacket.getConstructor(List.class);
+            newPacketPlayOutPlayerInfo = PacketPlayOutPlayerInfoClass.getConstructor(EnumSet.class, Collection.class);
+            ACTION = ReflectionUtils.getOnlyField(PacketPlayOutPlayerInfoClass, EnumSet.class);
+        } else {
+            newPacketPlayOutPlayerInfo = PacketPlayOutPlayerInfoClass.getConstructor(EnumPlayerInfoActionClass, Array.newInstance(nms.EntityPlayer, 0).getClass());
+            ACTION = ReflectionUtils.getOnlyField(PacketPlayOutPlayerInfoClass, EnumPlayerInfoActionClass);
+        }
+        PLAYERS = ReflectionUtils.getOnlyField(PacketPlayOutPlayerInfoClass, List.class);
+        newPlayerInfoData = ReflectionUtils.getOnlyConstructor(PlayerInfoDataClass);
+        PlayerInfoData_getProfile = ReflectionUtils.getOnlyMethod(PlayerInfoDataClass, GameProfile.class);
+        PlayerInfoData_Latency = ReflectionUtils.getOnlyField(PlayerInfoDataClass, int.class);
+        PlayerInfoData_GameMode = ReflectionUtils.getOnlyField(PlayerInfoDataClass, EnumGamemodeClass);
+        PlayerInfoData_DisplayName = ReflectionUtils.getOnlyField(PlayerInfoDataClass, nms.IChatBaseComponent);
+        if (nms.is1_19_3Plus()) {
+            PlayerInfoData_Listed = ReflectionUtils.getOnlyField(PlayerInfoDataClass, boolean.class);
+            PlayerInfoData_RemoteChatSession = ReflectionUtils.getOnlyField(PlayerInfoDataClass, RemoteChatSession$Data);
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void removeEntry(@NotNull UUID entry) {
+        if (ClientboundPlayerInfoRemovePacket != null) {
+            //1.19.3+
+            player.sendPacket(newClientboundPlayerInfoRemovePacket.newInstance(Collections.singletonList(entry)));
+        } else {
+            //1.19.2-
+            player.sendPacket(createPacket(Action.REMOVE_PLAYER, new Entry.Builder(entry).build(), player.getVersion()));
+        }
+    }
+
+    @Override
+    public void updateDisplayName(@NotNull UUID entry, @Nullable IChatBaseComponent displayName) {
+        player.sendPacket(createPacket(Action.UPDATE_DISPLAY_NAME,
+                new Entry.Builder(entry).displayName(displayName).build(), player.getVersion())
+        );
+    }
+
+    @Override
+    public void updateLatency(@NotNull UUID entry, int latency) {
+        player.sendPacket(createPacket(Action.UPDATE_LATENCY,
+                new Entry.Builder(entry).latency(latency).build(), player.getVersion())
+        );
+    }
+
+    @Override
+    public void updateGameMode(@NotNull UUID entry, int gameMode) {
+        player.sendPacket(createPacket(Action.UPDATE_GAME_MODE,
+                new Entry.Builder(entry).gameMode(gameMode).build(), player.getVersion())
+        );
+    }
+
+    @Override
+    public void addEntry(@NotNull Entry entry) {
+        player.sendPacket(createPacket(Action.ADD_PLAYER, entry, player.getVersion()));
+    }
+
+    @Override
+    @SneakyThrows
+    public void setPlayerListHeaderFooter(@NotNull IChatBaseComponent header, @NotNull IChatBaseComponent footer) {
+        if (PacketPlayOutPlayerListHeaderFooterClass == null) return;
+        NMSStorage nms = NMSStorage.getInstance();
+        Object packet;
+        if (nms.getMinorVersion() >= 17) {
+            packet = newPacketPlayOutPlayerListHeaderFooter.newInstance(
+                    nms.toNMSComponent(header, player.getVersion()), nms.toNMSComponent(footer, player.getVersion()));
+        } else {
+            packet = newPacketPlayOutPlayerListHeaderFooter.newInstance();
+            HEADER.set(packet, nms.toNMSComponent(header, player.getVersion()));
+            FOOTER.set(packet, nms.toNMSComponent(footer, player.getVersion()));
+        }
+        player.sendPacket(packet);
+    }
+
+    @SneakyThrows
+    private Object createPacket(TabList.Action action, TabList.Entry entry, ProtocolVersion clientVersion) {
+        NMSStorage nms = NMSStorage.getInstance();
+        if (nms.getMinorVersion() < 8) return null;
+        Object packet;
+        List<Object> players = new ArrayList<>();
+        if (NMSStorage.getInstance().is1_19_3Plus()) {
+            EnumSet<?> actions;
+            if (action == TabList.Action.ADD_PLAYER) {
+                actions = EnumSet.allOf(EnumPlayerInfoActionClass);
+            } else {
+                actions = EnumSet.of(Enum.valueOf(EnumPlayerInfoActionClass, action.name()));
+            }
+            packet = newPacketPlayOutPlayerInfo.newInstance(actions, Collections.emptyList());
+            GameProfile profile = new GameProfile(entry.getUniqueId(), entry.getName());
+            if (entry.getSkin() != null) profile.getProperties().put(TabList.TEXTURES_PROPERTY,
+                    new Property(TabList.TEXTURES_PROPERTY, entry.getSkin().getValue(), entry.getSkin().getSignature()));
+            players.add(newPlayerInfoData.newInstance(
+                    entry.getUniqueId(),
+                    profile,
+                    true,
+                    entry.getLatency(),
+                    int2GameMode(entry.getGameMode()),
+                    entry.getDisplayName() == null ? null : nms.toNMSComponent(entry.getDisplayName(), clientVersion),
+                    null
+            ));
+        } else {
+            packet = newPacketPlayOutPlayerInfo.newInstance(Enum.valueOf(EnumPlayerInfoActionClass, action.name()),
+                    Array.newInstance(NMSStorage.getInstance().EntityPlayer, 0));
+            GameProfile profile = new GameProfile(entry.getUniqueId(), entry.getName());
+            if (entry.getSkin() != null) profile.getProperties().put(TabList.TEXTURES_PROPERTY,
+                    new Property(TabList.TEXTURES_PROPERTY, entry.getSkin().getValue(), entry.getSkin().getSignature()));
+            List<Object> parameters = new ArrayList<>();
+            if (newPlayerInfoData.getParameterTypes()[0] == PacketPlayOutPlayerInfoClass) {
+                parameters.add(packet);
+            }
+            parameters.add(profile);
+            parameters.add(entry.getLatency());
+            parameters.add(int2GameMode(entry.getGameMode()));
+            parameters.add(entry.getDisplayName() == null ? null : nms.toNMSComponent(entry.getDisplayName(), clientVersion));
+            if (nms.getMinorVersion() >= 19) parameters.add(null);
+            players.add(newPlayerInfoData.newInstance(parameters.toArray()));
+        }
+        PLAYERS.set(packet, players);
+        return packet;
+    }
+
+    private Object int2GameMode(int gameMode) {
+        switch (gameMode) {
+            case 1: return Enum.valueOf(EnumGamemodeClass, "CREATIVE");
+            case 2: return Enum.valueOf(EnumGamemodeClass, "ADVENTURE");
+            case 3: return Enum.valueOf(EnumGamemodeClass, "SPECTATOR");
+            default: return Enum.valueOf(EnumGamemodeClass, "SURVIVAL");
+        }
+    }
+}
@@ -1,196 +1,179 @@
 package me.neznamy.tab.platforms.bukkit;

-import java.lang.reflect.Method;
-
-import org.bukkit.Bukkit;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import lombok.Getter;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.platform.BukkitPlatform;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.shared.hook.ViaVersionHook;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.TabList;
+import me.neznamy.tab.platforms.bukkit.bossbar.EntityBossBar;
+import me.neznamy.tab.platforms.bukkit.bossbar.BukkitBossBar;
+import me.neznamy.tab.platforms.bukkit.bossbar.ViaBossBar;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendTabPlayer;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.backend.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
-import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.metadata.MetadataValue;
 import org.bukkit.potion.PotionEffectType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;

-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 us.myles.ViaVersion.api.Via;
+import java.util.Collection;
+import java.util.UUID;

 /**
- * TabPlayer for Bukkit
+ * TabPlayer implementation for Bukkit platform
 */
-public class BukkitTabPlayer extends ITabPlayer {
+@SuppressWarnings("deprecation")
+@Getter
+public class BukkitTabPlayer extends BackendTabPlayer {

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

-	/**
-	 * Constructs new instance with given parameter
-	 * @param p - bukkit player
-	 */
-	public BukkitTabPlayer(Player p){
-		player = p;
-		world = p.getWorld().getName();
-		try {
-			handle = NMSStorage.getInstance().getHandle.invoke(player);
-			playerConnection = NMSStorage.getInstance().PLAYER_CONNECTION.get(handle);
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get playerConnection of " + p.getName(), e);
-		}
-		try {
-			if (NMSStorage.getInstance().CHANNEL != null)
-				channel = (Channel) NMSStorage.getInstance().CHANNEL.get(NMSStorage.getInstance().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(getProtocolVersion());
-		init();
-	}
+    /** Player's connection for sending packets, preloading for speed */
+    private final Object playerConnection;

-	/**
-	 * Gets protocol version and returns it
-	 * @return protocol version of this player
-	 */
-	private int getProtocolVersion() {
-		if (Bukkit.getPluginManager().isPluginEnabled("ProtocolSupport")){
-			int version = getProtocolVersionPS();
-			//some PS versions return -1 on unsupported server versions instead of throwing exception
-			if (version != -1 && version < ProtocolVersion.SERVER_VERSION.getNetworkId()) return version;
-		}
-		if (((BukkitPlatform)TAB.getInstance().getPlatform()).viaversion) {
-			return getProtocolVersionVia();
-		}
-		return ProtocolVersion.SERVER_VERSION.getNetworkId();
-	}
+    private final Scoreboard<BukkitTabPlayer> scoreboard = new PacketScoreboard(this);
+    private final TabList tabList = new BukkitTabList(this);
+    private final BossBar bossBar = TAB.getInstance().getServerVersion().getMinorVersion() >= 9 ?
+            new BukkitBossBar(this) : getVersion().getMinorVersion() >= 9 ? new ViaBossBar(this) : new EntityBossBar(this);

-	/**
-	 * Returns protocol version of this player using ProtocolSupport
-	 * @return protocol version of this player using ProtocolSupport
-	 */
-	private int getProtocolVersionPS(){
-		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 " + getName());
-			return version;
-		} catch (Throwable e) {
-			return TAB.getInstance().getErrorManager().printError(ProtocolVersion.SERVER_VERSION.getNetworkId(), "Failed to get protocol version of " + getName() + " using ProtocolSupport", e);
-		}
-	}
+    /**
+     * Constructs new instance with given bukkit player and protocol version
+     *
+     * @param   p
+     *          bukkit player
+     */
+    @SneakyThrows
+    public BukkitTabPlayer(Player p) {
+        super(p, p.getUniqueId(), p.getName(), TAB.getInstance().getConfiguration().getServerName(),
+                p.getWorld().getName(), ViaVersionHook.getInstance().getPlayerVersion(p.getUniqueId(), p.getName()));
+        handle = NMSStorage.getInstance().getHandle.invoke(player);
+        playerConnection = NMSStorage.getInstance().PLAYER_CONNECTION.get(handle);
+    }

-	/**
-	 * Returns protocol version of this player using ViaVersion
-	 * @return protocol version of this player using ViaVersion
-	 */
-	private int getProtocolVersionVia(){
-		try {
-			int version = Via.getAPI().getPlayerVersion(uniqueId);
-			TAB.getInstance().debug("ViaVersion returned protocol version " + version + " for " + getName());
-			return version;
-		} catch (Throwable e) {
-			return TAB.getInstance().getErrorManager().printError(ProtocolVersion.SERVER_VERSION.getNetworkId(), "Failed to get protocol version of " + getName() + " using ViaVersion", e);
-		}
-	}
+    @Override
+    public boolean hasPermission(@NotNull String permission) {
+        return getPlayer().hasPermission(permission);
+    }

-	@Override
-	public boolean hasPermission(String permission) {
-		return player.hasPermission(permission);
-	}
+    @Override
+    public int getPing() {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 17) {
+            return getPlayer().getPing();
+        }
+        try {
+            return NMSStorage.getInstance().PING.getInt(handle);
+        } catch (IllegalAccessException e) {
+            return -1;
+        }
+    }

-	@Override
-	public long getPing() {
-		try {
-			int ping = NMSStorage.getInstance().PING.getInt(handle);
-			if (ping > 10000 || ping < 0) ping = -1;
-			return ping;
-		} catch (Exception e) {
-			return -1;
-		}
-	}
+    @SneakyThrows
+    public void sendPacket(@Nullable Object nmsPacket) {
+        if (nmsPacket == null || !getPlayer().isOnline()) return;
+        NMSStorage.getInstance().sendPacket.invoke(playerConnection, nmsPacket);
+    }

-	@Override
-	public void sendPacket(Object nmsPacket) {
-		if (nmsPacket == null || !player.isOnline()) return;
-		try {
-			if (((BukkitPlatform)TAB.getInstance().getPlatform()).viaversion && nmsPacket instanceof ByteBuf) {
-				try {
-					Via.getAPI().sendRawPacket(uniqueId, (ByteBuf) 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
-				}
-				return;
-			}
-			NMSStorage.getInstance().sendPacket.invoke(playerConnection, nmsPacket);
-		} catch (Throwable e) {
-			TAB.getInstance().getErrorManager().printError("An error occurred when sending " + nmsPacket.getClass().getSimpleName(), e);
-		}
-	}
+    @Override
+    public void sendMessage(@NotNull IChatBaseComponent message) {
+        getPlayer().sendMessage(RGBUtils.getInstance().convertToBukkitFormat(message.toFlatText(),
+                getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+    }

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

-	@Override
-	public boolean isDisguised() {
-		return isDisguisedLD() || isDisguisediDis();
-	}
+    @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;
+        }
+    }

-	/**
-	 * Returns disguise status of player using LibsDisguises
-	 * @return disguise status of player using LibsDisguises
-	 */
-	private boolean isDisguisedLD() {
-		try {
-			if (!((BukkitPlatform)TAB.getInstance().getPlatform()).libsdisguises) return false;
-			return (boolean) Class.forName("me.libraryaddict.disguise.DisguiseAPI").getMethod("isDisguised", Entity.class).invoke(null, player);
-		} catch (Throwable e) {
-			return TAB.getInstance().getErrorManager().printError(false, "Failed to check disguise status using LibsDisguises", e);
-		}
-	}
+    @Override
+    @SneakyThrows
+    public TabList.Skin getSkin() {
+        Collection<Property> col = ((GameProfile)NMSStorage.getInstance().getProfile.invoke(handle)).getProperties().get(TabList.TEXTURES_PROPERTY);
+        if (col.isEmpty()) return null; //offline mode
+        Property property = col.iterator().next();
+        return new TabList.Skin(property.getValue(), property.getSignature());
+    }

-	/**
-	 * Returns disguise status of player using iDisguise
-	 * @return disguise status of player using iDisguise
-	 */
-	private boolean isDisguisediDis() {
-		try {
-			if (!((BukkitPlatform)TAB.getInstance().getPlatform()).idisguise) return false;
-			RegisteredServiceProvider<?> provider = Bukkit.getServicesManager().getRegistration(Class.forName("de.robingrether.idisguise.api.DisguiseAPI"));
-			Object iDisguise = provider.getProvider();
-			Method m = iDisguise.getClass().getMethod("isDisguised", Player.class);
-			m.setAccessible(true);
-			return (boolean) m.invoke(iDisguise, player);
-		} catch (Throwable e) {
-			return TAB.getInstance().getErrorManager().printError(false, "Failed to check disguise status using iDisguise", e);
-		}
-	}
+    @Override
+    public @NotNull Player getPlayer() {
+        return (Player) player;
+    }

-	@Override
-	public Object getSkin() {
-		try {
-			return Class.forName("com.mojang.authlib.GameProfile").getMethod("getProperties").invoke(NMSStorage.getInstance().getProfile.invoke(handle));
-		} catch (Throwable e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to get skin of " + getName(), e);
-		}
-	}
+    @Override
+    public boolean isOnline() {
+        return getPlayer().isOnline();
+    }

-	@Override
-	public Player getPlayer() {
-		return player;
-	}
+    @Override
+    public boolean isVanished() {
+        return getPlayer().getMetadata("vanished").stream().anyMatch(MetadataValue::asBoolean);
+    }

-	@Override
-	public boolean isOnline() {
-		return player.isOnline();
-	}
-}
+    @Override
+    public int getGamemode() {
+        return getPlayer().getGameMode().getValue();
+    }
+
+    @Override
+    public void spawnEntity(int entityId, @NotNull UUID id, @NotNull Object entityType, @NotNull Location location, @NotNull EntityData data) {
+        sendPacket(PacketPlayOutSpawnEntityLivingStorage.build(entityId, id, entityType, location, data));
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 15) {
+            updateEntityMetadata(entityId, data);
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void updateEntityMetadata(int entityId, @NotNull EntityData data) {
+        if (PacketPlayOutEntityMetadataStorage.CONSTRUCTOR.getParameterCount() == 2) {
+            //1.19.3+
+            sendPacket(PacketPlayOutEntityMetadataStorage.CONSTRUCTOR.newInstance(entityId, DataWatcher.packDirty.invoke(data.build())));
+        } else {
+            sendPacket(PacketPlayOutEntityMetadataStorage.CONSTRUCTOR.newInstance(entityId, data.build(), true));
+        }
+    }
+
+    @Override
+    public void teleportEntity(int entityId, @NotNull Location location) {
+        sendPacket(PacketPlayOutEntityTeleportStorage.build(entityId, location));
+    }
+
+    @Override
+    @SneakyThrows
+    public void destroyEntities(int... entities) {
+        if (PacketPlayOutEntityDestroyStorage.CONSTRUCTOR.getParameterTypes()[0] != int.class) {
+            sendPacket(PacketPlayOutEntityDestroyStorage.CONSTRUCTOR.newInstance(new Object[]{entities}));
+        } else {
+            //1.17.0 Mojank
+            for (int entity : entities) {
+                sendPacket(PacketPlayOutEntityDestroyStorage.CONSTRUCTOR.newInstance(entity));
+            }
+        }
+    }
+}
@@ -1,80 +0,0 @@
-package me.neznamy.tab.platforms.bukkit;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-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(){
-		ProtocolVersion.SERVER_VERSION = ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0]);
-		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;
-		}
-		if (ProtocolVersion.SERVER_VERSION == ProtocolVersion.UNKNOWN) {
-			Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Unknown server version: " + Bukkit.getBukkitVersion() + "! Plugin may not work correctly.");
-		}
-		TAB.setInstance(new TAB(new BukkitPlatform(this, NMSStorage.getInstance()), new BukkitPacketBuilder(NMSStorage.getInstance())));
-		Bukkit.getPluginManager().registerEvents(new BukkitEventListener(), this);
-		Bukkit.getPluginCommand("tab").setExecutor((sender, c, cmd, args) -> {
-			if (TAB.getInstance().isDisabled()) {
-				for (String message : TAB.getInstance().disabledCommand.execute(args, sender.hasPermission("tab.reload"), sender.hasPermission("tab.admin"))) {
-					sender.sendMessage(message.replace('&', '\u00a7'));
-				}
-			} else {
-				TAB.getInstance().command.execute(sender instanceof Player ? TAB.getInstance().getPlayer(((Player)sender).getUniqueId()) : null, args);
-			}
-			return false;
-		});
-		Bukkit.getPluginCommand("tab").setTabCompleter((sender, c, cmd, args) -> TAB.getInstance().command.complete(sender instanceof Player ? TAB.getInstance().getPlayer(((Player)sender).getUniqueId()) : null, args));
-		TAB.getInstance().load();
-		new BukkitMetrics(this);
-	}
-
-	@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> SUPPORTED_VERSIONS = Arrays.asList(
-				"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");
-		String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-		try {
-			NMSStorage.setInstance(new NMSStorage());
-			if (SUPPORTED_VERSIONS.contains(serverPackage)) {
-				return true;
-			} else {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] This plugin version does not claim to support your server version. This jar has only been tested on 1.7.x - 1.16.5. Disabling.");
-			}
-		} catch (Throwable e) {
-			if (SUPPORTED_VERSIONS.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)");
-				e.printStackTrace();
-			} else {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Your server version is completely unsupported. This plugin version only supports 1.7.x - 1.16.5. Disabling.");
-			}
-		}
-		return false;
-	}
-}
@@ -0,0 +1,68 @@
+package me.neznamy.tab.platforms.bukkit.bossbar;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.shared.TAB;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * BossBar for 1.9+ servers where Bukkit API is used. If ViaVersion is used
+ * to allow 1.8 players, it will handle the entity and teleporting by itself.
+ */
+@RequiredArgsConstructor
+public class BukkitBossBar implements BossBar {
+
+    /** Player this handler belongs to */
+    private final BukkitTabPlayer player;
+
+    /** Bukkit BossBars the player can currently see */
+    private final Map<UUID, org.bukkit.boss.BossBar> bossBars = new HashMap<>();
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        if (bossBars.containsKey(id)) return;
+        org.bukkit.boss.BossBar bar = Bukkit.createBossBar(
+                RGBUtils.getInstance().convertToBukkitFormat(title,
+                        player.getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16),
+                org.bukkit.boss.BarColor.valueOf(color.name()),
+                org.bukkit.boss.BarStyle.valueOf(style.getBukkitName()));
+        bar.setProgress(progress);
+        bar.addPlayer(player.getPlayer());
+        bossBars.put(id, bar);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        bossBars.get(id).setTitle(RGBUtils.getInstance().convertToBukkitFormat(title,
+                player.getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        bossBars.get(id).setProgress(progress);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {
+        bossBars.get(id).setStyle(org.bukkit.boss.BarStyle.valueOf(style.getBukkitName()));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {
+        bossBars.get(id).setColor(org.bukkit.boss.BarColor.valueOf(color.name()));
+    }
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        bossBars.remove(id).removePlayer(player.getPlayer());
+    }
+}
@@ -0,0 +1,64 @@
+package me.neznamy.tab.platforms.bukkit.bossbar;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.shared.backend.Location;
+import org.bukkit.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+/**
+ * BossBar using wither entity for <1.9 players on <1.9 servers.
+ * Additional logic, such as teleporting the entity must be done
+ * separately, as this class does not handle it.
+ */
+@RequiredArgsConstructor
+public class EntityBossBar implements BossBar {
+
+    /** Player this handler belongs to */
+    private final BukkitTabPlayer player;
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        DataWatcher w = new DataWatcher();
+        float health = 300*progress;
+        if (health == 0) health = 1;
+        w.getHelper().setHealth(health);
+        w.getHelper().setCustomName(title, player.getVersion());
+        w.getHelper().setEntityFlags((byte) 32);
+        w.getHelper().setWitherInvulnerableTime(880); // Magic number
+        player.spawnEntity(id.hashCode(), new UUID(0, 0), EntityType.WITHER, new Location(0, 0, 0, 0, 0), w);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        DataWatcher w = new DataWatcher();
+        w.getHelper().setCustomName(title, player.getVersion());
+        player.updateEntityMetadata(id.hashCode(), w);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        DataWatcher w = new DataWatcher();
+        float health = 300*progress;
+        if (health == 0) health = 1;
+        w.getHelper().setHealth(health);
+        player.updateEntityMetadata(id.hashCode(), w);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {/*Added in 1.9*/}
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {/*Added in 1.9*/}
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        player.destroyEntities(id.hashCode());
+    }
+}
@@ -0,0 +1,67 @@
+package me.neznamy.tab.platforms.bukkit.bossbar;
+
+import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.legacy.bossbar.BossColor;
+import com.viaversion.viaversion.api.legacy.bossbar.BossStyle;
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.platform.bossbar.BossBar;
+import me.neznamy.tab.api.bossbar.BarColor;
+import me.neznamy.tab.api.bossbar.BarStyle;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Handler for 1.9+ players on 1.8 server using ViaVersion API.
+ */
+@RequiredArgsConstructor
+public class ViaBossBar implements BossBar {
+
+    /** Player this handler belongs to */
+    private final BukkitTabPlayer player;
+
+    /** 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<>();
+
+    @Override
+    public void create(@NotNull UUID id, @NotNull String title, float progress, @NotNull BarColor color, @NotNull BarStyle style) {
+        if (viaBossBars.containsKey(id)) return;
+        com.viaversion.viaversion.api.legacy.bossbar.BossBar bar = Via.getAPI().legacyAPI().createLegacyBossBar(
+                RGBUtils.getInstance().convertToBukkitFormat(title, player.getVersion().getMinorVersion() >= 16),
+                progress,
+                BossColor.valueOf(color.name()),
+                BossStyle.valueOf(style.getBukkitName()));
+        viaBossBars.put(id, bar);
+        bar.addPlayer(player.getPlayer().getUniqueId());
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull String title) {
+        viaBossBars.get(id).setTitle(RGBUtils.getInstance().convertToBukkitFormat(title,
+                player.getVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, float progress) {
+        viaBossBars.get(id).setHealth(progress);
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarStyle style) {
+        viaBossBars.get(id).setStyle(BossStyle.valueOf(style.getBukkitName()));
+    }
+
+    @Override
+    public void update(@NotNull UUID id, @NotNull BarColor color) {
+        viaBossBars.get(id).setColor(BossColor.valueOf(color.name()));
+    }
+
+    @Override
+    public void remove(@NotNull UUID id) {
+        viaBossBars.remove(id).removePlayer(player.getPlayer().getUniqueId());
+    }
+}
@@ -1,72 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features;
-
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.BukkitPacketBuilder;
-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.bossbar.BossBar;
-import me.neznamy.tab.shared.features.types.event.RespawnEventListener;
-
-/**
- * An additional class with additional code for <1.9 servers due to an entity being required
- */
-public class BossBar_legacy implements RespawnEventListener {
-
-	//distance of wither in blocks
-	private final int WITHER_DISTANCE = 75;
-	
-	//main bossbar feature
-	private BossBar mainFeature;
-	
-	/**
-	 * Constructs a new instance of the class
-	 * @param mainFeature - main bossbar feature
-	 */
-	public BossBar_legacy(TAB tab) {
-		this.mainFeature = (BossBar) tab.getFeatureManager().getFeature("bossbar");
-		//bar disappears in client after ~1 second of not seeing boss entity
-		tab.getCPUManager().startRepeatingMeasuredTask(900, "refreshing bossbar", TabFeature.BOSSBAR, UsageType.TELEPORTING_ENTITY, new Runnable() {
-			public void run() {
-				for (TabPlayer all : tab.getPlayers()) {
-					if (all.getVersion().getMinorVersion() > 8) continue; //sending VV packets to those
-					for (me.neznamy.tab.api.bossbar.BossBar l : all.getActiveBossBars()) {
-						try {
-							all.sendPacket(((BukkitPacketBuilder)tab.getPacketBuilder()).buildEntityTeleportPacket(Math.abs(l.getUniqueId().hashCode()), getWitherLocation(all)), TabFeature.BOSSBAR);
-						} catch (Exception e) {
-							tab.getErrorManager().printError("Failed to create PacketPlayOutEntityTeleport", e);
-						}
-					}
-				}
-			}
-		});
-	}
-	
-	/**
-	 * Respawning all entities as respawn screen destroys all entities in client
-	 */
-	@Override
-	public void onRespawn(TabPlayer respawned) {
-		mainFeature.detectBossBarsAndSend(respawned);
-	}
-	
-	/**
-	 * Returns location where wither should be located based on where player is looking
-	 * @param p - player to get wither location for
-	 * @return location of wither
-	 */
-	public Location getWitherLocation(TabPlayer p) {
-		Player pl = (Player) p.getPlayer();
-		Location loc = pl.getEyeLocation().add(pl.getEyeLocation().getDirection().normalize().multiply(WITHER_DISTANCE));
-		if (loc.getY() < 1) loc.setY(1);
-		return loc;
-	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.BOSSBAR;
-	}
-}
@@ -0,0 +1,199 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.platform.BukkitPlatform;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.features.types.PacketSendListener;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.PacketPlayOutEntityDestroyStorage;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.PacketPlayOutEntityTeleportStorage;
+import me.neznamy.tab.shared.backend.BackendTabPlayer;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.backend.features.unlimitedtags.BackendNameTagX;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Pose;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerToggleSneakEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * The core class for unlimited NameTag mode on Bukkit
+ */
+public class BukkitNameTagX extends BackendNameTagX implements Listener, PacketSendListener {
+
+    /** Reference to NMS storage for quick access */
+    private final NMSStorage nms = NMSStorage.getInstance();
+
+    public BukkitNameTagX(@NotNull JavaPlugin plugin) {
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onSneak(PlayerToggleSneakEvent e) {
+        TabPlayer p = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+        if (p == null || isPlayerDisabled(p)) return;
+        TAB.getInstance().getCPUManager().runMeasuredTask(featureName, TabConstants.CpuUsageCategory.PLAYER_SNEAK,
+                () -> getArmorStandManager(p).sneak(e.isSneaking()));
+    }
+
+    @EventHandler
+    public void onRespawn(PlayerRespawnEvent e) {
+        TabPlayer respawned = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+        if (respawned == null || isPlayerDisabled(respawned)) return;
+        TAB.getInstance().getCPUManager().runMeasuredTask(featureName, TabConstants.CpuUsageCategory.PLAYER_RESPAWN,
+                () -> getArmorStandManager(respawned).teleport());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    @SneakyThrows
+    public void onPacketSend(@NotNull TabPlayer receiver, @NotNull Object packet) {
+        if (receiver.getVersion().getMinorVersion() < 8) return;
+        if (!receiver.isLoaded() || getDisableChecker().isDisabledPlayer(receiver) || getUnlimitedDisableChecker().isDisabledPlayer(receiver)) return;
+        if (nms.PacketPlayOutEntity.isInstance(packet) && !nms.PacketPlayOutEntityLook.isInstance(packet)) { //ignoring head rotation only packets
+            packetListener.onEntityMove((BackendTabPlayer) receiver, nms.PacketPlayOutEntity_ENTITYID.getInt(packet));
+        } else if (PacketPlayOutEntityTeleportStorage.CLASS.isInstance(packet)) {
+            packetListener.onEntityMove((BackendTabPlayer) receiver, PacketPlayOutEntityTeleportStorage.ENTITY_ID.getInt(packet));
+        } else if (nms.PacketPlayOutNamedEntitySpawn.isInstance(packet)) {
+            packetListener.onEntitySpawn((BackendTabPlayer) receiver, nms.PacketPlayOutNamedEntitySpawn_ENTITYID.getInt(packet));
+        } else if (PacketPlayOutEntityDestroyStorage.CLASS.isInstance(packet)) {
+            if (nms.getMinorVersion() >= 17) {
+                Object entities = PacketPlayOutEntityDestroyStorage.ENTITIES.get(packet);
+                if (entities instanceof List) {
+                    packetListener.onEntityDestroy((BackendTabPlayer) receiver, (List<Integer>) entities);
+                } else {
+                    //1.17.0
+                    packetListener.onEntityDestroy((BackendTabPlayer) receiver, (int) entities);
+                }
+            } else {
+                packetListener.onEntityDestroy((BackendTabPlayer) receiver, (int[]) PacketPlayOutEntityDestroyStorage.ENTITIES.get(packet));
+            }
+        }
+    }
+
+    @Override
+    public double getDistance(@NotNull TabPlayer player1, @NotNull TabPlayer player2) {
+        Location loc1 = ((Player) player1.getPlayer()).getLocation();
+        Location loc2 = ((Player) player2.getPlayer()).getLocation();
+        return Math.sqrt(Math.pow(loc1.getX()-loc2.getX(), 2) + Math.pow(loc1.getZ()-loc2.getZ(), 2));
+    }
+
+    @Override
+    public boolean areInSameWorld(@NotNull TabPlayer player1, @NotNull TabPlayer player2) {
+        return ((Player) player1.getPlayer()).getWorld() == ((Player) player2.getPlayer()).getWorld();
+    }
+
+    @Override
+    public boolean canSee(@NotNull TabPlayer viewer, @NotNull TabPlayer target) {
+        return ((Player)viewer.getPlayer()).canSee((Player) target.getPlayer());
+    }
+
+    @Override
+    public void unregisterListener() {
+        HandlerList.unregisterAll(this);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public @NotNull List<Integer> getPassengers(@NotNull Object entity) {
+        Entity vehicle = (Entity) entity;
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 11) {
+            return vehicle.getPassengers().stream().map(Entity::getEntityId).collect(Collectors.toList());
+        } else {
+            if (vehicle.getPassenger() != null) {
+                return Collections.singletonList(vehicle.getPassenger().getEntityId());
+            } else {
+                return Collections.emptyList();
+            }
+        }
+    }
+
+    @Override
+    public @Nullable Object getVehicle(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).getVehicle();
+    }
+
+    @Override
+    public int getEntityId(@NotNull Object entity) {
+        return ((Entity)entity).getEntityId();
+    }
+
+    @Override
+    public @NotNull String getEntityType(@NotNull Object entity) {
+        return ((Entity) entity).getType().toString().toLowerCase();
+    }
+
+    @Override
+    public boolean isSneaking(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).isSneaking();
+    }
+
+    @Override
+    public boolean isSwimming(@NotNull TabPlayer player) {
+        Player p = (Player) player.getPlayer();
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 14 && p.getPose() == Pose.SWIMMING) return true;
+        return TAB.getInstance().getServerVersion().getMinorVersion() == 13 && p.isSwimming();
+    }
+
+    @Override
+    public boolean isGliding(@NotNull TabPlayer player) {
+        return TAB.getInstance().getServerVersion().getMinorVersion() >= 9 && ((Player)player.getPlayer()).isGliding();
+    }
+
+    @Override
+    public boolean isSleeping(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).isSleeping();
+    }
+
+    @Override
+    public @NotNull Object getArmorStandType() {
+        return EntityType.ARMOR_STAND;
+    }
+
+    @Override
+    public double getX(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).getLocation().getX();
+    }
+
+    @Override
+    public double getY(@NotNull Object entity) {
+        return ((Entity)entity).getLocation().getY();
+    }
+
+    @Override
+    public double getZ(@NotNull TabPlayer player) {
+        return ((Player)player.getPlayer()).getLocation().getZ();
+    }
+
+    @Override
+    public EntityData createDataWatcher(@NotNull TabPlayer viewer, byte flags, @NotNull String displayName, boolean nameVisible) {
+        DataWatcher datawatcher = new DataWatcher();
+        datawatcher.getHelper().setEntityFlags(flags);
+        datawatcher.getHelper().setCustomName(displayName, viewer.getVersion());
+        datawatcher.getHelper().setCustomNameVisible(nameVisible);
+        datawatcher.getHelper().setArmorStandFlags((byte)16);
+        return datawatcher;
+    }
+
+    @Override
+    public void runInEntityScheduler(Object entity, Runnable task) {
+        ((BukkitPlatform)TAB.getInstance().getPlatform()).runEntityTask((Entity) entity, task);
+    }
+}
@@ -0,0 +1,60 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import lombok.Getter;
+import me.clip.placeholderapi.PlaceholderAPI;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.shared.placeholders.expansion.TabExpansion;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * TAB's expansion for PlaceholderAPI
+ */
+@Getter
+public class BukkitTabExpansion extends PlaceholderExpansion implements TabExpansion {
+
+    /** Map holding all values for all players for easy and high-performance access */
+    private final WeakHashMap<Player, Map<String, String>> values = new WeakHashMap<>();
+
+    private final String author = TabConstants.PLUGIN_AUTHOR;
+    private final String identifier = TabConstants.PLUGIN_ID;
+    private final String version = TabConstants.PLUGIN_VERSION;
+
+    @Override
+    public boolean persist() {
+        return true;
+    }
+
+    @Override
+    public String onPlaceholderRequest(@Nullable Player player, @NotNull String identifier) {
+        if (identifier.startsWith("replace_")) {
+            String text = "%" + identifier.substring(8) + "%";
+            String textBefore;
+            do {
+                textBefore = text;
+                for (String placeholder : TAB.getInstance().getPlaceholderManager().detectPlaceholders(text)) {
+                    text = text.replace(placeholder, TAB.getInstance().getPlaceholderManager().findReplacement(placeholder,
+                            PlaceholderAPI.setPlaceholders(player, placeholder)));
+                }
+            } while (!textBefore.equals(text));
+            return text;
+        }
+        if (identifier.startsWith("placeholder_")) {
+            TAB.getInstance().getPlaceholderManager().addUsedPlaceholder("%" + identifier.substring(12) + "%", TAB.getInstance().getPlaceholderManager());
+        }
+        return values.get(player).get(identifier);
+    }
+
+    @Override
+    public void setValue(@NotNull TabPlayer player, @NotNull String key, @NotNull String value) {
+        values.computeIfAbsent((Player) player.getPlayer(), p -> new HashMap<>()).put(key, value);
+    }
+}
@@ -1,99 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features;
-
-import java.io.File;
-import java.util.ConcurrentModificationException;
-import java.util.Set;
-
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import me.clip.placeholderapi.PlaceholderAPI;
-import me.neznamy.tab.shared.TAB;
-
-/**
- * Utility to execute /papi ecloud download <expansion> on expansions which are used but not installed
- * If an expansion was successfully downloaded (new expansion count is higher than previous in expansions folder),
- * /papi reload is executed.
- * Since this feature was added into the plugin amount of non-working placeholders caused by missing expansion went down rapidly.
- * I'm not sure why, must be a coinscidence.
- */
-public class ExpansionDownloader {
-
-	//the plugin to run bukkit tasks as
-	private JavaPlugin plugin;
-	
-	/**
-	 * Constructs new instance of the class with provided plugin instance
-	 * @param plugin - plugin to run bukkit tasks as
-	 */
-	public ExpansionDownloader(JavaPlugin plugin) {
-		this.plugin = plugin;
-	}
-
-	/**
-	 * Attempts to download all included expansions using /papi ecloud download <expansion> command and if something was successful /papi reload
-	 * @param expansions - list of expansions to attempt to download
-	 */
-	public void download(Set<String> expansions) {
-		//starting the task in the first tick just like PlaceholderAPI does to prevent downloading before PlaceholderAPI loads all expansions
-		Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
-
-			@Override
-			public void run() {
-				//starting the task asynchronously to not freeze the server with Thread.sleep
-				new Thread(new Runnable() {
-
-					@Override
-					public void run() {
-						try {
-							//initial delay to give PlaceholderAPI time to load
-							Thread.sleep(5000);
-							TAB.getInstance().debug("Used expansions: " + expansions.toString());
-							TAB.getInstance().debug("Registered expansions in PlaceholderAPI: " + PlaceholderAPI.getRegisteredIdentifiers());
-							expansions.removeAll(PlaceholderAPI.getRegisteredIdentifiers());
-							TAB.getInstance().debug("Expansions to install: " + expansions.toString());
-							if (!expansions.isEmpty()) {
-								File expansionsFolder = new File(Bukkit.getPluginManager().getPlugin("PlaceholderAPI").getDataFolder(), "expansions");
-								int oldExpansionDownloadedCount = expansionsFolder.listFiles().length;
-								for (String expansion : expansions) {
-									Bukkit.getConsoleSender().sendMessage("\u00a7d[TAB] Expansion \u00a7e" + expansion + "\u00a7d is used but not installed. Installing!");
-									runSyncCommand("papi ecloud download " + expansion);
-									Thread.sleep(5000);
-								}
-								if (expansionsFolder.listFiles().length > oldExpansionDownloadedCount) {
-									Bukkit.getConsoleSender().sendMessage("\u00a7d[TAB] Reloading PlaceholderAPI for the changes to take effect.");
-									runSyncCommand("papi reload");
-								}
-							}
-						} catch (InterruptedException | ConcurrentModificationException e) {
-							//fast shutdown probably
-						} catch (NoClassDefFoundError e){
-							//PAPI class not found, fast shutdown probably
-						} catch (Throwable e) {
-							TAB.getInstance().getErrorManager().printError("Failed to download PlaceholderAPI expansions. PlaceholderAPI version: " + Bukkit.getPluginManager().getPlugin("PlaceholderAPI").getDescription().getVersion(), e);
-						}
-					}
-				}).start();
-			}
-		}, 1);
-	}
-	
-	/**
-	 * Performs given command in the main thread
-	 * @param command - command to perform
-	 */
-	private void runSyncCommand(String command) {
-		//back to main thread as commands need to be ran in it
-		Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
-
-			@Override
-			public void run() {
-				try {
-					Bukkit.dispatchCommand(Bukkit.getConsoleSender(), command);
-				} catch (Exception e) {
-					//papi ecloud is disabled
-				}
-			}
-		});
-	}
-}
@@ -0,0 +1,112 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.features.types.Loadable;
+import me.neznamy.tab.shared.features.types.UnLoadable;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import me.neznamy.tab.shared.features.types.TabFeature;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.TAB;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Per-world-PlayerList feature handler
+ */
+@SuppressWarnings("deprecation")
+@RequiredArgsConstructor
+public class PerWorldPlayerList extends TabFeature implements Listener, Loadable, UnLoadable {
+
+    /** Config options */
+    private final boolean allowBypass = TAB.getInstance().getConfig().getBoolean("per-world-playerlist.allow-bypass-permission", false);
+    private final List<String> ignoredWorlds = TAB.getInstance().getConfig().getStringList("per-world-playerlist.ignore-effect-in-worlds", Arrays.asList("ignored_world", "build"));
+    private final Map<String, List<String>> sharedWorlds = TAB.getInstance().getConfig().getConfigurationSection("per-world-playerlist.shared-playerlist-world-groups");
+
+    /** Plugin reference*/
+    @NotNull private final JavaPlugin plugin;
+
+    @Getter private final String featureName = "Per world PlayerList";
+
+    @Override
+    public void load() {
+        Bukkit.getOnlinePlayers().forEach(this::checkPlayer);
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    @Override
+    public void unload() {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            for (Player pl : Bukkit.getOnlinePlayers()) {
+                p.showPlayer(pl);
+            }
+        }
+        HandlerList.unregisterAll(this);
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent e) {
+        long time = System.nanoTime();
+        checkPlayer(e.getPlayer());
+        TAB.getInstance().getCPUManager().addTime(featureName, TabConstants.CpuUsageCategory.PLAYER_JOIN, System.nanoTime()-time);
+    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        long time = System.nanoTime();
+        checkPlayer(e.getPlayer());
+        TAB.getInstance().getCPUManager().addTime(featureName, TabConstants.CpuUsageCategory.WORLD_SWITCH, System.nanoTime()-time);
+    }
+
+    /**
+     * Performs visibility check on the player. Shows players this player should see and does not,
+     * hides players the player should not see, shows the player to those who should see player and hides
+     * from those, who should not see.
+     *
+     * @param   p
+     *          Player to update
+     */
+    private void checkPlayer(@NotNull Player p) {
+        for (Player all : Bukkit.getOnlinePlayers()) {
+            if (all == p) continue;
+            if (!shouldSee(p, all) && p.canSee(all)) p.hidePlayer(all);
+            if (shouldSee(p, all) && !p.canSee(all)) p.showPlayer(all);
+            if (!shouldSee(all, p) && all.canSee(p)) all.hidePlayer(p);
+            if (shouldSee(all, p) && !all.canSee(p)) all.showPlayer(p);
+        }
+    }
+
+    /**
+     * Returns {@code true} if viewer should see target player, {@code false} if not.
+     * @param   viewer
+     *          Player viewing the TabList
+     * @param   target
+     *          Target displayed in the TabList
+     * @return  {@code true} if viewer should see target, {@code false} if not.
+     */
+    private boolean shouldSee(@NotNull Player viewer, @NotNull Player target) {
+        if (target == viewer) return true;
+        if ((allowBypass && viewer.hasPermission(TabConstants.Permission.PER_WORLD_PLAYERLIST_BYPASS)) || ignoredWorlds.contains(viewer.getWorld().getName())) return true;
+        String viewerWorldGroup = viewer.getWorld().getName() + "-default"; //preventing unwanted behavior when some group is called exactly like a world
+        String targetWorldGroup = target.getWorld().getName() + "-default";
+        for (Entry<String, List<String>> group : sharedWorlds.entrySet()) {
+            if (group.getValue() != null) {
+                if (group.getValue().contains(viewer.getWorld().getName())) viewerWorldGroup = group.getKey();
+                if (group.getValue().contains(target.getWorld().getName())) targetWorldGroup = group.getKey();
+            }
+        }
+        return viewerWorldGroup.equals(targetWorldGroup);
+    }
+}
@@ -1,178 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.features.types.Loadable;
-import me.neznamy.tab.shared.features.types.event.JoinEventListener;
-import me.neznamy.tab.shared.features.types.event.WorldChangeListener;
-import me.neznamy.tab.shared.features.types.packet.PlayerInfoPacketListener;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.EnumPlayerInfoAction;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.PlayerInfoData;
-
-/**
- * Per-world-playerlist feature. Currently bukkit API based, however that causes various (compatibility) issues.
- * Will be reworked to use packets in the future
- */
-@SuppressWarnings("deprecation")
-public class PerWorldPlayerlist implements Loadable, JoinEventListener, WorldChangeListener, PlayerInfoPacketListener {
-
-	//tab instance
-	private TAB tab;
-	
-	//plugin instance
-	private JavaPlugin plugin;
-	
-	//if bypass permission is allowed or not
-	private boolean allowBypass;
-	
-	//list of ignored worlds
-	private List<String> ignoredWorlds;
-	
-	//map of worlds that share playerlist
-	private Map<String, List<String>> sharedWorlds;
-
-	/**
-	 * Constructs new instance with given parameters and loads config options
-	 * @param plugin - plugin instance
-	 * @param tab - tab instance
-	 */
-	public PerWorldPlayerlist(JavaPlugin plugin, TAB tab) {
-		this.plugin = plugin;
-		this.tab = tab;
-		allowBypass = tab.getConfiguration().config.getBoolean("per-world-playerlist.allow-bypass-permission", false);
-		ignoredWorlds = tab.getConfiguration().config.getStringList("per-world-playerlist.ignore-effect-in-worlds", Arrays.asList("ignoredworld", "build"));
-		sharedWorlds = tab.getConfiguration().config.getConfigurationSection("per-world-playerlist.shared-playerlist-world-groups");
-		for (String group : sharedWorlds.keySet()) {
-			if (sharedWorlds.get(group).size() == 1) {
-				tab.getErrorManager().startupWarn("World group \"" + group + "\" in per-world-playerlist only contain a single world (\"" + sharedWorlds.get(group).get(0) +
-						"\"), which has no effect and only makes config less readable. Delete the group entirely for a cleaner config.");
-			}
-		}
-	}
-	
-	@Override
-	public void load(){
-		for (TabPlayer p : tab.getPlayers()){
-			hidePlayer(p);
-			showInSameWorldGroup(p);
-		}
-	}
-	
-	@Override
-	public void unload(){
-		for (TabPlayer p : tab.getPlayers()) {
-			for (TabPlayer pl : tab.getPlayers()) {
-				((Player) p.getPlayer()).showPlayer((Player) pl.getPlayer());
-			}
-		}
-	}
-	
-	@Override
-	public void onJoin(TabPlayer connectedPlayer) {
-		hidePlayer(connectedPlayer);
-		showInSameWorldGroup(connectedPlayer);
-	}
-	
-	@Override
-	public void onWorldChange(TabPlayer p, String from, String to) {
-		hidePlayer(p);
-		showInSameWorldGroup(p);
-	}
-	
-	/**
-	 * Shows all players that player should see
-	 * @param shown - player to process mutual visibility for
-	 */
-	private void showInSameWorldGroup(TabPlayer shown){
-		Bukkit.getScheduler().runTask(plugin, new Runnable() {
-
-			@Override
-			public void run() {
-				try {
-					for (TabPlayer everyone : tab.getPlayers()){
-						if (everyone == shown) continue;
-						if (shouldSee(shown, everyone)) ((Player) shown.getPlayer()).showPlayer((Player) everyone.getPlayer());
-						if (shouldSee(everyone, shown)) ((Player) everyone.getPlayer()).showPlayer((Player) shown.getPlayer());
-					}
-				} catch (Throwable t) {
-					tab.getErrorManager().printError("Failed to show players", t);
-				}
-			}
-		});
-	}
-	
-	/**
-	 * Returns true if specified viewer should see player, false if not
-	 * @param viewer - tablist viewer
-	 * @param displayed - player to check if should be visible
-	 * @return true if should, false if not
-	 */
-	private boolean shouldSee(TabPlayer viewer, TabPlayer displayed) {
-		if (displayed == viewer) return true;
-		if ((allowBypass && viewer.hasPermission("tab.bypass")) || ignoredWorlds.contains(((Player)viewer.getPlayer()).getWorld().getName())) return true;
-		String viewerWorldGroup = ((Player)viewer.getPlayer()).getWorld().getName() + "-default"; //preventing unwanted behavior when some group is called exactly like a world
-		String targetWorldGroup = ((Player)displayed.getPlayer()).getWorld().getName() + "-default";
-		for (String group : sharedWorlds.keySet()) {
-			if (sharedWorlds.get(group) != null) {
-				if (sharedWorlds.get(group).contains(((Player)viewer.getPlayer()).getWorld().getName())) viewerWorldGroup = group;
-				if (sharedWorlds.get(group).contains(((Player)displayed.getPlayer()).getWorld().getName())) targetWorldGroup = group;
-			}
-		}
-		return viewerWorldGroup.equals(targetWorldGroup);
-	}
-	
-	/**
-	 * Hides the player from everyone and everyone to the player
-	 * @param hidden - player to hide
-	 */
-	private void hidePlayer(TabPlayer hidden){
-		Bukkit.getScheduler().runTask(plugin, new Runnable() {
-
-			@Override
-			public void run() {
-				try {
-					for (TabPlayer everyone : tab.getPlayers()){
-						if (everyone == hidden) continue;
-						((Player) hidden.getPlayer()).hidePlayer((Player) everyone.getPlayer());
-						((Player) everyone.getPlayer()).hidePlayer((Player) hidden.getPlayer());
-					}
-				} catch (Throwable t) {
-					tab.getErrorManager().printError("Failed to hide players", t);
-				}
-			}
-		});
-	}
-	
-	//fixing bukkit api bug making players not hide when hidePlayer is called too early
-	@Override
-	public void onPacketSend(TabPlayer receiver, PacketPlayOutPlayerInfo info) {
-		if (info.action != EnumPlayerInfoAction.ADD_PLAYER) return;
-		List<PlayerInfoData> toRemove = new ArrayList<PlayerInfoData>();
-		for (PlayerInfoData data : info.entries) {
-			TabPlayer added = tab.getPlayerByTablistUUID(data.uniqueId);
-			if (added != null && !shouldSee(receiver, added)) {
-				toRemove.add(data);
-			}
-		}
-		List<PlayerInfoData> newList = new ArrayList<PlayerInfoData>();
-		info.entries.forEach(d -> newList.add(d));
-		newList.removeAll(toRemove);
-		info.entries = newList;
-	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.PER_WORLD_PLAYERLIST;
-	}
-}
@@ -1,118 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
-import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.features.types.event.QuitEventListener;
-import me.neznamy.tab.shared.features.types.packet.RawPacketListener;
-
-/**
- * A feature to disable minecraft 1.9+ feature making tamed animals with custom names copy nametag properties of their owner
- * This is achieved by listening to entity spawn (<1.15) / entity metadata packets and removing owner field from the datawatcher list
- * Since 1.16 this results in client sending entity use packet twice, so we must cancel the 2nd one to prevent double toggle
- */
-public class PetFix implements RawPacketListener, QuitEventListener {
-
-	//datawatcher position of pet owner field
-	private int PET_OWNER_POSITION = getPetOwnerPosition();
-
-	//logger of last interacts to prevent feature not working on 1.16
-	private Map<String, Long> lastInteractFix = new HashMap<String, Long>();
-	
-	//nms storage
-	private NMSStorage nms;
-	
-	/**
-	 * Constructs new instance with given parameter
-	 * @param nms
-	 */
-	public PetFix(NMSStorage nms) {
-		this.nms = nms;
-	}
-	
-	/**
-	 * Returns position of pet owner field based on server version
-	 * @return position of pet owner field based on server version
-	 */
-	private int getPetOwnerPosition() {
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 15) {
-			//1.15.x, 1.16.x
-			return 17;
-		} else if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 14) {
-			//1.14.x
-			return 16;
-		} else if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 10) {
-			//1.10.x - 1.13.x
-			return 14;
-		} else {
-			//1.9.x
-			return 13;
-		}
-	}
-	
-	/**
-	 * Cancels a packet if previous one arrived with no delay to prevent double toggle on 1.16
-	 */
-	@Override
-	public Object onPacketReceive(TabPlayer sender, Object packet) throws Throwable {
-		if (nms.PacketPlayInUseEntity.isInstance(packet)) {
-			if (lastInteractFix.containsKey(sender.getName()) && (System.currentTimeMillis() - lastInteractFix.get(sender.getName()) < 5)) {
-				//last interact packet was sent right now, cancelling to prevent double-toggle due to this feature enabled
-				return null;
-			}
-			if (nms.PacketPlayInUseEntity_ACTION.get(packet).toString().equals("INTERACT")) {
-				//this is the first packet, saving player so the next packet can be cancelled
-				lastInteractFix.put(sender.getName(), System.currentTimeMillis());
-			}
-		}
-		return packet;
-	}
-	
-	/**
-	 * Removes pet owner field from datawatcher
-	 */
-	@SuppressWarnings("unchecked")
-	@Override
-	public void onPacketSend(TabPlayer receiver, Object packet) throws Throwable {
-		if (nms.PacketPlayOutEntityMetadata.isInstance(packet)) {
-			List<Object> items = (List<Object>) nms.PacketPlayOutEntityMetadata_LIST.get(packet);
-			if (items == null) return;
-			List<Object> newList = new ArrayList<Object>();
-			for (Object item : items) {
-				DataWatcherItem i = DataWatcherItem.fromNMS(item);
-				if (i.type.position == PET_OWNER_POSITION && i.value.toString().startsWith("Optional")) continue;
-				newList.add(item);
-			}
-			nms.PacketPlayOutEntityMetadata_LIST.set(packet, newList);
-		}
-		if (nms.PacketPlayOutSpawnEntityLiving.isInstance(packet) && nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER != null) {
-			DataWatcher watcher = DataWatcher.fromNMS(nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER.get(packet));
-			DataWatcherItem petOwner = watcher.getItem(PET_OWNER_POSITION);
-			if (petOwner != null && petOwner.value.toString().startsWith("Optional")) {
-				watcher.removeValue(PET_OWNER_POSITION);
-				nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER.set(packet, watcher.toNMS());
-			}
-		}
-	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.PET_NAME_FIX;
-	}
-
-	/**
-	 * Removing player data to not have a memory leak
-	 */
-	@Override
-	public void onQuit(TabPlayer disconnectedPlayer) {
-		lastInteractFix.remove(disconnectedPlayer.getName());
-	}
-}
@@ -1,111 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features;
-
-import java.util.Map;
-
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import me.clip.placeholderapi.expansion.PlaceholderExpansion;
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.BukkitPlatform;
-import me.neznamy.tab.shared.Property;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.placeholders.Placeholder;
-
-/**
- * TAB's expansion for PlaceholderAPI
- */
-public class TabExpansion extends PlaceholderExpansion {
-
-	//plugin to take plugin.yml data from
-	private JavaPlugin plugin;
-	
-	
-	/**
-	 * Constructs new instance of the class and registers it
-	 * @param plugin - plugin to take plugin.yml data from
-	 */
-	public TabExpansion(JavaPlugin plugin) {
-		this.plugin = plugin;
-		register();
-	}
-	
-	@Override
-	public boolean persist(){
-		return true;
-	}
-
-	@Override
-	public boolean canRegister(){
-		return true;
-	}
-
-	@Override
-	public String getAuthor(){
-		return plugin.getDescription().getAuthors().toString();
-	}
-
-	@Override
-	public String getIdentifier(){
-		return "tab";
-	}
-
-	@Override
-	public String getVersion(){
-		return plugin.getDescription().getVersion();
-	}
-
-	@Override
-	public String onPlaceholderRequest(Player player, String identifier){
-		if (player == null) return "";
-		TabPlayer p = TAB.getInstance().getPlayer(player.getUniqueId());
-		if (identifier.equals("scoreboard_visible")) {
-			return p.isScoreboardVisible() ? "Enabled" : "Disabled";
-		}
-		if (identifier.equals("bossbar_visible")) {
-			return p.hasBossbarVisible() ? "Enabled" : "Disabled";
-		}
-		if (identifier.equals("ntpreview")) {
-			return p.isPreviewingNametag() ? "Enabled" : "Disabled";
-		}
-		if (identifier.startsWith("replace_")) {
-			return findReplacement("%" + identifier.substring(8) + "%", player);
-		}
-		if (identifier.startsWith("placeholder_")) {
-			//using Property function for fast & easy handling of nested placeholders and different placeholder types
-			return new Property(p, "%" + identifier.substring(12) + "%").get();
-		}
-		return getProperty(identifier, p);
-	}
-	
-	/**
-	 * Find replacement for specified placeholder
-	 * @param placeholder - placeholder to find replacement for
-	 * @param player - player to set placeholder for
-	 * @return replacement
-	 */
-	private String findReplacement(String placeholder, Player player) {
-		if (!TAB.getInstance().isPremium()) return "Placeholder output replacements require premium version to work";
-		String output = ((BukkitPlatform) TAB.getInstance().getPlatform()).setPlaceholders(player, placeholder);
-		Map<Object, String> replacements = TAB.getInstance().getConfiguration().premiumconfig.getConfigurationSection("placeholder-output-replacements." + placeholder);
-		return Placeholder.findReplacement(replacements, output).replace("%value%", output);
-	}
-	
-	/**
-	 * Returns value of defined property if found
-	 * @param name - property name
-	 * @param player - player to get property of
-	 * @return value of specified property
-	 */
-	private String getProperty(String name, TabPlayer player) {
-		String propName = name.replace("_raw", "");
-		Property prop = player.getProperty(propName);
-		if (prop != null) {
-		    if (name.endsWith("_raw")) {
-		    	return prop.getCurrentRawValue();
-		    }
-		    return prop.get();
-		}
-		return null;
-	}
-}
@@ -0,0 +1,83 @@
+package me.neznamy.tab.platforms.bukkit.features;
+
+import lombok.RequiredArgsConstructor;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import me.neznamy.tab.api.bossbar.BossBar;
+import me.neznamy.tab.shared.features.types.WorldSwitchListener;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendTabPlayer;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An additional class with additional code for &lt;1.9 servers due to an entity being required
+ */
+@RequiredArgsConstructor
+public class WitherBossBar extends BossBarManagerImpl implements Listener, WorldSwitchListener {
+
+    /** Distance of the Wither in blocks */
+    private static final int WITHER_DISTANCE = 60;
+
+    /** Reference to plugin for registering listener */
+    private final @NotNull JavaPlugin plugin;
+
+    @Override
+    public void load() {
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+        //when MC is on fullscreen, BossBar disappears after 1 second of not being seen
+        //when in a small window, it's about 100ms
+        TAB.getInstance().getCPUManager().startRepeatingMeasuredTask(100,
+                featureName, TabConstants.CpuUsageCategory.TELEPORTING_WITHER, this::teleport);
+        super.load();
+        teleport();
+    }
+
+    /**
+     * Updates Wither location for all online players
+     */
+    private void teleport() {
+        for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+            if (p.getVersion().getMinorVersion() > 8) continue; //sending VV packets to those
+            for (BossBar line : getRegisteredBossBars().values()) {
+                if (!line.getPlayers().contains(p)) continue;
+                Location loc = ((Player) p.getPlayer()).getEyeLocation().add(((Player) p.getPlayer()).getEyeLocation().getDirection().normalize().multiply(WITHER_DISTANCE));
+                if (loc.getY() < 1) loc.setY(1);
+                ((BackendTabPlayer)p).teleportEntity(line.getUniqueId().hashCode(), new me.neznamy.tab.shared.backend.Location(loc.getX(), loc.getY(), loc.getZ(), 0, 0));
+            }
+        }
+    }
+    
+    @Override
+    public void unload() {
+        super.unload();
+        HandlerList.unregisterAll(this);
+    }
+    
+    /**
+     * Respawning wither as respawn screen destroys all entities in client
+     */
+    @EventHandler
+    public void onRespawn(PlayerRespawnEvent e) {
+        TabPlayer player = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+        if (player == null) return;
+        TAB.getInstance().getCPUManager().runMeasuredTask(featureName, TabConstants.CpuUsageCategory.PLAYER_RESPAWN,
+                () -> detectBossBarsAndSend(player));
+    }
+
+    @Override
+    public void onWorldChange(@NotNull TabPlayer p, @NotNull String from, @NotNull String to) {
+        for (BossBar line : lineValues) {
+            line.removePlayer(p);
+        }
+        detectBossBarsAndSend(p);
+    }
+}
@@ -1,387 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
-
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Pose;
-import org.bukkit.potion.PotionEffectType;
-
-import me.neznamy.tab.api.ArmorStand;
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.BukkitPacketBuilder;
-import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
-import me.neznamy.tab.shared.Property;
-import me.neznamy.tab.shared.ProtocolVersion;
-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.packets.IChatBaseComponent;
-
-/**
- * A class representing an armor stand attached to a player (if the feature is enabled)
- */
-public class BukkitArmorStand implements ArmorStand {
-
-	//owner of the armor stand
-	private TabPlayer owner;
-
-	//instance of Bukkit player
-	private Player player;
-
-	//offset in blocks, 0 for original height
-	private double yOffset;
-
-	//entity ID of this armor stand
-	private int entityId;
-
-	//unique ID of this armor stand
-	private UUID uuid = UUID.randomUUID();
-
-	//sneaking flag of armor stands
-	private boolean sneaking;
-
-	//armor stand visibility
-	private boolean visible;
-
-	//list of players in entity tracking range (48 blocks)
-	private Set<TabPlayer> nearbyPlayers = Collections.synchronizedSet(new HashSet<TabPlayer>());
-
-	//property dedicated to this armor stand
-	private Property property;
-
-	//if offset is static or dynamic based on other armor stands
-	private boolean staticOffset;
-
-	//if marker tag should be used for 1.8.x clients
-	private boolean markerFor18x;
-
-	/**
-	 * Constructs new instance with given parameters
-	 * @param owner - armor stand owner
-	 * @param property - property for armor stand's name
-	 * @param yOffset - offset in blocks
-	 * @param staticOffset - if offset is static or not
-	 */
-	public BukkitArmorStand(int entityId, TabPlayer owner, Property property, double yOffset, boolean staticOffset) {
-		this.entityId = entityId;
-		this.owner = owner;
-		this.staticOffset = staticOffset;
-		player = (Player) owner.getPlayer();
-		this.yOffset = yOffset;
-		this.property = property;
-		markerFor18x = ((NameTagX)TAB.getInstance().getFeatureManager().getFeature("nametagx")).markerFor18x;
-		visible = getVisibility();
-	}
-
-	@Override
-	public void refresh() {
-		visible = getVisibility();
-		updateMetadata();
-	}
-
-	@Override
-	public Property getProperty() {
-		return property;
-	}
-
-	@Override
-	public boolean hasStaticOffset() {
-		return staticOffset;
-	}
-
-	@Override
-	public double getOffset() {
-		return yOffset;
-	}
-
-	@Override
-	public void setOffset(double offset) {
-		if (yOffset == offset) return;
-		yOffset = offset;
-		for (TabPlayer all : getNearbyPlayers()) {
-			all.sendPacket(getTeleportPacket(all), TabFeature.NAMETAGX);
-		}
-	}
-
-	/**
-	 * Returns list of packets to send to make armor stand spawn with metadata
-	 * @param viewer - viewer to apply relational placeholders for
-	 * @param addToRegistered - if player should be added to registered or not
-	 * @return List of packets that spawn the armor stand
-	 */
-	public Object[] getSpawnPackets(TabPlayer viewer) {
-		visible = getVisibility();
-		nearbyPlayers.add(viewer);
-		DataWatcher dataWatcher = createDataWatcher(property.getFormat(viewer), viewer);
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 15) {
-			return new Object[] {
-					getSpawnPacket(getArmorStandLocationFor(viewer), null),
-					getMetadataPacket(dataWatcher)
-			};
-		} else {
-			return new Object[] {
-					getSpawnPacket(getArmorStandLocationFor(viewer), dataWatcher)
-			};
-		}
-	}
-
-	@Override
-	public void spawn(TabPlayer viewer) {
-		for (Object packet : getSpawnPackets(viewer)) {
-			viewer.sendPacket(packet, TabFeature.NAMETAGX);
-		}
-	}
-
-	/**
-	 * Returns location where armor stand should be for specified viewer
-	 * @param viewer - player to get location for
-	 * @return location of armor stand
-	 */
-	private Location getArmorStandLocationFor(TabPlayer viewer) {
-		return viewer.getVersion().getMinorVersion() == 8 && !markerFor18x ? getLocation().clone().add(0,-2,0) : getLocation();
-	}
-
-	@Override
-	public void destroy(TabPlayer viewer) {
-		nearbyPlayers.remove(viewer);
-		viewer.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
-	}
-
-	@Override
-	public void teleport() {
-		for (TabPlayer all : getNearbyPlayers()) {
-			all.sendPacket(getTeleportPacket(all), TabFeature.NAMETAGX);
-		}
-	}
-
-	@Override
-	public void teleport(TabPlayer viewer) {
-		viewer.sendPacket(getTeleportPacket(viewer), TabFeature.NAMETAGX);
-	}
-
-	@Override
-	public void sneak(boolean sneaking) {
-		if (this.sneaking == sneaking) return; //idk
-		this.sneaking = sneaking;
-		for (TabPlayer viewer : getNearbyPlayers()) {
-			if (viewer.getVersion().getMinorVersion() == 14 && !TAB.getInstance().getConfiguration().armorStandsAlwaysVisible) {
-				//1.14.x client sided bug, despawning completely
-				if (sneaking) {
-					viewer.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
-				} else {
-					spawn(viewer);
-				}
-			} else {
-				//respawning so there's no animation and it's instant
-				viewer.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
-				Runnable spawn = () -> spawn(viewer);
-				if (viewer.getVersion().getMinorVersion() == 8) {
-					//1.8.0 client sided bug
-					TAB.getInstance().getCPUManager().runTaskLater(50, "compensating for 1.8.0 bugs", TabFeature.NAMETAGX, UsageType.v1_8_0_BUG_COMPENSATION, spawn);
-				} else {
-					spawn.run();
-				}
-			}
-		}
-	}
-
-	@Override
-	public void destroy() {
-		for (TabPlayer all : TAB.getInstance().getPlayers()) all.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
-		nearbyPlayers.clear();
-	}
-
-	@Override
-	public void updateVisibility(boolean force) {
-		boolean visible = getVisibility();
-		if (this.visible != visible || force) {
-			this.visible = visible;
-			updateMetadata();
-		}
-	}
-	
-
-	/**
-	 * Returns teleport packet for specified viewer
-	 * @param viewer - player to get location for
-	 * @return teleport packet
-	 */
-	private Object getTeleportPacket(TabPlayer viewer) {
-		try {
-			return ((BukkitPacketBuilder)TAB.getInstance().getPacketBuilder()).buildEntityTeleportPacket(entityId, getArmorStandLocationFor(viewer));
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to create PacketPlayOutEntityTeleport", e);
-		}
-	}
-	
-	/**
-	 * Returns destroy packet
-	 * @return destroy packet
-	 */
-	private Object getDestroyPacket() {
-		try {
-			return ((BukkitPacketBuilder)TAB.getInstance().getPacketBuilder()).buildEntityDestroyPacket(entityId);
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to create PacketPlayOutEntityDestroy", e);
-		}
-	}
-	
-	/**
-	 * Returns metadata packet with specified datawatcher
-	 * @param dataWatcher - datawatcher
-	 * @return metadata packet
-	 */
-	private Object getMetadataPacket(DataWatcher dataWatcher) {
-		try {
-			return ((BukkitPacketBuilder)TAB.getInstance().getPacketBuilder()).buildEntityMetadataPacket(entityId, dataWatcher);
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to create PacketPlayOutEntityMetadata", e);
-		}
-	}
-	
-	/**
-	 * Returns spawn packet with specified parameters
-	 * @param loc - location to spawn at
-	 * @param dataWatcher - datawatcher
-	 * @return spawn packet
-	 */
-	private Object getSpawnPacket(Location loc, DataWatcher dataWatcher) {
-		try {
-			return ((BukkitPacketBuilder)TAB.getInstance().getPacketBuilder()).buildEntitySpawnPacket(entityId, uuid, EntityType.ARMOR_STAND, loc, dataWatcher);
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to create PacketPlayOutSpawnEntityLiving", e);
-		}
-	}
-
-	/**
-	 * Updates armor stand's metadata
-	 */
-	private void updateMetadata() {
-		for (TabPlayer viewer : getNearbyPlayers()) {
-			viewer.sendPacket(getMetadataPacket(createDataWatcher(property.getFormat(viewer), viewer)), TabFeature.NAMETAGX);
-		}
-	}
-
-	/**
-	 * Returns general visibility rule for everyone with limited info
-	 * @return true if should be visible, false if not
-	 */
-	private boolean getVisibility() {
-		if (((BukkitTabPlayer)owner).isDisguised() || (((NameTagX)TAB.getInstance().getFeatureManager().getFeature("nametagx")).playersOnBoats.contains(owner))) return false;
-		if (TAB.getInstance().getConfiguration().armorStandsAlwaysVisible) return true;
-		return !player.hasPotionEffect(PotionEffectType.INVISIBILITY) && player.getGameMode() != GameMode.SPECTATOR && !owner.hasHiddenNametag() && property.get().length() > 0;
-	}
-
-	/**
-	 * Returns general location where armor stand should be at time of calling
-	 * @return Location where armor stand should be for everyone
-	 */
-	private Location getLocation() {
-		double x = player.getLocation().getX();
-		double y = getY() + yOffset + 2;
-		double z = player.getLocation().getZ();
-		if (player.isSleeping()) {
-			y -= 1.76;
-		} else {
-			if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-				y -= (sneaking ? 0.45 : 0.18);
-			} else {
-				y -= (sneaking ? 0.30 : 0.18);
-			}
-		}
-		return new Location(null,x,y,z);
-	}
-
-	/**
-	 * Returns Y where player is based on player's vehicle due to bukkit API bug
-	 * @return correct player's Y
-	 */
-	private double getY() {
-		//1.14+ bukkit api bug
-		Entity vehicle = player.getVehicle();
-		if (vehicle != null) {
-			if (vehicle.getType() == EntityType.HORSE) {
-				return vehicle.getLocation().getY() + 0.85;
-			}
-			if (vehicle.getType().toString().equals("DONKEY")) {
-				return vehicle.getLocation().getY() + 0.525;
-			}
-			if (vehicle.getType() == EntityType.PIG) {
-				return vehicle.getLocation().getY() + 0.325;
-			}
-			if (vehicle.getType().toString().equals("STRIDER")) { //preventing errors on <1.16
-				return vehicle.getLocation().getY() + 1.15;
-			}
-		}
-        //1.13+ swimming or 1.9+ flying with elytra
-        if (isSwimming() || (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9 && player.isGliding())) {
-            return player.getLocation().getY()-1.22;
-        }
-		return player.getLocation().getY();
-	}
-	
-	private boolean isSwimming() {
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 14 && player.getPose() == Pose.SWIMMING) return true;
-		return ProtocolVersion.SERVER_VERSION.getMinorVersion() == 13 && player.isSwimming();
-	}
-
-	@Override
-	public int getEntityId() {
-		return entityId;
-	}
-
-	@Override
-	public void removeFromRegistered(TabPlayer viewer) {
-		nearbyPlayers.remove(viewer);
-	}
-
-	/**
-	 * Creates data watcher with specified display name for viewer
-	 * @param displayName - armor stand name
-	 * @param viewer - player to apply checks against
-	 * @return datawatcher for viewer
-	 */
-	private DataWatcher createDataWatcher(String displayName, TabPlayer viewer) {
-		DataWatcher datawatcher = new DataWatcher();
-
-		byte flag = 32; //invisible
-		if (sneaking) flag += (byte)2;
-		datawatcher.helper().setEntityFlags(flag);
-		datawatcher.helper().setCustomName(displayName, viewer.getVersion());
-
-		boolean visible;
-		if (isNameVisiblyEmpty(displayName) || !((Player) viewer.getPlayer()).canSee(player) || owner.hasHiddenNametag(viewer.getUniqueId())) {
-			visible = false;
-		} else {
-			visible = this.visible;
-		}
-		datawatcher.helper().setCustomNameVisible(visible);
-
-		if (viewer.getVersion().getMinorVersion() > 8 || markerFor18x) datawatcher.helper().setArmorStandFlags((byte)16);
-		return datawatcher;
-	}
-
-	@Override
-	public Set<TabPlayer> getNearbyPlayers(){
-		synchronized (nearbyPlayers) {
-			return new HashSet<TabPlayer>(nearbyPlayers);
-		}
-	}
-
-	/**
-	 * Returns true if display name is in fact empty, for example only containing color codes
-	 * @param displayName - string to check
-	 * @return true if it's empty, false if not
-	 */
-	private boolean isNameVisiblyEmpty(String displayName) {
-		return IChatBaseComponent.fromColoredText(displayName).toRawText().replace(" ", "").length() == 0;
-	}
-}
@@ -1,176 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
-
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerTeleportEvent;
-
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
-
-/**
- * The event listener part for securing proper functionality of armor stands
- */
-public class EventListener implements Listener {
-	
-	//the nametag feature handler
-	private NameTagX feature;
-	
-	//list of players currently in a vehicle
-	private Map<TabPlayer, Entity> playersInVehicle = new ConcurrentHashMap<TabPlayer, Entity>();
-	
-	private Map<TabPlayer, Location> playerLocations = new ConcurrentHashMap<TabPlayer, Location>();
-
-	/**
-	 * Constructs new instance with given parameters
-	 * @param feature - nametagx feature handler
-	 */
-	public EventListener(NameTagX feature) {
-		this.feature = feature;
-		TAB.getInstance().getCPUManager().startRepeatingMeasuredTask(50, "ticking unlimited nametag mode", TabFeature.NAMETAGX, UsageType.TICKING_UNLIMITED_NAMETAGS, () -> {
-			
-			for (TabPlayer p : TAB.getInstance().getPlayers()) {
-				if (!p.isLoaded()) continue;
-				processVehicles(p);
-				if (feature.isDisabledWorld(p.getWorldName())) {
-					playerLocations.remove(p);
-					continue;
-				}
-				if (!playerLocations.containsKey(p) || !playerLocations.get(p).equals(((Player)p.getPlayer()).getLocation())) {
-					playerLocations.put(p, ((Player)p.getPlayer()).getLocation());
-					processPassengers((Entity) p.getPlayer());
-					if (p.isPreviewingNametag() && p.getArmorStandManager() != null) {
-						p.getArmorStandManager().teleport(p);
-					}
-				}
-				checkForTrackingRange(p);
-				
-				//death
-				if (((Player)p.getPlayer()).isDead()) {
-					for (TabPlayer other : p.getArmorStandManager().getNearbyPlayers()) {
-						p.getArmorStandManager().destroy(other);
-						other.getArmorStandManager().destroy(p);
-					}
-				}
-			}
-		});
-	}
-	
-	/**
-	 * Checks for vehicle changes of player and sends packets if needed
-	 * @param p - player to check
-	 */
-	private void processVehicles(TabPlayer p) {
-		if (feature.isDisabledWorld(p.getWorldName())) {
-			playersInVehicle.remove(p);
-			return;
-		}
-		Entity vehicle = ((Player)p.getPlayer()).getVehicle();
-		if (playersInVehicle.containsKey(p) && vehicle == null) {
-			//vehicle exit
-			feature.vehicles.remove(playersInVehicle.get(p).getEntityId());
-			p.getArmorStandManager().teleport();
-			playersInVehicle.remove(p);
-		}
-		if (!playersInVehicle.containsKey(p) && vehicle != null) {
-			//vehicle enter
-			feature.vehicles.put(vehicle.getEntityId(), feature.getPassengers(vehicle));
-			p.getArmorStandManager().teleport();
-			playersInVehicle.put(p, vehicle);
-		}
-	}
-	
-	/**
-	 * Teleport event listener to track vehicles & send own packets when using nametag preview
-	 * @param e - teleport event
-	 */
-	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-	public void onTeleport(PlayerTeleportEvent e) {
-		TabPlayer p = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
-		if (p == null || feature.isDisabledWorld(p.getWorldName())) return;
-		TAB.getInstance().getCPUManager().runTaskLater(100, "processing PlayerTeleportEvent", TabFeature.NAMETAGX, UsageType.PLAYER_TELEPORT_EVENT, () -> {
-			
-			if (p.getArmorStandManager() != null) p.getArmorStandManager().teleport();
-		});
-	}
-	
-	//preventing memory leak
-	public void onQuit(TabPlayer p) {
-		playersInVehicle.remove(p);
-		playerLocations.remove(p);
-	}
-	
-	/**
-	 * Checks for tracking range and spawns/despawns armor stands if needed
-	 * @param player - player to check tracking range of
-	 * @param newLocation - location player moved/teleported to
-	 */
-	private void checkForTrackingRange(TabPlayer player) {
-		Set<TabPlayer> nearbyPlayer = player.getArmorStandManager().getNearbyPlayers();
-		for (TabPlayer other : TAB.getInstance().getPlayers()) {
-			if (other == player || !other.getWorldName().equals(player.getWorldName()) || !other.isLoaded() || 
-					((Player)player.getPlayer()).isDead() || ((Player)other.getPlayer()).isDead()) continue;
-			Set<TabPlayer> nearbyOther = other.getArmorStandManager().getNearbyPlayers();
-			if (inRange(((Player)other.getPlayer()).getLocation(), ((Player)player.getPlayer()).getLocation())) {
-				//in range
-				if (!nearbyPlayer.contains(other) && ((Player)other.getPlayer()).canSee((Player)player.getPlayer())) {
-					player.getArmorStandManager().spawn(other);
-				}
-				if (!nearbyOther.contains(player) && ((Player)player.getPlayer()).canSee((Player)other.getPlayer())) {
-					other.getArmorStandManager().spawn(player);
-				}
-				if (nearbyPlayer.contains(other) && !((Player)other.getPlayer()).canSee((Player)player.getPlayer())) {
-					player.getArmorStandManager().destroy(other);
-				}
-				if (nearbyOther.contains(player) && !((Player)player.getPlayer()).canSee((Player)other.getPlayer())) {
-					other.getArmorStandManager().destroy(player);
-				}
-			} else {
-				//out of range
-				if (nearbyPlayer.contains(other)) {
-					player.getArmorStandManager().destroy(other);
-				}
-				if (nearbyOther.contains(player)) {
-					other.getArmorStandManager().destroy(player);
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Method with extra performance-saving checks that returns true if distance between locations is
-	 * lower than entity tracking range, false otherwise
-	 * @param loc1 - first location
-	 * @param loc2 - second location
-	 * @return true if distance is in tracking range, false if not
-	 */
-	private boolean inRange(Location loc1, Location loc2) {
-		if (Math.abs(loc1.getX() - loc2.getX()) > feature.entityTrackingRange || 
-			Math.abs(loc1.getZ() - loc2.getZ()) > feature.entityTrackingRange) return false;
-		return Math.sqrt(Math.pow(loc1.getX()-loc2.getX(), 2) + Math.pow(loc1.getZ()-loc2.getZ(), 2)) <= feature.entityTrackingRange;
-	}
-	
-	/**
-	 * Teleports armor stands of all passengers on specified vehicle
-	 * @param vehicle - entity to check passengers of
-	 */
-	private void processPassengers(Entity vehicle) {
-		for (Entity passenger : feature.getPassengers(vehicle)) {
-			if (passenger instanceof Player) {
-				TabPlayer pl = TAB.getInstance().getPlayer(passenger.getUniqueId());
-				pl.getArmorStandManager().teleport();
-			} else {
-				processPassengers(passenger);
-			}
-		}
-	}
-}
@@ -1,341 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import me.neznamy.tab.api.ArmorStand;
-import me.neznamy.tab.api.ArmorStandManager;
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.Property;
-import me.neznamy.tab.shared.ProtocolVersion;
-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.NameTag;
-import me.neznamy.tab.shared.features.types.event.RespawnEventListener;
-import me.neznamy.tab.shared.features.types.event.SneakEventListener;
-
-/**
- * The core class for unlimited nametag mode
- */
-public class NameTagX extends NameTag implements RespawnEventListener, SneakEventListener {
-
-	//config options
-	public boolean markerFor18x;
-	public boolean disableOnBoats;
-	private double spaceBetweenLines;
-	public double entityTrackingRange;
-	
-	//list of defined dynamic lines
-	public List<String> dynamicLines = Arrays.asList("belowname", "nametag", "abovename");
-	
-	//map of defined static lines
-	public Map<String, Object> staticLines = new ConcurrentHashMap<String, Object>();
-
-	//entity id counter to pick unique entity IDs
-	private int idCounter = 2000000000;
-
-	//player data by entityId, used for better performance
-	public Map<Integer, TabPlayer> entityIdMap = new ConcurrentHashMap<Integer, TabPlayer>();
-	
-	//map of vehicles carrying players
-	public Map<Integer, List<Entity>> vehicles = new ConcurrentHashMap<Integer, List<Entity>>();
-	
-	//bukkit event listener
-	private EventListener eventListener;
-	
-	//list of players currently on boats
-	public List<TabPlayer> playersOnBoats = new ArrayList<TabPlayer>();
-	
-	//list of worlds with unlimited nametag mode disabled
-	protected List<String> disabledUnlimitedWorlds;
-
-	/**
-	 * Constructs new instance with given parameters and loads config options
-	 * @param plugin - plugin instance
-	 * @param nms - nms storage
-	 * @param tab - tab instance
-	 */
-	public NameTagX(JavaPlugin plugin, NMSStorage nms, TAB tab) {
-		super(tab);
-		markerFor18x = tab.getConfiguration().config.getBoolean("unlimited-nametag-prefix-suffix-mode.use-marker-tag-for-1-8-x-clients", false);
-		disableOnBoats = tab.getConfiguration().config.getBoolean("unlimited-nametag-prefix-suffix-mode.disable-on-boats", true);
-		spaceBetweenLines = tab.getConfiguration().config.getDouble("unlimited-nametag-prefix-suffix-mode.space-between-lines", 0.22);
-		entityTrackingRange = tab.getConfiguration().config.getDouble("unlimited-nametag-prefix-suffix-mode.tracking-range", 48);
-		disabledUnlimitedWorlds = tab.getConfiguration().config.getStringList("disable-features-in-worlds.unlimited-nametags", Arrays.asList("disabledworld"));
-		if (tab.getConfiguration().premiumconfig != null) {
-			List<String> realList = tab.getConfiguration().premiumconfig.getStringList("unlimited-nametag-mode-dynamic-lines", Arrays.asList("abovename", "nametag", "belowname", "another"));
-			dynamicLines = new ArrayList<String>();
-			dynamicLines.addAll(realList);
-			Collections.reverse(dynamicLines);
-			staticLines = tab.getConfiguration().premiumconfig.getConfigurationSection("unlimited-nametag-mode-static-lines");
-		}
-		refreshUsedPlaceholders();
-		eventListener = new EventListener(this);
-		Bukkit.getPluginManager().registerEvents(eventListener, plugin);
-		tab.getFeatureManager().registerFeature("nametagx-packet", new PacketListener(this, nms, tab));
-	}
-
-	@Override
-	public void load() {
-		super.load();
-		for (TabPlayer all : tab.getPlayers()) {
-			entityIdMap.put(((Player) all.getPlayer()).getEntityId(), all);
-			loadArmorStands(all);
-			if (isDisabledWorld(all.getWorldName()) || isDisabledWorld(disabledUnlimitedWorlds, all.getWorldName())) continue;
-			loadPassengers(all);
-			for (TabPlayer viewer : tab.getPlayers()) {
-				spawnArmorStands(all, viewer, false);
-			}
-		}
-		tab.getCPUManager().startRepeatingMeasuredTask(500, "refreshing nametag visibility", getFeatureType(), UsageType.REFRESHING_NAMETAG_VISIBILITY_AND_COLLISION, new Runnable() {
-			public void run() {
-				for (TabPlayer p : tab.getPlayers()) {
-					if (!p.isLoaded() || isDisabledWorld(p.getWorldName()) || isDisabledWorld(disabledUnlimitedWorlds, p.getWorldName())) continue;
-					p.getArmorStandManager().updateVisibility(false);
-					if (!disableOnBoats) continue;
-					boolean onBoat = ((Player)p.getPlayer()).getVehicle() != null && ((Player)p.getPlayer()).getVehicle().getType() == EntityType.BOAT;
-					if (onBoat) {
-						if (!playersOnBoats.contains(p)) {
-							playersOnBoats.add(p);
-							updateTeamData(p);
-						}
-					} else {
-						if (playersOnBoats.contains(p)) {
-							playersOnBoats.remove(p);
-							updateTeamData(p);
-						}
-					}
-				}
-			}
-		});
-	}
-
-	@Override
-	public void unload() {
-		super.unload();
-		HandlerList.unregisterAll(eventListener);
-		for (TabPlayer p : tab.getPlayers()) {
-			if (p.getArmorStandManager() != null) p.getArmorStandManager().destroy();
-		}
-		entityIdMap.clear();
-	}
-
-	@Override
-	public void onJoin(TabPlayer connectedPlayer) {
-		super.onJoin(connectedPlayer);
-		entityIdMap.put(((Player) connectedPlayer.getPlayer()).getEntityId(), connectedPlayer);
-		loadArmorStands(connectedPlayer);
-		if (isDisabledWorld(connectedPlayer.getWorldName()) || isDisabledWorld(disabledUnlimitedWorlds, connectedPlayer.getWorldName())) return;
-		loadPassengers(connectedPlayer);
-		for (TabPlayer viewer : tab.getPlayers()) {
-			spawnArmorStands(connectedPlayer, viewer, true);
-		}
-	}
-	
-	/**
-	 * Returns flat distance between two players ignoring Y value
-	 * @param player1 - first player
-	 * @param player2 - second player
-	 * @return flat distance in blocks
-	 */
-	private double getDistance(TabPlayer player1, TabPlayer player2) {
-		Location loc1 = ((Player) player1.getPlayer()).getLocation();
-		Location loc2 = ((Player) player2.getPlayer()).getLocation();
-		return Math.sqrt(Math.pow(loc1.getX()-loc2.getX(), 2) + Math.pow(loc1.getZ()-loc2.getZ(), 2));
-	}
-
-	/**
-	 * Loads all passengers riding this player and adds them to vehicle list
-	 * @param p - player to load passengers of
-	 */
-	private void loadPassengers(TabPlayer p) {
-		if (((Entity) p.getPlayer()).getVehicle() == null) return;
-		Entity vehicle = ((Entity) p.getPlayer()).getVehicle();
-		vehicles.put(vehicle.getEntityId(), getPassengers(vehicle));
-	}
-
-	@Override
-	public void onQuit(TabPlayer disconnectedPlayer) {
-		super.onQuit(disconnectedPlayer);
-		for (TabPlayer all : tab.getPlayers()) {
-			if (all.getArmorStandManager() != null) all.getArmorStandManager().unregisterPlayer(disconnectedPlayer);
-		}
-		entityIdMap.remove(((Player) disconnectedPlayer.getPlayer()).getEntityId());
-		eventListener.onQuit(disconnectedPlayer);
-
-		tab.getCPUManager().runTaskLater(100, "processing onQuit", getFeatureType(), UsageType.PLAYER_QUIT_EVENT, () -> disconnectedPlayer.getArmorStandManager().destroy());
-	}
-
-	@Override
-	public void onWorldChange(TabPlayer p, String from, String to) {
-		super.onWorldChange(p, from, to);
-		p.getArmorStandManager().destroy();
-		loadArmorStands(p);
-		loadPassengers(p);
-		for (TabPlayer viewer : tab.getPlayers()) {
-			spawnArmorStands(p, viewer, true);
-			viewer.getArmorStandManager().destroy(p);
-		}
-	}
-	
-	/**
-	 * Spawns armor stands of specified owner to viewer and, mutually if set
-	 * @param owner - armor stand owner
-	 * @param viewer - player to spawn armor stands for
-	 * @param sendMutually - if packets should be sent both ways
-	 */
-	private void spawnArmorStands(TabPlayer owner, TabPlayer viewer, boolean sendMutually) {
-		if (owner == viewer) return; //not displaying own armorstands
-		if (((Player) viewer.getPlayer()).getWorld() != ((Player) owner.getPlayer()).getWorld()) return; //different world
-		if (getDistance(viewer, owner) <= entityTrackingRange) {
-			if (((Player)viewer.getPlayer()).canSee((Player)owner.getPlayer())) owner.getArmorStandManager().spawn(viewer);
-			if (sendMutually && viewer.getArmorStandManager() != null && ((Player)owner.getPlayer()).canSee((Player)viewer.getPlayer())) viewer.getArmorStandManager().spawn(owner);
-		}
-	}
-
-	/**
-	 * Restarts and loads armor stands from config
-	 * @param pl - player to load
-	 */
-	public void loadArmorStands(TabPlayer pl) {
-		pl.setArmorStandManager(new ArmorStandManager());
-		pl.setProperty("nametag", pl.getProperty("tagprefix").getCurrentRawValue() + pl.getProperty("customtagname").getCurrentRawValue() + pl.getProperty("tagsuffix").getCurrentRawValue());
-		double height = -spaceBetweenLines;
-		for (String line : dynamicLines) {
-			Property p = pl.getProperty(line);
-			if (p.getCurrentRawValue().length() == 0) continue;
-			pl.getArmorStandManager().addArmorStand(line, new BukkitArmorStand(idCounter++, pl, p, height+=spaceBetweenLines, false));
-		}
-		for (Entry<String, Object> line : staticLines.entrySet()) {
-			Property p = pl.getProperty(line.getKey());
-			if (p.getCurrentRawValue().length() == 0) continue;
-			pl.getArmorStandManager().addArmorStand(line.getKey(), new BukkitArmorStand(idCounter++, pl, p, Double.parseDouble(line.getValue().toString()), true));
-		}
-		fixArmorStandHeights(pl);
-	}
-
-	/**
-	 * Fixes heights of all armor stands of specified player due to dynamic lines
-	 * @param p - player to fix armor stands heights for
-	 */
-	public void fixArmorStandHeights(TabPlayer p) {
-		p.getArmorStandManager().refresh();
-		double currentY = -spaceBetweenLines;
-		for (ArmorStand as : p.getArmorStandManager().getArmorStands()) {
-			if (as.hasStaticOffset()) continue;
-			if (as.getProperty().get().length() != 0) {
-				currentY += spaceBetweenLines;
-				as.setOffset(currentY);
-			}
-		}
-	}
-
-	@Override
-	public void refresh(TabPlayer refreshed, boolean force) {
-		super.refresh(refreshed, force);
-		if (isDisabledWorld(refreshed.getWorldName()) || isDisabledWorld(disabledUnlimitedWorlds, refreshed.getWorldName())) return;
-		if (force) {
-			refreshed.getArmorStandManager().destroy();
-			loadArmorStands(refreshed);
-			loadPassengers(refreshed);
-			for (TabPlayer viewer : tab.getPlayers()) {
-				if (viewer == refreshed) continue;
-				if (viewer.getWorldName().equals(refreshed.getWorldName())) {
-					refreshed.getArmorStandManager().spawn(viewer);
-				}
-			}
-		} else {
-			boolean fix = false;
-			for (ArmorStand as : refreshed.getArmorStandManager().getArmorStands()) {
-				if (as.getProperty().update()) {
-					as.refresh();
-					fix = true;
-				}
-			}
-			if (fix) fixArmorStandHeights(refreshed);
-		}
-	}
-
-	/**
-	 * Updates raw values of properties for specified player
-	 * @param p - player to update
-	 */
-	public void updateProperties(TabPlayer p) {
-		super.updateProperties(p);
-		p.loadPropertyFromConfig("customtagname", p.getName());
-		p.setProperty("nametag", p.getProperty("tagprefix").getCurrentRawValue() + p.getProperty("customtagname").getCurrentRawValue() + p.getProperty("tagsuffix").getCurrentRawValue());
-		for (String property : dynamicLines) {
-			if (!property.equals("nametag")) p.loadPropertyFromConfig(property);
-		}
-		for (String property : staticLines.keySet()) {
-			if (!property.equals("nametag")) p.loadPropertyFromConfig(property);
-		}
-	}
-
-	/**
-	 * Returns list of all passengers on specified vehicle
-	 * @param vehicle - vehicle to check passengers of
-	 * @return list of passengers
-	 */
-	@SuppressWarnings("deprecation")
-	public List<Entity> getPassengers(Entity vehicle){
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 11) {
-			return vehicle.getPassengers();
-		} else {
-			if (vehicle.getPassenger() != null) {
-				return Arrays.asList(vehicle.getPassenger());
-			} else {
-				return new ArrayList<Entity>();
-			}
-		}
-	}
-
-	@Override
-	public void refreshUsedPlaceholders() {
-		usedPlaceholders = tab.getConfiguration().config.getUsedPlaceholderIdentifiersRecursive("tagprefix", "customtagname", "tagsuffix");
-		for (String line : dynamicLines) {
-			usedPlaceholders.addAll(tab.getConfiguration().config.getUsedPlaceholderIdentifiersRecursive(line));
-		}
-		for (String line : staticLines.keySet()) {
-			usedPlaceholders.addAll(tab.getConfiguration().config.getUsedPlaceholderIdentifiersRecursive(line));
-		}
-	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.NAMETAGX;
-	}
-
-	@Override
-	public void onRespawn(TabPlayer respawned) {
-		if (isDisabledWorld(respawned.getWorldName())) return;
-		respawned.getArmorStandManager().teleport();
-	}
-
-	@Override
-	public void onSneak(TabPlayer player, boolean isSneaking) {
-		if (isDisabledWorld(player.getWorldName())) return;
-		player.getArmorStandManager().sneak(isSneaking);
-	}
-
-	@Override
-	public boolean getTeamVisibility(TabPlayer p, TabPlayer viewer) {
-		//only visible if player is on boat & config option is enabled and player is not invisible (1.8 bug)
-		return playersOnBoats.contains(p) && !invisiblePlayers.contains(p.getName());
-	}
-}
@@ -1,117 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
-
-import java.util.List;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-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.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
-import me.neznamy.tab.shared.features.types.packet.PlayerInfoPacketListener;
-import me.neznamy.tab.shared.features.types.packet.RawPacketListener;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.EnumPlayerInfoAction;
-import me.neznamy.tab.shared.packets.PacketPlayOutPlayerInfo.PlayerInfoData;
-
-/**
- * The packet listening part for securing proper functionality of armor stands
- * Bukkit events are too unreliable and delayed/ahead which causes desync
- */
-public class PacketListener implements RawPacketListener, PlayerInfoPacketListener {
-
-	//main feature
-	private NameTagX nameTagX;
-	
-	//nms storage
-	private NMSStorage nms;
-	
-	//tab instance
-	private TAB tab;
-	
-	//if modifying npc names or not
-	private boolean modifyNPCnames;
-
-	/**
-	 * Constructs new instance with given parameters and loads config options
-	 * @param nameTagX - main feature
-	 * @param nms - nms storage
-	 * @param tab - tab instance
-	 */
-	public PacketListener(NameTagX nameTagX, NMSStorage nms, TAB tab) {
-		this.nameTagX = nameTagX;
-		this.nms = nms;
-		this.tab = tab;
-		modifyNPCnames = tab.getConfiguration().config.getBoolean("unlimited-nametag-prefix-suffix-mode.modify-npc-names", false);
-	}
-
-	@Override
-	public Object onPacketReceive(TabPlayer sender, Object packet) throws Throwable {
-		if (sender.getVersion().getMinorVersion() == 8 && nms.PacketPlayInUseEntity.isInstance(packet)) {
-			int entityId = nms.PacketPlayInUseEntity_ENTITY.getInt(packet);
-			TabPlayer attacked = null;
-			for (TabPlayer all : tab.getPlayers()) {
-				if (!all.isLoaded()) continue;
-				if (all.getArmorStandManager().hasArmorStandWithID(entityId)) {
-					attacked = all;
-					break;
-				}
-			}
-			if (attacked != null && attacked != sender) {
-				nms.PacketPlayInUseEntity_ENTITY.set(packet, ((Player) attacked.getPlayer()).getEntityId());
-			}
-		}
-		return packet;
-	}
-
-	@Override
-	public void onPacketSend(TabPlayer receiver, Object packet) throws Throwable {
-		if (nms.PacketPlayOutEntity.isInstance(packet) && !packet.getClass().getSimpleName().equals("PacketPlayOutEntityLook")) {
-			onEntityMove(receiver, nms.PacketPlayOutEntity_ENTITYID.getInt(packet));
-		}
-	}
-
-	/**
-	 * Processes entity move packet
-	 * @param receiver - packet receiver
-	 * @param entityId - entity that moved
-	 */
-	public void onEntityMove(TabPlayer receiver, int entityId) {
-		TabPlayer pl = nameTagX.entityIdMap.get(entityId);
-		List<Entity> vehicleList;
-		if (pl != null) {
-			//player moved
-			if (!pl.isLoaded() || nameTagX.isDisabledWorld(pl.getWorldName())) return;
-			tab.getCPUManager().runMeasuredTask("processing EntityMove", getFeatureType(), UsageType.PACKET_ENTITY_MOVE, () -> pl.getArmorStandManager().teleport(receiver));
-		} else if ((vehicleList = nameTagX.vehicles.get(entityId)) != null){
-			//a vehicle carrying something moved
-			for (Entity entity : vehicleList) {
-				TabPlayer passenger = nameTagX.entityIdMap.get(entity.getEntityId());
-				if (passenger != null && passenger.getArmorStandManager() != null && !nameTagX.isDisabledWorld(passenger.getWorldName())) {
-					tab.getCPUManager().runMeasuredTask("processing EntityMove", getFeatureType(), UsageType.PACKET_ENTITY_MOVE, () -> passenger.getArmorStandManager().teleport(receiver));
-				}
-			}
-		}
-	}
-
-	@Override
-	public void onPacketSend(TabPlayer receiver, PacketPlayOutPlayerInfo info) {
-		if (!modifyNPCnames || info.action != EnumPlayerInfoAction.ADD_PLAYER) return;
-		for (PlayerInfoData playerInfoData : info.entries) {
-			if (tab.getPlayerByTablistUUID(playerInfoData.uniqueId) == null && playerInfoData.name.length() <= 15) {
-				if (playerInfoData.name.length() <= 14) {
-					playerInfoData.name += "\u00a7r";
-				} else {
-					playerInfoData.name += " ";
-				}
-			}
-		}
-	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.NAMETAGX;
-	}
-}
@@ -1,703 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.nms;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-
-import io.netty.channel.Channel;
-import me.neznamy.tab.platforms.bukkit.Main;
-import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherRegistry;
-
-@SuppressWarnings({"unchecked", "rawtypes"})
-public class NMSStorage {
-
-	//instance of this class
-	private static NMSStorage instance;
-	
-	//field mapping changes in thermos
-	private Map<String, String> thermosFieldMappings = new HashMap<String, String>();
-	
-	//data watcher registry
-	public DataWatcherRegistry dataWatcherRegistry;
-	
-	//server package, such as "v1_16_R3"
-	private String serverPackage;
-	
-	//server minor version such as "16"
-	public int minorVersion;
-
-	public Field PING;
-	public Field PLAYER_CONNECTION;
-	public Field NETWORK_MANAGER;
-	public Field CHANNEL;
-	public Method getHandle;
-	public Method getProfile;
-	public Method sendPacket;
-
-	//chat
-	public Class<Enum> EnumChatFormat;
-	public Class<?> IChatBaseComponent;
-	public Class<?> ChatBaseComponent;
-	public Class<?> ChatSerializer;
-	public Class<?> EnumClickAction;
-	public Class<?> EnumHoverAction;
-	public Class<?> ChatModifier;
-	public Class<?> ChatComponentText;
-	public Class<?> ChatClickable;
-	public Class<?> ChatHoverable;
-	public Class<?> ChatHexColor;
-	public Constructor<?> newChatComponentText;
-	public Constructor<?> newChatClickable;
-	public Constructor<?> newChatHoverable;
-	public Constructor<?> newChatModifier;
-	public Field ChatBaseComponent_extra;
-	public Field ChatBaseComponent_modifier;
-	public Field ChatClickable_action;
-	public Field ChatClickable_value;
-	public Field ChatHexColor_name;
-	public Field ChatHexColor_rgb;
-	public Field ChatHoverable_action;
-	public Field ChatHoverable_value;
-	public Field ChatModifier_color;
-	public Field ChatModifier_bold;
-	public Field ChatModifier_italic;
-	public Field ChatModifier_underlined;
-	public Field ChatModifier_strikethrough;
-	public Field ChatModifier_obfuscated;
-	public Field ChatModifier_clickEvent;
-	public Field ChatModifier_hoverEvent;
-	public Field ChatComponentText_text;
-	public Method ChatSerializer_DESERIALIZE;
-	public Method EnumClickAction_a;
-	public Method EnumHoverAction_a;
-	public Method ChatHexColor_ofInt;
-	public Method ChatHexColor_ofString;
-	public Method ChatComponentText_addSibling;
-
-	//PacketPlayOutBoss
-	public Class<?> PacketPlayOutBoss;
-	public Class<Enum> BarColor;
-	public Class<Enum> BarStyle;
-	public Class<Enum> PacketPlayOutBoss_Action;
-	public Constructor<?> newPacketPlayOutBoss;
-	public Field PacketPlayOutBoss_UUID;
-	public Field PacketPlayOutBoss_ACTION;
-	public Field PacketPlayOutBoss_NAME;
-	public Field PacketPlayOutBoss_PROGRESS;
-	public Field PacketPlayOutBoss_COLOR;
-	public Field PacketPlayOutBoss_STYLE;
-	public Field PacketPlayOutBoss_DARKEN_SKY;
-	public Field PacketPlayOutBoss_PLAY_MUSIC;
-	public Field PacketPlayOutBoss_CREATE_FOG;
-
-	//PacketPlayOutChat
-	public Class<?> PacketPlayOutChat;
-	public Class<Enum> ChatMessageType;
-	public Constructor<?> newPacketPlayOutChat;
-	public Field PacketPlayOutChat_MESSAGE;
-	public Field PacketPlayOutChat_POSITION;
-	public Field PacketPlayOutChat_SENDER;
-
-	//PacketPlayOutPlayerListHeaderFooter
-	public Class<?> PacketPlayOutPlayerListHeaderFooter;
-	public Constructor<?> newPacketPlayOutPlayerListHeaderFooter;
-	public Field PacketPlayOutPlayerListHeaderFooter_HEADER;
-	public Field PacketPlayOutPlayerListHeaderFooter_FOOTER;
-
-	//PacketPlayOutScoreboardDisplayObjective
-	public Class<?> PacketPlayOutScoreboardDisplayObjective;
-	public Constructor<?> newPacketPlayOutScoreboardDisplayObjective;
-	public Field PacketPlayOutScoreboardDisplayObjective_POSITION;
-	public Field PacketPlayOutScoreboardDisplayObjective_OBJECTIVENAME;
-
-	//PacketPlayOutScoreboardObjective
-	public Class<?> PacketPlayOutScoreboardObjective;
-	public Class<Enum> EnumScoreboardHealthDisplay;
-	public Constructor<?> newPacketPlayOutScoreboardObjective;
-	public Field PacketPlayOutScoreboardObjective_OBJECTIVENAME;
-	public Field PacketPlayOutScoreboardObjective_DISPLAYNAME;
-	public Field PacketPlayOutScoreboardObjective_RENDERTYPE;
-	public Field PacketPlayOutScoreboardObjective_METHOD;
-
-	//PacketPlayOutScoreboardScore
-	public Class<?> PacketPlayOutScoreboardScore;
-	public Class<Enum> EnumScoreboardAction;
-	public Constructor<?> newPacketPlayOutScoreboardScore0;
-	public Constructor<?> newPacketPlayOutScoreboardScore_String;
-	public Constructor<?> newPacketPlayOutScoreboardScore_1_13;
-	public Field PacketPlayOutScoreboardScore_PLAYER;
-	public Field PacketPlayOutScoreboardScore_OBJECTIVENAME;
-	public Field PacketPlayOutScoreboardScore_SCORE;
-	public Field PacketPlayOutScoreboardScore_ACTION;
-
-	//PacketPlayOutScoreboardTeam
-	public Class<?> PacketPlayOutScoreboardTeam;
-	public Constructor<?> newPacketPlayOutScoreboardTeam;
-	public Field PacketPlayOutScoreboardTeam_NAME;
-	public Field PacketPlayOutScoreboardTeam_DISPLAYNAME;
-	public Field PacketPlayOutScoreboardTeam_PREFIX;
-	public Field PacketPlayOutScoreboardTeam_SUFFIX;
-	public Field PacketPlayOutScoreboardTeam_VISIBILITY; //1.8+
-	public Field PacketPlayOutScoreboardTeam_CHATFORMAT; //1.13+
-	public Field PacketPlayOutScoreboardTeam_COLLISION; //1.9+
-	public Field PacketPlayOutScoreboardTeam_PLAYERS;
-	public Field PacketPlayOutScoreboardTeam_ACTION;
-	public Field PacketPlayOutScoreboardTeam_SIGNATURE;
-
-	//PacketPlayOutPlayerInfo
-	public Class<?> PacketPlayOutPlayerInfo;
-	public Class<Enum> EnumGamemode;
-	public Class<Enum> EnumPlayerInfoAction;
-	public Class<?> PlayerInfoData;
-	public Constructor<?> newPacketPlayOutPlayerInfo;
-	public Constructor<?> newPlayerInfoData;
-
-	public Class<?> GameProfile;
-	public Constructor<?> newGameProfile;
-	public Field GameProfile_ID;
-	public Field GameProfile_NAME;
-	public Field GameProfile_PROPERTIES;
-	public Class<?> PropertyMap;
-	public Method PropertyMap_putAll;
-
-	public Field PacketPlayOutPlayerInfo_ACTION;
-	public Field PacketPlayOutPlayerInfo_PLAYERS;
-
-	public Field PlayerInfoData_PING;
-	public Field PlayerInfoData_GAMEMODE;
-	public Field PlayerInfoData_PROFILE;
-	public Field PlayerInfoData_LISTNAME;
-
-	//PacketPlayOutTitle
-	public Class<?> PacketPlayOutTitle;
-	public Constructor<?> newPacketPlayOutTitle;
-	public Class<Enum> EnumTitleAction;
-
-	public Class<?> PacketPlayOutEntityDestroy;
-	public Constructor<?> newPacketPlayOutEntityDestroy;
-
-	public Class<?> PacketPlayInUseEntity;
-	public Field PacketPlayInUseEntity_ENTITY;
-	public Field PacketPlayInUseEntity_ACTION;
-
-	public Class<?> PacketPlayOutEntity;
-	public Field PacketPlayOutEntity_ENTITYID;
-
-	public Class<?> PacketPlayOutEntityTeleport;
-	public Constructor<?> newPacketPlayOutEntityTeleport;
-	public Field PacketPlayOutEntityTeleport_ENTITYID;
-	public Field PacketPlayOutEntityTeleport_X;
-	public Field PacketPlayOutEntityTeleport_Y;
-	public Field PacketPlayOutEntityTeleport_Z;
-	public Field PacketPlayOutEntityTeleport_YAW;
-	public Field PacketPlayOutEntityTeleport_PITCH;
-
-	public Class<?> PacketPlayOutEntityMetadata;
-	public Constructor<?> newPacketPlayOutEntityMetadata;
-	public Field PacketPlayOutEntityMetadata_LIST;
-
-	public Class<?> PacketPlayOutSpawnEntityLiving;
-	public Constructor<?> newPacketPlayOutSpawnEntityLiving;
-	public Field PacketPlayOutSpawnEntityLiving_ENTITYID;
-	public Field PacketPlayOutSpawnEntityLiving_UUID;
-	public Field PacketPlayOutSpawnEntityLiving_ENTITYTYPE;
-	public Field PacketPlayOutSpawnEntityLiving_X;
-	public Field PacketPlayOutSpawnEntityLiving_Y;
-	public Field PacketPlayOutSpawnEntityLiving_Z;
-	public Field PacketPlayOutSpawnEntityLiving_YAW;
-	public Field PacketPlayOutSpawnEntityLiving_PITCH;
-	public Field PacketPlayOutSpawnEntityLiving_DATAWATCHER;
-
-	//DataWatcher
-	public Class<?> DataWatcher;
-	public Constructor<?> newDataWatcher;
-	public Method DataWatcher_REGISTER;
-
-	public Class<?> DataWatcherItem;
-	public Constructor<?> newDataWatcherItem;
-	public Field DataWatcherItem_TYPE;
-	public Field DataWatcherItem_VALUE;
-
-	public Class<?> DataWatcherObject;
-	public Constructor<?> newDataWatcherObject;
-	public Field DataWatcherObject_SLOT;
-	public Field DataWatcherObject_SERIALIZER;
-
-	public Class<?> DataWatcherRegistry;
-
-	/**
-	 * Creates new instance, initializes required NMS classes and fields
-	 * @throws Exception - if something fails
-	 */
-	public NMSStorage() throws Exception {
-		serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-		minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
-		loadThermosMappings();
-		initializeClasses();
-		initializeConstructors();
-		initializeFields();
-		initializeMethods();
-		dataWatcherRegistry = new DataWatcherRegistry(DataWatcherRegistry);
-	}
-	
-	/**
-	 * Sets new instance
-	 * @param instance - new instance
-	 */
-	public static void setInstance(NMSStorage instance) {
-		NMSStorage.instance = instance;
-	}
-	
-	/**
-	 * Returns instance
-	 * @return instance
-	 */
-	public static NMSStorage getInstance() {
-		return instance;
-	}
-
-	/**
-	 * Puts thermos mapping changes into map
-	 */
-	private void loadThermosMappings() {
-		thermosFieldMappings.put("ping", "field_71138_i");
-		thermosFieldMappings.put("playerConnection", "field_71135_a");
-		thermosFieldMappings.put("networkManager", "field_147371_a");
-	}
-	
-	/**
-	 * Initializes required NMS classes
-	 * @throws Exception - if something fails
-	 */
-	public void initializeClasses() throws Exception {
-		ChatModifier = getNMSClass("ChatModifier");
-		ChatBaseComponent = getNMSClass("ChatBaseComponent");
-		ChatComponentText = getNMSClass("ChatComponentText");
-		ChatClickable = getNMSClass("ChatClickable");
-		ChatHoverable = getNMSClass("ChatHoverable");
-		DataWatcher = getNMSClass("DataWatcher");
-		//1.9+; v1_8_R2 & v1_8_R3; 1.7 - v1_8_R1
-		DataWatcherItem = getNMSClass("DataWatcher$Item", "DataWatcher$WatchableObject", "WatchableObject");
-		EnumChatFormat = (Class<Enum>) getNMSClass("EnumChatFormat");
-		IChatBaseComponent = getNMSClass("IChatBaseComponent");
-		PacketPlayInUseEntity = getNMSClass("PacketPlayInUseEntity");
-		PacketPlayOutChat = getNMSClass("PacketPlayOutChat");
-		PacketPlayOutEntity = getNMSClass("PacketPlayOutEntity");
-		PacketPlayOutEntityDestroy = getNMSClass("PacketPlayOutEntityDestroy");
-		PacketPlayOutEntityMetadata = getNMSClass("PacketPlayOutEntityMetadata");
-		PacketPlayOutEntityTeleport = getNMSClass("PacketPlayOutEntityTeleport");
-		PacketPlayOutScoreboardDisplayObjective = getNMSClass("PacketPlayOutScoreboardDisplayObjective");
-		PacketPlayOutScoreboardObjective = getNMSClass("PacketPlayOutScoreboardObjective");
-		PacketPlayOutScoreboardScore = getNMSClass("PacketPlayOutScoreboardScore");
-		PacketPlayOutScoreboardTeam = getNMSClass("PacketPlayOutScoreboardTeam");
-		PacketPlayOutSpawnEntityLiving = getNMSClass("PacketPlayOutSpawnEntityLiving");
-		
-		//v1_8_R2+; //v1.8.R1-
-		ChatSerializer = getNMSClass("IChatBaseComponent$ChatSerializer", "ChatSerializer");
-		EnumClickAction = getNMSClass("ChatClickable$EnumClickAction", "EnumClickAction");
-		EnumHoverAction = getNMSClass("ChatHoverable$EnumHoverAction", "EnumHoverAction");
-		if (minorVersion >= 8) {
-			GameProfile = Class.forName("com.mojang.authlib.GameProfile");
-			PropertyMap = Class.forName("com.mojang.authlib.properties.PropertyMap");
-			PacketPlayOutPlayerInfo = getNMSClass("PacketPlayOutPlayerInfo");
-			PacketPlayOutPlayerListHeaderFooter = getNMSClass("PacketPlayOutPlayerListHeaderFooter");
-			PacketPlayOutTitle = getNMSClass("PacketPlayOutTitle");
-			
-			//v1_8_R2+; v1_8_R1
-			EnumPlayerInfoAction = (Class<Enum>) getNMSClass("PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "EnumPlayerInfoAction");
-			PlayerInfoData = getNMSClass("PacketPlayOutPlayerInfo$PlayerInfoData", "PlayerInfoData");
-			EnumScoreboardHealthDisplay = (Class<Enum>) getNMSClass("IScoreboardCriteria$EnumScoreboardHealthDisplay", "EnumScoreboardHealthDisplay");
-			EnumTitleAction = (Class<Enum>) getNMSClass("PacketPlayOutTitle$EnumTitleAction", "EnumTitleAction");
-			
-			//everything; v1_8_R2 - v1_9_R2
-			EnumGamemode = (Class<Enum>) getNMSClass("EnumGamemode", "WorldSettings$EnumGamemode");
-			
-			//1.13+; 1_8_R2 - 1.12; 1_8_R1
-			EnumScoreboardAction = (Class<Enum>) getNMSClass("ScoreboardServer$Action", "PacketPlayOutScoreboardScore$EnumScoreboardAction", "EnumScoreboardAction");
-		}
-		if (minorVersion >= 9) {
-			DataWatcherObject = getNMSClass("DataWatcherObject");
-			DataWatcherRegistry = getNMSClass("DataWatcherRegistry");
-			PacketPlayOutBoss = getNMSClass("PacketPlayOutBoss");
-			BarColor = (Class<Enum>) getNMSClass("BossBattle$BarColor");
-			BarStyle = (Class<Enum>) getNMSClass("BossBattle$BarStyle");
-			PacketPlayOutBoss_Action = (Class<Enum>) getNMSClass("PacketPlayOutBoss$Action");
-		}
-		if (minorVersion >= 12) {
-			ChatMessageType = (Class<Enum>) getNMSClass("ChatMessageType");
-		}
-		if (minorVersion >= 16) {
-			ChatHexColor = getNMSClass("ChatHexColor");
-		}
-	}
-
-	/**
-	 * Initializes required NMS constructors
-	 * @throws Exception - if something fails
-	 */
-	public void initializeConstructors() throws Exception {
-		newChatComponentText = ChatComponentText.getConstructor(String.class);
-		newChatClickable = ChatClickable.getConstructor(EnumClickAction, String.class);
-		newDataWatcher = DataWatcher.getConstructor(getNMSClass("Entity"));
-		newDataWatcherItem = DataWatcherItem.getConstructors()[0];
-		newPacketPlayOutChat = PacketPlayOutChat.getConstructor();
-		newPacketPlayOutScoreboardDisplayObjective = PacketPlayOutScoreboardDisplayObjective.getConstructor();
-		newPacketPlayOutScoreboardObjective = PacketPlayOutScoreboardObjective.getConstructor();
-		newPacketPlayOutScoreboardTeam = PacketPlayOutScoreboardTeam.getConstructor();
-		newPacketPlayOutEntityDestroy = PacketPlayOutEntityDestroy.getConstructor(int[].class);
-		newPacketPlayOutEntityMetadata = PacketPlayOutEntityMetadata.getConstructor(int.class, DataWatcher, boolean.class);
-		newPacketPlayOutEntityTeleport = PacketPlayOutEntityTeleport.getConstructor();
-		newPacketPlayOutSpawnEntityLiving = PacketPlayOutSpawnEntityLiving.getConstructor();
-		if (minorVersion >= 8) {
-			newGameProfile = GameProfile.getConstructor(UUID.class, String.class);
-			newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooter.getConstructor();
-			newPacketPlayOutTitle = PacketPlayOutTitle.getConstructor(EnumTitleAction, IChatBaseComponent, int.class, int.class, int.class);
-			newPacketPlayOutPlayerInfo = PacketPlayOutPlayerInfo.getConstructor();
-			try {
-				newPlayerInfoData = PlayerInfoData.getConstructor(PacketPlayOutPlayerInfo, GameProfile, int.class, EnumGamemode, IChatBaseComponent);
-			} catch (Exception e) {
-				//1.8.8 paper
-				newPlayerInfoData = PlayerInfoData.getConstructor(GameProfile, int.class, EnumGamemode, IChatBaseComponent);
-			}
-		}
-		if (minorVersion >= 9) {
-			newDataWatcherObject = DataWatcherObject.getConstructors()[0];
-			newPacketPlayOutBoss = PacketPlayOutBoss.getConstructor();
-		}
-		if (minorVersion >= 13) {
-			newPacketPlayOutScoreboardScore_1_13 = PacketPlayOutScoreboardScore.getConstructor(EnumScoreboardAction, String.class, String.class, int.class);
-		} else {
-			newPacketPlayOutScoreboardScore0 = PacketPlayOutScoreboardScore.getConstructor();
-			newPacketPlayOutScoreboardScore_String = PacketPlayOutScoreboardScore.getConstructor(String.class);
-		}
-		if (minorVersion >= 16) {
-			newChatHoverable = ChatHoverable.getConstructor(EnumHoverAction, Object.class);
-			newChatModifier = getConstructor(ChatModifier, 10);
-		} else {
-			newChatHoverable = ChatHoverable.getConstructor(EnumHoverAction, IChatBaseComponent);
-			newChatModifier = ChatModifier.getConstructor();
-		}
-	}
-
-	/**
-	 * Initializes required NMS fields
-	 * @throws Exception - if something fails
-	 */
-	public void initializeFields() throws Exception {
-		ChatBaseComponent_modifier = getFields(ChatBaseComponent, ChatModifier).get(0);
-		ChatComponentText_text = getFields(ChatComponentText, String.class).get(0);
-		ChatClickable_action = getField(ChatClickable, "a");
-		ChatClickable_value = getField(ChatClickable, "b");
-		try {
-			//1.14.4+
-			ChatBaseComponent_extra = getField(ChatBaseComponent, "siblings");
-			ChatModifier_color = getField(ChatModifier, "color");
-			ChatModifier_bold = getField(ChatModifier, "bold");
-			ChatModifier_italic = getField(ChatModifier, "italic");
-			ChatModifier_underlined = getField(ChatModifier, "underlined");
-			ChatModifier_strikethrough = getField(ChatModifier, "strikethrough");
-			ChatModifier_obfuscated = getField(ChatModifier, "obfuscated");
-			ChatModifier_clickEvent = getField(ChatModifier, "clickEvent");
-			ChatModifier_hoverEvent = getField(ChatModifier, "hoverEvent");
-		} catch (NoSuchFieldException e) {
-			//1.14.3-
-			ChatBaseComponent_extra = getField(ChatBaseComponent, "a");
-			ChatModifier_color = getField(ChatModifier, "b");
-			ChatModifier_bold = getField(ChatModifier, "c");
-			ChatModifier_italic = getField(ChatModifier, "d");
-			ChatModifier_underlined = getField(ChatModifier, "e");
-			ChatModifier_strikethrough = getField(ChatModifier, "f");
-			ChatModifier_obfuscated = getField(ChatModifier, "g");
-			ChatModifier_clickEvent = getField(ChatModifier, "h");
-			ChatModifier_hoverEvent = getField(ChatModifier, "i");
-		}
-		
-		PING = getField(getNMSClass("EntityPlayer"), "ping");
-		PLAYER_CONNECTION = getField(getNMSClass("EntityPlayer"), "playerConnection");
-		NETWORK_MANAGER = getField(PLAYER_CONNECTION.getType(), "networkManager");
-
-		PacketPlayOutChat_MESSAGE = getField(PacketPlayOutChat, "a");
-
-		PacketPlayOutScoreboardDisplayObjective_POSITION = getField(PacketPlayOutScoreboardDisplayObjective, "a");
-		PacketPlayOutScoreboardDisplayObjective_OBJECTIVENAME = getField(PacketPlayOutScoreboardDisplayObjective, "b");
-
-		PacketPlayOutScoreboardObjective_OBJECTIVENAME = getField(PacketPlayOutScoreboardObjective, "a");
-		PacketPlayOutScoreboardObjective_DISPLAYNAME = getField(PacketPlayOutScoreboardObjective, "b");
-
-		PacketPlayOutScoreboardScore_PLAYER = getField(PacketPlayOutScoreboardScore, "a");
-		PacketPlayOutScoreboardScore_OBJECTIVENAME = getField(PacketPlayOutScoreboardScore, "b");
-		PacketPlayOutScoreboardScore_SCORE = getField(PacketPlayOutScoreboardScore, "c");
-		PacketPlayOutScoreboardScore_ACTION = getField(PacketPlayOutScoreboardScore, "d");
-
-		PacketPlayOutScoreboardTeam_NAME = getField(PacketPlayOutScoreboardTeam, "a");
-		PacketPlayOutScoreboardTeam_DISPLAYNAME = getField(PacketPlayOutScoreboardTeam, "b");
-		PacketPlayOutScoreboardTeam_PREFIX = getField(PacketPlayOutScoreboardTeam, "c");
-		PacketPlayOutScoreboardTeam_SUFFIX = getField(PacketPlayOutScoreboardTeam, "d");
-
-		PacketPlayOutEntityTeleport_ENTITYID = getField(PacketPlayOutEntityTeleport, "a");
-		PacketPlayOutEntityTeleport_X = getField(PacketPlayOutEntityTeleport, "b");
-		PacketPlayOutEntityTeleport_Y = getField(PacketPlayOutEntityTeleport, "c");
-		PacketPlayOutEntityTeleport_Z = getField(PacketPlayOutEntityTeleport, "d");
-		PacketPlayOutEntityTeleport_YAW = getField(PacketPlayOutEntityTeleport, "e");
-		PacketPlayOutEntityTeleport_PITCH = getField(PacketPlayOutEntityTeleport, "f");
-
-		PacketPlayOutEntity_ENTITYID = getField(PacketPlayOutEntity, "a");
-		PacketPlayOutEntityMetadata_LIST = getField(PacketPlayOutEntityMetadata, "b");
-
-		PacketPlayOutSpawnEntityLiving_ENTITYID = getField(PacketPlayOutSpawnEntityLiving, "a");
-		
-		PacketPlayInUseEntity_ENTITY = getField(PacketPlayInUseEntity, "a");
-
-		if (minorVersion >= 8) {
-			//1.8+
-			CHANNEL = getFields(getNMSClass("NetworkManager"), Channel.class).get(0);
-
-			PacketPlayOutChat_POSITION = getField(PacketPlayOutChat, "b");
-
-			PacketPlayOutScoreboardObjective_RENDERTYPE = getField(PacketPlayOutScoreboardObjective, "c");
-			PacketPlayOutScoreboardObjective_METHOD = getField(PacketPlayOutScoreboardObjective, "d");
-
-			GameProfile_ID = getField(GameProfile, "id");
-			GameProfile_NAME = getField(GameProfile, "name");
-			GameProfile_PROPERTIES = getField(GameProfile, "properties");
-			PacketPlayOutPlayerInfo_ACTION = getField(PacketPlayOutPlayerInfo, "a");
-			PacketPlayOutPlayerInfo_PLAYERS = getField(PacketPlayOutPlayerInfo, "b");
-			PlayerInfoData_PING = getField(PlayerInfoData, "b");
-			PlayerInfoData_GAMEMODE = getField(PlayerInfoData, "c");
-			PlayerInfoData_PROFILE = getField(PlayerInfoData, "d");
-			PlayerInfoData_LISTNAME = getField(PlayerInfoData, "e");
-
-			List<Field> fields = getFields(PacketPlayOutPlayerListHeaderFooter, IChatBaseComponent);
-			PacketPlayOutPlayerListHeaderFooter_HEADER = fields.get(0);
-			PacketPlayOutPlayerListHeaderFooter_FOOTER = fields.get(1);
-		} else {
-			//1.7-
-			PacketPlayOutScoreboardObjective_METHOD = getField(PacketPlayOutScoreboardObjective, "c");
-		}
-		if (minorVersion >= 9) {
-			//1.9+
-			DataWatcherItem_TYPE = getField(DataWatcherItem, "a");
-			DataWatcherItem_VALUE = getField(DataWatcherItem, "b");
-			DataWatcherObject_SLOT = getField(DataWatcherObject, "a");
-			DataWatcherObject_SERIALIZER = getField(DataWatcherObject, "b");
-			
-			PacketPlayOutBoss_UUID = getField(PacketPlayOutBoss, "a");
-			PacketPlayOutBoss_ACTION = getField(PacketPlayOutBoss, "b");
-			PacketPlayOutBoss_NAME = getField(PacketPlayOutBoss, "c");
-			PacketPlayOutBoss_PROGRESS = getField(PacketPlayOutBoss, "d");
-			PacketPlayOutBoss_COLOR = getField(PacketPlayOutBoss, "e");
-			PacketPlayOutBoss_STYLE = getField(PacketPlayOutBoss, "f");
-			PacketPlayOutBoss_DARKEN_SKY = getField(PacketPlayOutBoss, "g");
-			PacketPlayOutBoss_PLAY_MUSIC = getField(PacketPlayOutBoss, "h");
-			PacketPlayOutBoss_CREATE_FOG = getField(PacketPlayOutBoss, "i");
-
-			PacketPlayOutScoreboardTeam_VISIBILITY = getField(PacketPlayOutScoreboardTeam, "e");
-			PacketPlayOutScoreboardTeam_COLLISION = getField(PacketPlayOutScoreboardTeam, "f");
-			PacketPlayOutScoreboardTeam_PLAYERS = getField(PacketPlayOutScoreboardTeam, "h");
-			PacketPlayOutScoreboardTeam_ACTION = getField(PacketPlayOutScoreboardTeam, "i");
-			PacketPlayOutScoreboardTeam_SIGNATURE = getField(PacketPlayOutScoreboardTeam, "j");
-
-			PacketPlayOutSpawnEntityLiving_UUID = getField(PacketPlayOutSpawnEntityLiving, "b");
-			PacketPlayOutSpawnEntityLiving_ENTITYTYPE = getField(PacketPlayOutSpawnEntityLiving, "c");
-			PacketPlayOutSpawnEntityLiving_X = getField(PacketPlayOutSpawnEntityLiving, "d");
-			PacketPlayOutSpawnEntityLiving_Y = getField(PacketPlayOutSpawnEntityLiving, "e");
-			PacketPlayOutSpawnEntityLiving_Z = getField(PacketPlayOutSpawnEntityLiving, "f");
-			PacketPlayOutSpawnEntityLiving_YAW = getField(PacketPlayOutSpawnEntityLiving, "j");
-			PacketPlayOutSpawnEntityLiving_PITCH = getField(PacketPlayOutSpawnEntityLiving, "k");
-			
-			PacketPlayInUseEntity_ACTION = getField(PacketPlayInUseEntity, "action");
-		} else {
-			//1.8-
-			DataWatcherItem_TYPE = getField(DataWatcherItem, "b");
-			DataWatcherItem_VALUE = getField(DataWatcherItem, "c");
-			
-			PacketPlayOutSpawnEntityLiving_ENTITYTYPE = getField(PacketPlayOutSpawnEntityLiving, "b");
-			PacketPlayOutSpawnEntityLiving_X = getField(PacketPlayOutSpawnEntityLiving, "c");
-			PacketPlayOutSpawnEntityLiving_Y = getField(PacketPlayOutSpawnEntityLiving, "d");
-			PacketPlayOutSpawnEntityLiving_Z = getField(PacketPlayOutSpawnEntityLiving, "e");
-			PacketPlayOutSpawnEntityLiving_YAW = getField(PacketPlayOutSpawnEntityLiving, "i");
-			PacketPlayOutSpawnEntityLiving_PITCH = getField(PacketPlayOutSpawnEntityLiving, "j");
-			if (minorVersion == 8) {
-				//1.8.x
-				PacketPlayOutScoreboardTeam_VISIBILITY = getField(PacketPlayOutScoreboardTeam, "e");
-				PacketPlayOutScoreboardTeam_PLAYERS = getField(PacketPlayOutScoreboardTeam, "g");
-				PacketPlayOutScoreboardTeam_ACTION = getField(PacketPlayOutScoreboardTeam, "h");
-				PacketPlayOutScoreboardTeam_SIGNATURE = getField(PacketPlayOutScoreboardTeam, "i");
-			} else {
-				//1.7.x
-				PacketPlayOutScoreboardTeam_PLAYERS = getField(PacketPlayOutScoreboardTeam, "e");
-				PacketPlayOutScoreboardTeam_ACTION = getField(PacketPlayOutScoreboardTeam, "f");
-				PacketPlayOutScoreboardTeam_SIGNATURE = getField(PacketPlayOutScoreboardTeam, "g");
-			}
-		}
-		if (minorVersion >= 13) {
-			//1.13+
-			PacketPlayOutScoreboardTeam_CHATFORMAT = getField(PacketPlayOutScoreboardTeam, "g");
-		}
-
-		if (minorVersion <= 14) {
-			PacketPlayOutSpawnEntityLiving_DATAWATCHER = getFields(PacketPlayOutSpawnEntityLiving, DataWatcher).get(0);
-		}
-
-		if (minorVersion >= 16) {
-			//1.16+
-			ChatHexColor_name = getField(ChatHexColor, "name");
-			ChatHexColor_rgb = getField(ChatHexColor, "rgb");
-			ChatHoverable_action = getField(ChatHoverable, "b");
-			ChatHoverable_value = getField(ChatHoverable, "c");
-			PacketPlayOutChat_SENDER = getField(PacketPlayOutChat, "c");
-		} else {
-			ChatHoverable_action = getField(ChatHoverable, "a");
-			ChatHoverable_value = getField(ChatHoverable, "b");
-		}
-	}
-
-	/**
-	 * Initializes required NMS methods
-	 * @throws Exception - if something fails
-	 */
-	public void initializeMethods() throws Exception {
-		ChatComponentText_addSibling = getMethod(ChatComponentText, new String[]{"addSibling", "a", "func_150257_a"}, IChatBaseComponent); //v1.7.R4+, v1.7.R3-
-		ChatSerializer_DESERIALIZE = getMethod(ChatSerializer, new String[]{"a", "func_150699_a"}, String.class);
-		EnumClickAction_a = getMethod(EnumClickAction, new String[]{"a", "func_150672_a"}, String.class);
-		EnumHoverAction_a = getMethod(EnumHoverAction, new String[]{"a", "func_150684_a"}, String.class);
-		getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".entity.CraftPlayer").getMethod("getHandle");
-		sendPacket = getMethod(getNMSClass("PlayerConnection"), new String[]{"sendPacket", "func_147359_a"}, getNMSClass("Packet"));
-		if (minorVersion >= 8) {
-			getProfile = getNMSClass("EntityHuman").getMethod("getProfile");
-			for (Method m : PropertyMap.getMethods()) {
-				if (m.getName().equals("putAll") && m.getParameterCount() == 1) PropertyMap_putAll = m;
-			}
-			if (PropertyMap_putAll == null) throw new IllegalStateException("putAll method not found");
-		}
-		if (minorVersion >= 9) {
-			//1.9+
-			DataWatcher_REGISTER = DataWatcher.getMethod("register", DataWatcherObject, Object.class);
-		} else {
-			//1.7.x - 1.8.x
-			DataWatcher_REGISTER = getMethod(DataWatcher, new String[]{"a", "func_75682_a"}, int.class, Object.class);
-		}
-		if (minorVersion >= 16) {
-			ChatHexColor_ofInt = ChatHexColor.getMethod("a", int.class);
-			ChatHexColor_ofString = ChatHexColor.getMethod("a", String.class);
-		}
-	}
-	
-	/**
-	 * A helper method that prints all methods of class into console, including their return type, name and parameters
-	 * Useful for modded servers which code I can not access
-	 * @param clazz - class to show methods of
-	 */
-	public void showMethods(Class<?> clazz) {
-		System.out.println("--- " + clazz.getSimpleName() + " ---");
-		for (Method m : clazz.getMethods()) {
-			System.out.println(m.getReturnType().getName() + " " + m.getName() + "(" + Arrays.toString(m.getParameterTypes()) + ")");
-		}
-	}
-
-	/**
-	 * Returns class with given potential names in same order
-	 * @param names - possible class names
-	 * @return class for specified name(s)
-	 * @throws ClassNotFoundException if class does not exist
-	 */
-	public Class<?> getNMSClass(String... names) throws ClassNotFoundException {
-		for (String name : names) {
-			try {
-				return getNMSClass(name);
-			} catch (ClassNotFoundException e) {
-			}
-		}
-		throw new ClassNotFoundException("No class found with possible names " + names);
-	}
-	
-	/**
-	 * Returns class from given name
-	 * @param name - class name
-	 * @return class from given name
-	 * @throws ClassNotFoundException if class was not found
-	 */
-	public Class<?> getNMSClass(String name) throws ClassNotFoundException {
-		try {
-			return Class.forName("net.minecraft.server." + serverPackage + "." + name);
-		} catch (ClassNotFoundException e) {
-			//modded server?
-			return Main.class.getClassLoader().loadClass("net.minecraft.server." + serverPackage + "." + name);
-		} catch (NullPointerException e) {
-			//nested class in modded server
-			throw new ClassNotFoundException(name);
-		}
-	}
-	
-	/**
-	 * Returns method with specified possible names and parameters. Throws exception if no such method was found
-	 * @param clazz - class to get method from
-	 * @param names - possible method names
-	 * @param parameterTypes - parameter types of the method
-	 * @return method with specified name and parameters
-	 * @throws NoSuchMethodException if no such method exists
-	 */
-	public Method getMethod(Class<?> clazz, String[] names, Class<?>... parameterTypes) throws NoSuchMethodException {
-		for (String name : names) {
-			try {
-				return clazz.getMethod(name, parameterTypes);
-			} catch (Exception e) {
-			}
-		}
-		throw new NoSuchMethodException("No method found with possible names " + Arrays.toString(names) + " in class " + clazz.getName());
-	}
-
-	/**
-	 * Returns all fields of class with defined class type
-	 * @param clazz - class to check fields of
-	 * @param type - field type to check for
-	 * @return list of all fields with specified class type
-	 */
-	private List<Field> getFields(Class<?> clazz, Class<?> type){
-		List<Field> list = new ArrayList<Field>();
-		if (clazz == null) return list;
-		for (Field field : clazz.getDeclaredFields()) {
-			field.setAccessible(true);
-			if (field.getType() == type) list.add(field);
-		}
-		return list;
-	}
-	
-	/**
-	 * Returns field with specified name and makes it accessible
-	 * @param clazz - class to get field from
-	 * @param name - field name
-	 * @return accessible field with defined name
-	 * @throws NoSuchFieldException if field was not found
-	 */
-	private Field getField(Class<?> clazz, String name) throws NoSuchFieldException {
-		for (Field f : clazz.getDeclaredFields()) {
-			if (f.getName().equals(name) || (f.getName().split("_").length == 3 && f.getName().split("_")[2].equals(name))) {
-				f.setAccessible(true);
-				return f;
-			}
-		}
-		if (thermosFieldMappings.containsKey(name)) {
-			return getField(clazz, thermosFieldMappings.get(name));
-		}
-		throw new NoSuchFieldException("Field \"" + name + "\" was not found in class " + clazz.getName());
-	}
-	
-	private Constructor<?> getConstructor(Class<?> clazz, int parameterCount) throws NoSuchMethodException {
-		for (Constructor<?> c : clazz.getDeclaredConstructors()) {
-			if (c.getParameterCount() == parameterCount) {
-				c.setAccessible(true);
-				return c;
-			}
-		}
-		throw new NoSuchMethodException("No constructor found in class " + clazz.getName() + " with " + parameterCount + " parameters");
-	}
-}
@@ -1,93 +1,89 @@
 package me.neznamy.tab.platforms.bukkit.nms.datawatcher;

-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import lombok.Getter;
+import lombok.SneakyThrows;
+import lombok.ToString;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;

-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.ProtocolVersion;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;

 /**
 * A class representing the n.m.s.DataWatcher class to make work with it much easier
 */
-public class DataWatcher {
+@ToString
+public class DataWatcher implements EntityData {

-	//datawatcher data
-	private Map<Integer, DataWatcherItem> dataValues = new HashMap<Integer, DataWatcherItem>();
-	
-	//a helper for easier data write
-	private DataWatcherHelper helper = new DataWatcherHelper(this);
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    private static Constructor<?> CONSTRUCTOR;
+    private static Method REGISTER;
+    public static Method markDirty;
+    public static Method packDirty;
+    
+    /** Watched data */
+    private final Map<Integer, DataWatcherItem> dataValues = new HashMap<>();

-	/**
-	 * Sets value into data values
-	 * @param type - type of value
-	 * @param value - value
-	 */
-	public void setValue(DataWatcherObject type, Object value){
-		dataValues.put(type.position, new DataWatcherItem(type, value));
-	}
+    /** Helper for easier data write */
+    @Getter private final DataWatcherHelper helper = new DataWatcherHelper(this);

-	/**
-	 * Removes value by position
-	 * @param position - position of value to remove
-	 */
-	public void removeValue(int position) {
-		dataValues.remove(position);
-	}
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        CONSTRUCTOR = ReflectionUtils.getOnlyConstructor(CLASS);
+        if (nms.getMinorVersion() >= 9) {
+            REGISTER = ReflectionUtils.getMethod(CLASS, new String[]{"register", "a"}, DataWatcherObject.CLASS, Object.class); // {Bukkit, Bukkit 1.18+}
+        } else {
+            REGISTER = ReflectionUtils.getMethod(CLASS, new String[]{"func_75682_a", "a"}, int.class, Object.class); // {Thermos 1.7.10, Bukkit}
+        }
+        if (nms.getMinorVersion() >= 19) {
+            packDirty = CLASS.getMethod("b");
+        }
+        if (nms.is1_19_3Plus()) {
+            markDirty = ReflectionUtils.getOnlyMethod(CLASS, void.class, DataWatcherObject.CLASS);
+        }
+    }
+    
+    /**
+     * Sets value into data values
+     *
+     * @param   type
+     *          type of value
+     * @param   value
+     *          value
+     */
+    public void setValue(@NotNull DataWatcherObject type, @NotNull Object value) {
+        dataValues.put(type.getPosition(), new DataWatcherItem(type, value));
+    }

-	/**
-	 * Returns item with given position
-	 * @param position - position of item
-	 * @return item or null if not set
-	 */
-	public DataWatcherItem getItem(int position) {
-		return dataValues.get(position);
-	}
-
-	/**
-	 * Returns helper created by this instance
-	 * @return data write helper
-	 */
-	public DataWatcherHelper helper() {
-		return helper;
-	}
-
-	/**
-	 * Converts the class into an instance of NMS.DataWatcher
-	 * @return an instance of NMS.DataWatcher with same data
-	 * @throws Exception - if something fails
-	 */
-	public Object toNMS() throws Exception {
-		NMSStorage nms = NMSStorage.getInstance();
-		Object nmsWatcher = nms.newDataWatcher.newInstance(new Object[] {null});
-		for (DataWatcherItem item : dataValues.values()) {
-			Object position;
-			if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-				position = nms.newDataWatcherObject.newInstance(item.type.position, item.type.classType);
-			} else {
-				position = item.type.position;
-			}
-			nms.DataWatcher_REGISTER.invoke(nmsWatcher, position, item.value);
-		}
-		return nmsWatcher;
-	}
-	
-	/**
-	 * Reads NMS data watcher and returns and instance of this class with same data
-	 * @param nmsWatcher - NMS datawatcher to read
-	 * @return an instance of this class with same values
-	 * @throws Exception - if something fails
-	 */
-	@SuppressWarnings("unchecked")
-	public static DataWatcher fromNMS(Object nmsWatcher) throws Exception{
-		DataWatcher watcher = new DataWatcher();
-		List<Object> items = (List<Object>) nmsWatcher.getClass().getMethod("c").invoke(nmsWatcher);
-		if (items != null) {
-			for (Object watchableObject : items) {
-				DataWatcherItem w = DataWatcherItem.fromNMS(watchableObject);
-				watcher.setValue(w.type, w.value);
-			}
-		}
-		return watcher;
-	}
+    /**
+     * Converts the class into an instance of NMS.DataWatcher
+     *
+     * @return  an instance of NMS.DataWatcher with same data
+     */
+    @SneakyThrows
+    public @NotNull Object build() {
+        NMSStorage nms = NMSStorage.getInstance();
+        Object nmsWatcher;
+        if (CONSTRUCTOR.getParameterCount() == 1) { //1.7+
+            nmsWatcher = CONSTRUCTOR.newInstance(new Object[] {null});
+        } else {
+            nmsWatcher = CONSTRUCTOR.newInstance();
+        }
+        for (DataWatcherItem item : dataValues.values()) {
+            Object nmsObject = item.getType().build();
+            REGISTER.invoke(nmsWatcher, nmsObject, item.getValue());
+            if (nms.is1_19_3Plus()) markDirty.invoke(nmsWatcher, nmsObject);
+        }
+        return nmsWatcher;
+    }
 }
@@ -1,110 +1,160 @@
 package me.neznamy.tab.platforms.bukkit.nms.datawatcher;

+import lombok.AllArgsConstructor;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import org.jetbrains.annotations.NotNull;
+
 import java.util.Optional;

-import me.neznamy.tab.platforms.bukkit.BukkitPacketBuilder;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.ProtocolVersion;
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.packets.IChatBaseComponent;
-
 /**
- * A class to help assigning DataWatcher items as positions often change per-version
+ * A class to help to assign DataWatcher items as positions often change per-version
 */
+@AllArgsConstructor
 public class DataWatcherHelper {

-	//position of armor stand flags
-	private final int ARMOR_STAND_BYTEFLAGS_POSITION = getArmorStandFlagsPosition();
+    /** NMS Fields */
+    public static Class<?> DataWatcherRegistry;
+    public static Class<?> DataWatcherSerializer;
+    public static Object DataWatcherSerializer_BYTE;
+    public static Object DataWatcherSerializer_FLOAT;
+    public static Object DataWatcherSerializer_STRING;
+    public static Object DataWatcherSerializer_OPTIONAL_COMPONENT;
+    public static Object DataWatcherSerializer_BOOLEAN;

-	//original datawatcher to write to
-	private DataWatcher data;
-	
-	//data watcher registry
-	private DataWatcherRegistry registry;
-	
-	/**
-	 * Constructs new instance of this class with given parent
-	 * @param data - data to write to
-	 */
-	public DataWatcherHelper(DataWatcher data) {
-		this.data = data;
-		this.registry = NMSStorage.getInstance().dataWatcherRegistry;
-	}
-	
-	/**
-	 * Returns armor stand flags position based on server version
-	 * @return armor stand flags position based on server version
-	 */
-	private int getArmorStandFlagsPosition() {
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 15) {
-			//1.15.x, 1.16.x
-			return 14;
-		} else if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 14) {
-			//1.14.x
-			return 13;
-		} else if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 10) {
-			//1.10.x - 1.13.x
-			return 11;
-		} else {
-			//1.8.1 - 1.9.x
-			return 10;
-		}
-	}
-	
-	/**
-	 * Writes entity byte flags
-	 * @param flags - flags to write
-	 */
-	public void setEntityFlags(byte flags) {
-		data.setValue(new DataWatcherObject(0, registry.Byte), flags);
-	}
-	
-	/**
-	 * Writes entity custom name with position based on server version and value depending on client version (RGB or not)
-	 * @param customName - target custom name
-	 * @param clientVersion - client version
-	 */
-	public void setCustomName(String customName, ProtocolVersion clientVersion) {
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 13) {
-			try {
-				data.setValue(new DataWatcherObject(2, registry.Optional_IChatBaseComponent), Optional.ofNullable(((BukkitPacketBuilder)TAB.getInstance().getPacketBuilder()).toNMSComponent(IChatBaseComponent.optimizedComponent(customName), clientVersion)));
-			} catch (Exception e) {
-				TAB.getInstance().getErrorManager().printError("Failed to create component", e);
-			}
-		} else if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 8){
-			data.setValue(new DataWatcherObject(2, registry.String), customName);
-		} else {
-			String cutName = (customName.length() > 64 ? customName.substring(0, 64) : customName);
-			data.setValue(new DataWatcherObject(10, registry.String), cutName);
-		}
-			
-	}
-	
-	/**
-	 * Writes custom name visibility boolean
-	 * @param visible - if visible or not
-	 */
-	public void setCustomNameVisible(boolean visible) {
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-			data.setValue(new DataWatcherObject(3, registry.Boolean), visible);
-		} else {
-			data.setValue(new DataWatcherObject(3, registry.Byte), (byte)(visible?1:0));
-		}
-	}
-	
-	/**
-	 * Writes entity health
-	 * @param health - health of entity
-	 */
-	public void setHealth(float health) {
-		data.setValue(new DataWatcherObject(6, registry.Float), health);
-	}
-	
-	/**
-	 * Writes armor stand flags
-	 * @param flags - flags to write
-	 */
-	public void setArmorStandFlags(byte flags) {
-		data.setValue(new DataWatcherObject(ARMOR_STAND_BYTEFLAGS_POSITION, registry.Byte), flags);
-	}
+    /** Instance fields */
+    private final int armorStandFlagsPosition = getArmorStandFlagsPosition();
+    @NotNull private final DataWatcher data;
+
+    /**
+     * Returns armor stand flags position based on server version
+     *
+     * @return  armor stand flags position based on server version
+     */
+    private int getArmorStandFlagsPosition() {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 17) {
+            //1.17.x, 1.18.x, 1.19.x
+            return 15;
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 15) {
+            //1.15.x, 1.16.x
+            return 14;
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 14) {
+            //1.14.x
+            return 13;
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 10) {
+            //1.10.x - 1.13.x
+            return 11;
+        } else {
+            //1.8.x - 1.9.x
+            return 10;
+        }
+    }
+
+    public static void load(NMSStorage nms) throws NoSuchFieldException, IllegalAccessException {
+        if (nms.getMinorVersion() < 9) return;
+        DataWatcherSerializer_BYTE = DataWatcherRegistry.getDeclaredField("a").get(null);
+        DataWatcherSerializer_FLOAT = DataWatcherRegistry.getDeclaredField("c").get(null);
+        DataWatcherSerializer_STRING = DataWatcherRegistry.getDeclaredField("d").get(null);
+        if (nms.is1_19_3Plus()) {
+            DataWatcherSerializer_OPTIONAL_COMPONENT = DataWatcherRegistry.getDeclaredField("g").get(null);
+            if (nms.is1_19_4Plus()) {
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("k").get(null);
+            } else {
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("j").get(null);
+            }
+        } else {
+            if (nms.getMinorVersion() >= 13) {
+                DataWatcherSerializer_OPTIONAL_COMPONENT = DataWatcherRegistry.getDeclaredField("f").get(null);
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("i").get(null);
+            } else {
+                DataWatcherSerializer_BOOLEAN = DataWatcherRegistry.getDeclaredField("h").get(null);
+            }
+        }
+    }
+
+    /**
+     * Writes entity byte flags
+     *
+     * @param   flags
+     *          flags to write
+     */
+    public void setEntityFlags(byte flags) {
+        data.setValue(new DataWatcherObject(0, DataWatcherSerializer_BYTE), flags);
+    }
+
+    /**
+     * Writes entity custom name with position based on server version and value depending on client version (RGB or not)
+     *
+     * @param   customName
+     *          target custom name
+     * @param   clientVersion
+     *          client version
+     */
+    public void setCustomName(@NotNull String customName, @NotNull ProtocolVersion clientVersion) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 13) {
+            data.setValue(new DataWatcherObject(2, DataWatcherSerializer_OPTIONAL_COMPONENT),
+                    Optional.ofNullable(NMSStorage.getInstance().toNMSComponent(IChatBaseComponent.optimizedComponent(customName), clientVersion)));
+        } else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 8) {
+            data.setValue(new DataWatcherObject(2, DataWatcherSerializer_STRING), customName);
+        } else {
+            //name length is limited to 64 characters on <1.8
+            String cutName = (customName.length() > 64 ? customName.substring(0, 64) : customName);
+            if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6) {
+                data.setValue(new DataWatcherObject(10, null), cutName);
+            } else {
+                data.setValue(new DataWatcherObject(5, null), cutName);
+            }
+        }
+    }
+
+    /**
+     * Writes custom name visibility boolean
+     *
+     * @param   visible
+     *          if visible or not
+     */
+    public void setCustomNameVisible(boolean visible) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 9) {
+            data.setValue(new DataWatcherObject(3, DataWatcherSerializer_BOOLEAN), visible);
+        } else {
+            data.setValue(new DataWatcherObject(3, null), (byte)(visible?1:0));
+        }
+    }
+
+    /**
+     * Writes entity health
+     *
+     * @param   health
+     *          health of entity
+     */
+    public void setHealth(float health) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6) {
+            data.setValue(new DataWatcherObject(6, DataWatcherSerializer_FLOAT), health);
+        } else {
+            data.setValue(new DataWatcherObject(16, null), (int)health);
+        }
+    }
+
+    /**
+     * Writes armor stand flags
+     *
+     * @param   flags
+     *          flags to write
+     */
+    public void setArmorStandFlags(byte flags) {
+        data.setValue(new DataWatcherObject(armorStandFlagsPosition, DataWatcherSerializer_BYTE), flags);
+    }
+
+    /**
+     * Writes wither invulnerable time
+     * @param   time
+     *          Time, apparently
+     */
+    public void setWitherInvulnerableTime(int time) {
+        if (TAB.getInstance().getServerVersion().getMinorVersion() > 8)
+            throw new UnsupportedOperationException("Not supported on 1.9+");
+        data.setValue(new DataWatcherObject(20, null), time);
+    }
 }
@@ -1,39 +1,39 @@
 package me.neznamy.tab.platforms.bukkit.nms.datawatcher;

-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
-import me.neznamy.tab.shared.ProtocolVersion;
+import lombok.Data;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;

+import java.lang.reflect.Field;
+
+/**
+ * Class representing NMS Data Watcher Item
+ */
+@Data
 public class DataWatcherItem {
-	
-	//type of value (position + data type (1.9+))
-	public DataWatcherObject type;
-	
-	//actual data value
-	public Object value;
-	
-	/**
-	 * Constructs new instance of the object with given parameters
-	 * @param type - value type
-	 * @param value - value
-	 */
-	public DataWatcherItem(DataWatcherObject type, Object value){
-		this.type = type;
-		this.value = value;
-	}
-	
-	/**
-	 * Returns and instance of this class from given NMS item
-	 * @param nmsItem - NMS item
-	 * @return instance of this class with same data
-	 * @throws Exception - if something fails
-	 */
-	public static DataWatcherItem fromNMS(Object nmsItem) throws Exception {
-		NMSStorage nms = NMSStorage.getInstance();
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-			Object nmsObject = nms.DataWatcherItem_TYPE.get(nmsItem);
-			return new DataWatcherItem(new DataWatcherObject(nms.DataWatcherObject_SLOT.getInt(nmsObject), nms.DataWatcherObject_SERIALIZER.get(nmsObject)), nms.DataWatcherItem_VALUE.get(nmsItem));
-		} else {
-			return new DataWatcherItem(new DataWatcherObject(nms.DataWatcherItem_TYPE.getInt(nmsItem), null), nms.DataWatcherItem_VALUE.get(nmsItem));
-		}
-	}
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Field TYPE;
+    public static Field VALUE;
+
+    /** Instance fields */
+    @NotNull private final DataWatcherObject type;
+    @NotNull private final Object value;
+
+    /**
+     * Loads all required Fields
+     *
+     * @param   nms
+     *          NMS storage reference
+     */
+    public static void load(NMSStorage nms) {
+        VALUE = ReflectionUtils.getFields(CLASS, Object.class).get(0);
+        if (nms.getMinorVersion() >= 9) {
+            TYPE = ReflectionUtils.getOnlyField(CLASS, DataWatcherObject.CLASS);
+        } else {
+            TYPE = ReflectionUtils.getFields(CLASS, int.class).get(1);
+        }
+    }
 }
@@ -1,23 +1,54 @@
 package me.neznamy.tab.platforms.bukkit.nms.datawatcher;

+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
 /**
 * A class representing the n.m.s.DataWatcherObject class to make work with it much easier
 */
+@Data @AllArgsConstructor
 public class DataWatcherObject {

-	//position in datawatcher
-	public int position;
-	
-	//value class type used since 1.9
-	public Object classType;
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+    public static Field SLOT;
+    public static Field SERIALIZER;
+    
+    /** Instance fields */
+    private final int position;
+    @Nullable private final Object serializer;

-	/**
-	 * Constructs a new instance of this class with given parameters
-	 * @param position - position in datawatcher
-	 * @param classType - value class type
-	 */
-	public DataWatcherObject(int position, Object classType){
-		this.position = position;
-		this.classType = classType;
-	}
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load() throws NoSuchMethodException {
+        CONSTRUCTOR = CLASS.getConstructor(int.class, DataWatcherHelper.DataWatcherSerializer);
+        SLOT = ReflectionUtils.getOnlyField(CLASS, int.class);
+        SERIALIZER = ReflectionUtils.getOnlyField(CLASS, DataWatcherHelper.DataWatcherSerializer);
+    }
+
+    /**
+     * Converts the object into NMS object
+     *
+     * @return  NMS object
+     */
+    @SneakyThrows
+    public Object build() {
+        if (NMSStorage.getInstance().getMinorVersion() >= 9) {
+            return DataWatcherObject.CONSTRUCTOR.newInstance(position, serializer);
+        } else {
+            return position;
+        }
+    }
 }
@@ -1,67 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.HashMap;
-import java.util.Map;
-
-import me.neznamy.tab.shared.ProtocolVersion;
-
-/**
- * A class representing the n.m.s.DataWatcherRegistry class to make work with it much easier
- */
-public class DataWatcherRegistry {
-
-	//used registry types
-	public Object Byte;
-	public Object Integer;
-	public Object Float;
-	public Object String;
-	public Object Optional_IChatBaseComponent;
-	public Object Boolean;
-
-	/**
-	 * Initializes required NMS classes and fields
-	 */
-	public DataWatcherRegistry(Class<?> registry) {
-		if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 9) {
-			Map<String, Object> fields = getStaticFields(registry);
-			Byte = fields.get("a");
-			Integer = fields.get("b");
-			Float = fields.get("c");
-			String = fields.get("d");
-			if (ProtocolVersion.SERVER_VERSION.getMinorVersion() >= 13) {
-				Optional_IChatBaseComponent = fields.get("f");
-				Boolean = fields.get("i");
-			} else {
-				Boolean = fields.get("h");
-			}
-		} else {
-			Byte = 0;
-			Integer = 2;
-			Float = 3;
-			String = 4;
-		}
-	}
-
-	/**
-	 * Gets values of all static fields in a class
-	 * @param clazz class to return field values from
-	 * @return map of values
-	 */
-	private Map<String, Object> getStaticFields(Class<?> clazz){
-		Map<String, Object> fields = new HashMap<String, Object>();
-		if (clazz == null) return fields;
-		for (Field field : clazz.getDeclaredFields()) {
-			field.setAccessible(true);
-			if (Modifier.isStatic(field.getModifiers())) {
-				try {
-					fields.put(field.getName(), field.get(null));
-				} catch (Exception e) {
-					e.printStackTrace();
-				}
-			}
-		}
-		return fields;
-	}
-}
@@ -0,0 +1,109 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.nms;
+
+import me.neznamy.tab.platforms.bukkit.BukkitTabList;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherHelper;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherObject;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+/**
+ * NMS loader for Minecraft 1.5.2 - 1.16.5 using Bukkit mapping.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class BukkitLegacyNMSStorage extends NMSStorage {
+
+    /**
+     * Returns class with given potential names in same order
+     *
+     * @param   names
+     *          possible class names
+     * @return  class for specified names
+     * @throws  ClassNotFoundException
+     *          if class does not exist
+     */
+    private Class<?> getLegacyClass(@NotNull String... names) throws ClassNotFoundException {
+        for (String name : names) {
+            try {
+                return getLegacyClass(name);
+            } catch (ClassNotFoundException e) {
+                //not the first class name in array
+            }
+        }
+        throw new ClassNotFoundException("No class found with possible names " + Arrays.toString(names));
+    }
+
+    /**
+     * Returns class from given name. Supports modded servers, such as Thermos.
+     *
+     * @param   name
+     *          class name
+     * @return  class from given name
+     * @throws  ClassNotFoundException
+     *          if class was not found
+     */
+    public Class<?> getLegacyClass(@NotNull String name) throws ClassNotFoundException {
+        try {
+            return getClass().getClassLoader().loadClass("net.minecraft.server." + serverPackage + "." + name);
+        } catch (NullPointerException e) {
+            // nested class not found
+            throw new ClassNotFoundException(name);
+        }
+    }
+
+    @Override
+    public void loadClasses() throws ClassNotFoundException {
+        EntityHuman = getLegacyClass("EntityHuman");
+        World = getLegacyClass("World");
+        Packet = getLegacyClass("Packet");
+        EnumChatFormat = (Class<Enum>) getLegacyClass("EnumChatFormat");
+        EntityPlayer = getLegacyClass("EntityPlayer");
+        Entity = getLegacyClass("Entity");
+        EntityLiving = getLegacyClass("EntityLiving");
+        PlayerConnection = getLegacyClass("PlayerConnection");
+        NetworkManager = getLegacyClass("NetworkManager");
+        DataWatcher.CLASS = getLegacyClass("DataWatcher");
+        DataWatcherItem.CLASS = getLegacyClass("DataWatcher$Item", "DataWatcher$WatchableObject", "WatchableObject");
+        PacketPlayOutSpawnEntityLivingStorage.CLASS = getLegacyClass("PacketPlayOutSpawnEntityLiving", "Packet24MobSpawn");
+        PacketPlayOutEntityTeleportStorage.CLASS = getLegacyClass("PacketPlayOutEntityTeleport", "Packet34EntityTeleport");
+        PacketPlayOutEntity = getLegacyClass("PacketPlayOutEntity", "Packet30Entity");
+        PacketPlayOutEntityDestroyStorage.CLASS = getLegacyClass("PacketPlayOutEntityDestroy", "Packet29DestroyEntity");
+        PacketPlayOutEntityLook = getLegacyClass("PacketPlayOutEntity$PacketPlayOutEntityLook", "PacketPlayOutEntityLook", "Packet32EntityLook");
+        PacketPlayOutEntityMetadataStorage.CLASS = getLegacyClass("PacketPlayOutEntityMetadata", "Packet40EntityMetadata");
+        PacketPlayOutNamedEntitySpawn = getLegacyClass("PacketPlayOutNamedEntitySpawn", "Packet20NamedEntitySpawn");
+        PacketScoreboard.DisplayObjectiveClass = getLegacyClass("PacketPlayOutScoreboardDisplayObjective", "Packet208SetScoreboardDisplayObjective");
+        PacketScoreboard.ObjectivePacketClass = getLegacyClass("PacketPlayOutScoreboardObjective", "Packet206SetScoreboardObjective");
+        PacketScoreboard.TeamPacketClass = getLegacyClass("PacketPlayOutScoreboardTeam", "Packet209SetScoreboardTeam");
+        PacketScoreboard.ScorePacketClass = getLegacyClass("PacketPlayOutScoreboardScore", "Packet207SetScoreboardScore");
+        PacketScoreboard.Scoreboard = getLegacyClass("Scoreboard");
+        PacketScoreboard.ScoreboardObjective = getLegacyClass("ScoreboardObjective");
+        PacketScoreboard.ScoreboardScoreClass = getLegacyClass("ScoreboardScore");
+        PacketScoreboard.IScoreboardCriteria = getLegacyClass("IScoreboardCriteria", "IObjective"); // 1.5.1+, 1.5
+        PacketScoreboard.ScoreboardTeam = getLegacyClass("ScoreboardTeam");
+        if (minorVersion >= 7) {
+            IChatBaseComponent = getLegacyClass("IChatBaseComponent");
+            ChatSerializer = getLegacyClass("IChatBaseComponent$ChatSerializer", "ChatSerializer");
+        }
+        if (minorVersion >= 8) {
+            BukkitTabList.PacketPlayOutPlayerListHeaderFooterClass = getLegacyClass("PacketPlayOutPlayerListHeaderFooter");
+            EntityArmorStand = getLegacyClass("EntityArmorStand");
+            BukkitTabList.PacketPlayOutPlayerInfoClass = getLegacyClass("PacketPlayOutPlayerInfo");
+            BukkitTabList.EnumPlayerInfoActionClass = (Class<Enum>) getLegacyClass("PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "EnumPlayerInfoAction");
+            BukkitTabList.PlayerInfoDataClass = getLegacyClass("PacketPlayOutPlayerInfo$PlayerInfoData", "PlayerInfoData");
+            BukkitTabList.EnumGamemodeClass = (Class<Enum>) getLegacyClass("EnumGamemode", "WorldSettings$EnumGamemode");
+            PacketScoreboard.EnumScoreboardHealthDisplay = (Class<Enum>) getLegacyClass("IScoreboardCriteria$EnumScoreboardHealthDisplay", "EnumScoreboardHealthDisplay");
+            PacketScoreboard.EnumScoreboardAction = (Class<Enum>) getLegacyClass("ScoreboardServer$Action", "PacketPlayOutScoreboardScore$EnumScoreboardAction", "EnumScoreboardAction");
+            PacketScoreboard.EnumNameTagVisibility = (Class<Enum>) getLegacyClass("ScoreboardTeamBase$EnumNameTagVisibility", "EnumNameTagVisibility");
+        }
+        if (minorVersion >= 9) {
+            DataWatcherObject.CLASS = getLegacyClass("DataWatcherObject");
+            DataWatcherHelper.DataWatcherRegistry = getLegacyClass("DataWatcherRegistry");
+            DataWatcherHelper.DataWatcherSerializer = getLegacyClass("DataWatcherSerializer");
+            PacketScoreboard.EnumTeamPush = (Class<Enum>) getLegacyClass("ScoreboardTeamBase$EnumTeamPush");
+        }
+    }
+}
@@ -0,0 +1,72 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.nms;
+
+import me.neznamy.tab.platforms.bukkit.BukkitTabList;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherHelper;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherObject;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+
+/**
+ * NMS loader for minecraft 1.17+ using Mojang packaging and bukkit names.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class BukkitModernNMSStorage extends NMSStorage {
+
+    @Override
+    public void loadClasses() throws ClassNotFoundException {
+        ChatSerializer = Class.forName("net.minecraft.network.chat.IChatBaseComponent$ChatSerializer");
+        World = Class.forName("net.minecraft.world.level.World");
+        EntityArmorStand = Class.forName("net.minecraft.world.entity.decoration.EntityArmorStand");
+        EntityHuman = Class.forName("net.minecraft.world.entity.player.EntityHuman");
+        NetworkManager = Class.forName("net.minecraft.network.NetworkManager");
+        IChatBaseComponent = Class.forName("net.minecraft.network.chat.IChatBaseComponent");
+        Packet = Class.forName("net.minecraft.network.protocol.Packet");
+        EnumChatFormat = (Class<Enum>) Class.forName("net.minecraft.EnumChatFormat");
+        EntityPlayer = Class.forName("net.minecraft.server.level.EntityPlayer");
+        Entity = Class.forName("net.minecraft.world.entity.Entity");
+        EntityLiving = Class.forName("net.minecraft.world.entity.EntityLiving");
+        PlayerConnection = Class.forName("net.minecraft.server.network.PlayerConnection");
+        BukkitTabList.PacketPlayOutPlayerListHeaderFooterClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerListHeaderFooter");
+        PacketScoreboard.DisplayObjectiveClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardDisplayObjective");
+        PacketScoreboard.ObjectivePacketClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardObjective");
+        PacketScoreboard.Scoreboard = Class.forName("net.minecraft.world.scores.Scoreboard");
+        PacketScoreboard.ScorePacketClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardScore");
+        PacketScoreboard.ScoreboardObjective = Class.forName("net.minecraft.world.scores.ScoreboardObjective");
+        PacketScoreboard.ScoreboardScoreClass = Class.forName("net.minecraft.world.scores.ScoreboardScore");
+        PacketScoreboard.IScoreboardCriteria = Class.forName("net.minecraft.world.scores.criteria.IScoreboardCriteria");
+        PacketScoreboard.EnumScoreboardHealthDisplay = (Class<Enum>) Class.forName("net.minecraft.world.scores.criteria.IScoreboardCriteria$EnumScoreboardHealthDisplay");
+        PacketScoreboard.EnumScoreboardAction = (Class<Enum>) Class.forName("net.minecraft.server.ScoreboardServer$Action");
+        PacketScoreboard.TeamPacketClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardTeam");
+        PacketScoreboard.ScoreboardTeam = Class.forName("net.minecraft.world.scores.ScoreboardTeam");
+        PacketScoreboard.EnumNameTagVisibility = (Class<Enum>) Class.forName("net.minecraft.world.scores.ScoreboardTeamBase$EnumNameTagVisibility");
+        PacketScoreboard.EnumTeamPush = (Class<Enum>) Class.forName("net.minecraft.world.scores.ScoreboardTeamBase$EnumTeamPush");
+        DataWatcher.CLASS = Class.forName("net.minecraft.network.syncher.DataWatcher");
+        DataWatcherItem.CLASS = Class.forName("net.minecraft.network.syncher.DataWatcher$Item");
+        DataWatcherObject.CLASS = Class.forName("net.minecraft.network.syncher.DataWatcherObject");
+        DataWatcherHelper.DataWatcherRegistry = Class.forName("net.minecraft.network.syncher.DataWatcherRegistry");
+        DataWatcherHelper.DataWatcherSerializer = Class.forName("net.minecraft.network.syncher.DataWatcherSerializer");
+        PacketPlayOutEntityTeleportStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntityTeleport");
+        PacketPlayOutEntity = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntity");
+        PacketPlayOutEntityDestroyStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntityDestroy");
+        PacketPlayOutEntityLook = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutEntityLook");
+        PacketPlayOutEntityMetadataStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutEntityMetadata");
+        PacketPlayOutNamedEntitySpawn = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutNamedEntitySpawn");
+        BukkitTabList.EnumGamemodeClass = (Class<Enum>) Class.forName("net.minecraft.world.level.EnumGamemode");
+        PacketPlayOutSpawnEntityLivingStorage.Vec3D = Class.forName("net.minecraft.world.phys.Vec3D");
+        PacketPlayOutSpawnEntityLivingStorage.EntityTypes = Class.forName("net.minecraft.world.entity.EntityTypes");
+        PacketPlayOutSpawnEntityLivingStorage.CLASS = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutSpawnEntity");
+        if (is1_19_3Plus()) {
+            BukkitTabList.ClientboundPlayerInfoRemovePacket = Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket");
+            BukkitTabList.PacketPlayOutPlayerInfoClass = Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket");
+            BukkitTabList.EnumPlayerInfoActionClass = (Class<Enum>) Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket$a");
+            BukkitTabList.PlayerInfoDataClass = Class.forName("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket$b");
+            BukkitTabList.RemoteChatSession$Data = Class.forName("net.minecraft.network.chat.RemoteChatSession$a");
+        } else {
+            BukkitTabList.PacketPlayOutPlayerInfoClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo");
+            BukkitTabList.EnumPlayerInfoActionClass = (Class<Enum>) Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$EnumPlayerInfoAction");
+            BukkitTabList.PlayerInfoDataClass = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$PlayerInfoData");
+        }
+    }
+}
@@ -0,0 +1,159 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.nms;
+
+import com.mojang.authlib.GameProfile;
+import io.netty.channel.Channel;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.BukkitTabList;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherHelper;
+import me.neznamy.tab.platforms.bukkit.scoreboard.PacketScoreboard;
+import me.neznamy.tab.shared.ProtocolVersion;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.util.ComponentCache;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherObject;
+import me.neznamy.tab.platforms.bukkit.nms.storage.packet.*;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * Class holding all NMS classes, methods, fields and constructors used by TAB.
+ */
+@SuppressWarnings("rawtypes")
+public abstract class NMSStorage {
+
+    /** Instance of this class */
+    @Getter @Setter private static NMSStorage instance;
+
+    /** Server's NMS/CraftBukkit package */
+    @Getter protected final String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+
+    /** Server's minor version */
+    @Getter protected final int minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
+
+    /** Flag determining whether the server version is at least 1.19.3 or not */
+    @Getter private final boolean is1_19_3Plus = ReflectionUtils.classExists("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket");
+    @Getter private final boolean is1_19_4Plus = is1_19_3Plus && !serverPackage.equals("v1_19_R2");
+
+    /** Basic universal values */
+    protected Class<?> Packet;
+    protected Class<?> NetworkManager;
+    protected Class<?> EntityArmorStand;
+    protected Class<?> World;
+    public Class<Enum> EnumChatFormat;
+    public Class<?> EntityPlayer;
+    protected Class<?> EntityHuman;
+    public Class<?> Entity;
+    public Class<?> EntityLiving;
+    protected Class<?> PlayerConnection;
+
+    // Ping field for 1.5.2 - 1.16.5, 1.17+ has Player#getPing()
+    public Field PING;
+
+    public Field PLAYER_CONNECTION;
+    public Field NETWORK_MANAGER;
+    public Field CHANNEL;
+    public Method getHandle;
+    public Method sendPacket;
+    public Method getProfile;
+
+    /** Chat components */
+    public Class<?> IChatBaseComponent;
+    protected Class<?> ChatSerializer;
+    public Method ChatSerializer_DESERIALIZE;
+
+    /** Other entity packets */
+    public Class<?> PacketPlayOutEntity;
+    public Field PacketPlayOutEntity_ENTITYID;
+
+    public Class<?> PacketPlayOutEntityLook;
+
+    public Class<?> PacketPlayOutNamedEntitySpawn;
+    public Field PacketPlayOutNamedEntitySpawn_ENTITYID;
+
+    public Object dummyEntity;
+
+    private final ComponentCache<IChatBaseComponent, Object> componentCache = new ComponentCache<>(10000,
+            (component, clientVersion) -> ChatSerializer_DESERIALIZE.invoke(null, component.toString(clientVersion)));
+
+    /**
+     * Constructs new instance and attempts to load all fields, methods and constructors.
+     */
+    @SneakyThrows
+    public NMSStorage() {
+        ProtocolVersion.UNKNOWN_SERVER_VERSION.setMinorVersion(minorVersion); //fixing compatibility with forks that set version field value to "Unknown"
+        loadClasses();
+        if (minorVersion >= 7) {
+            NETWORK_MANAGER = ReflectionUtils.getOnlyField(PlayerConnection, NetworkManager);
+            sendPacket = ReflectionUtils.getMethods(PlayerConnection, void.class, Packet).get(0);
+        } else {
+            sendPacket = ReflectionUtils.getMethod(PlayerConnection, new String[]{"sendPacket"}, Packet);
+        }
+        if (minorVersion >= 8) {
+            ChatSerializer_DESERIALIZE = ChatSerializer.getMethod("a", String.class);
+            CHANNEL = ReflectionUtils.getOnlyField(NetworkManager, Channel.class);
+            try {
+                getProfile = ReflectionUtils.getOnlyMethod(EntityHuman, GameProfile.class);
+            } catch (IllegalStateException catServer) {
+                getProfile = EntityHuman.getMethod("getProfile");
+            }
+            Constructor<?> newEntityArmorStand = EntityArmorStand.getConstructor(World, double.class, double.class, double.class);
+            Method World_getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".CraftWorld").getMethod("getHandle");
+            dummyEntity = newEntityArmorStand.newInstance(World_getHandle.invoke(Bukkit.getWorlds().get(0)), 0, 0, 0);
+            BukkitTabList.load(this);
+        }
+        if (minorVersion >= 9) {
+            DataWatcherObject.load();
+        }
+        PLAYER_CONNECTION = ReflectionUtils.getOnlyField(EntityPlayer, PlayerConnection);
+        getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".entity.CraftPlayer").getMethod("getHandle");
+        DataWatcher.load(this);
+        DataWatcherItem.load(this);
+        DataWatcherHelper.load(this);
+        PacketPlayOutEntityDestroyStorage.load();
+        PacketPlayOutEntityMetadataStorage.load(this);
+        PacketPlayOutEntityTeleportStorage.load(this);
+        PacketPlayOutSpawnEntityLivingStorage.load(this);
+        PacketScoreboard.load(this);
+        PacketPlayOutEntity_ENTITYID = ReflectionUtils.getFields(PacketPlayOutEntity, int.class).get(0);
+        PacketPlayOutNamedEntitySpawn_ENTITYID = ReflectionUtils.getFields(PacketPlayOutNamedEntitySpawn, int.class).get(0);
+        if (minorVersion < 17) {
+            try {
+                (PING = EntityPlayer.getDeclaredField("ping")).setAccessible(true); // 1.5.2 - 1.16.5
+            } catch (NoSuchFieldException e) {
+                (PING = EntityPlayer.getDeclaredField("field_71138_i")).setAccessible(true); // 1.7.10 Thermos
+            }
+        }
+    }
+
+    /**
+     * Loads all classes used by the plugin
+     *
+     * @throws  ClassNotFoundException
+     *          If a class was not found
+     */
+    public abstract void loadClasses() throws ClassNotFoundException;
+
+    /**
+     * Converts TAB's IChatBaseComponent into minecraft's component using String deserialization.
+     * If the requested component is found in cache, it is returned. If not, it is created, added into cache and returned.
+     * If {@code component} is {@code null}, returns {@code null}
+     *
+     * @param   component
+     *          component to convert
+     * @param   clientVersion
+     *          client version used to decide RGB conversion
+     * @return  converted component or {@code null} if {@code component} is {@code null}
+     */
+    public @Nullable Object toNMSComponent(@NotNull IChatBaseComponent component, @NotNull ProtocolVersion clientVersion) {
+        return componentCache.get(component, clientVersion);
+    }
+}
@@ -0,0 +1,33 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import me.neznamy.tab.shared.util.ReflectionUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+/**
+ * Custom class for holding data used in PacketPlayOutEntityDestroy minecraft packet.
+ */
+public class PacketPlayOutEntityDestroyStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+    public static Field ENTITIES;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load() throws NoSuchMethodException {
+        ENTITIES = ReflectionUtils.getOnlyField(CLASS);
+        try {
+            CONSTRUCTOR = CLASS.getConstructor(int[].class);
+        } catch (NoSuchMethodException e) {
+            //1.17.0
+            CONSTRUCTOR = CLASS.getConstructor(int.class);
+        }
+    }
+}
@@ -0,0 +1,33 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+
+import java.lang.reflect.Constructor;
+import java.util.List;
+
+/**
+ * Custom class for holding data used in PacketPlayOutEntityMetadata minecraft packet.
+ */
+public class PacketPlayOutEntityMetadataStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        if (nms.is1_19_3Plus()) {
+            CONSTRUCTOR = CLASS.getConstructor(int.class, List.class);
+        } else {
+            CONSTRUCTOR = CLASS.getConstructor(int.class, DataWatcher.CLASS, boolean.class);
+        }
+    }
+}
@@ -0,0 +1,87 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.backend.Location;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+
+/**
+ * Custom class for holding data used in PacketPlayOutEntityTeleport minecraft packet.
+ */
+public class PacketPlayOutEntityTeleportStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+    public static Field ENTITY_ID;
+    public static Field X;
+    public static Field Y;
+    public static Field Z;
+    public static Field YAW;
+    public static Field PITCH;
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException {
+        ENTITY_ID = ReflectionUtils.getFields(CLASS, int.class).get(0);
+        YAW = ReflectionUtils.getFields(CLASS, byte.class).get(0);
+        PITCH = ReflectionUtils.getFields(CLASS, byte.class).get(1);
+        if (nms.getMinorVersion() >= 17) {
+            CONSTRUCTOR = CLASS.getConstructor(nms.Entity);
+        } else {
+            CONSTRUCTOR = CLASS.getConstructor();
+        }
+        if (nms.getMinorVersion() >= 9) {
+            X = ReflectionUtils.getFields(CLASS, double.class).get(0);
+            Y = ReflectionUtils.getFields(CLASS, double.class).get(1);
+            Z = ReflectionUtils.getFields(CLASS, double.class).get(2);
+        } else {
+            X = ReflectionUtils.getFields(CLASS, int.class).get(1);
+            Y = ReflectionUtils.getFields(CLASS, int.class).get(2);
+            Z = ReflectionUtils.getFields(CLASS, int.class).get(3);
+        }
+    }
+
+    /**
+     * Converts this class into NMS packet
+     *
+     * @return  NMS packet
+     */
+    @SneakyThrows
+    public static Object build(int entityId, Location location) {
+        NMSStorage nms = NMSStorage.getInstance();
+        Object nmsPacket;
+        if (nms.getMinorVersion() >= 17) {
+            nmsPacket = CONSTRUCTOR.newInstance(nms.dummyEntity);
+        } else {
+            nmsPacket = CONSTRUCTOR.newInstance();
+        }
+        ENTITY_ID.set(nmsPacket, entityId);
+        if (nms.getMinorVersion() >= 9) {
+            X.set(nmsPacket, location.getX());
+            Y.set(nmsPacket, location.getY());
+            Z.set(nmsPacket, location.getZ());
+        } else {
+            X.set(nmsPacket, floor(location.getX()*32));
+            Y.set(nmsPacket, floor(location.getY()*32));
+            Z.set(nmsPacket, floor(location.getZ()*32));
+        }
+        YAW.set(nmsPacket, (byte) (location.getYaw()/360*256));
+        PITCH.set(nmsPacket, (byte) (location.getPitch()/360*256));
+        return nmsPacket;
+    }
+
+    private static int floor(double paramDouble) {
+        int i = (int)paramDouble;
+        return paramDouble < i ? i - 1 : i;
+    }
+}
@@ -0,0 +1,131 @@
+package me.neznamy.tab.platforms.bukkit.nms.storage.packet;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.backend.EntityData;
+import me.neznamy.tab.shared.backend.Location;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.bukkit.entity.EntityType;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.EnumMap;
+import java.util.UUID;
+
+/**
+ * Custom class for holding data used in PacketPlayOutSpawnEntityLiving minecraft packet.
+ */
+public class PacketPlayOutSpawnEntityLivingStorage {
+
+    /** NMS Fields */
+    public static Class<?> CLASS;
+    public static Constructor<?> CONSTRUCTOR;
+
+    /** 1.17+ */
+    public static Class<?> Vec3D;
+    public static Class<?> EntityTypes;
+    public static Object Vec3D_Empty;
+    public static Object EntityTypes_ARMOR_STAND;
+
+    /** 1.16.5- */
+    public static Field ENTITY_ID;
+    public static Field ENTITY_TYPE;
+    public static Field YAW;
+    public static Field PITCH;
+    public static Field UUID;
+    public static Field X;
+    public static Field Y;
+    public static Field Z;
+    public static Field DATA_WATCHER;
+    public static final EnumMap<EntityType, Integer> entityIds = new EnumMap<>(EntityType.class);
+
+    /**
+     * Loads all required Fields and throws Exception if something went wrong
+     *
+     * @param   nms
+     *          NMS storage reference
+     * @throws  NoSuchMethodException
+     *          If something fails
+     */
+    public static void load(NMSStorage nms) throws NoSuchMethodException, IllegalAccessException, NoSuchFieldException {
+        int minorVersion = nms.getMinorVersion();
+        if (minorVersion >= 13) {
+            entityIds.put(EntityType.ARMOR_STAND, 1);
+        } else {
+            entityIds.put(EntityType.WITHER, 64);
+            if (minorVersion >= 8) {
+                entityIds.put(EntityType.ARMOR_STAND, 30);
+            }
+        }
+
+        if (minorVersion >= 19) {
+            EntityTypes_ARMOR_STAND = EntityTypes.getDeclaredField("d").get(null);
+            CONSTRUCTOR = CLASS.getConstructor(int.class, UUID.class, double.class, double.class, double.class, float.class, float.class, EntityTypes, int.class, Vec3D, double.class);
+            Vec3D_Empty = ReflectionUtils.getOnlyField(Vec3D, Vec3D).get(null);
+        } else if (minorVersion >= 17) {
+            EntityTypes_ARMOR_STAND = EntityTypes.getDeclaredField("c").get(null);
+            CONSTRUCTOR = CLASS.getConstructor(int.class, UUID.class, double.class, double.class, double.class, float.class, float.class, EntityTypes, int.class, Vec3D);
+            Vec3D_Empty = ReflectionUtils.getOnlyField(Vec3D, Vec3D).get(null);
+        } else {
+            CONSTRUCTOR = CLASS.getConstructor();
+            ENTITY_ID = ReflectionUtils.getFields(CLASS, int.class).get(0);
+            YAW = ReflectionUtils.getFields(CLASS, byte.class).get(0);
+            PITCH = ReflectionUtils.getFields(CLASS, byte.class).get(1);
+            if (minorVersion >= 9) {
+                UUID = ReflectionUtils.getOnlyField(CLASS, UUID.class);
+                X = ReflectionUtils.getFields(CLASS, double.class).get(0);
+                Y = ReflectionUtils.getFields(CLASS, double.class).get(1);
+                Z = ReflectionUtils.getFields(CLASS, double.class).get(2);
+            } else {
+                X = ReflectionUtils.getFields(CLASS, int.class).get(2);
+                Y = ReflectionUtils.getFields(CLASS, int.class).get(3);
+                Z = ReflectionUtils.getFields(CLASS, int.class).get(4);
+            }
+            ENTITY_TYPE = ReflectionUtils.getFields(CLASS, int.class).get(1);
+            if (minorVersion <= 14) {
+                DATA_WATCHER = ReflectionUtils.getOnlyField(CLASS, DataWatcher.CLASS);
+            }
+        }
+    }
+
+    /**
+     * Converts this class into NMS packet
+     *
+     * @return  NMS packet
+     */
+    @SneakyThrows
+    public static Object build(int id, UUID uuid, Object entityType, Location l, EntityData data) {
+        int minorVersion = NMSStorage.getInstance().getMinorVersion();
+        if (minorVersion >= 19) {
+            return CONSTRUCTOR.newInstance(id, uuid, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch(), EntityTypes_ARMOR_STAND, 0, Vec3D_Empty, 0d);
+        }
+        if (minorVersion >= 17) {
+            return CONSTRUCTOR.newInstance(id, uuid, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch(), EntityTypes_ARMOR_STAND, 0, Vec3D_Empty);
+        }
+        Object nmsPacket = CONSTRUCTOR.newInstance();
+        ENTITY_ID.set(nmsPacket, id);
+        YAW.set(nmsPacket, (byte)(l.getYaw() * 256.0f / 360.0f));
+        PITCH.set(nmsPacket, (byte)(l.getPitch() * 256.0f / 360.0f));
+        if (minorVersion <= 14) {
+            DATA_WATCHER.set(nmsPacket, data.build());
+        }
+        if (minorVersion >= 9) {
+            UUID.set(nmsPacket, uuid);
+            X.set(nmsPacket, l.getX());
+            Y.set(nmsPacket, l.getY());
+            Z.set(nmsPacket, l.getZ());
+        } else {
+            X.set(nmsPacket, floor(l.getX()*32));
+            Y.set(nmsPacket, floor(l.getY()*32));
+            Z.set(nmsPacket, floor(l.getZ()*32));
+        }
+        ENTITY_TYPE.set(nmsPacket, entityIds.get((EntityType) entityType));
+        return nmsPacket;
+    }
+
+    private static int floor(double paramDouble) {
+        int i = (int)paramDouble;
+        return paramDouble < i ? i - 1 : i;
+    }
+}
@@ -1,51 +0,0 @@
-package me.neznamy.tab.platforms.bukkit.permission;
-
-import org.bukkit.entity.Player;
-
-import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.shared.permission.PermissionPlugin;
-import net.milkbowl.vault.permission.Permission;
-
-/**
- * Vault permission hook
- */
-public class Vault implements PermissionPlugin {
-
-	//permission plugi
-	private Permission permission;
-	
-	//vault version
-	private String vaultVersion;
-
-	/**
-	 * Constructs new instance with given parameters
-	 * @param permission permission plugin implementation
-	 * @param vaultVersion vault version
-	 */
-	public Vault(Permission permission, String vaultVersion) {
-		this.permission = permission;
-		this.vaultVersion = vaultVersion;
-	}
-
-	@Override
-	public String getPrimaryGroup(TabPlayer p) {
-		if (getName().equals("SuperPerms")) return "<null>";
-		return permission.getPrimaryGroup((Player) p.getPlayer());
-	}
-
-	@Override
-	public String[] getAllGroups(TabPlayer p) {
-		if (getName().equals("SuperPerms")) return new String[] {"<null>"};
-		return permission.getPlayerGroups((Player) p.getPlayer());
-	}
-
-	@Override
-	public String getName() {
-		return permission.getName();
-	}
-
-	@Override
-	public String getVersion() {
-		return "Vault " + vaultVersion;
-	}
-}
@@ -0,0 +1,176 @@
+package me.neznamy.tab.platforms.bukkit.platform;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.SneakyThrows;
+import me.clip.placeholderapi.PlaceholderAPI;
+import me.neznamy.tab.platforms.bukkit.BukkitPipelineInjector;
+import me.neznamy.tab.platforms.bukkit.BukkitPlaceholderRegistry;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.shared.GroupManager;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.chat.rgb.RGBUtils;
+import me.neznamy.tab.shared.features.injection.PipelineInjector;
+import me.neznamy.tab.shared.features.types.TabFeature;
+import me.neznamy.tab.platforms.bukkit.features.BukkitTabExpansion;
+import me.neznamy.tab.platforms.bukkit.features.PerWorldPlayerList;
+import me.neznamy.tab.platforms.bukkit.features.WitherBossBar;
+import me.neznamy.tab.platforms.bukkit.features.BukkitNameTagX;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.backend.BackendPlatform;
+import me.neznamy.tab.shared.features.PlaceholderManagerImpl;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
+import me.neznamy.tab.shared.features.nametags.NameTag;
+import me.neznamy.tab.shared.hook.LuckPermsHook;
+import me.neznamy.tab.shared.placeholders.PlayerPlaceholderImpl;
+import me.neznamy.tab.shared.placeholders.expansion.EmptyTabExpansion;
+import me.neznamy.tab.shared.placeholders.expansion.TabExpansion;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+
+/**
+ * Implementation of Platform interface for Bukkit platform
+ */
+@RequiredArgsConstructor
+@Getter
+public class BukkitPlatform implements BackendPlatform {
+
+    /** Plugin instance for registering tasks and events */
+    private final JavaPlugin plugin;
+
+    /** Variables checking presence of other plugins to hook into */
+    private final boolean placeholderAPI = ReflectionUtils.classExists("me.clip.placeholderapi.PlaceholderAPI");
+    @Setter private boolean libsDisguisesEnabled = ReflectionUtils.classExists("me.libraryaddict.disguise.DisguiseAPI");
+
+    public @NotNull BossBarManagerImpl getLegacyBossBar() {
+        return new WitherBossBar(plugin);
+    }
+
+    @Override
+    public void loadPlayers() {
+        for (Player p : getOnlinePlayers()) {
+            TAB.getInstance().addPlayer(new BukkitTabPlayer(p));
+        }
+    }
+
+    @Override
+    public void registerPlaceholders() {
+        new BukkitPlaceholderRegistry().registerPlaceholders(TAB.getInstance().getPlaceholderManager());
+    }
+
+    @Override
+    public @Nullable PipelineInjector createPipelineInjector() {
+        return NMSStorage.getInstance().getMinorVersion() >= 8 ? new BukkitPipelineInjector() : null;
+    }
+
+    @Override
+    public @NotNull NameTag getUnlimitedNameTags() {
+        return new BukkitNameTagX(plugin);
+    }
+
+    @Override
+    public @NotNull TabExpansion createTabExpansion() {
+        if (placeholderAPI) {
+            BukkitTabExpansion expansion = new BukkitTabExpansion();
+            expansion.register();
+            return expansion;
+        }
+        return new EmptyTabExpansion();
+    }
+
+    @Override
+    public @Nullable TabFeature getPerWorldPlayerList() {
+        return new PerWorldPlayerList(plugin);
+    }
+
+    /**
+     * Returns online players from Bukkit API
+     *
+     * @return  online players from Bukkit API
+     */
+    @SuppressWarnings("unchecked")
+    @SneakyThrows
+    private @NotNull Player[] getOnlinePlayers() {
+        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]);
+        }
+    }
+
+    @Override
+    public void registerUnknownPlaceholder(@NotNull String identifier) {
+        PlaceholderManagerImpl pl = TAB.getInstance().getPlaceholderManager();
+        int refresh = pl.getRefreshInterval(identifier);
+        if (identifier.startsWith("%rel_")) {
+            //relational placeholder
+            TAB.getInstance().getPlaceholderManager().registerRelationalPlaceholder(identifier, pl.getRefreshInterval(identifier), (viewer, target) ->
+                    placeholderAPI ? PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier) : identifier);
+        } else if (identifier.startsWith("%sync:")) {
+            registerSyncPlaceholder(identifier, refresh);
+        } else if (identifier.startsWith("%server_")) {
+            TAB.getInstance().getPlaceholderManager().registerServerPlaceholder(identifier, refresh, () ->
+                    placeholderAPI ? PlaceholderAPI.setPlaceholders(null, identifier) : identifier);
+        } else {
+            TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p ->
+                    placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), identifier) : identifier);
+        }
+    }
+
+    public void registerSyncPlaceholder(String identifier, int refresh) {
+        String syncedPlaceholder = "%" + identifier.substring(6);
+        PlayerPlaceholderImpl[] ppl = new PlayerPlaceholderImpl[1];
+        ppl[0] = TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p -> {
+            Bukkit.getScheduler().runTask(plugin, () -> {
+                long time = System.nanoTime();
+                ppl[0].updateValue(p, placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), syncedPlaceholder) : identifier);
+                TAB.getInstance().getCPUManager().addPlaceholderTime(identifier, System.nanoTime()-time);
+            });
+            return null;
+        });
+    }
+
+    @Override
+    public void sendConsoleMessage(@NotNull IChatBaseComponent message) {
+        Bukkit.getConsoleSender().sendMessage("[TAB] " + RGBUtils.getInstance().convertToBukkitFormat(message.toFlatText(),
+                TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
+    }
+
+    @Override
+    public String getServerVersionInfo() {
+        return "[Bukkit] " + Bukkit.getName() + " - " + Bukkit.getBukkitVersion().split("-")[0] + " (" + NMSStorage.getInstance().getServerPackage() + ")";
+    }
+
+    @Override
+    @NotNull public GroupManager detectPermissionPlugin() {
+        if (LuckPermsHook.getInstance().isInstalled()) {
+            return new GroupManager("LuckPerms", LuckPermsHook.getInstance().getGroupFunction());
+        }
+        if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
+            RegisteredServiceProvider<Permission> provider = Bukkit.getServicesManager().getRegistration(Permission.class);
+            if (provider != null && !provider.getProvider().getName().equals("SuperPerms")) {
+                return new GroupManager(provider.getProvider().getName(), p -> provider.getProvider().getPrimaryGroup((Player) p.getPlayer()));
+            }
+        }
+        return new GroupManager("None", p -> TabConstants.NO_GROUP);
+    }
+
+    public void runEntityTask(Entity entity, Runnable task) {
+        task.run();
+    }
+}
@@ -0,0 +1,88 @@
+package me.neznamy.tab.platforms.bukkit.platform;
+
+import lombok.SneakyThrows;
+import me.clip.placeholderapi.PlaceholderAPI;
+import me.neznamy.tab.platforms.bukkit.features.PerWorldPlayerList;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.TabConstants;
+import me.neznamy.tab.shared.placeholders.PlayerPlaceholderImpl;
+import me.neznamy.tab.shared.platform.TabPlayer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.function.Consumer;
+
+/**
+ * Platform override for Folia
+ */
+public class FoliaPlatform extends BukkitPlatform {
+
+    public FoliaPlatform(JavaPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public void loadPlayers() {
+        super.loadPlayers();
+
+        // Values are never updated in the API, warn users
+        TAB.getInstance().sendConsoleMessage("&cFolia never updates MSPT and TPS values in the API, making " +
+                "%mspt% and %tps% return the default values (0 and 20).", true);
+
+        // Folia never calls PlayerChangedWorldEvent, this is a workaround
+        TAB.getInstance().getCPUManager().startRepeatingMeasuredTask(100, "Folia compatibility", "Refreshing world", () -> {
+            for (TabPlayer player : TAB.getInstance().getOnlinePlayers()) {
+                String bukkitWorld = ((Player)player.getPlayer()).getWorld().getName();
+                if (!player.getWorld().equals(bukkitWorld)) {
+                    TAB.getInstance().getFeatureManager().onWorldChange(player.getUniqueId(), bukkitWorld);
+                    PerWorldPlayerList pwp = TAB.getInstance().getFeatureManager().getFeature(TabConstants.Feature.PER_WORLD_PLAYER_LIST);
+                    if (pwp != null) {
+                        runSync((Entity) player.getPlayer(), () -> pwp.onWorldChange(new PlayerChangedWorldEvent((Player) player.getPlayer(), ((Player) player.getPlayer()).getWorld())));
+                    }
+                }
+            }
+        });
+    }
+
+    @Override
+    public void registerSyncPlaceholder(String identifier, int refresh) {
+        String syncedPlaceholder = "%" + identifier.substring(6);
+        PlayerPlaceholderImpl[] ppl = new PlayerPlaceholderImpl[1];
+        ppl[0] = TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p -> {
+            runSync((Entity) p.getPlayer(), () -> {
+                long time = System.nanoTime();
+                String output = isPlaceholderAPI() ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), syncedPlaceholder) : identifier;
+                TAB.getInstance().getCPUManager().addPlaceholderTime(identifier, System.nanoTime()-time);
+                TAB.getInstance().getCPUManager().runTask(() -> ppl[0].updateValue(p, output)); // To ensure player is loaded
+            });
+            return null;
+        });
+    }
+
+    /**
+     * Runs task using player's entity scheduler. It's using reflection, because
+     * Folia uses Java 17 while TAB maintains Java 8 compatibility for compatibility
+     * with MC versions older than their player base.
+     *
+     * @param   entity
+     *          entity to run task for
+     * @param   task
+     *          Task to run
+     */
+    @SneakyThrows
+    @SuppressWarnings("JavaReflectionMemberAccess")
+    private void runSync(Entity entity, Runnable task) {
+        Object entityScheduler = Entity.class.getMethod("getScheduler").invoke(entity);
+        Consumer<?> consumer = $ -> task.run(); // Reflection and lambdas don't go together
+        entityScheduler.getClass().getMethod("run", Plugin.class, Consumer.class, Runnable.class)
+                .invoke(entityScheduler, getPlugin(), consumer, null);
+    }
+
+    @Override
+    public void runEntityTask(Entity entity, Runnable task) {
+        runSync(entity, task);
+    }
+}
@@ -0,0 +1,312 @@
+package me.neznamy.tab.platforms.bukkit.scoreboard;
+
+import lombok.SneakyThrows;
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.platforms.bukkit.nms.storage.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import me.neznamy.tab.shared.util.ReflectionUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Scoreboard implementation for Bukkit, which uses packets
+ * to send scoreboards. While md_5 keeps saying that you don't
+ * need packets for scoreboards in every single spigot update,
+ * this is not true. It may seem that way at first, but after
+ * investigating, fatal problems are found:<p>
+ * #1 - Limitations on legacy versions are forced in the API.
+ *      While this may not seem like a problem, it enforces those
+ *      limits even for 1.13+ players (if using ViaVersion).<p>
+ * #2 - Modern versions no longer have any limits, but md_5
+ *      decided to add some random limits for absolutely no reason
+ *      at all. Scoreboard title received a random 128 characters
+ *      limit including color codes. Together with the almighty bukkit
+ *      RGB format using 14 characters for 1 color code, this makes
+ *      gradients just impossible to use. Team prefix/suffix also
+ *      received a 64 characters limit (excluding color codes at least),
+ *      however that might not be enough for displaying a line of text
+ *      in sidebar, which would require splitting the text into prefix
+ *      and suffix, which is just begging for bugs to be introduced.<p>
+ * #3 - Other plugins can decide to put players into their own
+ *      scoreboard, automatically destroying all visuals made by the
+ *      plugin. They might also put all players into the same scoreboard,
+ *      making per-player view of teams, especially sidebar not working.<p>
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class PacketScoreboard extends Scoreboard<BukkitTabPlayer> {
+
+    private static NMSStorage nms;
+
+    public static Class<?> Scoreboard;
+    public static Class<?> IScoreboardCriteria;
+    private static Object emptyScoreboard;
+    private static Field IScoreboardCriteria_self;
+
+    // PacketPlayOutScoreboardDisplayObjective
+    public static Class<?> DisplayObjectiveClass;
+    private static Constructor<?> newDisplayObjective;
+    public static Field DisplayObjective_POSITION;
+    public static Field DisplayObjective_OBJECTIVE_NAME;
+
+    // PacketPlayOutScoreboardScore
+    public static Class<?> ScorePacketClass;
+    public static Class<?> ScoreboardScoreClass;
+    public static Class<Enum> EnumScoreboardAction;
+    private static Constructor<?> newScorePacket_1_13;
+    private static Constructor<?> newScorePacket_String;
+    private static Constructor<?> newScorePacket;
+    private static Constructor<?> newScoreboardScore;
+    public static Method ScoreboardScore_setScore;
+
+    // PacketPlayOutScoreboardObjective
+    public static Class<?> ObjectivePacketClass;
+    private static Constructor<?> newObjectivePacket;
+    public static Field Objective_OBJECTIVE_NAME;
+    public static Field Objective_METHOD;
+    private static Field Objective_RENDER_TYPE;
+    private static Field Objective_DISPLAY_NAME;
+    public static Class<Enum> EnumScoreboardHealthDisplay;
+    public static Class<?> ScoreboardObjective;
+    private static Constructor<?> newScoreboardObjective;
+
+    // PacketPlayOutScoreboardTeamStorage
+    public static Class<?> TeamPacketClass;
+    private static Constructor<?> newTeamPacket;
+    private static Method TeamPacketConstructor_of;
+    private static Method TeamPacketConstructor_ofBoolean;
+    public static Field TeamPacket_NAME;
+    public static Field TeamPacket_ACTION;
+    public static Field TeamPacket_PLAYERS;
+    public static Class<Enum> EnumNameTagVisibility;
+    public static Class<Enum> EnumTeamPush;
+    public static Class<?> ScoreboardTeam;
+    private static Constructor<?> newScoreboardTeam;
+    private static Method ScoreboardTeam_getPlayerNameSet;
+    public static Method ScoreboardTeam_setNameTagVisibility;
+    private static Method ScoreboardTeam_setCollisionRule;
+    public static Method ScoreboardTeam_setPrefix;
+    public static Method ScoreboardTeam_setSuffix;
+    private static Method ScoreboardTeam_setColor;
+    public static Method ScoreboardTeam_setAllowFriendlyFire;
+    public static Method ScoreboardTeam_setCanSeeFriendlyInvisibles;
+
+    public static void load(NMSStorage nms) throws ReflectiveOperationException {
+        PacketScoreboard.nms = nms;
+        emptyScoreboard = Scoreboard.getConstructor().newInstance();
+        IScoreboardCriteria_self = ReflectionUtils.getFields(IScoreboardCriteria, IScoreboardCriteria).get(0);
+        newDisplayObjective = DisplayObjectiveClass.getConstructor(int.class, ScoreboardObjective);
+        DisplayObjective_POSITION = ReflectionUtils.getOnlyField(DisplayObjectiveClass, int.class);
+        DisplayObjective_OBJECTIVE_NAME = ReflectionUtils.getOnlyField(DisplayObjectiveClass, String.class);
+        newScoreboardObjective = ReflectionUtils.getOnlyConstructor(ScoreboardObjective);
+        Objective_OBJECTIVE_NAME = ReflectionUtils.getFields(ObjectivePacketClass, String.class).get(0);
+        List<Field> list = ReflectionUtils.getFields(ObjectivePacketClass, int.class);
+        Objective_METHOD = list.get(list.size()-1);
+        newScoreboardScore = ScoreboardScoreClass.getConstructor(Scoreboard, ScoreboardObjective, String.class);
+        newScoreboardTeam = ScoreboardTeam.getConstructor(Scoreboard, String.class);
+        TeamPacket_NAME = ReflectionUtils.getFields(TeamPacketClass, String.class).get(0);
+        TeamPacket_ACTION = ReflectionUtils.getInstanceFields(TeamPacketClass, int.class).get(0);
+        TeamPacket_PLAYERS = ReflectionUtils.getOnlyField(TeamPacketClass, Collection.class);
+        ScoreboardTeam_getPlayerNameSet = ReflectionUtils.getOnlyMethod(ScoreboardTeam, Collection.class);
+        ScoreboardScore_setScore = ReflectionUtils.getMethod(ScoreboardScoreClass, new String[] {"func_96647_c", "setScore", "b", "c"}, int.class); // {Thermos, 1.5.1 - 1.17.1, 1.18+, 1.5}
+        ScoreboardTeam_setAllowFriendlyFire = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_96660_a", "setAllowFriendlyFire", "a"}, boolean.class); // {Thermos, 1.5.1+, 1.5 & 1.18+}
+        ScoreboardTeam_setCanSeeFriendlyInvisibles = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_98300_b", "setCanSeeFriendlyInvisibles", "b"}, boolean.class); // {Thermos, 1.5.1+, 1.5 & 1.18+}
+        if (nms.getMinorVersion() >= 13) {
+            newScorePacket_1_13 = ScorePacketClass.getConstructor(EnumScoreboardAction, String.class, String.class, int.class);
+            newObjectivePacket = ObjectivePacketClass.getConstructor(ScoreboardObjective, int.class);
+            Objective_DISPLAY_NAME = ReflectionUtils.getOnlyField(ObjectivePacketClass, nms.IChatBaseComponent);
+            ScoreboardTeam_setColor = ReflectionUtils.getOnlyMethod(ScoreboardTeam, void.class, nms.EnumChatFormat);
+            ScoreboardTeam_setPrefix = ReflectionUtils.getMethod(ScoreboardTeam, new String[]{"setPrefix", "b"}, nms.IChatBaseComponent); // {1.17.1-, 1.18+}
+            ScoreboardTeam_setSuffix = ReflectionUtils.getMethod(ScoreboardTeam, new String[]{"setSuffix", "c"}, nms.IChatBaseComponent); // {1.17.1-, 1.18+}
+        } else {
+            newScorePacket_String = ScorePacketClass.getConstructor(String.class);
+            newObjectivePacket = ObjectivePacketClass.getConstructor();
+            Objective_DISPLAY_NAME = ReflectionUtils.getFields(ObjectivePacketClass, String.class).get(1);
+            ScoreboardTeam_setPrefix = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_96666_b", "setPrefix", "b"}, String.class); // {Thermos, 1.5.1+, 1.5}
+            ScoreboardTeam_setSuffix = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"func_96662_c", "setSuffix", "c"}, String.class); // {Thermos, 1.5.1+, 1.5}
+            if (nms.getMinorVersion() >= 8) {
+                newScorePacket = ScorePacketClass.getConstructor(ScoreboardScoreClass);
+                Objective_RENDER_TYPE = ReflectionUtils.getOnlyField(ObjectivePacketClass, EnumScoreboardHealthDisplay);
+            } else {
+                newScorePacket = ScorePacketClass.getConstructor(ScoreboardScoreClass, int.class);
+            }
+        }
+        if (nms.getMinorVersion() >= 8) {
+            ScoreboardTeam_setNameTagVisibility = ReflectionUtils.getMethod(ScoreboardTeam, new String[] {"setNameTagVisibility", "a"}, EnumNameTagVisibility); // {1.8.1+, 1.8 & 1.18+}
+        }
+        if (nms.getMinorVersion() >= 9) {
+            ScoreboardTeam_setCollisionRule = ReflectionUtils.getOnlyMethod(ScoreboardTeam, void.class, EnumTeamPush);
+        }
+        if (nms.getMinorVersion() >= 17) {
+            TeamPacketConstructor_of = ReflectionUtils.getOnlyMethod(TeamPacketClass, TeamPacketClass, ScoreboardTeam);
+            TeamPacketConstructor_ofBoolean = ReflectionUtils.getOnlyMethod(TeamPacketClass, TeamPacketClass, ScoreboardTeam, boolean.class);
+        } else {
+            newTeamPacket = TeamPacketClass.getConstructor(ScoreboardTeam, int.class);
+        }
+    }
+
+    public PacketScoreboard(BukkitTabPlayer player) {
+        super(player);
+    }
+
+    @Override
+    @SneakyThrows
+    public void setDisplaySlot(@NotNull DisplaySlot slot, @NotNull String objective) {
+        player.sendPacket(newDisplayObjective.newInstance(slot.ordinal(), newScoreboardObjective(objective)));
+    }
+
+    @Override
+    @SneakyThrows
+    public void registerObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(buildObjective(0, objectiveName, title, hearts));
+    }
+
+    @Override
+    public void unregisterObjective0(@NotNull String objectiveName) {
+        player.sendPacket(buildObjective(1, objectiveName, "", false));
+    }
+
+    @Override
+    public void updateObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        player.sendPacket(buildObjective(2, objectiveName, title, hearts));
+    }
+
+    @SneakyThrows
+    private Object buildObjective(int action, String objectiveName, String title, boolean hearts) {
+        if (nms.getMinorVersion() >= 13) {
+            return newObjectivePacket.newInstance(
+                    newScoreboardObjective.newInstance(null, objectiveName, null,
+                    nms.toNMSComponent(IChatBaseComponent.optimizedComponent(title), player.getVersion()),
+                    asDisplayType(hearts)),
+                    action
+            );
+        }
+        Object nmsPacket = newObjectivePacket.newInstance();
+        Objective_OBJECTIVE_NAME.set(nmsPacket, objectiveName);
+        Objective_DISPLAY_NAME.set(nmsPacket, title);
+        if (nms.getMinorVersion() >= 8) {
+            Objective_RENDER_TYPE.set(nmsPacket, asDisplayType(hearts));
+        }
+        Objective_METHOD.set(nmsPacket, action);
+        return nmsPacket;
+    }
+
+    private Object asDisplayType(boolean hearts) {
+        return Enum.valueOf(EnumScoreboardHealthDisplay, hearts ? "HEARTS" : "INTEGER");
+    }
+
+    @Override
+    @SneakyThrows
+    public void registerTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                              @NotNull NameVisibility visibility, @NotNull CollisionRule collision,
+                              @NotNull Collection<String> players, int options) {
+        Object team = createTeam(name, prefix, suffix, visibility, collision, options);
+        ((Collection<String>)ScoreboardTeam_getPlayerNameSet.invoke(team)).addAll(players);
+        if (nms.getMinorVersion() >= 17) {
+            player.sendPacket(TeamPacketConstructor_ofBoolean.invoke(null, team, true));
+        } else {
+            player.sendPacket(newTeamPacket.newInstance(team, 0));
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void unregisterTeam0(@NotNull String name) {
+        Object team = newScoreboardTeam.newInstance(emptyScoreboard, name);
+        if (nms.getMinorVersion() >= 17) {
+            player.sendPacket(TeamPacketConstructor_of.invoke(null, team));
+        } else {
+            player.sendPacket(newTeamPacket.newInstance(team, 1));
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public void updateTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                            @NotNull NameVisibility visibility, @NotNull CollisionRule collision, int options) {
+        Object team = createTeam(name, prefix, suffix, visibility, collision, options);
+        if (nms.getMinorVersion() >= 17) {
+            player.sendPacket(TeamPacketConstructor_ofBoolean.invoke(null, team, false));
+        } else {
+            player.sendPacket(newTeamPacket.newInstance(team, 2));
+        }
+    }
+
+    @SneakyThrows
+    private Object createTeam(String teamName, String prefix, String suffix, NameVisibility visibility, CollisionRule collision, int options) {
+        Object team = newScoreboardTeam.newInstance(emptyScoreboard, teamName);
+        ScoreboardTeam_setAllowFriendlyFire.invoke(team, (options & 0x1) > 0);
+        ScoreboardTeam_setCanSeeFriendlyInvisibles.invoke(team, (options & 0x2) > 0);
+        if (nms.getMinorVersion() >= 13) {
+            ScoreboardTeam_setPrefix.invoke(team, nms.toNMSComponent(IChatBaseComponent.optimizedComponent(prefix), player.getVersion()));
+            ScoreboardTeam_setSuffix.invoke(team, nms.toNMSComponent(IChatBaseComponent.optimizedComponent(suffix), player.getVersion()));
+            ScoreboardTeam_setColor.invoke(team, Enum.valueOf(nms.EnumChatFormat, EnumChatFormat.lastColorsOf(prefix).toString()));
+        } else {
+            ScoreboardTeam_setPrefix.invoke(team, prefix);
+            ScoreboardTeam_setSuffix.invoke(team, suffix);
+        }
+        if (nms.getMinorVersion() >= 8) ScoreboardTeam_setNameTagVisibility.invoke(team, Enum.valueOf(EnumNameTagVisibility, visibility.name()));
+        if (nms.getMinorVersion() >= 9) ScoreboardTeam_setCollisionRule.invoke(team, Enum.valueOf(EnumTeamPush, collision.name()));
+        return team;
+    }
+
+    @Override
+    @SneakyThrows
+    public void setScore0(@NotNull String objective, @NotNull String playerName, int score) {
+        Object packet;
+        if (nms.getMinorVersion() >= 13) {
+            packet = newScorePacket_1_13.newInstance(Enum.valueOf(EnumScoreboardAction, "CHANGE"), objective, playerName, score);
+        } else {
+            Object scoreboardScore = newScoreboardScore.newInstance(emptyScoreboard, newScoreboardObjective(objective), playerName);
+            ScoreboardScore_setScore.invoke(scoreboardScore, score);
+            if (nms.getMinorVersion() >= 8) {
+                packet = newScorePacket.newInstance(scoreboardScore);
+            } else {
+                packet = newScorePacket.newInstance(scoreboardScore, 0);
+            }
+        }
+        player.sendPacket(packet);
+    }
+
+    @Override
+    @SneakyThrows
+    public void removeScore0(@NotNull String objective, @NotNull String playerName) {
+        if (nms.getMinorVersion() >= 13) {
+            player.sendPacket(newScorePacket_1_13.newInstance(Enum.valueOf(EnumScoreboardAction, "REMOVE"), objective, playerName, 0));
+        } else {
+            player.sendPacket(newScorePacket_String.newInstance(playerName));
+        }
+    }
+
+    /**
+     * Creates a new Scoreboard Objective with given name.
+     *
+     * @param   objectiveName
+     *          Objective name
+     * @return  NMS Objective
+     */
+    @SneakyThrows
+    public Object newScoreboardObjective(@NotNull String objectiveName) {
+        if (nms.getMinorVersion() >= 13) {
+            return newScoreboardObjective.newInstance(
+                    null,
+                    objectiveName,
+                    null,
+                    nms.toNMSComponent(new IChatBaseComponent(""), TAB.getInstance().getServerVersion()),
+                    null
+            );
+        }
+        return newScoreboardObjective.newInstance(
+                null,
+                objectiveName,
+                IScoreboardCriteria_self.get(null)
+        );
+    }
+}
@@ -0,0 +1,147 @@
+package me.neznamy.tab.platforms.bukkit.scoreboard;
+
+import me.neznamy.tab.platforms.bukkit.BukkitTabPlayer;
+import me.neznamy.tab.shared.TAB;
+import me.neznamy.tab.shared.chat.EnumChatFormat;
+import me.neznamy.tab.shared.chat.IChatBaseComponent;
+import me.neznamy.tab.shared.platform.Scoreboard;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.RenderType;
+import org.bukkit.scoreboard.Team;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+/**
+ * Scoreboard handler using Paper API, which got added
+ * in early 1.16.5 builds. Unlike the Bukkit API, the new
+ * methods using adventure components do not have any
+ * pointless artificial limits added in.
+ * <p>
+ * However, it still inherits the issue with compatibility
+ * with other plugins that create scoreboards.
+ * <p>
+ * Currently, this class is never used. In the future, it might
+ * be used as a fallback solution for unsupported versions if NMS
+ * changes and fields fail to load. Or as a complete replacement
+ * if compatibility with other plugins turns out not to be a problem.
+ */
+// Throw the NPE if something is not as expected, parent class should ensure it anyway
+// Use Bukkit setColor, the adventure one does not support magic codes while they are permitted
+@SuppressWarnings({"ConstantConditions", "deprecation"})
+public class PaperScoreboard extends Scoreboard<BukkitTabPlayer> {
+
+    private final org.bukkit.scoreboard.Scoreboard scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
+
+    public PaperScoreboard(BukkitTabPlayer player) {
+        super(player);
+
+        // Put player into a different scoreboard for per-player view
+        player.getPlayer().setScoreboard(scoreboard);
+    }
+
+    @Override
+    public void setDisplaySlot(@NotNull DisplaySlot slot, @NotNull String objective) {
+        checkPlayerScoreboard();
+        scoreboard.getObjective(objective).setDisplaySlot(org.bukkit.scoreboard.DisplaySlot.valueOf(slot.name()));
+    }
+
+    @Override
+    public void setScore0(@NotNull String objective, @NotNull String playerName, int score) {
+        checkPlayerScoreboard();
+        scoreboard.getObjective(objective).getScore(playerName).setScore(score);
+    }
+
+    @Override
+    public void removeScore0(@NotNull String objective, @NotNull String playerName) {
+        checkPlayerScoreboard();
+        scoreboard.resetScores(playerName);
+    }
+
+    @Override
+    public void registerObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        checkPlayerScoreboard();
+        scoreboard.registerNewObjective(objectiveName, "dummy", toAdventure(title), hearts ? RenderType.HEARTS : RenderType.INTEGER);
+    }
+
+    @Override
+    public void unregisterObjective0(@NotNull String objectiveName) {
+        checkPlayerScoreboard();
+        scoreboard.getObjective(objectiveName).unregister();
+    }
+
+    @Override
+    public void updateObjective0(@NotNull String objectiveName, @NotNull String title, boolean hearts) {
+        checkPlayerScoreboard();
+        Objective obj = scoreboard.getObjective(objectiveName);
+        obj.setRenderType(hearts ? RenderType.HEARTS : RenderType.INTEGER);
+        obj.displayName(toAdventure(title));
+    }
+
+    @Override
+    public void registerTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                              @NotNull NameVisibility visibility, @NotNull CollisionRule collision,
+                              @NotNull Collection<String> players, int options) {
+        checkPlayerScoreboard();
+        Team team = scoreboard.registerNewTeam(name);
+        team.prefix(toAdventure(prefix));
+        team.suffix(toAdventure(suffix));
+        team.setColor(ChatColor.valueOf(EnumChatFormat.lastColorsOf(prefix).name()));
+        team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.values()[visibility.ordinal()]);
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.values()[collision.ordinal()]);
+        players.forEach(team::addEntry);
+        team.setAllowFriendlyFire((options & 0x01) != 0);
+        team.setCanSeeFriendlyInvisibles((options & 0x02) != 0);
+    }
+
+    @Override
+    public void unregisterTeam0(@NotNull String name) {
+        checkPlayerScoreboard();
+        scoreboard.getTeam(name).unregister();
+    }
+
+    @Override
+    public void updateTeam0(@NotNull String name, @NotNull String prefix, @NotNull String suffix,
+                            @NotNull NameVisibility visibility, @NotNull CollisionRule collision, int options) {
+        checkPlayerScoreboard();
+        Team team = scoreboard.getTeam(name);
+        team.prefix(toAdventure(prefix));
+        team.suffix(toAdventure(suffix));
+        team.setColor(ChatColor.valueOf(EnumChatFormat.lastColorsOf(prefix).name()));
+        team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.values()[visibility.ordinal()]);
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.values()[collision.ordinal()]);
+        team.setAllowFriendlyFire((options & 0x01) != 0);
+        team.setCanSeeFriendlyInvisibles((options & 0x02) != 0);
+    }
+
+    /**
+     * Converts raw text into adventure component
+     *
+     * @param   text
+     *          Text to convert
+     * @return  Converted component
+     */
+    private @NotNull Component toAdventure(@NotNull String text) {
+        return IChatBaseComponent.optimizedComponent(text).toAdventureComponent(player.getVersion());
+    }
+
+    /**
+     * Makes sure player is in the correct scoreboard.
+     * If not, puts the player into correct scoreboard and prints
+     * a warning.
+     * The only possible reason for this to happen is another plugin
+     * putting a player into a different scoreboard.
+     * Sadly there is no efficient solution to this, which md_5 fails
+     * to understand and keeps saying you don't need packets for scoreboards.
+     */
+    private void checkPlayerScoreboard() {
+        if (player.getPlayer().getScoreboard() != scoreboard) {
+            player.getPlayer().setScoreboard(scoreboard);
+            TAB.getInstance().getErrorManager().printError("Player " + player.getName() + " was in a different scoreboard " +
+                    "than expected. This means another plugin changed player's scoreboard.");
+        }
+    }
+}
@@ -1,249 +0,0 @@
-# Detailed explanation of all options available at https://github.com/NEZNAMY/TAB/wiki/config.yml
-
-#changing nametags, affecting sorting, collision rule
-change-nametag-prefix-suffix: true
-
-#prefix/suffix in tablist
-change-tablist-prefix-suffix: true
-
-#header/footer
-enable-header-footer: true
-
-header:
-  - "&3&lServer name"
-  - "&7&l>> %animation:Welcome%&3 &l%player%&7&l! &7&l<<"
-  - "&7Online players: &f%online%"
-  - "&6Online staff: &e%staffonline%"
-  - "%animation:ping-tps%"
-  - ""
-  - "&7&l Used memory: %memory-used% MB / %memory-max% MB"
-  - "%animation:MyAnimation1%"
-footer:
-  - "%animation:MyAnimation1%"
-  - "%animation:time%"
-  - ""
-  - "&7Visit our webpage %animation:web%"
-
-#supports any numeric placeholder, set to "" to disable the feature
-yellow-number-in-tablist: "%ping%"
-
-#literally what it says
-group-sorting-priority-list:
-  - owner
-  - admin
-  - mod
-  - helper
-  - builder
-  - premium
-  - player
-  - default
-
-Groups:
-  Owner:
-    tabprefix: "&0&l[&a&lOwner&0&l] &a"
-    tagprefix: "&2&lOwner &a"
-  Admin:
-    tabprefix: "&0&l[&4&lAdmin&0&l] &1"
-    tagprefix: "%animation:admin_prefix%"
-  Player:
-    tabprefix: "&0&l[&7&lPlayer&0&l] &3"
-    tagprefix: "&2&lPlayer &3"
-  example_group:
-    header:
-      - "This is an example of per-group header/footer"
-    footer:
-      - "applied to a group"
-      
-  #default settings for all groups, all groups will take properties from this section unless player's primary group overrides a specific setting
-  _OTHER_:
-    tabprefix: "%vault-prefix%"
-    tagprefix: "%vault-prefix%"
-    tabsuffix: "%afk%"
-    tagsuffix: "%afk%"
-    customtabname: "%essentialsnick%"
-    customtagname: "%essentialsnick%"
-
-Users:
-  _NEZNAMY_:
-    tabprefix: "&6&lTAB Author &a"
-    tagprefix: "&6&lTAB &r&a"
-    abovename: "&bOh look, 3 lines of text !"
-    belowname: "&eThere's only one plugin out there supporting it"
-
-#additional very limited line of text below nametag
-#don't forget this enables on all player entities, which includes NPCs
-#tags so you can find this section using the mighty ctrl + f feature: [NPC, Citizens, below_name, health]
-classic-vanilla-belowname:
-
-  #enabling the feature
-  enabled: true
-  
-  #number or numeric placeholder, supports per-player placeholders
-  number: "%health%"
-  
-  #text after number, must be same on all players
-  text: "Health"
-
-#controlling the collision rule
-enable-collision: true
-
-#using the opposite of the setting above for worlds
-revert-collision-rule-in-worlds:
-  - revertedworld
-  
-#preventing players with spectator gamemode from being moved to the bottom of tablist with transparent name
-do-not-move-spectators: false
-
-#allows players with tab.spectatorbypass permission to see spectators moved despite the option above enabled
-allow-spectator-bypass-permission: false
-
-#using armor stands for nametags, bypassing all limits
-#THEY ARE CLIENT SIDED AND DO NOT EXIST ON SERVER SO STOP SAYING YOUR SERVER IS LAGGING FROM THIS
-unlimited-nametag-prefix-suffix-mode:
-
-  #enabling the feature
-  enabled: false
-  
-  #enabling will result in NPCs ignoring nametag prefix/suffix/visibility to prevent NPCs with names of online players from being invisible
-  modify-npc-names: false
-  
-  #using a feature introduced in 1.8.1 to make hitbox zero so you can't cry it affects pvp despite hit redirection
-  #1.8.0 clients will see wild things
-  #automatically enabled for 1.9+
-  use-marker-tag-for-1-8-x-clients: false
-  
-  #disabling the feature for players riding boats to prevent massive desync
-  disable-on-boats: true
-  
-  #in blocks
-  space-between-lines: 0.22
-  tracking-range: 48
-
-per-world-settings:
-  world1:
-    header:
-      - "an example of world with custom"
-    footer:
-      - "header/footer and prefix/suffix"
-    Groups:
-      Owner:
-        tabprefix: "&0&l[&a&lOwner&0&l] &a"
-        tagprefix: "&2&lOwner &a"
-        
-  #separating multiple worlds with "-"
-  world2-world3:
-    header:
-      - "This is a shared header for"
-      - "world2 and world3"
-
-placeholders:
-  #output of %afk%
-  afk-yes: " &4*&4&lAFK&4*&r"
-  afk-no: ""
-  
-  #%date%
-  date-format: "dd.MM.yyyy"
-  
-  #%time%
-  time-format: "[HH:mm:ss / h:mm a]"
-  
-  #in hours, in case of wrong timezone
-  time-offset: 0
-  
-  #don't forget color codes
-  remove-strings:
-    - "[]"
-    - "< >"
-    
-#aliases for %rank%, this is not the place where group prefix is defined!
-rank-aliases:
-  Admin: "&4&lADMIN"
-  Mod: "&b&lMOD"
-  Premium: "&6&lPREMIUM"
-  Ultra: "&b&lULTRA"
-  Legend: "&a&lLEGEND"
-  Titan: "&c&lTITAN"
-  Youtuber: "&c&lYOUTUBE"
-  _OTHER_: "&7No Rank"
-  
-disable-features-in-worlds:
-  header-footer:
-    - disabledworld
-  tablist-names:
-    - disabledworld
-  nametag:
-    - disabledworld
-  yellow-number:
-    - disabledworld
-  bossbar:
-    - disabledworld
-  belowname:
-    - disabledworld
-  unlimited-nametags:
-    - disabledworld
-
-placeholderapi-refresh-intervals:
-  default-refresh-interval: 100
-  server:
-    "%server_uptime%": 1000
-    "%server_tps_1_colored%": 1000
-  player:
-    "%player_health%": 200
-    "%player_ping%": 1000
-    "%vault_prefix%": 1000
-  relational:
-    "%rel_factionsuuid_relation_color%": 500
-    
-#different playerlist in different worlds
-per-world-playerlist:
-
-  #to enable the feature
-  enabled: false
-  
-  #allows players with tab.bypass permission to see everyone in tablist despite this option enabled
-  allow-bypass-permission: false
-  
-  #players in these worlds will see everyone despite the feature enabled
-  ignore-effect-in-worlds:
-    - ignoredworld
-    - build
-    
-  #groups of worlds to share playerlist
-  shared-playerlist-world-groups:
-    #group name, can be anything
-    lobby:
-      - lobby1
-      - lobby2
-    minigames:
-      - paintball
-      - bedwars
-
-#permission node is tab.sort.<permission group from sorting list>
-sort-players-by-permissions: false
-
-#making tamed animals no longer copy nametag properties from their owner (prefix/suffix/visibility)
-#do not enable this if you're on paper, you'll feed the trolls even more
-fix-pet-names: false
-
-#taking primary group from permission plugin
-use-primary-group: true
-
-#if the option above is false, all groups are taken from permission plugin and the one higher in this list is used as primary
-primary-group-finding-list:
-  - Owner
-  - Admin
-  - Helper
-  - default
-  
-#if none of the above fits your needs, you can enable this to give groups using tab.group.<group name from the list above> permission
-assign-groups-by-permissions: false
-
-#preventing other plugins from overriding TAB
-anti-override:
-  scoreboard-teams: true
-  scoreboard-objectives: true
-  tablist-names: true
-  usernames: true
-  
-#permanently invisible nametags
-invisible-nametags: false
@@ -1,10 +1,111 @@
-name: ${project.parent.name}
-version: ${project.parent.version}
-author: NEZNAMY
-main: me.neznamy.tab.platforms.bukkit.Main
-api-version: 1.13
-softdepend: [PlaceholderAPI, Vault, UltraPermissions, LuckPerms, Essentials, LibsDisguises]
-website: "https://www.spigotmc.org/resources/57806/"
-description: ${project.parent.description}
+main: me.neznamy.tab.platforms.bukkit.BukkitTAB
+name: @name@
+version: @version@
+description: @description@
+api-version: 1.13 # Defining to avoid legacy plugin warn
+load: POSTWORLD
+author: @author@
+website: "@website@"
+depend: []
+softdepend: [PlaceholderAPI, LuckPerms, LibsDisguises, ViaVersion, ViaRewind, floodgate]
+loadbefore: []
+prefix: TAB
+libraries: []
+folia-supported: true
 commands:
-  tab:
+  tab:
+    description: Plugin's main command
+permissions:
+  tab.admin:
+    description: Grants all TAB permissions
+    default: op
+  tab.tabcomplete:
+    description: Allows player to complete all TAB commands
+    default: op
+  tab.reload:
+    description: Allows player to run /tab reload
+    default: op
+  tab.cpu:
+    description: Allows player to run /tab cpu
+    default: op
+  tab.debug:
+    description: Allows player to run /tab debug [player]
+    default: op
+  tab.groupinfo:
+    description: Allows player to run /tab group <group>
+    default: op
+  tab.grouplist:
+    description: Allows player to run /tab groups
+    default: op
+  tab.parse:
+    description: Allows player to run /tab parse <player> <placeholder>
+    default: op
+  tab.setcollision:
+    description: Allows player to run /tab setcollision <player> <true/false>
+    default: op
+  tab.remove:
+    description: Allows player to remove group/user using commands
+    default: op
+  tab.change.*:
+    description: Allows player to change property using command
+    default: op
+  tab.width:
+    description: Allows player to run /tab width
+    default: op
+  tab.announce.bar:
+    description: Allows player to run /tab announce bar
+    default: op
+  tab.bossbar.toggle:
+    description: Allows player to run /tab bossbar
+    default: op
+  tab.send.bar:
+    description: Allows player to run /tab bossbar send
+    default: op
+  tab.mysql.download:
+    description: Allows player to run /tab mysql download
+    default: op
+  tab.mysql.upload:
+    description: Allows player to run /tab mysql upload
+    default: op
+  tab.nametag.toggle:
+    description: Allows player to run /tab nametag toggle
+    default: op
+  tab.nametag.toggle.other:
+    description: Allows player to run /tab nametag toggle [other player]
+    default: op
+  tab.nametag.preview:
+    description: Allows player to run /tab nametag preview
+    default: op
+  tab.nametag.preview.other:
+    description: Allows player to run /tab nametag preview [other player]
+    default: op
+  tab.announce.scoreboard:
+    description: Allows player to run /tab scoreboard announce
+    default: op
+  tab.scoreboard.toggle:
+    description: Allows player to run /tab scoreboard
+    default: op
+  tab.scoreboard.toggle.other:
+    description: Allows player to run /tab scoreboard for other players
+    default: op
+  tab.scoreboard.show:
+    description: Allows player to run /tab scoreboard show
+    default: op
+  tab.scoreboard.show.other:
+    description: Allows player to run /tab scoreboard show for other players
+    default: op
+  tab.staff:
+    description: Makes player counted in %staffonline% placeholder
+    default: op
+  tab.group.*:
+    description: Considers player in group if assigning by permissions
+    default: op
+  tab.bypass:
+    description: Makes player bypass per world playerlist if bypass permission is enabled
+    default: op
+  tab.seevanished:
+    description: Marks player as able to see vanished players for features hooking into vanish plugins
+    default: op
+  tab.spectatorbypass:
+    description: Makes player bypass spectator fix
+    default: op
@@ -0,0 +1,7 @@
+dependencies {
+    implementation(projects.shared)
+    implementation("org.bstats:bstats-bungeecord:3.0.1")
+    compileOnly("net.md-5:bungeecord-proxy:1.20-R0.1-SNAPSHOT")
+    compileOnly("com.github.limework.redisbungee:RedisBungee-Bungee:0.11.0")
+    compileOnly("com.github.LeonMangler:PremiumVanishAPI:2.8.8")
+}
@@ -1,192 +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.8.11-pre13</version>
-	</parent>
-	<artifactId>bungeecord</artifactId>
-
-	<repositories>
-
-		<!-- PremiumVanishAPI -->
-		<repository>
-			<id>jitpack.io</id>
-			<url>https://jitpack.io</url>
-		</repository>
-
-		<!-- BungeeCord -->
-		<repository>
-			<id>luck-repo</id>
-			<url>https://ci.lucko.me/plugin/repository/everything/</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.google.j2objc</groupId>
-					<artifactId>j2objc-annotations</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.code.findbugs</groupId>
-					<artifactId>jsr305</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.github.NEZNAMY</groupId>
-					<artifactId>YamlAssist</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.errorprone</groupId>
-					<artifactId>error_prone_annotations</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.guava</groupId>
-					<artifactId>listenablefuture</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.googlecode.json-simple</groupId>
-					<artifactId>json-simple</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.guava</groupId>
-					<artifactId>failureaccess</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.checkerframework</groupId>
-					<artifactId>checker-qual</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- BungeeCord -->
-		<dependency>
-			<groupId>net.md-5</groupId>
-			<artifactId>bungeecord-proxy</artifactId>
-			<version>1.16-R0.5-SNAPSHOT</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-codec-haproxy</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-codec-http</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-handler</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-transport-native-epoll</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-transport-native-unix-common</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.md-5</groupId>
-					<artifactId>brigadier</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>jline</groupId>
-					<artifactId>jline</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-transport</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>netty-codec</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.sf.trove4j</groupId>
-					<artifactId>core</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.md-5</groupId>
-					<artifactId>bungeecord-query</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>se.llbit</groupId>
-					<artifactId>jo-nbt</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.sf.jopt-simple</groupId>
-					<artifactId>jopt-simple</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>mysql</groupId>
-					<artifactId>mysql-connector-java</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.code.gson</groupId>
-					<artifactId>gson</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.guava</groupId>
-					<artifactId>guava</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.apache.maven</groupId>
-					<artifactId>maven-resolver-provider</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.apache.maven.resolver</groupId>
-					<artifactId>
-						maven-resolver-connector-basic
-					</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.apache.maven.resolver</groupId>
-					<artifactId>
-						maven-resolver-transport-http
-					</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.slf4j</groupId>
-					<artifactId>slf4j-jdk14</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.yaml</groupId>
-					<artifactId>snakeyaml</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- PremiumVanishAPI -->
-		<dependency>
-			<groupId>com.github.MyzelYam</groupId>
-			<artifactId>PremiumVanishAPI</artifactId>
-			<version>2.0.3</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>com.google.code.findbugs</groupId>
-					<artifactId>jsr305</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Bungee Metrics -->
-		<dependency>
-			<groupId>org.bstats</groupId>
-			<artifactId>bstats-bungeecord</artifactId>
-			<version>2.2.1</version>
-			<scope>compile</scope>
-		</dependency>
-	</dependencies>
-</project>