update README

Added blossom for plugin version source replacement

.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: ['https://paypal.me/neznamy1'] # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/build.yml

@@ -3,6 +3,7 @@ on:
   push:
     branches:
       - master
+      - v3
   pull_request:
     types: [opened, synchronize, reopened]
 jobs:
@@ -23,14 +24,16 @@ jobs:
           path: ~/.sonar/cache
           key: ${{ runner.os }}-sonar
           restore-keys: ${{ runner.os }}-sonar
-      - name: Cache Maven packages
-        uses: actions/cache@v1
+      - name: Cache Gradle
+        uses: actions/cache@v2
         with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
-          restore-keys: ${{ runner.os }}-m2
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: "${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}"
+          restore-keys: |
+            ${{ runner.os }}-gradle-
       - name: Build and analyze
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        run: mvn -B verify org.sonarsource.scanner.maven:sonar-maven-plugin:sonar
+        run: ./gradlew clean build

.gitignore

@@ -35,3 +35,8 @@ hs_err_pid*
 # other
 .gitattributes
 *.iml
+
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar

README.md

@@ -1,41 +1,18 @@
-## Introduction  
-Here it is. After countless requests to go opensource, I did it to make those people quiet. It worked.  
-It's already been a year and I still can't see any positives of it. This way I just made it easier for everyone to make a plugin as good, so people can stop using it and switch to something better. Or just get premium version for free.  
+# About
+This is where you can download the plugin for free without needing to buy me a coffee or just grab some code inspiration for your plugin. God bless opensource.  
   
-  
-## Compiling
-Plugin can be compiled using maven. Once you've purchased the premium version, you can enable premium features by setting [this line to return true](https://github.com/NEZNAMY/TAB/blob/master/shared/src/main/java/me/neznamy/tab/shared/TAB.java#L82) and apply your code improvements. Enabling it without purchasing the plugin may result in the features not working correctly.  
-**No support is provided for self-compiled jars, only for official compilations.** If you compiled it yourself, it is highly likely you modified something, which might be the reason why is the plugin not working. If you didn't modify anything, you can just get the plugin from official download locations.
-  
-  
-## Links
-Free version  
-    Spigot (releases): https://www.spigotmc.org/resources/57806/  
-    Pre-releases https://github.com/NEZNAMY/TAB/releases  
-Premium version  
-    Polymart (releases): https://polymart.org/resource/484  
-    MC-Market (releases): https://www.mc-market.org/resources/14009/  
-    Pre-releases on discord for verified buyers  
-Bukkit bridge https://www.spigotmc.org/resources/83966/  
-Wiki https://github.com/NEZNAMY/TAB/wiki  
-Discord invite link: https://discord.gg/EaSvdk6  
+# Compiling from source
+Compilation requires JDK 8 and up.  
+To compile the plugin, run `./gradlew build` from the terminal.  
+Once the plugin compiles, you can grab the jar from `jar/build/libs/` folder.
 
+# Links
+See [releases](https://github.com/NEZNAMY/TAB/releases) for precompiled jar.  
 
-## Maven Repository
-```
-<repositories>
-  <repository>
-    <id>jitpack.io</id>
-    <url>https://jitpack.io</url>
-  </repository>
-</repositories>
+Has the plugin helped you in any way and you wish to support the development?  
+You can purchase the plugin on [MC-Market](https://www.mc-market.org/resources/20631/), [Polymart](https://polymart.org/resource/484) or just [send a donation](https://paypal.me/neznamy1).
+  
+Supporters have access to high-quality [discord support](https://discord.gg/EaSvdk6).  
 
-<dependencies>
-  <!-- TAB -->
-  <dependency>
-    <groupId>com.github.NEZNAMY</groupId>
-    <artifactId>TAB</artifactId>
-    <version>2.9.0</version>
-  </dependency>
-</dependencies>
- ```
+Want to know more about the plugin's functions? Check out the [wiki](https://github.com/NEZNAMY/TAB/wiki).
+  

api/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+    id("tab.publishing")
+}
+
+dependencies {
+    compileOnlyApi(libs.netty)
+    api(libs.jsonSimple) {
+        exclude("junit", "junit")
+    }
+    compileOnlyApi(libs.snakeyaml)
+    api(libs.yamlAssist)
+    compileOnlyApi(libs.gson)
+}

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

@@ -1,9 +1,5 @@
 package me.neznamy.tab.api;
 
-import java.util.Set;
-
-import me.neznamy.tab.shared.Property;
-
 public interface ArmorStand {
 
 	/**
@@ -69,12 +65,6 @@ public interface ArmorStand {
 	 */
 	public void updateVisibility(boolean force);
 	
-	/**
-	 * Removes specified player from list of players in range
-	 * @param viewer - player to remove
-	 */
-	public void removeFromRegistered(TabPlayer viewer);
-	
 	/**
 	 * Returns entity ID of this armor stand
 	 * @return entity ID of this armor stand
@@ -88,9 +78,5 @@ public interface ArmorStand {
 	 */
 	public void spawn(TabPlayer viewer);
 	
-	/**
-	 * Returns list of players in entity tracking range (48 blocks)
-	 * @return list of nearby players
-	 */
-	public Set<TabPlayer> getNearbyPlayers();
+	public void respawn(TabPlayer viewer);
 }

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

@@ -0,0 +1,178 @@
+package me.neznamy.tab.api;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A helper class for easy management of armor stands of a player
+ */
+public class ArmorStandManager {
+
+	//map of registered armor stands
+	private final Map<String, ArmorStand> armorStands = new LinkedHashMap<>();
+	
+	//players in entity tracking range
+	private final List<TabPlayer> nearbyPlayers = Collections.synchronizedList(new ArrayList<>());
+	
+	//array to iterate over to avoid concurrent modification and slightly boost performance & memory
+	private ArmorStand[] armorStandArray = new ArmorStand[0];
+	
+	private TabPlayer[] nearbyPlayerArray = new TabPlayer[0];
+	
+	/**
+	 * Adds armor stand into list
+	 * @param name - key name of the armor stand
+	 * @param as - armor stand to add
+	 */
+	public synchronized void addArmorStand(String name, ArmorStand as) {
+		armorStands.put(name, as);
+		armorStandArray = armorStands.values().toArray(new ArmorStand[0]);
+		for (TabPlayer p : nearbyPlayerArray) as.spawn(p);
+	}
+	
+	/**
+	 * Returns armor stand with given name or null if not present
+	 * @param name - name of armor stand registered with
+	 * @return armor stand with given name
+	 */
+	public ArmorStand getArmorStand(String name) {
+		return armorStands.get(name);
+	}
+
+	/**
+	 * Removes armor stand from list. It is not automatically destroyed for players
+	 * @param name - name of armor stand to remove
+	 */
+	public void removeArmorStand(String name) {
+		armorStands.get(name).destroy();
+		armorStands.remove(name);
+		armorStandArray = armorStands.values().toArray(new ArmorStand[0]);
+	}
+
+	/**
+	 * Spawns all armor stands for specified viewer and adds them into nearby players
+	 * @param viewer - player to spawn armor stands for
+	 */
+	public void spawn(TabPlayer viewer) {
+		synchronized (nearbyPlayers) {
+			nearbyPlayers.add(viewer);
+			nearbyPlayerArray = nearbyPlayers.toArray(new TabPlayer[0]);
+		}
+		if (viewer.getVersion().getMinorVersion() < 8) return;
+		for (ArmorStand a : armorStandArray) a.spawn(viewer);
+	}
+
+	/**
+	 * Sets sneak value of armor stands to specified value
+	 * @param sneaking - new sneaking status
+	 */
+	public void sneak(boolean sneaking) {
+		for (ArmorStand a : armorStandArray) a.sneak(sneaking);
+	}
+
+	/**
+	 * Teleports armor stands to player's current location for all nearby players
+	 */
+	public void teleport() {
+		for (ArmorStand a : armorStandArray) a.teleport();
+	}
+
+	/**
+	 * Teleports armor stands to player's current location for specified viewer
+	 * @param viewer - player to teleport armor stands for
+	 */
+	public void teleport(TabPlayer viewer) {
+		for (ArmorStand a : armorStandArray) a.teleport(viewer);
+	}
+
+	/**
+	 * Refreshes name of all armor stands for all nearby players
+	 */
+	public void refresh() {
+		for (ArmorStand a : armorStandArray) a.refresh();
+	}
+
+	/**
+	 * Updates armor stand visibility for all armor stands
+	 * @param force - true if packets should be sent despite seemingly not needed
+	 */
+	public void updateVisibility(boolean force) {
+		for (ArmorStand a : armorStandArray) a.updateVisibility(force);
+	}
+
+	/**
+	 * Removes specified player from list of nearby players
+	 * @param viewer - player to remove
+	 */
+	public void unregisterPlayer(TabPlayer viewer) {
+		synchronized (nearbyPlayers) {
+			nearbyPlayers.remove(viewer);
+			nearbyPlayerArray = nearbyPlayers.toArray(new TabPlayer[0]);
+		}
+	}
+
+	/**
+	 * Sends destroy packet of all armor stands to everyone and clears nearby players list
+	 */
+	public void destroy() {
+		for (ArmorStand a : armorStandArray) a.destroy();
+		synchronized (nearbyPlayers) {
+			nearbyPlayers.clear();
+			nearbyPlayerArray = new TabPlayer[0];
+		}
+	}
+
+	/**
+	 * Sends destroy packet of all armor stands to specified player and removes them from nearby players list
+	 * @param viewer - player to destroy armor stands for
+	 */
+	public void destroy(TabPlayer viewer) {
+		for (ArmorStand a : armorStandArray) a.destroy(viewer);
+		unregisterPlayer(viewer);
+	}
+
+	/**
+	 * Returns true if manager contains armor stand with specified entity id, false if not
+	 * @param entityId - entity id
+	 * @return true if armor stand with specified entity id exists, false if not
+	 */
+	public boolean hasArmorStandWithID(int entityId) {
+		for (ArmorStand a : armorStandArray) {
+			if (a.getEntityId() == entityId) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Returns array of all registered armor stands
+	 * @return armor stand array
+	 */
+	public ArmorStand[] getArmorStands(){
+		return armorStandArray;
+	}
+
+	/**
+	 * Returns array of nearby players
+	 * @return array of nearby players
+	 */
+	public TabPlayer[] getNearbyPlayers(){
+		return nearbyPlayerArray;
+	}
+	
+	public boolean isNearby(TabPlayer viewer) {
+		return nearbyPlayers.contains(viewer);
+	}
+	
+	public void respawn() {
+		for (ArmorStand a : armorStandArray) {
+			for (TabPlayer viewer : nearbyPlayerArray) {
+				a.respawn(viewer);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,35 @@
+package me.neznamy.tab.api;
+
+public interface FeatureManager {
+
+	/**
+	 * Registers a feature, which will start recieiving events
+	 * 
+	 * @param featureName - name of feature
+	 * @param featureHandler - the handler
+	 */
+	public void registerFeature(String name, TabFeature feature);
+	
+	/**
+	 * Unregisters feature making it no longer receive events. This does not run unload method nor cancel
+	 * tasks created by the feature
+	 * @param name - feature name defined in registerFeature
+	 */
+	public void unregisterFeature(String name);
+	
+	/**
+	 * Returns whether a feature with said name is registered or not
+	 * 
+	 * @param name - name of feature defined in registerFeature method
+	 * @return true if feature exists, false if not
+	 */
+	public boolean isFeatureEnabled(String name);
+
+	/**
+	 * Returns feature handler by it's name
+	 * 
+	 * @param name - name of feature defined in registerFeature method
+	 * @return the feature or null if feature does not exist
+	 */
+	public TabFeature getFeature(String name);
+}

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

@@ -0,0 +1,16 @@
+package me.neznamy.tab.api;
+
+public interface HeaderFooterManager {
+
+	public void setHeader(TabPlayer player, String header);
+	
+	public void setFooter(TabPlayer player, String footer);
+	
+	public void setHeaderAndFooter(TabPlayer player, String header, String footer);
+	
+	public void resetHeader(TabPlayer player);
+	
+	public void resetFooter(TabPlayer player);
+	
+	public void resetHeaderAndFooter(TabPlayer player);
+}

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

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

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

@@ -0,0 +1,10 @@
+package me.neznamy.tab.api;
+
+public interface PropertyConfiguration {
+
+	public void setProperty(String name, String property, String server, String world, String value);
+	
+	public String[] getProperty(String name, String property, String server, String world);
+	
+	public void remove(String name);
+}

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

@@ -1,11 +1,14 @@
-package me.neznamy.tab.shared;
+package me.neznamy.tab.api;
 
 /**
  * Enum class representing all possibly used protocol versions
  */
 public enum ProtocolVersion {
 
-	UNKNOWN	(999),
+	UNKNOWN	(999, "Unknown"),
+	PROXY	(999, "Proxy"),
+	V1_18	(757),
+	V1_17_1	(756),
 	V1_17	(755),
 	V1_16_5 (754),
 	V1_16_4	(754),
@@ -57,13 +60,13 @@ public enum ProtocolVersion {
 	V1_4_6	(51);
 
 	//version's network id found at https://wiki.vg/Protocol_version_numbers
-	private int networkId;
+	private final int networkId;
 	
 	//minor version, such as 16
-	private int minorVersion;
+	private final int minorVersion;
 	
 	//friendly name displayed in %player-version% placeholder
-	private String friendlyName;
+	private final String friendlyName;
 
 	/**
 	 * Constructs new instance with given network id
@@ -71,13 +74,19 @@ public enum ProtocolVersion {
 	 */
 	private ProtocolVersion(int networkId){
 		this.networkId = networkId;
-		if (toString().equals("UNKNOWN")) {
-			this.minorVersion = 17;
-			this.friendlyName = "Unknown";
-		} else {
-			this.minorVersion = Integer.parseInt(toString().split("_")[1]);
-			this.friendlyName = toString().substring(1).replace("_", ".");
-		}
+		this.minorVersion = Integer.parseInt(toString().split("_")[1]);
+		this.friendlyName = toString().substring(1).replace("_", ".");
+	}
+	
+	/**
+	 * Constructs new instance with given network id and friendly name
+	 * @param networkId - network id of this version
+	 * @param friendlyName - friendly name to display
+	 */
+	private ProtocolVersion(int networkId, String friendlyName){
+		this.networkId = networkId;
+		this.minorVersion = 17;
+		this.friendlyName = friendlyName;
 	}
 
 	/**
@@ -113,7 +122,7 @@ public enum ProtocolVersion {
 		if (friendlyName.startsWith("1.8")) return V1_8;
 		try {
 			return valueOf("V" + friendlyName.replace(".", "_"));
-		} catch (Exception e) {
+		} catch (IllegalArgumentException e) {
 			return UNKNOWN;
 		}
 	}

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

@@ -0,0 +1,107 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import me.neznamy.tab.api.bossbar.BossBarManager;
+import me.neznamy.tab.api.config.ConfigurationFile;
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.api.scoreboard.ScoreboardManager;
+import me.neznamy.tab.api.task.ThreadManager;
+import me.neznamy.tab.api.team.TeamManager;
+
+/**
+ * The primary API class to get instances of other API classes
+ */
+public abstract class TabAPI {
+
+	private static TabAPI instance;
+	
+	public static TabAPI getInstance() {
+		return instance;
+	}
+	
+	public static void setInstance(TabAPI instance) {
+		TabAPI.instance = instance;
+	}
+
+	/**
+	 * Returns player object from given UUID
+	 * @return player object from given UUID
+	 * @param id - Player UUID
+	 */
+	public abstract TabPlayer getPlayer(UUID id);
+
+	/**
+	 * Returns player object from given name
+	 * @return player object from given name
+	 * @param name - Player name
+	 */
+	public abstract TabPlayer getPlayer(String name);
+	
+	/**
+	 * Returns collection of all online players. Will return empty list if plugin is disabled (due to a broken configuration file for example).
+	 * @return collection of online players
+	 */
+	public abstract TabPlayer[] getOnlinePlayers();
+
+	/**
+	 * Return bossbar manager instance if the feature is enabled. Returns null otherwise.
+	 * @return bossbar manager
+	 */
+	public abstract BossBarManager getBossBarManager();
+	
+	/**
+	 * Returns scoreboard manager instance if the feature is enabled. Returns null otherwise.
+	 * @return scoreboard manager
+	 */
+	public abstract ScoreboardManager getScoreboardManager();
+	
+	/**
+	 * Returns team manager instance if the feature is enabled, false otherwise
+	 * @return team manager
+	 */
+	public abstract TeamManager getTeamManager();
+	
+	public abstract HeaderFooterManager getHeaderFooterManager();
+	
+	/**
+	 * Returns PlaceholderManager instance
+	 * @return PlaceholderManager instance
+	 */
+	public abstract PlaceholderManager getPlaceholderManager();
+
+	/**
+	 * Returns feature manager instance
+	 * @return feature manager instance
+	 */
+	public abstract FeatureManager getFeatureManager();
+	
+	public abstract TablistFormatManager getTablistFormatManager();
+
+	/**
+	 * Returns server version. On proxy installation returns PROXY.
+	 * @return server version
+	 */
+	public abstract ProtocolVersion getServerVersion();
+	
+	/**
+	 * Prints message into console
+	 * @param message - message to print
+	 * @param translateColors - true if colors should be translated, false if not
+	 */
+	public abstract void sendConsoleMessage(String message, boolean translateColors);
+	
+	public abstract ThreadManager getThreadManager();
+	
+	public abstract ConfigurationFile getPlayerCache();
+	
+	public abstract ConfigurationFile getConfig();
+	
+	public abstract PropertyConfiguration getGroups();
+	
+	public abstract PropertyConfiguration getUsers();
+	
+	public abstract void debug(String message);
+	
+	public abstract void logError(String message, Throwable t);
+}

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

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

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

@@ -0,0 +1,256 @@
+package me.neznamy.tab.api;
+
+import java.util.UUID;
+
+import io.netty.channel.Channel;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import me.neznamy.tab.api.protocol.TabPacket;
+
+/**
+ * An interface representing a player
+ */
+public interface TabPlayer {
+
+	/**
+	 * Refreshes all visuals on the player
+	 */
+	public void forceRefresh();
+
+	/**
+	 * Returns player's name
+	 * @return Player's name
+	 */
+	public String getName();
+
+	/**
+	 * Returns player's UUID
+	 * @return Player's UUID
+	 */
+	public UUID getUniqueId();
+
+	/**
+	 * Returns player's uuid used in tablist. This may only be different than real uuid if
+	 * TAB is installed on velocity with some specific velocity setup
+	 * @return player's uuid in tablist
+	 */
+	public UUID getTablistUUID();
+
+	/**
+	 * Returns player's protocol version
+	 * @return player's protocol version
+	 */
+	public ProtocolVersion getVersion();
+
+	/**
+	 * Returns platform-specific entity
+	 * @return an instance of bukkit/bungee player depending on platform
+	 */
+	public Object getPlayer();
+
+	/**
+	 * Returns player's current world name (on bungeecord this requires bridge installed)
+	 * @return name of world where player is currently in, null on bungeecord if bridge is not installed
+	 */
+	public String getWorld();
+	
+	/**
+	 * Returns player's current server name on bungeecord (on bukkit this returns null)
+	 * @return name of server where player is currently in, null on bukkit
+	 */
+	public String getServer();
+
+	/**
+	 * Performs platform-specific API call to check for permission and returns the result
+	 * @param permission - the permission to check for
+	 * @return - true if has, false if not
+	 */
+	public boolean hasPermission(String permission);
+
+	/**
+	 * Sends the player a custom universal packet
+	 * @param packet - packet to send
+	 */
+	public void sendCustomPacket(TabPacket packet);
+
+	/**
+	 * Sends the player a custom universal packet and adds that packet into counter that
+	 * is displayed in /tab cpu
+	 * @param packet - packet to send
+	 * @param feature - feature to increment sent packet counter of 
+	 */
+	public void sendCustomPacket(TabPacket packet, TabFeature feature);
+	
+	/**
+	 * Sends the player a custom universal packet and adds that packet into counter that
+	 * is displayed in /tab cpu
+	 * @param packet - packet to send
+	 * @param feature - feature to increment sent packet counter of 
+	 */
+	public void sendCustomPacket(TabPacket packet, String feature);
+
+	/**
+	 * Sends the player a platform-specific packet
+	 * @param packet - an instance of packet depending on platform
+	 */
+	public void sendPacket(Object packet);
+
+	/**
+	 * Sends the player a platform-specific packet and adds that packet into counter that
+	 * is displayed in /tab cpu
+	 * @param packet - an instance of packet depending on platform
+	 * @param feature - feature to increment sent packet counter of 
+	 */
+	public void sendPacket(Object packet, TabFeature feature);
+
+	/**
+	 * Sends the player a platform-specific packet and adds that packet into counter that
+	 * is displayed in /tab cpu
+	 * @param packet - an instance of packet depending on platform
+	 * @param feature - feature to increment sent packet counter of
+	 */
+	public void sendPacket(Object packet, String feature);
+
+	/**
+	 * Returns player's property by name
+	 * @param name - name of property
+	 * @return the property or null if not found
+	 */
+	public Property getProperty(String name);
+
+	/**
+	 * Sends a message to the player
+	 * @param message - message to be sent
+	 * @param translateColors - whether colors should be translated or not
+	 */
+	public void sendMessage(String message, boolean translateColors);
+
+	/**
+	 * Sends specified component as a chat message
+	 * @param message - message to send
+	 */
+	public void sendMessage(IChatBaseComponent message);
+
+	/**
+	 * Returns player's primary permission group
+	 * @return player's group depending on configuration
+	 */
+	public String getGroup();
+
+	/**
+	 * Toggles armor stands preview mode for the player
+	 */
+	public void toggleNametagPreview();
+
+	/**
+	 * Returns whether player is previewing nametag or not
+	 * @return true if previewing, false if not
+	 */
+	public boolean isPreviewingNametag();
+
+	/**
+	 * Returns player's channel or null if server is 1.7 or older
+	 * @return player's channel
+	 */
+	public Channel getChannel();
+
+	/**
+	 * Returns player's ping calculated by server
+	 * @return player's ping
+	 */
+	public int getPing();
+
+	/**
+	 * Returns player's platform-specific skin data
+	 * @return player's skin
+	 */
+	public Object getSkin();
+
+	/**
+	 * Returns true once the player is successfully loaded (onJoin method ran through all methods)
+	 * @return true if player is fully loaded, false otherwise
+	 */
+	public boolean isLoaded();
+
+	/**
+	 * Sets property with specified name to new value. If property did no exist before, it is
+	 * created and true is returned. If it existed, it is overridden and true is returned. False is returned othewise.
+	 * @param feature - feature using this property to get placeholders registered
+	 * @param identifier - property name
+	 * @param rawValue - new raw value
+	 * @return true if value changed / did not exist, false if value did not change
+	 */
+	public boolean setProperty(TabFeature feature, String identifier, String rawValue);
+
+	/**
+	 * Loads property from config using standard property loading algorithm
+	 * @param property - property name to load
+	 */
+	public void loadPropertyFromConfig(TabFeature feature, String property);
+
+	/**
+	 * Loads property from config using standard property loading algorithm. If the property is
+	 * not set in config, sets it to ifNotSet value
+	 * @param property - property name to load
+	 * @param ifNotSet - value to use if property is not defined in config
+	 */
+	public void loadPropertyFromConfig(TabFeature feature, String property, String ifNotSet);
+
+	/**
+	 * Returns name of player's scoreboard team or null if nametag feature is disabled
+	 * @return name of player's team
+	 */
+	public String getTeamName();
+
+	/**
+	 * Returns user-friendly explanation of team name
+	 * @return explanation behind team name
+	 */
+	public String getTeamNameNote();
+
+	/**
+	 * Returns true if player is disguised using iDisguide or LibsDisguises on bukkit, LibsDisguises 
+	 * only on bungeecord via bukkit bridge
+	 * @return true if player is disguised, false if not
+	 */
+	public boolean isDisguised();
+
+	/**
+	 * Returns true if player has invisiblity potion, false if not. For bukkit, API is used, for bungeecord
+	 * bukkit bridge is used
+	 * @return true if has invisiblity potion, false if not
+	 */
+	public boolean hasInvisibilityPotion();
+
+	/**
+	 * Currently only PV hook on bungeecord for global playerlist function. Looking to expand this
+	 * in the future
+	 * @return true if vanished with PV on bungeecord
+	 */
+	public boolean isVanished();
+
+	/**
+	 * Returns true if player is online according to server
+	 * @return true if online, false if not
+	 */
+	public boolean isOnline();
+
+	/**
+	 * Returns player's armor stand manager if unlimited nametag mode is enabled, null if disabled
+	 * @return player's armor stand manager
+	 */
+	public ArmorStandManager getArmorStandManager();
+
+	/**
+	 * Sets player's armor stands manager to new instance
+	 * @param armorStandManager - new instance
+	 */
+	public void setArmorStandManager(ArmorStandManager armorStandManager);
+	
+	/**
+	 * Returns gamemode of the player (0 for survival, 1 creative, 2 adventure, 3 spectator)
+	 * @return gamemode of the player
+	 */
+	public int getGamemode();
+	
+	public boolean isBedrockPlayer();
+}

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

@@ -0,0 +1,29 @@
+package me.neznamy.tab.api;
+
+public interface TablistFormatManager {
+
+	public void setPrefix(TabPlayer player, String prefix);
+	
+	public void setName(TabPlayer player, String customname);
+	
+	public void setSuffix(TabPlayer player, String suffix);
+	
+	public void resetPrefix(TabPlayer player);
+	
+	public void resetName(TabPlayer player);
+	
+	public void resetSuffix(TabPlayer player);
+	
+	public String getCustomPrefix(TabPlayer player);
+	
+	public String getCustomName(TabPlayer player);
+	
+	public String getCustomSuffix(TabPlayer player);
+	
+	public String getOriginalPrefix(TabPlayer player);
+	
+	public String getOriginalName(TabPlayer player);
+	
+	public String getOriginalSuffix(TabPlayer player);
+	
+}

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

@@ -1,7 +1,8 @@
 package me.neznamy.tab.api.bossbar;
 
 /**
- * An enum representing bossbar colors
+ * An enum representing all available bossbar colors.
+ * Calling ordinal() will return color's network ID.
  */
 public enum BarColor {
 

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

@@ -0,0 +1,36 @@
+package me.neznamy.tab.api.bossbar;
+
+/**
+ * An enum representing all available bossbar styles.
+ * Calling ordinal() will return style's network ID.
+ * Style names are equal to NMS names.
+ */
+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 */
+	private String bukkitName;
+
+	/**
+	 * Initializes enum constant with given bukkit name
+	 * 
+	 * @param 	bukkitName
+	 * 			Name of color to be returned in {@code getBukkitName()}
+	 */
+	private BarStyle(String bukkitName){
+		this.bukkitName = bukkitName;
+	}
+
+	/**
+	 * Returns name of this style in Bukkit API
+	 * @return	name of this style in Bukkit API
+	 */
+	public String getBukkitName() {
+		return bukkitName;
+	}
+}

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

@@ -0,0 +1,185 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.UUID;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * An interface representing a bossbar line. 
+ * <p>
+ * For clients 1.8 and lower it uses wither, which only allows 1 bar 
+ * to be displayed at a time. Entity packets are not available on bungeecord,
+ * where nothing will be displayed for these players.
+ * <p>
+ * For 1.9+ it uses the new bossbar feature, allowing configurable styles
+ * and colors, as well as display several bars at once. Limit of maximum 
+ * displayed bossbars depends on client resolution and GUI scale, up to
+ * 9 concurrent bossbars displayed at once.
+ */
+public interface BossBar {
+
+	/**
+	 * Returns name of this bossbar. If it was defined in config, returns
+	 * the name specified in config. If it was made using the API, returns
+	 * randomly generated ID given to this bossbar when creating.
+	 * @return	name of bossbar
+	 */
+	public 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
+	 */
+	public 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
+	 */
+	public void setTitle(String title);
+
+	/**
+	 * Changes bossbar progress to specified string, supporting placeholders.
+	 * The string must be a string version of a float value, or a placeholder that 
+	 * outputs a float value with range 0-100.
+	 * <p>
+	 * If progress contains new placeholders not used before, they are registered using
+	 * standard registration logic and refreshed periodically. No need to call
+	 * this method to try to keep placeholder values up to date.
+	 * <p>
+	 * If specified progress is equal to the current one, nothing happens.
+	 * 
+	 * @param	progress
+	 * 			New progress to use in this bossbar
+	 */
+	public void setProgress(String progress);
+
+	/**
+	 * Changes bossbar progress to specified value ranging from 0 to 100.
+	 * <p>
+	 * If specified progress is equal to the current one, nothing happens.
+	 * @param	progress
+	 * 			New progress to use in this bossbar
+	 */
+	public 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
+	 */
+	public void setColor(String color);
+
+	/**
+	 * Changes bossbar color to specified enum constant.
+	 * <p>
+	 * If specified color is equal to the current one, nothing happens.
+	 * 
+	 * @param	color
+	 * 			New color to use in this bossbar
+	 */
+	public void setColor(BarColor color);
+
+	/**
+	 * Changes bossbar style to specified string, supporting placeholders.
+	 * The string must be a string version of one of the supported values, 
+	 * or a placeholder that outputs one of them.
+	 * <p>
+	 * If style contains new placeholders not used before, they are registered using
+	 * standard registration logic and refreshed periodically. No need to call
+	 * this method to try to keep placeholder values up to date.
+	 * <p>
+	 * If specified style is equal to the current one, nothing happens.
+	 * 
+	 * @param	style
+	 * 			New style to use in this bossbar
+	 */
+	public void setStyle(String style);
+
+	/**
+	 * Changes bossbar style to specified enum constant.
+	 * <p>
+	 * If specified style is equal to the current one, nothing happens.
+	 * 
+	 * @param	style
+	 * 			New style to use in this bossbar
+	 */
+	public void setStyle(BarStyle style);
+
+	/**
+	 * Returns current title of the bossbar in raw format. If it contains placeholders,
+	 * their raw identifiers are used in the result.
+	 * @return	title of the bossbar
+	 */
+	public 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
+	 */
+	public 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
+	 */
+	public 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
+	 */
+	public 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
+	 */
+	public void addPlayer(TabPlayer player);
+
+	/**
+	 * Unregisters this bossbar from specified player.
+	 * <p>
+	 * If the player does not see this bossbar, nothing happens.
+	 * 
+	 * @param	player
+	 * 			Player to unregister this bossbar from
+	 */
+	public void removePlayer(TabPlayer player);
+
+	/**
+	 * Returns list of players who can see this bossbar.
+	 * <p>
+	 * The returned list can only be used to read. Writing
+	 * will not work properly. For adding/removing playes see {@link #addPlayer(TabPlayer)}
+	 * and {@link #removePlayer(TabPlayer)}.
+	 * @return	List of players seeing this bossbar
+	 */
+	public List<TabPlayer> getPlayers();
+}

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

@@ -0,0 +1,167 @@
+package me.neznamy.tab.api.bossbar;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * An interface allowing work with bossbars such as creating, sending 
+ * and toggling.
+ * <p>
+ * Instance can be obtained using {@link me.neznamy.tab.api.TabAPI#getBossBarManager()}.
+ * This requires the bossbar feature to be enabled in config, otherwise the method will
+ * return 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
+	 */
+	public BossBar createBossBar(String title, float progress, BarColor color, BarStyle style);
+
+	/**
+	 * Creates bossbar with specified parameters and registers it to bossbar manager,
+	 * allowing to retrieve it later.
+	 * 
+	 * @param	title
+	 * 			Title to display, supports placeholders
+	 * 
+	 * @param	progress
+	 * 			Progress to use. Must be a string version of a number, or
+	 * 			a placeholder that returns a number
+	 * 
+	 * @param	color
+	 * 			Color to use. Must be a string version of one of enum constants, or
+	 * 			a placeholder that returns one of them
+	 * 
+	 * @param	style
+	 * 			Style to use. Must be a string version of one of enum constants, or
+	 * 			a placeholder that returns one of them
+	 * @return	The newly created bossbar
+	 */
+	public BossBar createBossBar(String title, String progress, String color, String style);
+
+	/**
+	 * Returns registered bossbar with given name. For bossbars from config it is the name
+	 * they were created with, for API bossbars their randomly generated name, which can be
+	 * retrieved using {@link me.neznamy.tab.api.bossbar.BossBar#getName()}.
+	 * Returns null if no such bossbar exists.
+	 * 
+	 * @param	name
+	 * 			Name of registered bossbar
+	 * @return	bossbar with specified name
+	 */
+	public BossBar getBossBar(String name);
+
+	/**
+	 * Returns registered bossbar with specified UUID. This UUID is randomly generated when
+	 * bossbar is created and used in packets / to match which the one from Bukkit API.
+	 * Returns null if no such bossbar exists.
+	 * 
+	 * @param	id
+	 * 			UUID to return bossbar by
+	 * @return	bossbar with specified uuid
+	 */
+	public BossBar getBossBar(UUID id);
+
+	/**
+	 * Returns a map of all registered bossbars. This includes both bossbars from config 
+	 * and those registered via API.
+	 * <p>
+	 * Map key is bossbar's name available in {@link me.neznamy.tab.api.bossbar.BossBar#getName()},
+	 * map value is the bossbar interface.
+	 * @return	all registered bossbars
+	 */
+	public 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)
+	 */
+	public void toggleBossBar(TabPlayer player, boolean sendToggleMessage);
+
+	/**
+	 * Returns true if player can see bossbars, false if toggled via command or API.
+	 * 
+	 * @param	player
+	 * 			Player to check toggle status of
+	 * @return	{@code true} if visible, {@code false} if disabled (toggled)
+	 * @see #toggleBossBar(TabPlayer, boolean)
+	 * @see #setBossBarVisible(TabPlayer, boolean, boolean)
+	 */
+	public boolean hasBossBarVisible(TabPlayer player);
+
+	/**
+	 * Sets bossbar visibility of player to set value. If value did not change, nothing happens.
+	 * If visibility changed, toggle message is sent if {@code sendToggleMessage} is {@code true}.
+	 * 
+	 * @param	player
+	 * 			Player to set bossbar visibility of
+	 * @param	visible
+	 * 			{@code true} if bossbar should be visible, {@code false} if not
+	 * @param	sendToggleMessage
+	 * 			{@code true} if toggle message should be sent if value changed, {@code false} if not
+	 * @see #toggleBossBar(TabPlayer, boolean)
+	 * @see #hasBossBarVisible(TabPlayer)
+	 */
+	public void setBossBarVisible(TabPlayer player, boolean visible, boolean sendToggleMessage);
+
+	/**
+	 * Temporarily displays registered bossbar to player for specified amount of time in milliseconds.
+	 * @param	player
+	 * 			Player to show bossbar to
+	 * @param	bossbar
+	 * 			Name of registered bossbar to show
+	 * @param	duration
+	 * 			In milliseconds for how long should bossbar be displayed
+	 * @throws	IllegalArgumentException
+	 * 			if no bossbar with specified name exists
+	 * @see #announceBossBar(String, int)
+	 * @see #getAnnouncedBossBars()
+	 */
+	public void sendBossBarTemporarily(TabPlayer player, String bossbar, int duration);
+
+	/**
+	 * Temporarily displays registered bossbar to all players for specified amount of time in milliseconds.
+	 * @param	bossbar
+	 * 			Name of registered bossbar to show
+	 * @param	duration
+	 * 			In milliseconds for how long should bossbar be displayed
+	 * @throws	IllegalArgumentException
+	 * 			if no bossbar with specified name exists
+	 * @see #sendBossBarTemporarily(TabPlayer, String, int)
+	 * @see #getAnnouncedBossBars()
+	 */
+	public void announceBossBar(String bossbar, int duration);
+
+	/**
+	 * Returns list of bossbars which are currently being announced.
+	 * @return	list of currently active bossbar announcements
+	 * @see #sendBossBarTemporarily(TabPlayer, String, int)
+	 * @see #announceBossBar(String, int)
+	 */
+	public List<BossBar> getAnnouncedBossBars();
+}

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

@@ -0,0 +1,40 @@
+package me.neznamy.tab.api.chat;
+
+public class ChatClickable {
+
+	private EnumClickAction action;
+	private String value;
+
+	public ChatClickable(EnumClickAction action, String value) {
+		this.action = action;
+		this.value = value;
+	}
+
+	public EnumClickAction getAction() {
+		return action;
+	}
+
+	public void setAction(EnumClickAction action) {
+		this.action = action;
+	}
+
+	public String getValue() {
+		return value;
+	}
+
+	public void setValue(String value) {
+		this.value = value;
+	}
+
+	/**
+	 * Enum for all possible click actions
+	 */
+	public enum EnumClickAction {
+		
+		OPEN_URL,
+		RUN_COMMAND,
+		CHANGE_PAGE, //since 1.8
+		SUGGEST_COMMAND,
+		COPY_TO_CLIPBOARD; //since 1.15
+	}
+}

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

@@ -0,0 +1,38 @@
+package me.neznamy.tab.api.chat;
+
+import java.util.UUID;
+
+import com.google.gson.JsonObject;
+
+public class ChatComponentEntity extends IChatBaseComponent {
+
+	private final String type;
+	private final UUID id;
+	private final String name;
+	
+	public ChatComponentEntity(String type, UUID id, String name) {
+		this.type = type;
+		this.id = id;
+		this.name = name;
+	}
+
+	@Override
+	public String toRawText() {
+		return toString();
+	}
+	
+	@Override
+	public String toString() {
+		return String.format("{\"type\":\"%s\",\"id\":\"%s\",\"name\":{\"text\":\"%s\"}}", type, id, name);
+	}
+	
+	public JsonObject toJson() {
+		JsonObject json = new JsonObject();
+		json.addProperty("type", type);
+		json.addProperty("id", id.toString());
+		JsonObject json2 = new JsonObject();
+		json2.addProperty("text", name);
+		json.add("name", json2);
+		return json;
+	}
+}

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

@@ -0,0 +1,38 @@
+package me.neznamy.tab.api.chat;
+
+public class ChatHoverable {
+
+	private EnumHoverAction action;
+	private IChatBaseComponent value;
+	
+	public ChatHoverable(EnumHoverAction action, IChatBaseComponent value) {
+		this.action = action;
+		this.value = value;
+	}
+	
+	public EnumHoverAction getAction() {
+		return action;
+	}
+
+	public void setAction(EnumHoverAction action) {
+		this.action = action;
+	}
+
+	public IChatBaseComponent getValue() {
+		return value;
+	}
+
+	public void setValue(IChatBaseComponent value) {
+		this.value = value;
+	}
+
+	/**
+	 * Enum for all possible hover actions
+	 */
+	public enum EnumHoverAction {
+
+		SHOW_TEXT,
+		SHOW_ITEM,
+		SHOW_ENTITY;
+	}
+}

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

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

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

@@ -1,29 +1,28 @@
-package me.neznamy.tab.shared.packets;
+package me.neznamy.tab.api.chat;
 
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.rgb.RGBUtils;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
 
 /**
  * A class representing the n.m.s.EnumChatFormat class to make work with it much easier
  */
 public enum EnumChatFormat {
 
-	BLACK(0, '0', "#000000"),
-	DARK_BLUE(1, '1', "#0000AA"),
-	DARK_GREEN(2, '2', "#00AA00"),
-	DARK_AQUA(3, '3', "#00AAAA"),
-	DARK_RED(4, '4', "#AA0000"),
-	DARK_PURPLE(5, '5', "#AA00AA"),
-	GOLD(6, '6', "#FFAA00"),
-	GRAY(7, '7', "#AAAAAA"),
-	DARK_GRAY(8, '8', "#555555"),
-	BLUE(9, '9', "#5555FF"),
-	GREEN(10, 'a', "#55FF55"),
-	AQUA(11, 'b', "#55FFFF"),
-	RED(12, 'c', "#FF5555"),
-	LIGHT_PURPLE(13, 'd', "#FF55FF"),
-	YELLOW(14, 'e', "#FFFF55"),
-	WHITE(15, 'f', "#FFFFFF"),
+	BLACK(0, '0', "000000"),
+	DARK_BLUE(1, '1', "0000AA"),
+	DARK_GREEN(2, '2', "00AA00"),
+	DARK_AQUA(3, '3', "00AAAA"),
+	DARK_RED(4, '4', "AA0000"),
+	DARK_PURPLE(5, '5', "AA00AA"),
+	GOLD(6, '6', "FFAA00"),
+	GRAY(7, '7', "AAAAAA"),
+	DARK_GRAY(8, '8', "555555"),
+	BLUE(9, '9', "5555FF"),
+	GREEN(10, 'a', "55FF55"),
+	AQUA(11, 'b', "55FFFF"),
+	RED(12, 'c', "FF5555"),
+	LIGHT_PURPLE(13, 'd', "FF55FF"),
+	YELLOW(14, 'e', "FFFF55"),
+	WHITE(15, 'f', "FFFFFF"),
 	OBFUSCATED(16, 'k'),
 	BOLD(17, 'l'),
 	STRIKETHROUGH(18, 'm'),
@@ -31,27 +30,29 @@ public enum EnumChatFormat {
 	ITALIC(20, 'o'),
 	RESET(21, 'r');
 
-	private static EnumChatFormat[] values = values();
+	public static final char COLOR_CHAR = 0x00a7;
+	public static final String COLOR_STRING = String.valueOf(COLOR_CHAR);
+
 	//network id of the color
-	private int networkId;
+	private final int networkId;
 	
 	//characer representing the color
-	private char character;
+	private final char character;
 	
 	//red value of this color
-	private int red;
+	private final int red;
 	
 	//green value of this color
-	private int green;
+	private final int green;
 	
 	//blue value of this color
-	private int blue;
+	private final int blue;
 	
-	//hex code as string prefixed with #
-	private String hexCode;
+	//hex code as string
+	private final String hexCode;
 	
-	//\u00a7 followed by color's character
-	private String chatFormat;
+	//color char followed by color's character
+	private final String chatFormat;
 
 	/**
 	 * Constructs new instance with given parameters
@@ -60,9 +61,11 @@ public enum EnumChatFormat {
 	 * @param hexColor - hex code of the color
 	 */
 	private EnumChatFormat(int networkId, char character, String hexCode) {
-		this(networkId, character);
+		this.networkId = networkId;
+		this.character = character;
+		this.chatFormat = String.valueOf(COLOR_CHAR) + character;
 		this.hexCode = hexCode;
-		int hexColor = Integer.parseInt(hexCode.substring(1), 16);
+		int hexColor = Integer.parseInt(hexCode, 16);
 		red = (hexColor >> 16) & 0xFF;
 		green = (hexColor >> 8) & 0xFF;
 		blue = hexColor & 0xFF;
@@ -76,7 +79,11 @@ public enum EnumChatFormat {
 	private EnumChatFormat(int networkId, char character) {
 		this.networkId = networkId;
 		this.character = character;
-		this.chatFormat = "\u00a7" + character;
+		this.chatFormat = String.valueOf(COLOR_CHAR) + character;
+		red = 0;
+		green = 0;
+		blue = 0;
+		hexCode = null;
 	}
 	
 	/**
@@ -117,7 +124,7 @@ public enum EnumChatFormat {
 	 * @return instance from the character
 	 */
 	public static EnumChatFormat getByChar(char c) {
-		for (EnumChatFormat format : values) {
+		for (EnumChatFormat format : values()) {
 			if (format.character == c) return format;
 		}
 		return null;
@@ -131,10 +138,10 @@ public enum EnumChatFormat {
 	public static EnumChatFormat lastColorsOf(String string) {
 		if (string == null || string.length() == 0) return EnumChatFormat.WHITE;
 		String legacyText = RGBUtils.getInstance().convertRGBtoLegacy(string); //translating RGB into legacy for nametags
-		String last = TAB.getInstance().getPlaceholderManager().getLastColors(legacyText);
-		if (last != null && last.length() > 0) {
+		String last = getLastColors(legacyText);
+		if (last.length() > 0) {
 			char c = last.toCharArray()[1];
-			for (EnumChatFormat e : values) {
+			for (EnumChatFormat e : values()) {
 				if (e.character == c) return e;
 			}
 		}
@@ -142,8 +149,8 @@ public enum EnumChatFormat {
 	}
 	
 	/**
-	 * Returns \u00a7 followed by color's character
-	 * @return \u00a7 followed by color's character
+	 * Returns color char followed by color's character
+	 * @return color char followed by color's character
 	 */
 	public String getFormat() {
 		return chatFormat;
@@ -158,8 +165,8 @@ public enum EnumChatFormat {
 	}
 	
 	/**
-	 * Returns hex code of this format prefixed with #, null if this is a magic code
-	 * @return hex code of this format prefixed with #
+	 * Returns hex code of this format, null if this is a magic code
+	 * @return hex code of this format
 	 */
 	public String getHexCode() {
 		return hexCode;
@@ -173,9 +180,48 @@ public enum EnumChatFormat {
 	 * @return enum value or null if no such combination exists
 	 */
 	public static EnumChatFormat fromRGBExact(int red, int green, int blue){
-		for (EnumChatFormat format : values) {
+		for (EnumChatFormat format : values()) {
 			if (format.red == red && format.green == green && format.blue == blue) return format;
 		}
 		return null;
 	}
+	
+	//code taken from bukkit, so it can work on bungee too
+	public static String color(String textToTranslate){
+		if (textToTranslate == null) return null;
+		if (!textToTranslate.contains("&")) return textToTranslate;
+		char[] b = textToTranslate.toCharArray();
+		for (int i = 0; i < b.length - 1; i++) {
+			if ((b[i] == '&') && ("0123456789AaBbCcDdEeFfKkLlMmNnOoRrXx".indexOf(b[(i + 1)]) > -1)){
+				b[i] = COLOR_CHAR;
+				b[(i + 1)] = Character.toLowerCase(b[(i + 1)]);
+			}
+		}
+		return new String(b);
+	}
+	
+	public static String decolor(String text) {
+		if (!text.contains(COLOR_STRING)) return text;
+		return text.replace(COLOR_CHAR, '&');
+	}
+	
+	//code taken from bukkit, so it can work on bungee too
+	public static String getLastColors(String input) {
+		StringBuilder result = new StringBuilder();
+		int length = input.length();
+		for (int index = length - 1; index > -1; index--){
+			char section = input.charAt(index);
+			if ((section == COLOR_CHAR || section == '&') && (index < length - 1)){
+				char c = input.charAt(index + 1);
+				if ("0123456789AaBbCcDdEeFfKkLlMmNnOoRr".contains(String.valueOf(c))) {
+					result.insert(0, COLOR_CHAR);
+					result.insert(1, c);
+					if ("0123456789AaBbCcDdEeFfRr".contains(String.valueOf(c))) {
+						break;
+					}
+				}
+			}
+		}
+		return result.toString();
+	}
 }

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

@@ -0,0 +1,441 @@
+package me.neznamy.tab.api.chat;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+
+import me.neznamy.tab.api.ProtocolVersion;
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.tab.api.chat.ChatClickable.EnumClickAction;
+import me.neznamy.tab.api.chat.ChatHoverable.EnumHoverAction;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
+
+/**
+ * A class representing the n.m.s.IChatBaseComponent class to make work with it much easier
+ */
+@SuppressWarnings("unchecked")
+public class IChatBaseComponent {
+
+	private static final Map<String, IChatBaseComponent> componentCache = new HashMap<>();
+	private static final Map<IChatBaseComponent, String> serializeCacheModern = new HashMap<>();
+	private static final Map<IChatBaseComponent, String> serializeCacheLegacy = new HashMap<>();
+	
+	//constants
+	private static final String EMPTY_TRANSLATABLE = "{\"translate\":\"\"}";
+	private static final String EMPTY_TEXT = "{\"text\":\"\"}";
+	private static final List<IChatBaseComponent> EMPTY_LIST = new ArrayList<>(0);
+
+	//component text
+	private String text;
+	
+	private ChatModifier modifier = new ChatModifier();
+
+	//extra components
+	private List<IChatBaseComponent> extra;
+
+	/**
+	 * Constructs a new empty component
+	 */
+	public IChatBaseComponent() {
+	}
+	
+	/**
+	 * Constructs a new component which is a clone of provided component
+	 * @param component - component to clone
+	 */
+	public IChatBaseComponent(IChatBaseComponent component) {
+		this.text = component.text;
+		this.modifier = new ChatModifier(component.modifier);
+		for (IChatBaseComponent child : component.getExtra()) {
+			addExtra(new IChatBaseComponent(child));
+		}
+	}
+
+	/**
+	 * Constructs new instance with given text
+	 * @param text - text to display
+	 */
+	public IChatBaseComponent(String text) {
+		this.text = text;
+	}
+
+	/**
+	 * Returns list of extra components or null if none are defined
+	 * @return list of extras
+	 */
+	public List<IChatBaseComponent> getExtra(){
+		if (extra == null) return EMPTY_LIST;
+		return extra;
+	}
+
+	/**
+	 * Sets full list of extra components to given list
+	 * @param components - components to use as extra
+	 * @return self
+	 */
+	public IChatBaseComponent setExtra(List<IChatBaseComponent> components){
+		if (components.isEmpty()) throw new IllegalArgumentException("Unexpected empty array of components"); //exception taken from minecraft
+		this.extra = components;
+		return this;
+	}
+
+	/**
+	 * Appends provided component as extra component
+	 * @param child - component to append
+	 * @return self
+	 */
+	public IChatBaseComponent addExtra(IChatBaseComponent child) {
+		if (extra == null) extra = new ArrayList<>();
+		extra.add(child);
+		return this;
+	}
+
+	/**
+	 * Returns text of this component
+	 * @return text of this component
+	 */
+	public String getText() {
+		return text;
+	}
+
+	public ChatModifier getModifier() {
+		return modifier;
+	}
+	
+	public void setModifier(ChatModifier modifier) {
+		this.modifier = modifier;
+	}
+
+	/**
+	 * Sets text of this component
+	 * @param text - text to show
+	 * @return self
+	 */
+	public IChatBaseComponent setText(String text) {
+		this.text = text;
+		return this;
+	}
+
+	/**
+	 * Deserializes string and returns created component
+	 * @param json - serialized string
+	 * @return Deserialized component
+	 */
+	public static IChatBaseComponent deserialize(String json) {
+		try {
+			if (json == null) return null;
+			if (json.startsWith("\"") && json.endsWith("\"") && json.length() > 1) {
+				//simple component with only text used, minecraft serializer outputs the text in quotes instead of full json
+				return new IChatBaseComponent(json.substring(1, json.length()-1));
+			}
+			JSONObject jsonObject = (JSONObject) new JSONParser().parse(json);
+			IChatBaseComponent component;
+			if (jsonObject.containsKey("type")) {
+				return new ChatComponentEntity((String) jsonObject.get("type"), UUID.fromString((String) jsonObject.get("id")), IChatBaseComponent.deserialize(((JSONObject) jsonObject.get("name")).toString()).toFlatText());
+			}
+			component = new IChatBaseComponent();
+			component.setText((String) jsonObject.get("text"));
+			component.modifier.setBold(getBoolean(jsonObject, "bold"));
+			component.modifier.setItalic(getBoolean(jsonObject, "italic"));
+			component.modifier.setUnderlined(getBoolean(jsonObject, "underlined"));
+			component.modifier.setStrikethrough(getBoolean(jsonObject, "strikethrough"));
+			component.modifier.setObfuscated(getBoolean(jsonObject, "obfuscated"));
+			component.modifier.setColor(TextColor.fromString(((String) jsonObject.get("color"))));
+			if (jsonObject.containsKey("clickEvent")) {
+				JSONObject clickEvent = (JSONObject) jsonObject.get("clickEvent");
+				String action = (String) clickEvent.get("action");
+				String value = clickEvent.get("value").toString();
+				component.modifier.onClick(EnumClickAction.valueOf(action.toUpperCase()), value);
+			}
+			if (jsonObject.containsKey("hoverEvent")) {
+				JSONObject hoverEvent = (JSONObject) jsonObject.get("hoverEvent");
+				String action = (String) hoverEvent.get("action");
+				String value = (String) hoverEvent.get("value");
+				component.modifier.onHover(EnumHoverAction.valueOf(action.toUpperCase()), deserialize(value));
+			}
+			if (jsonObject.containsKey("extra")) {
+				List<Object> list = (List<Object>) jsonObject.get("extra");
+				for (Object extra : list) {
+					String string = extra.toString();
+					//reverting .toString() removing "" for simple text
+					if (!string.startsWith("{")) string = "\"" + string + "\"";
+					component.addExtra(deserialize(string));
+				}
+			}
+			return component;
+		} catch (Exception e) {
+			TabAPI.getInstance().logError("Failed to deserialize json component " + json, e);
+			return null;
+		}
+	}
+
+	/**
+	 * Returns boolean value of requested key
+	 * @param jsonObject - object to get value from
+	 * @param key - name of key
+	 * @return value from json object or null if not present
+	 */
+	private static Boolean getBoolean(JSONObject jsonObject, String key) {
+		String value = String.valueOf(jsonObject.getOrDefault(key, null));
+		return "null".equals(value) ? null : Boolean.parseBoolean(value);
+	}
+
+	@Override
+	public String toString() {
+		JSONObject json = new JSONObject();
+		if (text != null) json.put("text", text);
+		if (modifier.getTargetVersion() == null) modifier.setTargetVersion(TabAPI.getInstance().getServerVersion()); //packet.toString() was called as a part of a debug message
+		json.putAll(modifier.serialize());
+		if (extra != null) json.put("extra", extra);
+		return json.toString();
+	}
+
+	/**
+	 * Serializes this component with colors based on client version
+	 * @param clientVersion - client version
+	 * @return Serialized string
+	 */
+	public String toString(ProtocolVersion clientVersion) {
+		return toString(clientVersion, false);
+	}
+
+	/**
+	 * Serializes this component with colors based on client version
+	 * @param clientVersion - client version
+	 * @param sendTranslatableIfEmpty - if empty translatable should be sent if text is empty or not
+	 * @return Serialized string
+	 */
+	public String toString(ProtocolVersion clientVersion, boolean sendTranslatableIfEmpty) {
+		if (extra == null) {
+			if (text == null) return null;
+			if (text.length() == 0) {
+				if (sendTranslatableIfEmpty) {
+					return EMPTY_TRANSLATABLE;
+				} else {
+					return EMPTY_TEXT;
+				}
+			}
+		}
+		modifier.setTargetVersion(clientVersion);
+		for (IChatBaseComponent child : getExtra()) {
+			child.modifier.setTargetVersion(clientVersion);
+		}
+		String string;
+		if (clientVersion.getMinorVersion() >= 16) {
+			if (serializeCacheModern.containsKey(this)) return serializeCacheModern.get(this);
+			string = toString();
+			if (serializeCacheModern.size() > 10000) serializeCacheModern.clear();
+			serializeCacheModern.put(this, string);
+		} else {
+			if (serializeCacheLegacy.containsKey(this)) return serializeCacheLegacy.get(this);
+			string = toString();
+			if (serializeCacheLegacy.size() > 10000) serializeCacheLegacy.clear();
+			serializeCacheLegacy.put(this, string);
+		}
+		return string;
+	}
+
+	/**
+	 * Returns organized component from colored text
+	 * @param originalText - text to convert
+	 * @return organized component from colored text
+	 */
+	public static IChatBaseComponent fromColoredText(String originalText){
+		String text = RGBUtils.getInstance().applyFormats(EnumChatFormat.color(originalText), false);
+		List<IChatBaseComponent> components = new ArrayList<>();
+		StringBuilder builder = new StringBuilder();
+		IChatBaseComponent component = new IChatBaseComponent();
+		for (int i = 0; i < text.length(); i++){
+			char c = text.charAt(i);
+			if (c == EnumChatFormat.COLOR_CHAR){
+				i++;
+				if (i >= text.length()) {
+					break;
+				}
+				c = text.charAt(i);
+				if ((c >= 'A') && (c <= 'Z')) {
+					c = (char)(c + ' ');
+				}
+				EnumChatFormat format = EnumChatFormat.getByChar(c);
+				if (format != null){
+					if (builder.length() > 0) {
+						component.setText(builder.toString());
+						components.add(component);
+						component = new IChatBaseComponent(component);
+						component.text = null;
+						builder = new StringBuilder();
+					}
+					switch (format){
+					case BOLD: 
+						component.modifier.setBold(true);
+						break;
+					case ITALIC: 
+						component.modifier.setItalic(true);
+						break;
+					case UNDERLINE: 
+						component.modifier.setUnderlined(true);
+						break;
+					case STRIKETHROUGH: 
+						component.modifier.setStrikethrough(true);
+						break;
+					case OBFUSCATED: 
+						component.modifier.setObfuscated(true);
+						break;
+					case RESET: 
+						component = new IChatBaseComponent();
+						component.modifier.setColor(new TextColor(EnumChatFormat.WHITE));
+						break;
+					default:
+						component = new IChatBaseComponent();
+						component.modifier.setColor(new TextColor(format));
+						break;
+					}
+				}
+			} else if (c == '#' && text.length() > i+6){
+				String hex = text.substring(i+1, i+7);
+				if (RGBUtils.getInstance().isHexCode(hex)) {
+					TextColor color;
+					if (containsLegacyCode(text, i)) {
+						color = new TextColor(hex, EnumChatFormat.getByChar(text.charAt(i+8)));
+						i += 8;
+					} else {
+						color = new TextColor(hex);
+						i += 6;
+					}
+					if (builder.length() > 0){
+						component.setText(builder.toString());
+						components.add(component);
+						builder = new StringBuilder();
+					}
+					component = new IChatBaseComponent();
+					component.modifier.setColor(color);
+				} else {
+					builder.append(c);
+				}
+			} else {
+				builder.append(c);
+			}
+		}
+		component.setText(builder.toString());
+		components.add(component);
+		return new IChatBaseComponent("").setExtra(components);
+	}
+
+	/**
+	 * Returns true if text contains legacy color request at defined RGB index start
+	 * @param text - text to check
+	 * @param i - current index start
+	 * @return true if legacy color is defined, false if not
+	 */
+	private static boolean containsLegacyCode(String text, int i) {
+		if (text.length() - i < 9 || text.charAt(i+7) != '|') return false;
+		return EnumChatFormat.getByChar(text.charAt(i+8)) != null;
+	}
+
+	/**
+	 * Converts this component into a simple text with legacy colors (closest match if color is set to RGB)
+	 * @return The simple text format
+	 */
+	public String toLegacyText() {
+		StringBuilder builder = new StringBuilder();
+		append(builder, "");
+		return builder.toString();
+	}
+
+	/**
+	 * Appends text to string builder, might also add color and magic codes if different
+	 * than previous component in chain
+	 * @param builder - builder to append text to
+	 * @param previousFormatting - colors and magic codes in previous component
+	 * @return New formatting, might be identical to previous one
+	 */
+	private String append(StringBuilder builder, String previousFormatting) {
+		String formatting = previousFormatting;
+		if (text != null) {
+			formatting = getFormatting();
+			if (!formatting.equals(previousFormatting)) {
+				builder.append(formatting);
+			}
+			builder.append(text);
+
+		}
+		for (IChatBaseComponent component : getExtra()) {
+			formatting = component.append(builder, formatting);
+		}
+		return formatting;
+	}
+
+	/**
+	 * Returns colors and magic codes of this component
+	 * @return used colors and magic codes
+	 */
+	private String getFormatting() {
+		StringBuilder builder = new StringBuilder();
+		if (modifier.getColor() != null) {
+			if (modifier.getColor().getLegacyColor() == EnumChatFormat.WHITE) {
+				//preventing unwanted &r -> &f conversion and stopping the <1.13 client bug fix from working
+				builder.append(EnumChatFormat.RESET.getFormat());
+			} else {
+				builder.append(modifier.getColor().getLegacyColor().getFormat());
+			}
+		}
+		builder.append(modifier.getMagicCodes());
+		return builder.toString();
+	}
+
+	/**
+	 * Returns raw text without colors, only works correctly when component is organized
+	 * @return raw text in this component
+	 */
+	public String toRawText() {
+		StringBuilder builder = new StringBuilder();
+		if (text != null) builder.append(text);
+		for (IChatBaseComponent child : getExtra()) {
+			if (child.text != null) builder.append(child.text);
+		}
+		return builder.toString();
+	}
+
+	/**
+	 * Converts the component into flat text with used colors (including rgb) and magic codes
+	 * @return converted text
+	 */
+	public String toFlatText() {
+		StringBuilder builder = new StringBuilder();
+		if (modifier.getColor() != null) builder.append("#" + modifier.getColor().getHexCode());
+		builder.append(modifier.getMagicCodes());
+		if (text != null) builder.append(text);
+		for (IChatBaseComponent child : getExtra()) {
+			builder.append(child.toFlatText());
+		}
+		return builder.toString();
+	}
+
+	/**
+	 * Returns the most optimized component based on text. Returns null if text is null,
+	 * organized component if RGB colors are used or simple component with only text field
+	 * containing the whole text when no RGB colors are used
+	 * @param text - text to create component from
+	 * @return The most performance-optimized component based on text
+	 */
+	public static IChatBaseComponent optimizedComponent(String text){
+		if (text == null) return null;
+		if (componentCache.containsKey(text)) return componentCache.get(text);
+		IChatBaseComponent component;
+		if (text.contains("#") || text.contains("&x") || text.contains(EnumChatFormat.COLOR_CHAR + "x")){
+			//contains RGB colors
+			component = IChatBaseComponent.fromColoredText(text);
+		} else {
+			//no RGB
+			component = new IChatBaseComponent(text);
+		}
+		if (componentCache.size() > 10000) componentCache.clear();
+		componentCache.put(text, component);
+		return component;
+	}
+}

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

@@ -1,34 +1,32 @@
-package me.neznamy.tab.shared.rgb;
-
-import me.neznamy.tab.shared.packets.EnumChatFormat;
+package me.neznamy.tab.api.chat;
 
 /**
  * A class used to represent any combination of RGB colors
  */
 public class TextColor {
 
-	private static EnumChatFormat[] legacyColors = EnumChatFormat.values();
-	
-	//red value
-	private Integer red;
-	
-	//green value
-	private Integer green;
-	
-	//blue value
-	private Integer blue;
+	//rgb values, only initializing when they are actually requested
+	private int red = -1;
+	private int green = -1;
+	private int blue = -1;
 	
 	//closest legacy color
 	private EnumChatFormat legacyColor;
 	
-	//hex code as string prefixed with #
+	//6-digit combination of hexadecimal numbers
 	private String hexCode;
 	
 	//true if legacy color was forced via constructor, false if automatically
 	private boolean legacyColorForced;
 	
-	//true if toString should return legacy color
-	private boolean returnLegacy;
+	public TextColor(TextColor color) {
+		red = color.red;
+		green = color.green;
+		blue = color.blue;
+		legacyColor = color.legacyColor;
+		hexCode = color.hexCode;
+		legacyColorForced = color.legacyColorForced;
+	}
 	
 	/**
 	 * Constructs new instance based on hex code as string
@@ -79,7 +77,7 @@ public class TextColor {
 		double minMaxDist = 9999;
 		double maxDist;
 		EnumChatFormat closestColor = EnumChatFormat.WHITE;
-		for (EnumChatFormat color : legacyColors) {
+		for (EnumChatFormat color : EnumChatFormat.values()) {
 			int rDiff = color.getRed() - red;
 			int gDiff = color.getGreen() - green;
 			int bDiff = color.getBlue() - blue;
@@ -102,8 +100,8 @@ public class TextColor {
 	 * @return amount of red
 	 */
 	public int getRed() {
-		if (red == null) {
-			int hexColor = Integer.parseInt(hexCode.substring(1), 16);
+		if (red == -1) {
+			int hexColor = Integer.parseInt(hexCode, 16);
 			red = (hexColor >> 16) & 0xFF;
 			green = (hexColor >> 8) & 0xFF;
 			blue = hexColor & 0xFF;
@@ -116,8 +114,8 @@ public class TextColor {
 	 * @return amount of green
 	 */
 	public int getGreen() {
-		if (green == null) {
-			int hexColor = Integer.parseInt(hexCode.substring(1), 16);
+		if (green == -1) {
+			int hexColor = Integer.parseInt(hexCode, 16);
 			red = (hexColor >> 16) & 0xFF;
 			green = (hexColor >> 8) & 0xFF;
 			blue = hexColor & 0xFF;
@@ -130,8 +128,8 @@ public class TextColor {
 	 * @return amount of blue
 	 */
 	public int getBlue() {
-		if (blue == null) {
-			int hexColor = Integer.parseInt(hexCode.substring(1), 16);
+		if (blue == -1) {
+			int hexColor = Integer.parseInt(hexCode, 16);
 			red = (hexColor >> 16) & 0xFF;
 			green = (hexColor >> 8) & 0xFF;
 			blue = hexColor & 0xFF;
@@ -156,7 +154,7 @@ public class TextColor {
 	 */
 	public String getHexCode() {
 		if (hexCode == null) {
-			hexCode = String.format("#%06X", (red << 16) + (green << 8) + blue);
+			hexCode = String.format("%06X", (red << 16) + (green << 8) + blue);
 		}
 		return hexCode;
 	}
@@ -166,16 +164,13 @@ public class TextColor {
 	 * @return the color converted into string acceptable by client
 	 */
 	public String toString() {
-		if (!returnLegacy) {
-			EnumChatFormat legacyEquivalent = EnumChatFormat.fromRGBExact(getRed(), getGreen(), getBlue());
-			if (legacyEquivalent != null) {
-				//not sending old colors as RGB to 1.16 clients if not needed as <1.16 servers will fail to apply color
-				return legacyEquivalent.toString().toLowerCase();
-			}
-			return getHexCode();
-		} else {
-			return getLegacyColor().toString().toLowerCase();
+		EnumChatFormat legacyEquivalent = EnumChatFormat.fromRGBExact(getRed(), getGreen(), getBlue());
+		if (legacyEquivalent != null) {
+			//not sending old colors as RGB to 1.16 clients if not needed as <1.16 servers will fail to apply color
+			return legacyEquivalent.toString().toLowerCase();
 		}
+		return "#" + getHexCode();
+
 	}
 	
 	/**
@@ -185,15 +180,7 @@ public class TextColor {
 	public boolean isLegacyColorForced() {
 		return legacyColorForced;
 	}
-	
-	/**
-	 * Sets returnLegacy flag to given value
-	 * @param returnLegacy - true if color should return legacy
-	 */
-	public void setReturnLegacy(boolean returnLegacy) {
-		this.returnLegacy = returnLegacy;
-	}
-	
+
 	/**
 	 * Reads the string and turns into text color. String is either #RRGGBB or a lowercased legacy color
 	 * @param string - string from color field in chat component
@@ -201,7 +188,7 @@ public class TextColor {
 	 */
 	public static TextColor fromString(String string) {
 		if (string == null) return null;
-		if (string.startsWith("#")) return new TextColor(string);
+		if (string.startsWith("#")) return new TextColor(string.substring(1));
 		return new TextColor(EnumChatFormat.valueOf(string.toUpperCase()));
 	}
 }

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

@@ -0,0 +1,155 @@
+package me.neznamy.tab.api.chat.rgb;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import me.neznamy.tab.api.chat.TextColor;
+import me.neznamy.tab.api.chat.rgb.format.BukkitFormat;
+import me.neznamy.tab.api.chat.rgb.format.CMIFormat;
+import me.neznamy.tab.api.chat.rgb.format.HtmlFormat;
+import me.neznamy.tab.api.chat.rgb.format.HtmlFormat2;
+import me.neznamy.tab.api.chat.rgb.format.RGBFormatter;
+import me.neznamy.tab.api.chat.rgb.format.UnnamedFormat1;
+import me.neznamy.tab.api.chat.rgb.gradient.CMIGradient;
+import me.neznamy.tab.api.chat.rgb.gradient.CommonGradient;
+import me.neznamy.tab.api.chat.rgb.gradient.GradientPattern;
+import me.neznamy.tab.api.chat.rgb.gradient.KyoriGradient;
+
+/**
+ * A helper class to reformat all RGB formats into the default #RRGGBB and apply gradients
+ */
+public class RGBUtils {
+
+	//instance of class
+	private final static RGBUtils instance = new RGBUtils();
+	
+	//rgb formatters
+	private final RGBFormatter[] formats;
+	
+	//gradient patterns
+	private final GradientPattern[] gradients;
+	
+	//TAB's RGB format
+	private final Pattern tabPattern = Pattern.compile("#[0-9a-fA-F]{6}");
+	private final Pattern tabPatternLegacy = Pattern.compile("#[0-9a-fA-F]{6}\\|.");
+
+	public RGBUtils() {
+		formats = new RGBFormatter[] {
+				new BukkitFormat(),
+				new CMIFormat(),
+				new UnnamedFormat1(),
+				new HtmlFormat(),
+				new HtmlFormat2()
+		};
+		gradients = new GradientPattern[] {
+				//{#RRGGBB>}text{#RRGGBB<}
+				new CMIGradient(),
+				//<#RRGGBB>Text</#RRGGBB>
+				new CommonGradient(Pattern.compile("<#[0-9a-fA-F]{6}>[^<]*</#[0-9a-fA-F]{6}>"), 
+						Pattern.compile("<#[0-9a-fA-F]{6}\\|.>[^<]*</#[0-9a-fA-F]{6}>"), 
+						"<#", 9, 2, 9, 7),
+				//<$#RRGGBB>Text<$#RRGGBB>
+				new CommonGradient(Pattern.compile("<\\$#[0-9a-fA-F]{6}>[^<]*<\\$#[0-9a-fA-F]{6}>"), 
+						Pattern.compile("<\\$#[0-9a-fA-F]{6}\\|.>[^<]*<\\$#[0-9a-fA-F]{6}>"), 
+						"<$", 10, 3, 10, 7),
+				new KyoriGradient()
+		};
+	}
+	
+	/**
+	 * Returns instance of this class
+	 * @return instance
+	 */
+	public static RGBUtils getInstance() {
+		return instance;
+	}
+	
+	/**
+	 * Applies all RGB formats and gradients to text and returns it
+	 * @param text - original text
+	 * @return text where everything is converted to #RRGGBB
+	 */
+	public String applyFormats(String text, boolean ignorePlaceholders) {
+		String replaced = text;
+		for (GradientPattern pattern : gradients) {
+			replaced = pattern.applyPattern(replaced, ignorePlaceholders);
+		}
+		for (RGBFormatter formatter : formats) {
+			replaced = formatter.reformat(replaced);
+		}
+		return replaced;
+	}
+	
+	public String convertToBukkitFormat(String text, boolean rgbClient) {
+		if (!text.contains("#")) return text; //no rgb codes
+		if (rgbClient) {
+			//converting random formats to TAB one
+			String replaced = applyFormats(text, false);
+			for (Pattern p : new Pattern[]{tabPatternLegacy, tabPattern}) {
+				Matcher m = p.matcher(replaced);
+				while (m.find()) {
+					String hexcode = m.group();
+					String fixed = "&x&" + hexcode.charAt(1) + "&" + hexcode.charAt(2) + "&" + hexcode.charAt(3) + "&" + hexcode.charAt(4) + "&" + hexcode.charAt(5) + "&" + hexcode.charAt(6);
+					replaced = replaced.replace(hexcode, EnumChatFormat.color(fixed));
+				}
+			}
+			return replaced;
+		} else {
+			return IChatBaseComponent.fromColoredText(text).toLegacyText();
+		}
+	}
+
+	/**
+	 * Converts all hex codes in given string to legacy codes
+	 * @param text - text to translate
+	 * @return - translated text
+	 */
+	public String convertRGBtoLegacy(String text) {
+		if (text == null) return null;
+		if (!text.contains("#")) return EnumChatFormat.color(text);
+		String applied = applyFormats(text, false);
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < applied.length(); i++){
+			char c = applied.charAt(i);
+			if (c == '#' && applied.length() > i+6) {
+				String hexCode = applied.substring(i+1, i+7);
+				if (isHexCode(hexCode)) {
+					if (containsLegacyCode(applied, i)) {
+						sb.append(new TextColor(hexCode, EnumChatFormat.getByChar(applied.charAt(i+8))).getLegacyColor().getFormat());
+						i += 8;
+					} else {
+						sb.append(new TextColor(hexCode).getLegacyColor().getFormat());
+						i += 6;
+					}
+				} else {
+					sb.append(c);
+				}
+			} else {
+				sb.append(c);
+			}
+		}
+		return sb.toString();
+	}
+	
+	public boolean isHexCode(String string) {
+		if (string.length() != 6) return false;
+		for (int i=0; i<6; i++) {
+			char c = string.charAt(i);
+			if (c < 48 || (c > 57 && c < 65) || (c > 70 && c < 97) || c > 102) return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Returns true if text contains legacy color request at defined RGB index start
+	 * @param text - text to check
+	 * @param i - current index start
+	 * @return true if legacy color is defined, false if not
+	 */
+	private static boolean containsLegacyCode(String text, int i) {
+		if (text.length() - i < 9 || text.charAt(i+7) != '|') return false;
+		return EnumChatFormat.getByChar(text.charAt(i+8)) != null;
+	}
+}

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

@@ -1,18 +1,20 @@
-package me.neznamy.tab.shared.rgb.format;
+package me.neznamy.tab.api.chat.rgb.format;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import me.neznamy.tab.api.chat.EnumChatFormat;
+
 /**
  * Formatter for &x&R&R&G&G&B&B
  */
 public class BukkitFormat implements RGBFormatter {
 
-	private final Pattern pattern = Pattern.compile("[\\\u00a7&]{1}x[[\\\u00a7&]{1}0-9a-fA-F]{12}");
+	private final Pattern pattern = Pattern.compile("[" + EnumChatFormat.COLOR_CHAR + "&]x[[" + EnumChatFormat.COLOR_CHAR + "&]\\p{XDigit}]{12}");
 	
 	@Override
 	public String reformat(String text) {
-		if (!text.contains("&") && !text.contains("\u00a7x")) return text;
+		if (!text.contains("&") && !text.contains(EnumChatFormat.COLOR_CHAR + "x")) return text;
 		String replaced = text;
 		Matcher m = pattern.matcher(replaced);
 		while (m.find()) {

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

@@ -1,4 +1,4 @@
-package me.neznamy.tab.shared.rgb.format;
+package me.neznamy.tab.api.chat.rgb.format;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

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

@@ -1,4 +1,4 @@
-package me.neznamy.tab.shared.rgb.format;
+package me.neznamy.tab.api.chat.rgb.format;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

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

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

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

@@ -1,4 +1,4 @@
-package me.neznamy.tab.shared.rgb.format;
+package me.neznamy.tab.api.chat.rgb.format;
 
 /**
  * Abstract class for different RGB patterns

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

@@ -1,4 +1,4 @@
-package me.neznamy.tab.shared.rgb.format;
+package me.neznamy.tab.api.chat.rgb.format;
 
 /**
  * Formatter for &#RRGGBB

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

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

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

@@ -1,20 +1,20 @@
-package me.neznamy.tab.shared.rgb.gradient;
+package me.neznamy.tab.api.chat.rgb.gradient;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import me.neznamy.tab.shared.packets.EnumChatFormat;
-import me.neznamy.tab.shared.rgb.TextColor;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.TextColor;
 
-public class CommonGradient extends GradientPattern {
+public class CommonGradient implements GradientPattern {
 
-	private Pattern pattern;
-	private Pattern legacyPattern;
-	private String containCheck;
-	private int legacyCharPosition;
-	private int startColorStart;
-	private int messageStart;
-	private int endColorStartSub;
+	private final Pattern pattern;
+	private final Pattern legacyPattern;
+	private final String containCheck;
+	private final int legacyCharPosition;
+	private final int startColorStart;
+	private final int messageStart;
+	private final int endColorStartSub;
 	
 	public CommonGradient(Pattern pattern, Pattern legacyPattern, String containCheck, int legacyCharPosition,
 			int startColorStart, int messageStart, int endColorStartSub) {
@@ -36,9 +36,9 @@ public class CommonGradient extends GradientPattern {
 			String format = m.group();
 			EnumChatFormat legacyColor = EnumChatFormat.getByChar(format.charAt(legacyCharPosition));
 			if ((ignorePlaceholders && format.contains("%")) || legacyColor == null) continue;
-			TextColor start = new TextColor(format.substring(startColorStart, startColorStart+7), legacyColor);
+			TextColor start = new TextColor(format.substring(startColorStart, startColorStart+6), legacyColor);
 			String message = format.substring(messageStart+2, format.length()-10);
-			TextColor end = new TextColor(format.substring(format.length()-endColorStartSub, format.length()-endColorStartSub+7));
+			TextColor end = new TextColor(format.substring(format.length()-endColorStartSub, format.length()-endColorStartSub+6));
 			String applied = asGradient(start, message, end);
 			replaced = replaced.replace(format, applied);
 		}
@@ -46,9 +46,9 @@ public class CommonGradient extends GradientPattern {
 		while (m.find()) {
 			String format = m.group();
 			if (ignorePlaceholders && format.contains("%")) continue;
-			TextColor start = new TextColor(format.substring(startColorStart, startColorStart+7));
+			TextColor start = new TextColor(format.substring(startColorStart, startColorStart+6));
 			String message = format.substring(messageStart, format.length()-10);
-			TextColor end = new TextColor(format.substring(format.length()-endColorStartSub, format.length()-endColorStartSub+7));
+			TextColor end = new TextColor(format.substring(format.length()-endColorStartSub, format.length()-endColorStartSub+6));
 			String applied = asGradient(start, message, end);
 			replaced = replaced.replace(format, applied);
 		}

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

@@ -1,19 +1,19 @@
-package me.neznamy.tab.shared.rgb.gradient;
+package me.neznamy.tab.api.chat.rgb.gradient;
 
-import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.rgb.TextColor;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.TextColor;
 
 /**
  * Abstract class for applying different gradient patterns
  */
-public abstract class GradientPattern {
+public interface GradientPattern {
 
 	/**
 	 * Applies gradients in provided text and returns text using only #RRGGBB
 	 * @param text - text to be reformatted
 	 * @return reformatted text
 	 */
-	public abstract String applyPattern(String text, boolean ignorePlaceholders);
+	public String applyPattern(String text, boolean ignorePlaceholders);
 	
 	/**
 	 * Returns gradient text based on start color, text and end color
@@ -22,19 +22,29 @@ public abstract class GradientPattern {
 	 * @param end - end color
 	 * @return reformatted text
 	 */	
-	protected String asGradient(TextColor start, String text, TextColor end) {
+	public default String asGradient(TextColor start, String text, TextColor end) {
 		//lazy support for magic codes in gradients
-		String magicCodes = TAB.getInstance().getPlaceholderManager().getLastColors(text);
+		String magicCodes = EnumChatFormat.getLastColors(text);
 		String decolorized = text.substring(magicCodes.length());
 		StringBuilder sb = new StringBuilder();
 		int length = decolorized.length();
+		if (length == 1) {
+			sb.append("#");
+			sb.append(new TextColor(start.getRed(), start.getGreen(), start.getBlue()).getHexCode());
+			if (start.isLegacyColorForced()) sb.append("|" + start.getLegacyColor().getCharacter());
+			sb.append(magicCodes);
+			sb.append(decolorized);
+			return sb.toString();
+		}
 		for (int i=0; i<length; i++) {
 			int red = (int) (start.getRed() + (float)(end.getRed() - start.getRed())/(length-1)*i);
 			int green = (int) (start.getGreen() + (float)(end.getGreen() - start.getGreen())/(length-1)*i);
 			int blue = (int) (start.getBlue() + (float)(end.getBlue() - start.getBlue())/(length-1)*i);
+			sb.append("#");
 			sb.append(new TextColor(red, green, blue).getHexCode());
 			if (start.isLegacyColorForced()) sb.append("|" + start.getLegacyColor().getCharacter());
-			sb.append(magicCodes + decolorized.charAt(i));
+			sb.append(magicCodes);
+			sb.append(decolorized.charAt(i));
 		}
 		return sb.toString();
 	}

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

@@ -1,15 +1,15 @@
-package me.neznamy.tab.shared.rgb.gradient;
+package me.neznamy.tab.api.chat.rgb.gradient;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import me.neznamy.tab.shared.packets.EnumChatFormat;
-import me.neznamy.tab.shared.rgb.TextColor;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.TextColor;
 
 /**
  * Gradient applier for <gradient:#RRGGBB:#RRGGBB>Text</gradient> and <gradient:#RRGGBB|L:#RRGGBB>Text</gradient>
  */
-public class KyoriGradient extends GradientPattern {
+public class KyoriGradient implements GradientPattern {
 
 	private final Pattern pattern = Pattern.compile("<gradient:#[0-9a-fA-F]{6}:#[0-9a-fA-F]{6}>[^<]*</gradient>");
 
@@ -24,9 +24,9 @@ public class KyoriGradient extends GradientPattern {
 			String format = m.group();
 			EnumChatFormat legacyColor = EnumChatFormat.getByChar(format.charAt(18));
 			if ((ignorePlaceholders && format.contains("%")) || legacyColor == null) continue;
-			TextColor start = new TextColor(format.substring(10, 17), legacyColor);
+			TextColor start = new TextColor(format.substring(11, 17), legacyColor);
 			String message = format.substring(28, format.length()-11);
-			TextColor end = new TextColor(format.substring(20, 27));
+			TextColor end = new TextColor(format.substring(21, 27));
 			String applied = asGradient(start, message, end);
 			replaced = replaced.replace(format, applied);
 		}
@@ -34,9 +34,9 @@ public class KyoriGradient extends GradientPattern {
 		while (m.find()) {
 			String format = m.group();
 			if (ignorePlaceholders && format.contains("%")) continue;
-			TextColor start = new TextColor(format.substring(10, 17));
+			TextColor start = new TextColor(format.substring(11, 17));
 			String message = format.substring(26, format.length()-11);
-			TextColor end = new TextColor(format.substring(18, 25));
+			TextColor end = new TextColor(format.substring(19, 25));
 			String applied = asGradient(start, message, end);
 			replaced = replaced.replace(format, applied);
 		}

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

@@ -0,0 +1,434 @@
+package me.neznamy.tab.api.config;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import me.neznamy.tab.api.TabAPI;
+
+/**
+ * Abstract class for configuration file
+ */
+@SuppressWarnings("unchecked")
+public abstract class ConfigurationFile {
+
+	/** Comments on top of the file */
+	protected List<String> header;
+
+	/** Configuration file content */
+	protected Map<String, Object> values;
+
+	/** File to use */
+	protected final File file;
+
+	/**
+	 * Constructs new instance and attempts to load specified configuration file.
+	 * If file does not exist, default file is copied from {@code source}.
+	 * 
+	 * @param	source
+	 * 			Source to copy file from if it does not exist
+	 * @param	destination
+	 * 			File destination to use
+	 * @throws	IllegalArgumentException
+	 * 			if {@code destination} is null
+	 * @throws	IllegalStateException
+	 * 			if file does not exist and source is null
+	 * @throws	IOException
+	 * 			if I/O operation with the file unexpectedly fails
+	 */
+	protected ConfigurationFile(InputStream source, File destination) throws IOException {
+		if (destination == null) throw new IllegalArgumentException("Destination cannot be null");
+		this.file = destination;
+		if (file.getParentFile() != null) file.getParentFile().mkdirs();
+		if (!file.exists()) {
+			if (source == null) throw new IllegalStateException("File does not exist and source is null");
+//			Files.copy(source, file.toPath());
+			//avoiding MalformedInputException thrown on fabric due to file not having UTF8 encoding by default
+			//also automatically using the encoding so users don't have to worry about it anymore
+			file.createNewFile();
+			try (BufferedReader reader = new BufferedReader(new InputStreamReader(source, StandardCharsets.UTF_8));
+				BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8))){
+				String line;
+				while ((line = reader.readLine()) != null) {
+					writer.write(line + "\n");
+				}
+				reader.close();
+				writer.close();
+			}
+
+		}
+		detectHeader();
+	}
+
+	/**
+	 * Saves values from map to the file
+	 */
+	public abstract void save();
+
+	/**
+	 * Returns simple name of the file
+	 * @return	simple name of the file
+	 */
+	public String getName() {
+		return file.getName();
+	}
+
+	/**
+	 * Returns the root value map
+	 * @return	the root value map
+	 */
+	public Map<String, Object> getValues(){
+		return values;
+	}
+
+	public void setValues(Map<String, Object> values) {
+		this.values = values;
+	}
+
+	/**
+	 * Gets config option with specified path. If the option is not present and 
+	 * {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} 
+	 * called and {@code defaultValue} returned.
+	 * 
+	 * @param	path
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	defaultValue
+	 * 			Value to be inserted and returned if option is not present
+	 * @return	value from configuration file
+	 */
+	public Object getObject(String path, Object defaultValue) {
+		Object value = values;
+		for (String section : path.contains(".") ? path.split("\\.") : new String[] {path}) {
+			if (!(value instanceof Map)) {
+				if (defaultValue != null) set(path, defaultValue);
+				return defaultValue;
+			}
+			value = getIgnoreCase((Map<Object, Object>) value, section);
+		}
+		if (value == null && defaultValue != null) {
+			TabAPI.getInstance().debug("Inserting missing config option \"" + path + "\" with value \"" + defaultValue + "\" into " + file.getName());
+			set(path, defaultValue);
+			return defaultValue;
+		}
+		return value;
+	}
+
+	/**
+	 * Returns config option with specified path. If option is not present,
+	 * {@code null} is returned.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @return	value from configuration file or null if not present
+	 */
+	public Object getObject(String path) {
+		return getObject(path, null);
+	}
+	
+	public Object getObject(String[] path) {
+		Object value = values;
+		for (String section : path) {
+			if (!(value instanceof Map)) {
+				return null;
+			}
+			value = getIgnoreCase((Map<Object, Object>) value, section);
+		}
+		return value;
+	}
+
+	/**
+	 * Returns value from map without case sensitivity of the key. Returns
+	 * {@code null} if no such key is found.
+	 * 
+	 * @param	map
+	 * 			map to get value from
+	 * @param	key
+	 * 			case insensitive key name
+	 * @return	map value from case insensitive key
+	 */
+	private Object getIgnoreCase(Map<Object, Object> map, String key) {
+		for (Entry<Object, Object> entry : map.entrySet()) {
+			if (entry.getKey().toString().equalsIgnoreCase(key)) return entry.getValue();
+		}
+		return map.get(key);
+	}
+
+	/**
+	 * Returns config option with specified path as {@code String}. Returns {@code null} if
+	 * option is not present.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @return	value from file or null if not present
+	 */
+	public String getString(String path) {
+		return getString(path, null);
+	}
+
+	/**
+	 * Returns config option with specified path as {@code String}. If the option is not present 
+	 * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called 
+	 * and {@code defaultValue} returned.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	defaultValue
+	 * 			Value to be inserted and returned if option is not present
+	 * @return	value from configuration file as {@code String}
+	 */
+	public String getString(String path, String defaultValue) {
+		Object value = getObject(path, defaultValue);
+		if (value == null) return defaultValue;
+		return String.valueOf(value);
+	}
+
+	/**
+	 * Returns config option with specified path as {@code List<String>}. Returns {@code null} if
+	 * option is not present.
+	 * 
+	 * @param	path
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @return	value from file or null if not present
+	 */
+	public List<String> getStringList(String path) {
+		return getStringList(path, null);
+	}
+
+	/**
+	 * Returns config option with specified path as {@code List<String>}. If the option is not present 
+	 * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called 
+	 * and {@code defaultValue} returned.
+	 * 
+	 * @param	path	
+	 * 			Path of the option with sections separated with "{@code .}"
+	 * @param	defaultValue
+	 * 			Value to be inserted and returned if option is not present
+	 * @return	value from configuration file as {@code List<String>}
+	 */
+	public List<String> getStringList(String path, List<String> defaultValue) {
+		Object value = getObject(path, defaultValue);
+		if (value == null) return defaultValue;
+		if (!(value instanceof List)) {
+			return new ArrayList<>();
+		}
+		List<String> fixedList = new ArrayList<>();
+		for (Object key : (List<Object>)value) {
+			fixedList.add(key.toString());
+		}
+		return fixedList;
+	}
+
+	/**
+	 * Returns config option with specified path as {@code Integer}. Returns {@code null} if
+	 * option is not present.
+	 * 
+	 * @param	path
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @return	value from file or null if not present
+	 */
+	public Integer getInt(String path) {
+		return getInt(path, null);
+	}
+
+	/**
+	 * Returns config option with specified path as {@code Integer}. If the option is not present 
+	 * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called 
+	 * and {@code defaultValue} returned.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	defaultValue
+	 * 			Value to be inserted and returned if option is not present
+	 * @return	value from configuration file as {@code Integer}
+	 */
+	public Integer getInt(String path, Integer defaultValue) {
+		Object value = getObject(path, defaultValue);
+		if (value == null) return defaultValue;
+		try{
+			return Integer.parseInt(value.toString());
+		} catch (NumberFormatException e) {
+			return defaultValue;
+		}
+	}
+
+	/**
+	 * Returns config option with specified path as {@code Boolean}. If the option is not present 
+	 * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called 
+	 * and {@code defaultValue} returned.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	defaultValue
+	 * 			Value to be inserted and returned if option is not present
+	 * @return	value from configuration file as {@code Boolean}
+	 */
+	public boolean getBoolean(String path, boolean defaultValue) {
+		Object value = getObject(path, defaultValue);
+		if (value == null) return defaultValue;
+		return Boolean.parseBoolean(value.toString());
+	}
+
+	/**
+	 * Returns config option with specified path as {@code Double}. If the option is not present 
+	 * and {@code defaultValue} is not {@code null}, value is inserted, {@link #save()} called 
+	 * and {@code defaultValue} returned.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	defaultValue
+	 * 			Value to be inserted and returned if option is not present
+	 * @return	value from configuration file as {@code Double}
+	 */
+	public Double getDouble(String path, double defaultValue) {
+		Object value = getObject(path, defaultValue);
+		if (value == null) return defaultValue;
+		try {
+			return Double.parseDouble(value.toString());
+		} catch (NumberFormatException e) {
+			return defaultValue;
+		}
+	}
+
+	/**
+	 * Returns config option with specified path as {@code Map<K, V>}. If the option 
+	 * is not present or value is not a {@code Map}, new empty {@code Map} is returned.
+	 * 
+	 * @param	path	
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @return	value from configuration file as {@code Map<K, V>}
+	 */
+	public <K, V> Map<K, V> getConfigurationSection(String path) {
+		if (path == null || path.length() == 0) return (Map<K, V>) values;
+		Object value = getObject(path, null);
+		if (value == null) return new LinkedHashMap<>();
+		if (value instanceof Map) {
+			return (Map<K, V>) value;
+		} else {
+			return new LinkedHashMap<>();
+		}
+	}
+
+	/**
+	 * Returns {@code true} if the file has option with specified path, {@code false}
+	 * if not.
+	 * 
+	 * @param	path
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @return	{@code true} if present, {@code false} if not
+	 */
+	public boolean hasConfigOption(String path) {
+		return getObject(path) != null;
+	}
+
+	/**
+	 * Sets value to the specified path and saves the file to disk by calling {@link #save()}.
+	 * 
+	 * @param	path
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	value
+	 * 			Value to save
+	 */
+	public void set(String path, Object value) {
+		set(values, path, value);
+		save();
+	}
+
+	/**
+	 * Sets value to the specified map with specified path and value. This is an internal method
+	 * that correctly creates maps to separate sections using "{@code .}".
+	 * 
+	 * @param	map
+	 * 			Map to insert value to
+	 * @param	path
+	 * 			Path to the option with sections separated with "{@code .}"
+	 * @param	value
+	 * 			Value to save
+	 * @return	the first argument to allow chaining
+	 */
+	private Map<String, Object> set(Map<String, Object> map, String path, Object value) {
+		if (path.contains(".")) {
+			String keyWord = getRealKey(map, path.split("\\.")[0]);
+			Object submap = map.get(keyWord);
+			if (!(submap instanceof Map)) {
+				submap = new LinkedHashMap<>();
+			}
+			map.put(keyWord, set((Map<String, Object>) submap, path.substring(keyWord.length()+1, path.length()), value));
+		} else {
+			if (value == null) {
+				map.remove(getRealKey(map, path));
+			} else {
+				map.put(path, value);
+			}
+		}
+		return map;
+	}
+
+	/**
+	 * Returns the real key name without case sensitivity from map. If not found, inserted key
+	 * is returned.
+	 * 
+	 * @param	map
+	 * 			Map to check keys of
+	 * @param	key
+	 * 			Key to find
+	 * @return	The real key name
+	 */
+	private String getRealKey(Map<?, ?> map, String key) {
+		for (Object mapkey : map.keySet()) {
+			if (mapkey.toString().equalsIgnoreCase(key)) return mapkey.toString();
+		}
+		return key;
+	}
+
+	/**
+	 * Detects header of a file (first lines of file starting with #).
+	 * 
+	 * @return	list of comment lines on top
+	 * @throws	IOException
+	 * 			if I/O operation fails
+	 */
+	private List<String> detectHeader() throws IOException {
+		header = new ArrayList<>();
+		for (String line : Files.readAllLines(file.toPath())) {
+			if (line.startsWith("#")) {
+				header.add(line);
+			} else {
+				break;
+			}
+		}
+		return header;
+	}
+
+	/**
+	 * Inserts header back into file. This is required after calling {@link #save()}, because
+	 * it destroys the header.
+	 * 
+	 * @throws	IOException
+	 * 			if I/O operation fails
+	 */
+	public void fixHeader() throws IOException {
+		if (header == null) return;
+		List<String> content = new ArrayList<>(header);
+		content.addAll(Files.readAllLines(file.toPath()));
+		Files.delete(file.toPath());
+		if (file.createNewFile()) {
+			Files.write(file.toPath(), content);
+		}
+	}
+
+	public File getFile() {
+		return file;
+	}
+}

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

@@ -0,0 +1,92 @@
+package me.neznamy.tab.api.config;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.error.YAMLException;
+
+import me.neznamy.tab.api.TabAPI;
+import me.neznamy.yamlassist.YamlAssist;
+
+/**
+ * YAML implementation of ConfigurationFile
+ */
+public class YamlConfigurationFile extends ConfigurationFile {
+
+	/** SnakeYAML instance */
+	private static final Yaml yaml;
+	
+	/**
+	 * Initializes SnakeYAML instance with BLOCK flowstyle dumper option
+	 */
+	static {
+		DumperOptions options = new DumperOptions();
+		options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+		yaml = new Yaml(options);
+	}
+
+	/**
+	 * Constructs new instance and attempts to load specified configuration file.
+	 * If file does not exist, default file is copied from {@code source}.
+	 * 
+	 * @param	source
+	 * 			Source to copy file from if it does not exist
+	 * @param	destination
+	 * 			File destination to use
+	 * @throws	IllegalArgumentException
+	 * 			if {@code destination} is null
+	 * @throws	IllegalStateException
+	 * 			if file does not exist and source is null
+	 * @throws	YAMLException
+	 * 			if file has invalid YAML syntax
+	 * @throws	IOException
+	 * 			if I/O operation with the file unexpectedly fails
+	 */
+	@SuppressWarnings("unchecked")
+	public YamlConfigurationFile(InputStream source, File destination) throws YAMLException, IOException {
+		super(source, destination);
+		FileInputStream input = null;
+		try {
+			input = new FileInputStream(file);
+			values = (Map<String, Object>) yaml.load(input);
+			if (values == null) values = new LinkedHashMap<>();
+			input.close();
+		} catch (YAMLException e) {
+			if (input != null) input.close();
+			TabAPI tab = TabAPI.getInstance();
+			tab.sendConsoleMessage("&c[TAB] File " + destination + " has broken syntax.", true);
+			tab.sendConsoleMessage("&6[TAB] Error message from yaml parser: " + e.getMessage(), true);
+			List<String> suggestions = YamlAssist.getSuggestions(file);
+			if (!suggestions.isEmpty()) {
+				tab.sendConsoleMessage("&d[TAB] Suggestions to fix yaml syntax:", true);
+				for (String suggestion : suggestions) {
+					tab.sendConsoleMessage("&d[TAB] - " + suggestion, true);
+				}
+			}
+			throw e;
+		}
+	}
+
+	@Override
+	public void save() {
+		try {
+			Writer writer = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8);
+			yaml.dump(values, writer);
+			writer.close();
+			fixHeader();
+		} catch (IOException e) {
+			TabAPI.getInstance().sendConsoleMessage("&c[TAB] Failed to save yaml file " + file.getPath() + " with content " + values.toString(), true);
+		}
+	}
+}

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

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

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

@@ -0,0 +1,44 @@
+package me.neznamy.tab.api.placeholder;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import me.neznamy.tab.api.TabFeature;
+import me.neznamy.tab.api.TabPlayer;
+
+public interface PlaceholderManager {
+
+	/**
+	 * Registers a server placeholder (placeholder with same output for all players)
+	 */
+	public ServerPlaceholder registerServerPlaceholder(String identifier, int refresh, Supplier<Object> supplier);
+	
+	/**
+	 * Registers a player placeholder (placeholder with player-specific output)
+	 */
+	public PlayerPlaceholder registerPlayerPlaceholder(String identifier, int refresh, Function<TabPlayer, Object> function);
+
+	/**
+	 * Registers a relational placeholder (different output for each player pair)
+	 */
+	public RelationalPlaceholder registerRelationalPlaceholder(String identifier, int refresh, BiFunction<TabPlayer, TabPlayer, Object> function);
+	
+	/**
+	 * Detects placeholders in text using %% pattern and returns list of all detected identifiers
+	 * @param text - text to detect placeholders in
+	 * @return list of detected identifiers
+	 */
+	public List<String> detectPlaceholders(String text);
+
+	/**
+	 * Adds placeholder to list of used placeholders and assigns this feature as using it,
+	 * which will then receive refresh() if values changes
+	 * @param identifier - placeholder identifier
+	 * @param feature - feature using the placeholder
+	 */
+	public void addUsedPlaceholder(String identifier, TabFeature feature);
+	
+	public String findReplacement(String placeholder, String output);
+}

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

@@ -0,0 +1,10 @@
+package me.neznamy.tab.api.placeholder;
+
+import me.neznamy.tab.api.TabPlayer;
+
+public interface PlayerPlaceholder extends Placeholder {
+
+	public void updateValue(TabPlayer player, Object value);
+	
+	public Object request(TabPlayer p);
+}

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

@@ -0,0 +1,10 @@
+package me.neznamy.tab.api.placeholder;
+
+import me.neznamy.tab.api.TabPlayer;
+
+public interface RelationalPlaceholder extends Placeholder {
+
+	public void updateValue(TabPlayer viewer, TabPlayer target, Object value);
+	
+	public Object request(TabPlayer viewer, TabPlayer target);
+}

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

@@ -0,0 +1,8 @@
+package me.neznamy.tab.api.placeholder;
+
+public interface ServerPlaceholder extends Placeholder {
+
+	public void updateValue(Object value);
+	
+	public Object request();
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+package me.neznamy.tab.api.scoreboard;
+
+/**
+ * An interface allowing to work with a line of
+ * text in scoreboard.
+ *
+ */
+public interface Line {
+
+	/**
+	 * Returns configured raw text of this line. Placeholders
+	 * remain unparsed.
+	 * 
+	 * @return	raw text of this line
+	 */
+	public 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
+	 */
+	public void setText(String text);
+}

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

@@ -0,0 +1,89 @@
+package me.neznamy.tab.api.scoreboard;
+
+import java.util.List;
+
+/**
+ * An interface allowing to work with scoreboard, such as adding plyaers,
+ * 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
+	 */
+	public String getName();
+
+	/**
+	 * Returns raw title of this scoreboard. Placeholders stay in their
+	 * raw, unparsed format.
+	 * 
+	 * @return	scoreboard title
+	 * @see		#setTitle(String)
+	 */
+	public 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 <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()
+	 */
+	public void setTitle(String title);
+
+	/**
+	 * Returns list of lines in this scoreboard in the order they appear
+	 * in game (first line is on top). This list should only be used for reading,
+	 * for adding/removing lines see {@link #addLine(String)} and {@link #removeLine(int)}.
+	 * 
+	 * @return	list of lines in this scoreboard
+	 * @see		#addLine(String)
+	 * @see		#removeLine(int)
+	 */
+	public 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)
+	 */
+	public void addLine(String text);
+
+	/**
+	 * Removes line with specified index. Index starts at {@code 0} and ends at 
+	 * {@link #getLines()}.size()-1.
+	 * 
+	 * @param	index
+	 * 			Index of line to remove, starting at 0
+	 * @throws	IndexOutOfBoundsException
+	 * 			if the index is out of range (index < 0 || index >= {@link #getLines()}.size())
+	 * @see		#getLines()
+	 * @see		#addLine(String)
+	 */
+	public void removeLine(int index);
+
+	/**
+	 * Unregisters this scoreboard from all players who can see it.
+	 * Calling this method is equal to iterating over {@link #getPlayers()}
+	 * and calling {@link #removePlayer(TabPlayer)} on each player.
+	 */
+	public void unregister();
+}

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

@@ -0,0 +1,155 @@
+package me.neznamy.tab.api.scoreboard;
+
+import java.util.List;
+import java.util.Map;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Interface allowing work with scoreboards, such as creating,
+ * sending, toggling and modifying.
+ * <p>
+ * Instance can be obtained using {@link me.neznamy.tab.api.TabAPI#getScoreboardManager()}.
+ * This requires the scoreboard feature to be enabled in config,
+ * the method will return null otherwise.
+ */
+public interface ScoreboardManager {
+
+	/**
+	 * Creates new scoreboard, registers and returns it. {@code name}
+	 * is internal name of the scoreboard, which it will be registered
+	 * with and further work where scoreboard name is used allowed.
+	 * <p>
+	 * Scoreboard {@code title} is limited to 32 characters on <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.
+	 * Placholders 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}
+	 */
+	public Scoreboard createScoreboard(String name, String title, List<String> lines);
+	
+	/**
+	 * Returns map of registered scoreboards via config and API.
+	 * Map key is name of scoreboard, which is defined either in config
+	 * or using {@link #createScoreboard(String, String, List)}.
+	 * Map value is reference to the actual scoreboard.
+	 * 
+	 * @return	map of registered scoreboards
+	 */
+	public 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)
+	 */
+	public void showScoreboard(TabPlayer player, Scoreboard scoreboard);
+	
+	/**
+	 * Returns {@code true} if player has custom scoreboard set using
+	 * {@link #showScoreboard(TabPlayer, Scoreboard)}, {@code false} if not.
+	 * 
+	 * @param	player
+	 * 			Player to check
+	 * @return	{@code true} if player has custom scoreboard set using API, 
+	 * 			{@code false} if not
+	 * @see		#showScoreboard(TabPlayer, Scoreboard)
+	 * @see		#resetScoreboard(TabPlayer)
+	 */
+	public boolean hasCustomScoreboard(TabPlayer player);
+	
+	/**
+	 * Hides custom scoreboard sent using {@link #showScoreboard(TabPlayer, Scoreboard)}
+	 * and re-enables internal display logic with conditions. If player does not
+	 * have any forced scoreboard, nothing happens.
+	 * 
+	 * @param	player
+	 * 			Player to hide custom scoreboard from
+	 * @see		#showScoreboard(TabPlayer, Scoreboard)
+	 * @see		#hasCustomScoreboard(TabPlayer)
+	 */
+	public void resetScoreboard(TabPlayer player);
+	
+	/**
+	 * Returns {@code true} if player has scoreboard enabled, {@code false} 
+	 * if disabled (toggled) using either toggle command, 
+	 * {@link #toggleScoreboard(TabPlayer, boolean)} or
+	 * {@link #setScoreboardVisible(TabPlayer, boolean, boolean)}.
+	 * 
+	 * @param	player
+	 * 			Player to get visibility status of
+	 * @return	{@code true} if visible, {@code false} if disabled
+	 * @see		#setScoreboardVisible(TabPlayer, boolean, boolean)
+	 * @see		#toggleScoreboard(TabPlayer, boolean)
+	 */
+	public boolean hasScoreboardVisible(TabPlayer player);
+	
+	/**
+	 * Sets scoreboard visibility of player to defined value. If visibility status
+	 * is same as player had before, nothing happens. If this call changes
+	 * visibility, scoreboard is toggled. If {@code sendToggleMessage} is {@code true},
+	 * toggle message defined in configuration is sent.
+	 * 
+	 * @param	player
+	 * 			Player to set visibility for
+	 * @param	visible
+	 * 			New visibility status
+	 * @param	sendToggleMessage
+	 * 			whether to send toggle message if status changed or not
+	 * @see		#toggleScoreboard(TabPlayer, boolean)
+	 * @see		#hasScoreboardVisible(TabPlayer)
+	 */
+	public void setScoreboardVisible(TabPlayer player, boolean visible, boolean sendToggleMessage);
+	
+	/**
+	 * Toggles scoreboard for specified player. If player had scoreboard visible,
+	 * hides it. If hidden, shows it. If {@code sendToggleMessage} is {@code true},
+	 * toggle message defined in configuration is sent.
+	 * 
+	 * @param	player
+	 * 			Player to toggle scoreboard for
+	 * @param	sendToggleMessage
+	 * 			Whether to send toggle message or not
+	 * @see		#hasScoreboardVisible(TabPlayer)
+	 * @see		#setScoreboardVisible(TabPlayer, boolean, boolean)
+	 */
+	public void toggleScoreboard(TabPlayer player, boolean sendToggleMessage);
+	
+	/**
+	 * Temporarily displays scoreboard to all players for specified amount of 
+	 * time (in milliseconds). Scoreboard name is either defined in config, or 
+	 * through API in {@link #createScoreboard(String, String, List)}.
+	 * 
+	 * @param	scoreboard
+	 * 			Scoreboard from config or registered via API
+	 * @param	duration
+	 * 			Duration in milliseconds
+	 * @throws	IllegalArgumentException
+	 * 			if no scoreboard was found with such name or {@code duration}
+	 * 			is < 0.
+	 */
+	public void announceScoreboard(String scoreboard, int duration);
+}

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

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

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

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

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

@@ -0,0 +1,113 @@
+package me.neznamy.tab.api.team;
+
+import me.neznamy.tab.api.TabPlayer;
+
+public interface TeamManager {
+
+	/**
+	 * Makes player's nametag globally invisible
+	 * @see showNametag 
+	 * @see hasHiddenNametag
+	 */
+	public void hideNametag(TabPlayer player);
+
+	/**
+	 * Hides player's nametag for specified player until it's shown again
+	 * @param viewer - player to hide nametag for
+	 */
+	public void hideNametag(TabPlayer player, TabPlayer viewer);
+
+	/**
+	 * Makes player's nametag visible again
+	 * @see hideNametag
+	 * @see hasHiddenNametag
+	 */
+	public void showNametag(TabPlayer player);
+
+	/**
+	 * Shows player's nametag for specified viewer if it was hidden before
+	 * @param viewer - player to show nametag back for
+	 */
+	public void showNametag(TabPlayer player, TabPlayer viewer);
+
+	/**
+	 * Return whether player has hidden nametag or not
+	 * @return Whether player has hidden nametag or not
+	 * @see hideNametag
+	 * @see showNametag
+	 */
+	public boolean hasHiddenNametag(TabPlayer player);
+
+	/**
+	 * Returns true if nametag is hidden for specified viewer, false if not
+	 * @param viewer - player to check visibility status for
+	 * @return true if hidden, false if not
+	 */
+	public boolean hasHiddenNametag(TabPlayer player, TabPlayer viewer);
+	
+	/**
+	 * Unregisters player's team and no longer handles it, as well as disables anti-override for teams.
+	 * This can be resumed using resumeTeamHandling(). If team handling was paused already, nothing happens.
+	 */
+	public void pauseTeamHandling(TabPlayer player);
+
+	/**
+	 * Resumes team handling if it was before paused using pauseTeamHandling(), if not, nothing happens
+	 */
+	public void resumeTeamHandling(TabPlayer player);
+
+	/**
+	 * Returns true if team handling is paused for this player using pauseTeamHandling(), false if not or 
+	 * it was resumed already using resumeTeamHandling
+	 * @return true if paused, false if not
+	 */
+	public boolean hasTeamHandlingPaused(TabPlayer player);
+	
+	/**
+	 * Forces new team name for the player until this method is called again with null argument and 
+	 * performs all actions to change player's team name
+	 * @param teamName - forced team name
+	 */
+	public void forceTeamName(TabPlayer player, String teamName);
+
+	/**
+	 * Returns forced team name of player or null if not forced
+	 * @return forced team name of player or null if not forced
+	 */
+	public String getForcedTeamName(TabPlayer player);
+	
+
+	/**
+	 * Forces collision rule for the player. Setting it to null will remove forced value
+	 * @param collision - forced collision rule
+	 */
+	public void setCollisionRule(TabPlayer player, Boolean collision);
+
+	/**
+	 * Returns forced collision rule or null if collision is not forced using setCollisionRule
+	 * @return forced value or null if not forced
+	 */
+	public Boolean getCollisionRule(TabPlayer player);
+	
+	/**
+	 * Sends update team properties packet of player's team to everyone
+	 * @param player - player to update team data of
+	 */
+	public void updateTeamData(TabPlayer player);
+	
+	public void setPrefix(TabPlayer player, String prefix);
+	
+	public void setSuffix(TabPlayer player, String suffix);
+	
+	public void resetPrefix(TabPlayer player);
+	
+	public void resetSuffix(TabPlayer player);
+	
+	public String getCustomPrefix(TabPlayer player);
+	
+	public String getCustomSuffix(TabPlayer player);
+	
+	public String getOriginalPrefix(TabPlayer player);
+	
+	public String getOriginalSuffix(TabPlayer player);
+}

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

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

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

@@ -0,0 +1,18 @@
+package me.neznamy.tab.api.util;
+
+/**
+ * An interface for BiFunction which can throw an exception.
+ * Used in {@link me.neznamy.tab.api.protocol.PacketBuilder} to 
+ * call build method for packet classes, which may throw an
+ * exception due to reflection.
+ * @param	<A>
+ * 			First function argument
+ * @param	<B>
+ * 			Second function argument
+ * @param	<C>
+ * 			Function return type
+ */
+public interface BiFunctionWithException<A, B, C> {
+
+	C apply(A a, B b) throws ReflectiveOperationException;
+}

build-logic/build.gradle.kts

@@ -0,0 +1,12 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+    mavenCentral()
+}
+
+dependencies {
+    implementation("gradle.plugin.com.github.johnrengelman", "shadow", "7.1.0")
+}

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

@@ -0,0 +1,30 @@
+import org.apache.tools.ant.filters.ReplaceTokens
+
+plugins {
+    `java-library`
+}
+
+tasks {
+    processResources {
+        filter<ReplaceTokens>("tokens" to mapOf(
+            "name" to rootProject.name,
+            "version" to project.version,
+            "description" to project.description
+        ))
+    }
+    javadoc {
+        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))
+    }
+}

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

@@ -0,0 +1,12 @@
+plugins {
+    id("tab.base-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")
+    }
+}

build-logic/src/main/kotlin/tab.publishing.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+    id("tab.base-conventions")
+    `maven-publish`
+}
+
+java {
+    withSourcesJar()
+    withJavadocJar()
+}
+
+publishing {
+    publications.create<MavenPublication>("mavenJava") {
+        groupId = rootProject.group as String
+        artifactId = project.name
+        version = rootProject.version as String
+        from(components["java"])
+    }
+}

build.gradle.kts

@@ -0,0 +1,23 @@
+plugins {
+    id("tab.parent")
+}
+
+allprojects {
+    group = "me.neznamy"
+    version = property("projectVersion") as String // from gradle.properties
+    description = "An all-in-one solution that works"
+}
+
+val platforms = setOf(
+    projects.bukkit,
+    projects.bungeecord,
+    projects.krypton,
+    projects.velocity
+).map { it.dependencyProject }
+
+subprojects {
+    when (this) {
+        in platforms -> plugins.apply("tab.platform-conventions")
+        else -> plugins.apply("tab.base-conventions")
+    }
+}

bukkit/build.gradle.kts

@@ -0,0 +1,11 @@
+dependencies {
+    implementation(projects.shared)
+    implementation(libs.bstats.bukkit)
+    compileOnly(libs.bukkit)
+    compileOnly(libs.placeholderapi)
+    compileOnly(libs.vault)
+    compileOnly(libs.via)
+    compileOnly(libs.authlib)
+    compileOnly(libs.libsDisguises)
+    compileOnly(libs.essentials)
+}

bukkit/pom.xml

@@ -1,150 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<parent>
-		<groupId>me.neznamy</groupId>
-		<artifactId>TAB</artifactId>
-		<version>2.9.2-pre2</version>
-	</parent>
-	<artifactId>bukkit</artifactId>
-
-	<repositories>
-
-		<!-- Spigot API -->
-		<repository>
-			<id>spigot-repo</id>
-			<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-		</repository>
-
-		<!-- PlaceholderAPI -->
-		<repository>
-			<id>placeholderapi</id>
-			<url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
-		</repository>
-
-		<!-- Vault -->
-		<repository>
-			<id>jitpack.io</id>
-			<url>https://jitpack.io</url>
-		</repository>
-
-		<!-- ViaVersion -->
-		<repository>
-			<id>viaversion</id>
-			<url>https://repo.viaversion.com/</url>
-		</repository>
-
-		<repository>
-			<id>aikar</id>
-			<url>https://repo.aikar.co/content/groups/aikar/</url>
-		</repository>
-	</repositories>
-
-	<dependencies>
-
-		<!-- TAB Core -->
-		<dependency>
-			<groupId>me.neznamy</groupId>
-			<artifactId>shared</artifactId>
-			<version>${project.version}</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>com.github.NEZNAMY</groupId>
-					<artifactId>YamlAssist</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.googlecode.json-simple</groupId>
-					<artifactId>json-simple</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Spigot API -->
-		<dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot-api</artifactId>
-			<version>1.17-R0.1-SNAPSHOT</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-lang</groupId>
-					<artifactId>commons-lang</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>net.md-5</groupId>
-					<artifactId>bungeecord-chat</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.code.gson</groupId>
-					<artifactId>gson</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.yaml</groupId>
-					<artifactId>snakeyaml</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- PlaceholderAPI -->
-		<dependency>
-			<groupId>me.clip</groupId>
-			<artifactId>placeholderapi</artifactId>
-			<version>2.10.9</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>org.jetbrains</groupId>
-					<artifactId>annotations</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Vault -->
-		<dependency>
-			<groupId>com.github.MilkBowl</groupId>
-			<artifactId>VaultAPI</artifactId>
-			<version>1.7</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-lang</groupId>
-					<artifactId>commons-lang</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>com.google.code.gson</groupId>
-					<artifactId>gson</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.bukkit</groupId>
-					<artifactId>bukkit</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- ViaVersion -->
-		<dependency>
-			<groupId>com.viaversion</groupId>
-			<artifactId>viaversion-api</artifactId>
-			<version>4.0.0</version>
-			<scope>provided</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>com.mojang</groupId>
-			<artifactId>authlib</artifactId>
-			<version>1.11</version>
-			<scope>provided</scope>
-		</dependency>
-		
-		
-		<!-- Bukkit Metrics -->
-		<dependency>
-			<groupId>org.bstats</groupId>
-			<artifactId>bstats-bukkit</artifactId>
-			<version>2.2.1</version>
-			<scope>compile</scope>
-		</dependency>
-	</dependencies>
-</project>

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/BukkitEventListener.java

@@ -15,6 +15,12 @@ import me.neznamy.tab.shared.TAB;
  */
 public class BukkitEventListener implements Listener {
 
+	private final Main main;
+	
+	public BukkitEventListener(Main main) {
+		this.main = main;
+	}
+	
 	/**
 	 * Listener to PlayerQuitEvent to remove player data and forward the event to features
 	 * @param e quit event
@@ -32,22 +38,7 @@ public class BukkitEventListener implements Listener {
 	@EventHandler(priority = EventPriority.LOWEST)
 	public void onJoin(PlayerJoinEvent e) {
 		if (TAB.getInstance().isDisabled()) return;
-		TAB.getInstance().getCPUManager().runTask("processing PlayerJoinEvent", () -> {
-			try {
-				int i = 0;
-				int version;
-				while ((version = Main.getProtocolVersion(e.getPlayer())) == -1 && ++i < 100) {
-					Thread.sleep(2);
-				}
-				if (!e.getPlayer().isOnline()) return;
-				if (i == 50) {
-					TAB.getInstance().getErrorManager().printError("Failed to get protocol version of " + e.getPlayer().getName() + " after 50 retries");
-				}
-				TAB.getInstance().getFeatureManager().onJoin(new BukkitTabPlayer(e.getPlayer(), version));
-			} catch (InterruptedException pluginDisabled) {
-				Thread.currentThread().interrupt();
-			}
-		});
+		TAB.getInstance().getCPUManager().runTask("processing PlayerJoinEvent", () -> TAB.getInstance().getFeatureManager().onJoin(new BukkitTabPlayer(e.getPlayer(), main.getProtocolVersion(e.getPlayer()))));
 	}
 
 	/**

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/BukkitPipelineInjector.java

@@ -2,60 +2,31 @@ 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.TabFeature;
 import me.neznamy.tab.api.TabPlayer;
 import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import me.neznamy.tab.shared.TabConstants;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
+import me.neznamy.tab.shared.features.NickCompatibility;
 import me.neznamy.tab.shared.features.PipelineInjector;
 
 public class BukkitPipelineInjector extends PipelineInjector {
 
-	//handler to inject before
-	private static final String INJECT_POSITION = "packet_handler";
-	
 	//nms storage
-	private NMSStorage nms;
+	private final NMSStorage nms = NMSStorage.getInstance();
 
 	/**
-	 * Constructs new instance with given parameters
-	 * @param tab - tab instance
-	 * @param nms - nms storage
+	 * Constructs new instance
 	 */
-	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
-		}
+	public BukkitPipelineInjector(){
+		super("packet_handler");
+		channelFunction = BukkitChannelDuplexHandler::new;
 	}
 
-	@Override
-	public void uninject(TabPlayer player) {
-		try {
-			if (player.getChannel().pipeline().names().contains(DECODER_NAME)) player.getChannel().pipeline().remove(DECODER_NAME);
-		} catch (NoSuchElementException e) {
-			//for whatever reason this rarely throws
-			//java.util.NoSuchElementException: TABReader
-		}
-	}
-	
 	/**
 	 * Custom channel duplex handler override
 	 */
@@ -75,70 +46,82 @@ public class BukkitPipelineInjector extends PipelineInjector {
 		@Override
 		public void channelRead(ChannelHandlerContext context, Object packet) {
 			try {
-				Object modifiedPacket = tab.getFeatureManager().onPacketReceive(player, packet);
-				if (modifiedPacket != null) super.channelRead(context, modifiedPacket);
+				if (TAB.getInstance().getFeatureManager().onPacketReceive(player, packet)) return;
+				super.channelRead(context, packet);
 			} catch (Exception e){
-				tab.getErrorManager().printError("An error occurred when reading packets", e);
+				TAB.getInstance().getErrorManager().printError("An error occurred when reading packets", e);
 			}
 		}
 
 		@Override
 		public void write(ChannelHandlerContext context, Object packet, ChannelPromise channelPromise) {
 			try {
-				if (nms.getClass("PacketPlayOutPlayerInfo").isInstance(packet)) {
-					super.write(context, tab.getFeatureManager().onPacketPlayOutPlayerInfo(player, packet), channelPromise);
+				if (nms.PacketPlayOutPlayerInfo.isInstance(packet)) {
+					super.write(context, TAB.getInstance().getFeatureManager().onPacketPlayOutPlayerInfo(player, packet), channelPromise);
 					return;
 				}
-				if (tab.getFeatureManager().getNameTagFeature() != null && antiOverrideTeams && nms.getClass("PacketPlayOutScoreboardTeam").isInstance(packet)) {
+				if (antiOverrideTeams && nms.PacketPlayOutScoreboardTeam != null && nms.PacketPlayOutScoreboardTeam.isInstance(packet)) {
 					modifyPlayers(packet);
 					super.write(context, packet, channelPromise);
 					return;
 				}
-				if (nms.getClass("PacketPlayOutScoreboardDisplayObjective").isInstance(packet) && antiOverrideObjectives && tab.getFeatureManager().onDisplayObjective(player, packet)) {
+				if (nms.PacketPlayOutScoreboardDisplayObjective.isInstance(packet) && TAB.getInstance().getFeatureManager().onDisplayObjective(player, packet)) {
 					return;
 				}
-				if (antiOverrideObjectives && nms.getClass("PacketPlayOutScoreboardObjective").isInstance(packet)) {
-					tab.getFeatureManager().onObjective(player, packet);
+				if (nms.PacketPlayOutScoreboardObjective.isInstance(packet)) {
+					TAB.getInstance().getFeatureManager().onObjective(player, packet);
 				}
-				tab.getFeatureManager().onPacketSend(player, packet);
+				TAB.getInstance().getFeatureManager().onPacketSend(player, packet);
 			} catch (Exception e){
-				tab.getErrorManager().printError("An error occurred when reading packets", e);
+				TAB.getInstance().getErrorManager().printError("An error occurred when reading packets", e);
 			}
 			try {
 				super.write(context, packet, channelPromise);
 			} catch (Exception e) {
-				tab.getErrorManager().printError("Failed to forward packet " + packet.getClass().getSimpleName() + " to " + player.getName(), e);
+				TAB.getInstance().getErrorManager().printError("Failed to forward packet " + packet.getClass().getSimpleName() + " to " + player.getName(), e);
 			}
 		}
 		
 		/**
 		 * Removes all real players from team if packet does not come from TAB and reports this to override log
 		 * @param packetPlayOutScoreboardTeam - team packet
-		 * @throws IllegalAccessException 
+		 * @throws ReflectiveOperationException 
 		 */
 		@SuppressWarnings("unchecked")
-		private void modifyPlayers(Object packetPlayOutScoreboardTeam) throws IllegalAccessException {
+		private void modifyPlayers(Object packetPlayOutScoreboardTeam) throws ReflectiveOperationException {
 			long time = System.nanoTime();
-			Collection<String> players = (Collection<String>) nms.getField("PacketPlayOutScoreboardTeam_PLAYERS").get(packetPlayOutScoreboardTeam);
-			String teamName = (String) nms.getField("PacketPlayOutScoreboardTeam_NAME").get(packetPlayOutScoreboardTeam);
+			Collection<String> players = (Collection<String>) nms.PacketPlayOutScoreboardTeam_PLAYERS.get(packetPlayOutScoreboardTeam);
+			String teamName = (String) nms.PacketPlayOutScoreboardTeam_NAME.get(packetPlayOutScoreboardTeam);
 			if (players == null) return;
 			//creating a new list to prevent NoSuchFieldException in minecraft packet encoder when a player is removed
 			Collection<String> newList = new ArrayList<>();
 			for (String entry : players) {
-				TabPlayer p = tab.getPlayer(entry);
+				TabPlayer p = getPlayer(entry);
 				if (p == null) {
 					newList.add(entry);
 					continue;
 				}
-				if (!tab.getFeatureManager().getNameTagFeature().getPlayersInDisabledWorlds().contains(p) && !p.hasTeamHandlingPaused() && 
-						!p.getTeamName().equals(teamName)) {
-					logTeamOverride(teamName, entry);
+				if (!((TabFeature)TAB.getInstance().getTeamManager()).isDisabledPlayer(p) && 
+						!TAB.getInstance().getTeamManager().hasTeamHandlingPaused(p) && !teamName.equals(p.getTeamName())) {
+					logTeamOverride(teamName, p.getName(), p.getTeamName());
 				} else {
 					newList.add(entry);
 				}
 			}
-			nms.setField(packetPlayOutScoreboardTeam, "PacketPlayOutScoreboardTeam_PLAYERS", newList);
-			tab.getCPUManager().addTime(TabFeature.NAMETAGS, UsageType.ANTI_OVERRIDE, System.nanoTime()-time);
+			nms.setField(packetPlayOutScoreboardTeam, nms.PacketPlayOutScoreboardTeam_PLAYERS, newList);
+			TAB.getInstance().getCPUManager().addTime("Nametags", TabConstants.CpuUsageCategory.ANTI_OVERRIDE, System.nanoTime()-time);
+		}
+		
+		private TabPlayer getPlayer(String name) {
+			for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+				if (getName(p).equals(name)) return p;
+			}
+			return null;
+		}
+
+		
+		private String getName(TabPlayer p) {
+			return ((NickCompatibility) TAB.getInstance().getFeatureManager().getFeature("nick")).getNickname(p);
 		}
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/BukkitPlaceholderRegistry.java

@@ -1,30 +1,32 @@
 package me.neznamy.tab.platforms.bukkit;
 
-import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+import java.math.RoundingMode;
 import java.text.DecimalFormat;
 import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Locale;
-import java.util.UUID;
 
 import org.bukkit.Bukkit;
-import org.bukkit.Statistic;
 import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityRegainHealthEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.java.JavaPlugin;
+
+import com.earth2me.essentials.Essentials;
 
 import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import me.neznamy.tab.api.placeholder.PlaceholderManager;
+import me.neznamy.tab.api.placeholder.PlayerPlaceholder;
 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.TabConstants;
 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
@@ -34,272 +36,162 @@ public class BukkitPlaceholderRegistry implements PlaceholderRegistry {
 	//formatter for 2 decimal places
 	public final DecimalFormat decimal2 = ((DecimalFormat)NumberFormat.getNumberInstance(Locale.US));
 
-	//plugin instance
-	private JavaPlugin plugin;
+	private final Plugin plugin;
 
-	//vault economy
-	private Economy economy;
+	private Object chat;
+	private final Plugin essentials = Bukkit.getPluginManager().getPlugin("Essentials");
+	private Object server;
+	private Field recentTps;
+	private boolean paperTps;
+	private boolean paperMspt;
+	private boolean purpur;
 
-	//vault chat
-	private Chat chat;
-
-	//placeholder registry buffer
-	private List<Placeholder> placeholders;
-
-	private Object essentials;
-	
-	//essentials methods
-	private Method essGetUser;
-	private Method essGetNickname;
-	private Method essIsAfk;
-	
-	private Method purpurIsAfk;
+	private Listener healthListener = null;
 
 	/**
 	 * Constructs new instance with given parameter
 	 * @param plugin - plugin instance
 	 */
-	public BukkitPlaceholderRegistry(JavaPlugin plugin) {
-		decimal2.applyPattern("#.##");
+	public BukkitPlaceholderRegistry(Plugin plugin) {
 		this.plugin = plugin;
-		essentials = Bukkit.getPluginManager().getPlugin("Essentials");
-		if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
-			RegisteredServiceProvider<Economy> rspEconomy = Bukkit.getServicesManager().getRegistration(Economy.class);
-			if (rspEconomy != null) economy = rspEconomy.getProvider();
-			RegisteredServiceProvider<Chat> rspChat = Bukkit.getServicesManager().getRegistration(Chat.class);
-			if (rspChat != null) chat = rspChat.getProvider();
-		}
-		if (essentials != null) {
-			try {
-				essGetUser = Class.forName("com.earth2me.essentials.Essentials").getMethod("getUser", Player.class);
-				essGetNickname = Class.forName("com.earth2me.essentials.User").getMethod("getNickname");
-				essIsAfk = Class.forName("com.earth2me.essentials.User").getMethod("isAfk");
-			} catch (Exception e) {
-				TAB.getInstance().getErrorManager().printError("Failed to load essentials methods", e);
-			}
-		}
-	}
-
-	@Override
-	public List<Placeholder> registerPlaceholders() {
-		placeholders = new ArrayList<>();
-		placeholders.add(new PlayerPlaceholder("%money%", 1000) {
-			public String get(TabPlayer p) {
-				if (economy != null) return decimal2.format(economy.getBalance((Player) p.getPlayer()));
-				return "-";
-			}
-		});
-
-		placeholders.add(new PlayerPlaceholder("%displayname%", 500) {
-			public String get(TabPlayer p) {
-				return ((Player) p.getPlayer()).getDisplayName();
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%deaths%", 1000) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getStatistic(Statistic.DEATHS));
-			}
-		});
-		placeholders.add(new ServerPlaceholder("%tps%", 1000) {
-			public String get() {
-				try {
-					Object nmsServer = Bukkit.getServer().getClass().getMethod("getServer").invoke(Bukkit.getServer());
-					double value = ((double[]) nmsServer.getClass().getField("recentTps").get(nmsServer))[0];
-					return decimal2.format(Math.min(20, value));
-				} catch (Exception t) {
-					return "-1";
-				}
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%canseeonline%", 2000) {
-			public String get(TabPlayer p) {
-				int count = 0;
-				for (TabPlayer all : TAB.getInstance().getPlayers()){
-					if (((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
-				}
-				return String.valueOf(count);
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%canseestaffonline%", 2000) {
-			public String get(TabPlayer p) {
-				int count = 0;
-				for (TabPlayer all : TAB.getInstance().getPlayers()){
-					if (all.isStaff() && ((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
-				}
-				return String.valueOf(count);
-			}
-		});
-		if (NMSStorage.getInstance().getMinorVersion() >= 6) {
-			placeholders.add(new PlayerPlaceholder("%health%", 100) {
-				public String get(TabPlayer p) {
-					return String.valueOf((int) Math.ceil(((Player) p.getPlayer()).getHealth()));
-				}
-			});
-		}
-		registerAFKPlaceholder();
-		registerVaultPlaceholders();
-		registerPositionPlaceholders();
-		registerEssentialsPlaceholders();
-		registerSyncPlaceholders();
-		return placeholders;
-	}
-
-	/**
-	 * Registers AFK placeholder
-	 */
-	private void registerAFKPlaceholder() {
-		Plugin afkplus = Bukkit.getPluginManager().getPlugin("AFKPlus");
-		boolean antiafkplus = Bukkit.getPluginManager().isPluginEnabled("AntiAFKPlus");
+		decimal2.applyPattern("#.##");
 		try {
-			purpurIsAfk = Player.class.getMethod("isAfk");
-		} catch (NoSuchMethodException | SecurityException e1) {
+			if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
+				RegisteredServiceProvider<?> rspChat = Bukkit.getServicesManager().getRegistration(Class.forName("net.milkbowl.vault.chat.Chat"));
+				if (rspChat != null) chat = rspChat.getProvider();
+			}
+		} catch (ClassNotFoundException e) {
+			//modded server without vault
+		}
+		try {
+			server = Bukkit.getServer().getClass().getMethod("getServer").invoke(Bukkit.getServer());
+			recentTps = server.getClass().getField("recentTps");
+		} catch (ReflectiveOperationException e) {
+			//not spigot
+		}
+		try {
+			Bukkit.class.getMethod("getTPS");
+			paperTps = true;
+		} catch (NoSuchMethodException e) {
+			//not paper
+		}
+		try {
+			Bukkit.class.getMethod("getAverageTickTime");
+			paperMspt = true;
+		} catch (NoSuchMethodException e) {
+			//not paper
+		}
+		try {
+			Player.class.getMethod("isAfk");
+			purpur = true;
+		} catch (NoSuchMethodException e) {
 			//not purpur
 		}
-		String noAfk = TAB.getInstance().getConfiguration().getConfig().getString("placeholders.afk-no", "");
-		String yesAfk = TAB.getInstance().getConfiguration().getConfig().getString("placeholders.afk-yes", " &4*&4&lAFK&4*&r");
-		placeholders.add(new PlayerPlaceholder("%afk%", 500) {
-			public String get(TabPlayer p) {
-				try {
-					if (essentials != null) {
-						Object user = essGetUser.invoke(Bukkit.getPluginManager().getPlugin("Essentials"), p.getPlayer());
-						if ((boolean) essIsAfk.invoke(user)) return yesAfk;
-					}
-					if (afkplus != null) {
-						Object afkplusplayer = afkplus.getClass().getMethod("getPlayer", UUID.class).invoke(afkplus, p.getUniqueId());
-						if ((boolean) afkplusplayer.getClass().getMethod("isAFK").invoke(afkplusplayer)) return yesAfk;
-					}
-					if (antiafkplus) {
-						Object api = Class.forName("de.kinglol12345.AntiAFKPlus.api.AntiAFKPlusAPI").getDeclaredMethod("getAPI").invoke(null);
-						if ((boolean) api.getClass().getMethod("isAFK", Player.class).invoke(api, p.getPlayer())) return yesAfk;
-					}
-				} catch (Exception e) {
-					return TAB.getInstance().getErrorManager().printError("", "Failed to check AFK status of " + p.getName(), e);
-				}
-				try {
-					if (purpurIsAfk != null && (boolean) purpurIsAfk.invoke(p.getPlayer())) return yesAfk;
-				} catch (Exception e) {
-					//not purpur
-				}
-				return noAfk;
-			}
-			@Override
-			public String[] getNestedStrings(){
-				return new String[] {yesAfk, noAfk};
-			}
-		});
 	}
 
-	/**
-	 * Registers vault placeholders
-	 */
-	private void registerVaultPlaceholders() {
-		if (Bukkit.getPluginManager().isPluginEnabled("Vault") && chat != null) {
-			placeholders.add(new PlayerPlaceholder("%vault-prefix%", 500) {
-
-				public String get(TabPlayer p) {
-					return chat.getPlayerPrefix((Player) p.getPlayer());
-				}
-			});
-			placeholders.add(new PlayerPlaceholder("%vault-suffix%", 500) {
-
-				public String get(TabPlayer p) {
-					return chat.getPlayerSuffix((Player) p.getPlayer());
+	@SuppressWarnings("deprecation")
+	@Override
+	public void registerPlaceholders(PlaceholderManager manager) {
+		NumberFormat roundDown = NumberFormat.getInstance();
+		roundDown.setRoundingMode(RoundingMode.DOWN);
+		roundDown.setMaximumFractionDigits(2);
+		manager.registerPlayerPlaceholder("%displayname%", 500, p -> ((Player) p.getPlayer()).getDisplayName());
+		manager.registerPlayerPlaceholder("%vanished%", 1000, TabPlayer::isVanished);
+		if (paperTps) {
+			manager.registerServerPlaceholder("%tps%", 1000, () -> formatTPS(Bukkit.getTPS()[0]));
+		} else if (recentTps != null) {
+			manager.registerServerPlaceholder("%tps%", 1000, () -> {
+				try {
+					return formatTPS(((double[]) recentTps.get(server))[0]);
+				} catch (IllegalAccessException e) {
+					return "-1";
 				}
 			});
 		} else {
-			placeholders.add(new ServerPlaceholder("%vault-prefix%", 1000000) {
-				public String get() {
-					return "";
-				}
-			});
-			placeholders.add(new ServerPlaceholder("%vault-suffix%", 1000000) {
-				public String get() {
-					return "";
-				}
-			});
+			manager.registerServerPlaceholder("%tps%", -1, () -> "-1").enableTriggerMode();
 		}
-	}
-
-	/**
-	 * 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());
-			}
+		if (paperMspt) {
+			manager.registerServerPlaceholder("%mspt%", 1000, () -> roundDown.format(Bukkit.getAverageTickTime()));
+		}
+		manager.registerPlayerPlaceholder("%afk%", 500, p -> {
+			if (essentials != null && ((Essentials)essentials).getUser(p.getUniqueId()).isAfk()) return true;
+			return purpur && ((Player)p.getPlayer()).isAfk();
 		});
-		placeholders.add(new PlayerPlaceholder("%yPos%", 100) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getLocation().getBlockY());
-			}
-		});
-		placeholders.add(new PlayerPlaceholder("%zPos%", 100) {
-			public String get(TabPlayer p) {
-				return String.valueOf(((Player) p.getPlayer()).getLocation().getBlockZ());
-			}
-		});
-	}
-
-	/**
-	 * Registers essentials placeholders
-	 */
-	private void registerEssentialsPlaceholders() {
-		if (essentials != null) {
-			placeholders.add(new PlayerPlaceholder("%essentialsnick%", 1000) {
-				public String get(TabPlayer p) {
-					if (essGetNickname == null) return "<Internal plugin error>";
-					String name = null;
-					try {
-						name = (String) essGetNickname.invoke(essGetUser.invoke(essentials, p.getPlayer()));
-					} catch (Exception e) {
-						TAB.getInstance().getErrorManager().printError("Failed to get Essentials nickname of " + p.getName(), e);
-					}
-					if (name == null || name.length() == 0) return p.getName();
-					return TAB.getInstance().getConfiguration().getEssentialsNickPrefix() + name;
-				}
-			});
+		if (chat != null) {
+			manager.registerPlayerPlaceholder("%vault-prefix%", 500, p -> ((Chat) chat).getPlayerPrefix((Player) p.getPlayer()));
+			manager.registerPlayerPlaceholder("%vault-suffix%", 500, p -> ((Chat) chat).getPlayerSuffix((Player) p.getPlayer()));
 		} else {
-			placeholders.add(new PlayerPlaceholder("%essentialsnick%", 100000000) {
-				public String get(TabPlayer p) {
-					return p.getName();
-				}
-			});
+			manager.registerServerPlaceholder("%vault-prefix%", -1, () -> "").enableTriggerMode();
+			manager.registerServerPlaceholder("%vault-suffix%", -1, () -> "").enableTriggerMode();
 		}
+		registerOnlinePlaceholders(manager);
+		registerHealthPlaceholder(manager);
 	}
 
-	/**
-	 * Registers synchronous placeholders
-	 */
-	private void registerSyncPlaceholders() {
-		PlaceholderManager pl = TAB.getInstance().getPlaceholderManager();
-		for (String identifier : pl.getAllUsedPlaceholderIdentifiers()) {
-			if (identifier.startsWith("%sync:")) {
-				int refresh;
-				if (pl.getServerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					refresh = pl.getServerPlaceholderRefreshIntervals().get(identifier);
-				} else if (pl.getPlayerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					refresh = pl.getPlayerPlaceholderRefreshIntervals().get(identifier);
-				} else {
-					refresh = pl.getDefaultRefresh();
-				}
-				placeholders.add(new PlayerPlaceholder(identifier, refresh) {
+	private String formatTPS(double tps) {
+		return decimal2.format(Math.min(20, tps));
+	}
 
-					@Override
-					public String get(TabPlayer p) {
-						Bukkit.getScheduler().runTask(plugin, () -> {
-
-							long time = System.nanoTime();
-							String syncedPlaceholder = identifier.substring(6, identifier.length()-1);
-							String value = ((BukkitPlatform) TAB.getInstance().getPlatform()).setPlaceholders((Player) p.getPlayer(), "%" + syncedPlaceholder + "%");
-							getLastValues().put(p.getName(), value);
-							if (!getForceUpdate().contains(p.getName())) getForceUpdate().add(p.getName());
-							TAB.getInstance().getCPUManager().addPlaceholderTime(getIdentifier(), System.nanoTime()-time);
-						});
-						return getLastValues().get(p.getName());
-					}
-				});
+	private void registerOnlinePlaceholders(PlaceholderManager manager) {
+		manager.registerPlayerPlaceholder("%online%", -1, p -> {
+			int count = 0;
+			for (TabPlayer all : TAB.getInstance().getOnlinePlayers()){
+				if (((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
 			}
+			return count;
+		}).enableTriggerMode();
+		manager.registerPlayerPlaceholder("%staffonline%", 2000, p -> {
+			int count = 0;
+			for (TabPlayer all : TAB.getInstance().getOnlinePlayers()){
+				if (all.hasPermission(TabConstants.Permission.STAFF) && ((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
+			}
+			return count;
+		});
+		manager.registerPlayerPlaceholder("%nonstaffonline%", 2000, p -> {
+			int count = 0;
+			for (TabPlayer all : TAB.getInstance().getOnlinePlayers()){
+				if (!all.hasPermission(TabConstants.Permission.STAFF) && ((Player) p.getPlayer()).canSee((Player) all.getPlayer())) count++;
+			}
+			return count;
+		});
+	}
+
+	@SuppressWarnings("deprecation")
+	private void registerHealthPlaceholder(PlaceholderManager manager) {
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6) {
+			PlayerPlaceholder health = manager.registerPlayerPlaceholder("%health%", -1, p -> (int) Math.ceil(((Player) p.getPlayer()).getHealth()));
+			health.enableTriggerMode(() -> {
+				healthListener = new Listener() {
+
+					@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+					public void onDamage(EntityDamageEvent e) {
+						if (e.getEntity() instanceof Player) {
+							Player p = (Player) e.getEntity();
+							TabPlayer tabp = TAB.getInstance().getPlayer(e.getEntity().getUniqueId());
+							if (tabp == null) return;
+							health.updateValue(tabp, (int) Math.ceil(Math.max(p.getHealth() - e.getFinalDamage(), 0)));
+						}
+					}
+
+					@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+					public void onRegain(EntityRegainHealthEvent e) {
+						if (e.getEntity() instanceof Player) {
+							Player p = (Player) e.getEntity();
+							TabPlayer tabp = TAB.getInstance().getPlayer(e.getEntity().getUniqueId());
+							if (tabp == null) return;
+							health.updateValue(tabp, (int) Math.ceil(Math.min(p.getHealth() + e.getAmount(), p.getMaxHealth())));
+						}
+					}
+
+					@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+					public void onRespawn(PlayerRespawnEvent e) {
+						health.updateValue(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId()), e.getPlayer().getMaxHealth());
+					}
+				};
+				Bukkit.getPluginManager().registerEvents(healthListener, plugin);
+			}, () -> {
+				HandlerList.unregisterAll(healthListener);
+			});
 		}
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/BukkitPlatform.java

@@ -2,39 +2,38 @@ package me.neznamy.tab.platforms.bukkit;
 
 import java.io.File;
 import java.util.Collection;
+import java.util.List;
 
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.java.JavaPlugin;
+
+import com.earth2me.essentials.Essentials;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
 
 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.WitherBossBar;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.protocol.PacketBuilder;
+import me.neznamy.tab.platforms.bukkit.event.TabLoadEvent;
+import me.neznamy.tab.platforms.bukkit.event.TabPlayerLoadEvent;
 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.WitherBossBar;
 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.TAB;
-import me.neznamy.tab.shared.features.BelowName;
-import me.neznamy.tab.shared.features.NameTag;
-import me.neznamy.tab.shared.features.PingSpoof;
-import me.neznamy.tab.shared.features.PlaceholderManager;
-import me.neznamy.tab.shared.features.SpectatorFix;
-import me.neznamy.tab.shared.features.TabObjective;
-import me.neznamy.tab.shared.features.scoreboard.ScoreboardManager;
+import me.neznamy.tab.shared.features.PlaceholderManagerImpl;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
+import me.neznamy.tab.shared.features.nametags.NameTag;
 import me.neznamy.tab.shared.permission.LuckPerms;
 import me.neznamy.tab.shared.permission.None;
 import me.neznamy.tab.shared.permission.PermissionPlugin;
 import me.neznamy.tab.shared.permission.UltraPermissions;
-import me.neznamy.tab.shared.placeholders.Placeholder;
-import me.neznamy.tab.shared.placeholders.PlayerPlaceholder;
-import me.neznamy.tab.shared.placeholders.RelationalPlaceholder;
-import me.neznamy.tab.shared.placeholders.ServerPlaceholder;
+import me.neznamy.tab.shared.placeholders.PlayerPlaceholderImpl;
 import me.neznamy.tab.shared.placeholders.UniversalPlaceholderRegistry;
 import net.milkbowl.vault.permission.Permission;
 
@@ -42,38 +41,35 @@ import net.milkbowl.vault.permission.Permission;
  * Bukkit implementation of Platform
  */
 public class BukkitPlatform implements Platform {
-	
+
 	//plugin instance
-	private JavaPlugin plugin;
-	
-	//nms storage
-	private NMSStorage nms;
-	
+	private final Main plugin;
+
+	private final BukkitPacketBuilder packetBuilder = new BukkitPacketBuilder();
+
 	//booleans to check plugin presence
-	private Plugin placeholderAPI;
+	private boolean placeholderAPI;
 	private boolean viaversion;
 	private boolean idisguise;
 	private boolean libsdisguises;
-	private boolean essentials;
+	private Plugin essentials;
 
 	/**
 	 * Constructs new instance with given parameters
 	 * @param plugin - plugin instance
-	 * @param nms - nms storage
 	 */
-	public BukkitPlatform(JavaPlugin plugin, NMSStorage nms) {
+	public BukkitPlatform(Main plugin) {
 		this.plugin = plugin;
-		this.nms = nms;
 	}
 
 	@Override
 	public PermissionPlugin detectPermissionPlugin() {
 		if (Bukkit.getPluginManager().isPluginEnabled("LuckPerms")) {
-			return new LuckPerms(Bukkit.getPluginManager().getPlugin("LuckPerms").getDescription().getVersion());
+			return new LuckPerms(getPluginVersion("LuckPerms"));
 		} else if (Bukkit.getPluginManager().isPluginEnabled("UltraPermissions")) {
-			return new UltraPermissions(Bukkit.getPluginManager().getPlugin("UltraPermissions").getDescription().getVersion());
+			return new UltraPermissions(getPluginVersion("UltraPermissions"));
 		} else if (Bukkit.getPluginManager().isPluginEnabled("Vault")) {
-			return new Vault(Bukkit.getServicesManager().getRegistration(Permission.class).getProvider(), Bukkit.getPluginManager().getPlugin("Vault").getDescription().getVersion());
+			return new Vault(Bukkit.getServicesManager().getRegistration(Permission.class).getProvider(), getPluginVersion("Vault"));
 		} else {
 			return new None();
 		}
@@ -81,46 +77,60 @@ public class BukkitPlatform implements Platform {
 
 	@Override
 	public void loadFeatures() {
-		placeholderAPI = Bukkit.getPluginManager().getPlugin("PlaceholderAPI");
-		viaversion = Bukkit.getPluginManager().isPluginEnabled("ViaVersion");
+		if (Bukkit.getPluginManager().isPluginEnabled("ViaVersion")) {
+			try {
+				Class.forName("com.viaversion.viaversion.api.Via");
+				viaversion = true;
+			} catch (ClassNotFoundException e) {
+				TAB.getInstance().sendConsoleMessage("&c[TAB] An outdated version of ViaVersion (" + getPluginVersion("ViaVersion") + ") was detected.", true);
+				TAB.getInstance().sendConsoleMessage("&c[TAB] TAB only supports ViaVersion 4.0.0 and above. Disabling ViaVersion hook.", true);
+				TAB.getInstance().sendConsoleMessage("&c[TAB] This might cause problems, such as limitations still being present for latest MC clients as well as RGB not working.", true);
+			}
+		}
+		if (Bukkit.getPluginManager().isPluginEnabled("Tablisknu")) {
+			TAB.getInstance().sendConsoleMessage("&c[TAB] Detected plugin \"Tablisknu\", which causes TAB to not work properly. Consider removing the plugin.", true);
+		}
+		placeholderAPI = Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI");
 		idisguise = Bukkit.getPluginManager().isPluginEnabled("iDisguise");
 		libsdisguises = Bukkit.getPluginManager().isPluginEnabled("LibsDisguises");
-		essentials = Bukkit.getPluginManager().isPluginEnabled("Essentials");
+		essentials = Bukkit.getPluginManager().getPlugin("Essentials");
 		TAB tab = TAB.getInstance();
-		tab.getPlaceholderManager().addRegistry(new BukkitPlaceholderRegistry(plugin));
-		tab.getPlaceholderManager().addRegistry(new UniversalPlaceholderRegistry());
-		tab.getPlaceholderManager().registerPlaceholders();
-		if (nms.getMinorVersion() >= 8 && tab.getConfiguration().isPipelineInjection()) {
-			tab.getFeatureManager().registerFeature("injection", new BukkitPipelineInjector(tab, nms));
-		}
+		if (tab.getConfiguration().isPipelineInjection()) tab.getFeatureManager().registerFeature("injection", new BukkitPipelineInjector());
+		new BukkitPlaceholderRegistry(plugin).registerPlaceholders(tab.getPlaceholderManager());
+		new UniversalPlaceholderRegistry().registerPlaceholders(tab.getPlaceholderManager());
 		loadNametagFeature(tab);
-		loadUniversalFeatures();
-		if (tab.getConfiguration().getConfig().getBoolean("ping-spoof.enabled", false)) tab.getFeatureManager().registerFeature("pingspoof", new PingSpoof());
-		if (tab.getConfiguration().getConfig().getString("yellow-number-in-tablist", "%ping%").length() > 0) tab.getFeatureManager().registerFeature("tabobjective", new TabObjective(tab));
-		if (tab.getConfiguration().getConfig().getBoolean("do-not-move-spectators", false)) tab.getFeatureManager().registerFeature("spectatorfix", new SpectatorFix());
-		if (tab.getConfiguration().getConfig().getBoolean("classic-vanilla-belowname.enabled", true)) tab.getFeatureManager().registerFeature("belowname", new BelowName(tab));
-		if (tab.getConfiguration().getPremiumConfig() != null && tab.getConfiguration().getPremiumConfig().getBoolean("scoreboard.enabled", false)) tab.getFeatureManager().registerFeature("scoreboard", new ScoreboardManager(tab));
-		if (tab.getConfiguration().getBossbarConfig().getBoolean("bossbar-enabled", false) && nms.getMinorVersion() < 9) tab.getFeatureManager().registerFeature("bossbar1.8", new WitherBossBar(tab, plugin));
-		if (nms.getMinorVersion() >= 9 && tab.getConfiguration().getConfig().getBoolean("fix-pet-names", false)) tab.getFeatureManager().registerFeature("petfix", new PetFix(nms));
-		if (tab.getConfiguration().getConfig().getBoolean("per-world-playerlist.enabled", false)) tab.getFeatureManager().registerFeature("pwp", new PerWorldPlayerlist(plugin, tab));
-		if (placeholderAPI != null) {
+		tab.loadUniversalFeatures();
+		if (tab.getConfiguration().getConfig().getBoolean("bossbar.enabled", false)) {
+			if (tab.getServerVersion().getMinorVersion() < 9) {
+				tab.getFeatureManager().registerFeature("bossbar", new WitherBossBar(plugin));
+			} else {
+				tab.getFeatureManager().registerFeature("bossbar", new BossBarManagerImpl());
+			}
+		}
+		if (tab.getServerVersion().getMinorVersion() >= 9 && tab.getConfiguration().getConfig().getBoolean("fix-pet-names.enabled", false)) tab.getFeatureManager().registerFeature("petfix", new PetFix());
+		if (tab.getConfiguration().getConfig().getBoolean("per-world-playerlist.enabled", false)) tab.getFeatureManager().registerFeature("pwp", new PerWorldPlayerlist(plugin));
+		if (placeholderAPI) {
 			new TabExpansion(plugin);
 		}
 		for (Player p : getOnlinePlayers()) {
-			tab.addPlayer(new BukkitTabPlayer(p, Main.getProtocolVersion(p)));
+			tab.addPlayer(new BukkitTabPlayer(p, plugin.getProtocolVersion(p)));
 		}
 	}
 	
+	private String getPluginVersion(String plugin) {
+		return Bukkit.getPluginManager().getPlugin(plugin).getDescription().getVersion();
+	}
+
 	/**
 	 * Loads nametag feature from config
 	 * @param tab - tab instance
 	 */
 	private void loadNametagFeature(TAB tab) {
-		if (tab.getConfiguration().getConfig().getBoolean("change-nametag-prefix-suffix", true)) {
-			if (tab.getConfiguration().getConfig().getBoolean("unlimited-nametag-prefix-suffix-mode.enabled", false) && nms.getMinorVersion() >= 8) {
-				tab.getFeatureManager().registerFeature("nametagx", new NameTagX(plugin, nms, tab));
+		if (tab.getConfiguration().getConfig().getBoolean("scoreboard-teams.enabled", true)) {
+			if (tab.getConfiguration().getConfig().getBoolean("scoreboard-teams.unlimited-nametag-mode.enabled", false) && tab.getServerVersion().getMinorVersion() >= 8) {
+				tab.getFeatureManager().registerFeature("nametagx", new NameTagX(plugin));
 			} else {
-				tab.getFeatureManager().registerFeature("nametag16", new NameTag(tab));
+				tab.getFeatureManager().registerFeature("nametag16", new NameTag());
 			}
 		}
 	}
@@ -140,7 +150,7 @@ public class BukkitPlatform implements Platform {
 				//1.8+
 				return ((Collection<Player>)players).toArray(new Player[0]); 
 			}
-		} catch (Exception e) {
+		} catch (ReflectiveOperationException e) {
 			TAB.getInstance().getErrorManager().printError("Failed to get online players", e);
 			return new Player[0];
 		}
@@ -148,140 +158,68 @@ public class BukkitPlatform implements Platform {
 
 	@Override
 	public void sendConsoleMessage(String message, boolean translateColors) {
-		Bukkit.getConsoleSender().sendMessage(translateColors ? message.replace('&', '\u00a7') : message);
+		Bukkit.getConsoleSender().sendMessage(translateColors ? EnumChatFormat.color(message) : 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));
+		PlaceholderManagerImpl pl = TAB.getInstance().getPlaceholderManager();
+		if (identifier.startsWith("%rel_")) {
+			//relational placeholder
+			TAB.getInstance().getPlaceholderManager().registerRelationalPlaceholder(identifier, pl.getRelationalRefresh(identifier), (viewer, target) -> 
+				placeholderAPI ? PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier) : identifier);
+		} else {
+			//normal placeholder
+			if (identifier.startsWith("%sync:")) {
+				int refresh = pl.getServerPlaceholderRefreshIntervals().getOrDefault(identifier,
+						pl.getPlayerPlaceholderRefreshIntervals().getOrDefault(identifier, pl.getDefaultRefresh()));
+				pl.registerPlaceholder(new PlayerPlaceholderImpl(identifier, refresh, null) {
+					
+					@Override
+					public Object request(TabPlayer p) {
+						Bukkit.getScheduler().runTask(plugin, () -> {
+
+							long time = System.nanoTime();
+							String syncedPlaceholder = identifier.substring(6, identifier.length()-1);
+							String value = placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), "%" + syncedPlaceholder + "%") : identifier;
+							getLastValues().put(p.getName(), value);
+							if (!getForceUpdate().contains(p.getName())) getForceUpdate().add(p.getName());
+							TAB.getInstance().getCPUManager().addPlaceholderTime(getIdentifier(), System.nanoTime()-time);
+						});
+						return getLastValues().get(p.getName());
+					}
+				});
+				return;
+			}
+			if (pl.getServerPlaceholderRefreshIntervals().containsKey(identifier)) {
+				TAB.getInstance().getPlaceholderManager().registerServerPlaceholder(identifier, pl.getServerPlaceholderRefreshIntervals().get(identifier), () ->
+						placeholderAPI ? PlaceholderAPI.setPlaceholders(null, identifier) : identifier);
 			} else {
-				//normal placeholder
-				String expansion = identifier.split("_")[0].substring(1).toLowerCase();
-				if (expansion.equals("some")) return;
-				if (pl.getServerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					registerServerPlaceholder(identifier, pl.getServerPlaceholderRefreshIntervals().get(identifier));
-					return;
-				}
-				if (pl.getPlayerPlaceholderRefreshIntervals().containsKey(identifier)) {
-					registerPlayerPlaceholder(identifier, pl.getPlayerPlaceholderRefreshIntervals().get(identifier));
-					return;
-				}
-				registerPlayerPlaceholder(identifier, pl.getDefaultRefresh());
+				int refresh = pl.getPlayerPlaceholderRefreshIntervals().getOrDefault(identifier, pl.getDefaultRefresh());
+				TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder(identifier, refresh, p -> 
+					placeholderAPI ? PlaceholderAPI.setPlaceholders((Player) p.getPlayer(), identifier) : identifier);
 			}
 		}
 	}
-	
-	/**
-	 * Registers server placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerServerPlaceholder(String identifier, int refresh) {
-		BukkitPlatform pl = this;
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new ServerPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)){
-			
-			@Override
-			public String get() {
-				return pl.setPlaceholders(null, identifier);
-			}
-		});
-	}
-	
-	/**
-	 * Registers player placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerPlayerPlaceholder(String identifier, int refresh) {
-		BukkitPlatform pl = this;
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new PlayerPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)) {
-
-			@Override
-			public String get(TabPlayer p) {
-				return pl.setPlaceholders((Player) p.getPlayer(), identifier);
-			}
-		});
-	}
-	
-	/**
-	 * Registers relational placeholder
-	 * @param identifier - placeholder identifier
-	 * @param refresh - refresh interval in milliseconds
-	 */
-	private void registerRelationalPlaceholder(String identifier, int refresh) {
-		TAB.getInstance().getPlaceholderManager().registerPlaceholder(new RelationalPlaceholder(identifier, TAB.getInstance().getErrorManager().fixPlaceholderInterval(identifier, refresh)) {
-
-			@Override
-			public String get(TabPlayer viewer, TabPlayer target) {
-				if (placeholderAPI == null) return identifier;
-				try {
-					return PlaceholderAPI.setRelationalPlaceholders((Player) viewer.getPlayer(), (Player) target.getPlayer(), identifier);
-				} catch (Exception t) {
-					TAB.getInstance().getErrorManager().printError("PlaceholderAPI v" + placeholderAPI.getDescription().getVersion() + " generated an error when setting relational placeholder " + identifier + " for viewer " + viewer.getName() + " and target " + target.getName(), t, false, TAB.getInstance().getErrorManager().getPapiErrorLog());
-				}
-				return identifier;
-			}
-		});
-	}
-	
-	/**
-	 * Runs PlaceholderAPI call and returns the output. If the task fails, error is logged and "ERROR" returned instead
-	 * @param player - player to set placeholder for
-	 * @param placeholder - placeholder
-	 * @return result from PlaceholderAPI
-	 */
-	public String setPlaceholders(Player player, String placeholder) {
-		if (placeholderAPI == null) return placeholder;
-		try {
-			return PlaceholderAPI.setPlaceholders(player, placeholder);
-		} catch (Exception t) {
-			String playername = (player == null ? "<null>" : player.getName());
-			TAB.getInstance().getErrorManager().printError("PlaceholderAPI v" + placeholderAPI.getDescription().getVersion() + " generated an error when setting placeholder " + placeholder + " for player " + playername, t, false, TAB.getInstance().getErrorManager().getPapiErrorLog());
-			return "ERROR";
-		}
-	}
 
 	@Override
 	public 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());
+		Bukkit.getPluginManager().callEvent(new TabLoadEvent());
+	}
+
+	@Override
+	public void callLoadEvent(TabPlayer player) {
+		Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> Bukkit.getPluginManager().callEvent(new TabPlayerLoadEvent(player)));
 	}
 
 	@Override
@@ -289,11 +227,6 @@ public class BukkitPlatform implements Platform {
 		return Bukkit.getMaxPlayers();
 	}
 
-	@Override
-	public String getConfigName() {
-		return "bukkitconfig.yml";
-	}
-
 	public boolean isViaversionEnabled() {
 		return viaversion;
 	}
@@ -301,12 +234,44 @@ public class BukkitPlatform implements Platform {
 	public boolean isLibsdisguisesEnabled() {
 		return libsdisguises;
 	}
+	
+	public void setLibsdisguisesEnabled(boolean enabled) {
+		libsdisguises = enabled;
+	}
 
 	public boolean isIdisguiseEnabled() {
 		return idisguise;
 	}
 
-	public boolean isEssentialsEnabled() {
-		return essentials;
+	public Essentials getEssentials() {
+		return (Essentials) essentials;
+	}
+
+	@Override
+	public PacketBuilder getPacketBuilder() {
+		return packetBuilder;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Object getSkin(List<String> properties) {
+		PropertyMap map = new PropertyMap();
+		map.put("textures", new Property("textures", properties.get(0), properties.get(1)));
+		return map;
+	}
+	
+	@Override
+	public boolean isProxy() {
+		return false;
+	}
+
+	@Override
+	public boolean isPluginEnabled(String plugin) {
+		return Bukkit.getPluginManager().isPluginEnabled(plugin);
+	}
+
+	@Override
+	public String getConfigName() {
+		return "bukkitconfig.yml";
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/BukkitTabPlayer.java

@@ -1,10 +1,8 @@
 package me.neznamy.tab.platforms.bukkit;
 
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.UUID;
 
 import org.bukkit.Bukkit;
@@ -12,30 +10,31 @@ import org.bukkit.boss.BarColor;
 import org.bukkit.boss.BarFlag;
 import org.bukkit.boss.BarStyle;
 import org.bukkit.boss.BossBar;
-import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.metadata.MetadataValue;
 import org.bukkit.potion.PotionEffectType;
 
+import com.earth2me.essentials.Essentials;
+import com.mojang.authlib.GameProfile;
 import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.legacy.bossbar.BossColor;
+import com.viaversion.viaversion.api.legacy.bossbar.BossFlag;
+import com.viaversion.viaversion.api.legacy.bossbar.BossStyle;
 
-import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
+import me.libraryaddict.disguise.DisguiseAPI;
+import me.neznamy.tab.api.ProtocolVersion;
+import me.neznamy.tab.api.chat.rgb.RGBUtils;
+import me.neznamy.tab.api.protocol.PacketPlayOutBoss;
 import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
 import me.neznamy.tab.shared.ITabPlayer;
-import me.neznamy.tab.shared.ProtocolVersion;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.packets.PacketPlayOutBoss;
-import me.neznamy.tab.shared.rgb.RGBUtils;
 
 /**
  * TabPlayer for Bukkit
  */
 public class BukkitTabPlayer extends ITabPlayer {
 
-	//bukkit player
-	private Player player;
-
 	//nms handle
 	private Object handle;
 
@@ -43,99 +42,93 @@ public class BukkitTabPlayer extends ITabPlayer {
 	private Object playerConnection;
 	
 	//player's visible boss bars
-	private Map<UUID, BossBar> bossbars = new HashMap<>();
+	private final Map<UUID, BossBar> bossbars = new HashMap<>();
+	private final Map<UUID, com.viaversion.viaversion.api.legacy.bossbar.BossBar> viaBossbars = new HashMap<>();
 
 	/**
 	 * Constructs new instance with given parameter
 	 * @param p - bukkit player
 	 */
 	public BukkitTabPlayer(Player p, int protocolVersion){
-		player = p;
-		world = p.getWorld().getName();
+		super(p, p.getUniqueId(), p.getName(), "N/A", p.getWorld().getName());
 		try {
-			handle = NMSStorage.getInstance().getMethod("getHandle").invoke(player);
-			playerConnection = NMSStorage.getInstance().getField("PLAYER_CONNECTION").get(handle);
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get playerConnection of " + p.getName(), e);
+			handle = NMSStorage.getInstance().getHandle.invoke(player);
+			playerConnection = NMSStorage.getInstance().PLAYER_CONNECTION.get(handle);
+			if (NMSStorage.getInstance().CHANNEL != null)
+				channel = (Channel) NMSStorage.getInstance().CHANNEL.get(NMSStorage.getInstance().NETWORK_MANAGER.get(playerConnection));
+		} catch (ReflectiveOperationException e) {
+			TAB.getInstance().getErrorManager().printError("Failed to get playerConnection or channel of " + p.getName(), e);
 		}
-		try {
-			if (NMSStorage.getInstance().getField("CHANNEL") != null)
-				channel = (Channel) NMSStorage.getInstance().getField("CHANNEL").get(NMSStorage.getInstance().getField("NETWORK_MANAGER").get(playerConnection));
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get channel of " + p.getName(), e);
-		}
-		uniqueId = p.getUniqueId();
-		name = p.getName();
 		version = ProtocolVersion.fromNetworkId(protocolVersion);
-		init();
 	}
 
 	@Override
 	public boolean hasPermission(String permission) {
-		return player.hasPermission(permission);
+		long time = System.nanoTime();
+		boolean value = getPlayer().hasPermission(permission);
+		TAB.getInstance().getCPUManager().addMethodTime("hasPermission", System.nanoTime()-time);
+		return value;
 	}
 
 	@Override
-	public long getPing() {
+	public int getPing() {
 		try {
-			int ping = NMSStorage.getInstance().getField("PING").getInt(handle);
+			int ping = NMSStorage.getInstance().PING.getInt(handle);
 			if (ping > 10000 || ping < 0) ping = -1;
 			return ping;
-		} catch (Exception e) {
+		} catch (IllegalAccessException e) {
 			return -1;
 		}
 	}
 
 	@Override
 	public void sendPacket(Object nmsPacket) {
-		if (nmsPacket == null || !player.isOnline()) return;
+		if (nmsPacket == null || !getPlayer().isOnline()) return;
+		long time = System.nanoTime();
 		try {
-			if (((BukkitPlatform)TAB.getInstance().getPlatform()).isViaversionEnabled() && nmsPacket instanceof ByteBuf) {
-				Via.getAPI().sendRawPacket(uniqueId, (ByteBuf) nmsPacket);
-				return;
-			}
 			if (nmsPacket instanceof PacketPlayOutBoss) {
-				handle((PacketPlayOutBoss) nmsPacket);
-				return;
+				if (TAB.getInstance().getServerVersion().getMinorVersion() >= 9) {
+					handle((PacketPlayOutBoss) nmsPacket);
+				} else {
+					handleVia((PacketPlayOutBoss) nmsPacket);
+				}
+			} else {
+				NMSStorage.getInstance().sendPacket.invoke(playerConnection, nmsPacket);
 			}
-			NMSStorage.getInstance().getMethod("sendPacket").invoke(playerConnection, nmsPacket);
-		} catch (IllegalArgumentException e) {
-			//java.lang.IllegalArgumentException: This player is not controlled by ViaVersion!
-			//this is only used to send 1.9 bossbar packets on 1.8 servers, no idea why it does this sometimes
-		} catch (Exception e) {
+		} catch (ReflectiveOperationException e) {
 			TAB.getInstance().getErrorManager().printError("An error occurred when sending " + nmsPacket.getClass().getSimpleName(), e);
 		}
+		TAB.getInstance().getCPUManager().addMethodTime("sendPacket", System.nanoTime()-time);
 	}
 	
 	private void handle(PacketPlayOutBoss packet) {
-		Set<BarFlag> flags = new HashSet<>();
 		BossBar bar;
 		switch (packet.getOperation()) {
 		case ADD:
-			if (packet.isCreateWorldFog()) flags.add(BarFlag.CREATE_FOG);
-			if (packet.isDarkenScreen()) flags.add(BarFlag.DARKEN_SKY);
-			if (packet.isPlayMusic()) flags.add(BarFlag.PLAY_BOSS_MUSIC);
-			bar = Bukkit.createBossBar(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && NMSStorage.getInstance().getMinorVersion() >= 16), 
+			if (bossbars.containsKey(packet.getId())) return;
+			bar = Bukkit.createBossBar(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16), 
 					BarColor.valueOf(packet.getColor().name()), 
-					BarStyle.valueOf(packet.getOverlay().name().replace("PROGRESS", "SOLID").replace("NOTCHED", "SEGMENTED")),
-					flags.toArray(new BarFlag[0]));
+					BarStyle.valueOf(packet.getOverlay().getBukkitName()));
+			if (packet.isCreateWorldFog()) bar.addFlag(BarFlag.CREATE_FOG);
+			if (packet.isDarkenScreen()) bar.addFlag(BarFlag.DARKEN_SKY);
+			if (packet.isPlayMusic()) bar.addFlag(BarFlag.PLAY_BOSS_MUSIC);
 			bar.setProgress(packet.getPct());
 			bossbars.put(packet.getId(), bar);
-			bar.addPlayer(player);
+			bar.addPlayer(getPlayer());
 			break;
 		case REMOVE:
-			bossbars.get(packet.getId()).removePlayer(player);
+			bossbars.get(packet.getId()).removePlayer(getPlayer());
 			bossbars.remove(packet.getId());
 			break;
 		case UPDATE_PCT:
 			bossbars.get(packet.getId()).setProgress(packet.getPct());
 			break;
 		case UPDATE_NAME:
-			bossbars.get(packet.getId()).setTitle(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && NMSStorage.getInstance().getMinorVersion() >= 16));
+			bossbars.get(packet.getId()).setTitle(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16 && TAB.getInstance().getServerVersion().getMinorVersion() >= 16));
 			break;
 		case UPDATE_STYLE:
 			bossbars.get(packet.getId()).setColor(BarColor.valueOf(packet.getColor().name()));
-			bossbars.get(packet.getId()).setStyle(BarStyle.valueOf(packet.getOverlay().name().replace("PROGRESS", "SOLID").replace("NOTCHED", "SEGMENTED")));
+			bossbars.get(packet.getId()).setStyle(BarStyle.valueOf(packet.getOverlay().getBukkitName()));
 			break;
 		case UPDATE_PROPERTIES:
 			bar = bossbars.get(packet.getId());
@@ -148,6 +141,46 @@ public class BukkitTabPlayer extends ITabPlayer {
 		}
 	}
 	
+	private void handleVia(PacketPlayOutBoss packet) {
+		com.viaversion.viaversion.api.legacy.bossbar.BossBar bar;
+		switch (packet.getOperation()) {
+		case ADD:
+			if (viaBossbars.containsKey(packet.getId())) return;
+			bar = Via.getAPI().legacyAPI().createLegacyBossBar(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16), 
+					packet.getPct(),
+					BossColor.valueOf(packet.getColor().name()), 
+					BossStyle.valueOf(packet.getOverlay().getBukkitName()));
+			//fog missing from via API
+			if (packet.isDarkenScreen()) bar.addFlag(BossFlag.DARKEN_SKY);
+			if (packet.isPlayMusic()) bar.addFlag(BossFlag.PLAY_BOSS_MUSIC);
+			viaBossbars.put(packet.getId(), bar);
+			bar.addPlayer(getPlayer().getUniqueId());
+			break;
+		case REMOVE:
+			viaBossbars.get(packet.getId()).removePlayer(getPlayer().getUniqueId());
+			viaBossbars.remove(packet.getId());
+			break;
+		case UPDATE_PCT:
+			viaBossbars.get(packet.getId()).setHealth(packet.getPct());
+			break;
+		case UPDATE_NAME:
+			viaBossbars.get(packet.getId()).setTitle(RGBUtils.getInstance().convertToBukkitFormat(packet.getName(), getVersion().getMinorVersion() >= 16));
+			break;
+		case UPDATE_STYLE:
+			viaBossbars.get(packet.getId()).setColor(BossColor.valueOf(packet.getColor().name()));
+			viaBossbars.get(packet.getId()).setStyle(BossStyle.valueOf(packet.getOverlay().getBukkitName()));
+			break;
+		case UPDATE_PROPERTIES:
+			bar = viaBossbars.get(packet.getId());
+			//fog missing from via API
+			processFlagVia(bar, packet.isDarkenScreen(), BossFlag.DARKEN_SKY);
+			processFlagVia(bar, packet.isPlayMusic(), BossFlag.PLAY_BOSS_MUSIC);
+			break;
+		default:
+			break;
+		}
+	}
+	
 	private void processFlag(BossBar bar, boolean targetValue, BarFlag flag) {
 		if (targetValue) {
 			if (!bar.hasFlag(flag)) {
@@ -159,61 +192,68 @@ public class BukkitTabPlayer extends ITabPlayer {
 			}
 		}
 	}
+	
+	private void processFlagVia(com.viaversion.viaversion.api.legacy.bossbar.BossBar bar, boolean targetValue, BossFlag flag) {
+		if (targetValue) {
+			if (!bar.hasFlag(flag)) {
+				bar.addFlag(flag);
+			}
+		} else {
+			if (bar.hasFlag(flag)) {
+				bar.removeFlag(flag);
+			}
+		}
+	}
 
 	@Override
 	public boolean hasInvisibilityPotion() {
-		return player.hasPotionEffect(PotionEffectType.INVISIBILITY);
+		return getPlayer().hasPotionEffect(PotionEffectType.INVISIBILITY);
 	}
 
 	@Override
 	public boolean isDisguised() {
 		try {
 			if (!((BukkitPlatform)TAB.getInstance().getPlatform()).isLibsdisguisesEnabled()) return false;
-			return (boolean) Class.forName("me.libraryaddict.disguise.DisguiseAPI").getMethod("isDisguised", Entity.class).invoke(null, player);
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(false, "Failed to check disguise status using LibsDisguises", e);
+			return DisguiseAPI.isDisguised(getPlayer());
+		} catch (NoClassDefFoundError | ExceptionInInitializerError 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;
 		}
 	}
 
 	@Override
 	public Object getSkin() {
 		try {
-			return Class.forName("com.mojang.authlib.GameProfile").getMethod("getProperties").invoke(NMSStorage.getInstance().getMethod("getProfile").invoke(handle));
-		} catch (Exception e) {
-			return TAB.getInstance().getErrorManager().printError(null, "Failed to get skin of " + getName(), e);
+			return ((GameProfile)NMSStorage.getInstance().getProfile.invoke(handle)).getProperties();
+		} catch (ReflectiveOperationException e) {
+			TAB.getInstance().getErrorManager().printError("Failed to get skin of " + getName(), e);
+			return null;
 		}
 	}
 
 	@Override
 	public Player getPlayer() {
-		return player;
+		return (Player) player;
 	}
 
 	@Override
 	public boolean isOnline() {
-		return player.isOnline();
+		return getPlayer().isOnline();
 	}
 
 	@Override
 	public boolean isVanished() {
-		try {
-			if (((BukkitPlatform)TAB.getInstance().getPlatform()).isEssentialsEnabled()) {
-				Object essentials = Bukkit.getPluginManager().getPlugin("Essentials");
-				Object user = essentials.getClass().getMethod("getUser", Player.class).invoke(essentials, player);
-				boolean vanished = (boolean) user.getClass().getMethod("isVanished").invoke(user);
-				if (vanished) return true;
-			}
-			List<MetadataValue> metadata = player.getMetadata("vanished");
-			return !metadata.isEmpty() && metadata.get(0).asBoolean();
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to check vanish status of " + player.getName(), e);
-		}
-		return false;
+		Essentials essentials = ((BukkitPlatform)TAB.getInstance().getPlatform()).getEssentials();
+		if (essentials != null && essentials.getUser(getUniqueId()).isVanished()) return true;
+		List<MetadataValue> metadata = getPlayer().getMetadata("vanished");
+		return !metadata.isEmpty() && metadata.get(0).asBoolean();
 	}
 
 	@SuppressWarnings("deprecation")
 	@Override
 	public int getGamemode() {
-		return player.getGameMode().getValue();
+		return getPlayer().getGameMode().getValue();
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/Main.java

@@ -16,28 +16,35 @@ import org.bukkit.plugin.java.JavaPlugin;
 
 import com.viaversion.viaversion.api.Via;
 
+import me.neznamy.tab.api.ProtocolVersion;
 import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.api.chat.EnumChatFormat;
 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.TabConstants;
 
 /**
  * Main class for Bukkit platform
  */
 public class Main extends JavaPlugin {
 	
+	private boolean viaversion;
+	private boolean protocolsupport;
+	
 	@Override
 	public void onEnable(){
-		Bukkit.getConsoleSender().sendMessage("\u00a77[TAB] Server version: " + Bukkit.getBukkitVersion().split("-")[0] + " (" + Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3] + ")");
+		Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&7[TAB] Server version: " + Bukkit.getBukkitVersion().split("-")[0] + " (" + Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3] + ")"));
 		if (!isVersionSupported()){
 			Bukkit.getPluginManager().disablePlugin(this);
 			return;
 		}
-		TAB.setInstance(new TAB(new BukkitPlatform(this, NMSStorage.getInstance()), new BukkitPacketBuilder(NMSStorage.getInstance()), ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0])));
+		viaversion = Bukkit.getPluginManager().isPluginEnabled("ViaVersion");
+		protocolsupport = Bukkit.getPluginManager().isPluginEnabled("ProtocolSupport");
+		TAB.setInstance(new TAB(new BukkitPlatform(this), ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0])));
 		if (TAB.getInstance().getServerVersion() == ProtocolVersion.UNKNOWN) {
-			Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Unknown server version: " + Bukkit.getBukkitVersion() + "! Plugin may not work correctly.");
+			Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Unknown server version: " + Bukkit.getBukkitVersion() + "! Plugin may not work correctly."));
 		}
-		Bukkit.getPluginManager().registerEvents(new BukkitEventListener(), this);
+		Bukkit.getPluginManager().registerEvents(new BukkitEventListener(this), this);
 		TABCommand command = new TABCommand();
 		Bukkit.getPluginCommand("tab").setExecutor(command);
 		Bukkit.getPluginCommand("tab").setTabCompleter(command);
@@ -45,9 +52,8 @@ public class Main extends JavaPlugin {
 		Metrics metrics = new Metrics(this, 5304);
 		metrics.addCustomChart(new SimplePie("unlimited_nametag_mode_enabled", () -> TAB.getInstance().getFeatureManager().isFeatureEnabled("nametagx") ? "Yes" : "No"));
 		metrics.addCustomChart(new SimplePie("placeholderapi", () -> Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI") ? "Yes" : "No"));
-		metrics.addCustomChart(new SimplePie("permission_system", () -> TAB.getInstance().getPermissionPlugin().getName()));
-		metrics.addCustomChart(new SimplePie("server_version", () -> "1." + NMSStorage.getInstance().getMinorVersion() + ".x"));
-		metrics.addCustomChart(new SimplePie("using_premium_version", () -> TAB.getInstance().isPremium() ? "Yes" : "No"));
+		metrics.addCustomChart(new SimplePie("permission_system", () -> TAB.getInstance().getGroupManager().getPlugin().getName()));
+		metrics.addCustomChart(new SimplePie("server_version", () -> "1." + TAB.getInstance().getServerVersion().getMinorVersion() + ".x"));
 	}
 
 	@Override
@@ -65,24 +71,26 @@ public class Main extends JavaPlugin {
 				"v1_5_R1", "v1_5_R2", "v1_5_R3", "v1_6_R1", "v1_6_R2", "v1_6_R3",
 				"v1_7_R1", "v1_7_R2", "v1_7_R3", "v1_7_R4", "v1_8_R1", "v1_8_R2", "v1_8_R3",
 				"v1_9_R1", "v1_9_R2", "v1_10_R1", "v1_11_R1", "v1_12_R1", "v1_13_R1", "v1_13_R2",
-				"v1_14_R1", "v1_15_R1", "v1_16_R1", "v1_16_R2", "v1_16_R3", "v1_17_R1");
+				"v1_14_R1", "v1_15_R1", "v1_16_R1", "v1_16_R2", "v1_16_R3", "v1_17_R1", "v1_18_R1");
 		String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
 		try {
+			long time = System.currentTimeMillis();
 			NMSStorage.setInstance(new NMSStorage());
 			if (supportedVersions.contains(serverPackage)) {
+				Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&7[TAB] Loaded NMS hook in " + (System.currentTimeMillis()-time) + "ms"));
 				return true;
 			} else {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] No compatibility issue was found, but this plugin version does not claim to support your server version. This jar has only been tested on 1.5.x - 1.17. Disabling just to stay safe.");
+				Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] No compatibility issue was found, but this plugin version does not claim to support your server version. This jar has only been tested on 1.5.x - 1.18. Disabling just to stay safe."));
 			}
 		} catch (Exception ex) {
 			if (supportedVersions.contains(serverPackage)) {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Your server version is marked as compatible, but a compatibility issue was found. Please report the error below (include your server version & fork too)");
+				Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Your server version is marked as compatible, but a compatibility issue was found. Please report the error below (include your server version & fork too)"));
 				Bukkit.getConsoleSender().sendMessage(ex.getClass().getName() + ": " + ex.getMessage());
 				for (StackTraceElement e : ex.getStackTrace()) {
-					Bukkit.getConsoleSender().sendMessage(e.toString());
+					Bukkit.getConsoleSender().sendMessage("\t" + e.toString());
 				}
 			} else {
-				Bukkit.getConsoleSender().sendMessage("\u00a7c[TAB] Your server version is completely unsupported. This plugin version only supports 1.5.x - 1.17. Disabling.");
+				Bukkit.getConsoleSender().sendMessage(EnumChatFormat.color("&c[TAB] Your server version is completely unsupported. This plugin version only supports 1.5.x - 1.18. Disabling."));
 			}
 		}
 		return false;
@@ -92,14 +100,14 @@ public class Main extends JavaPlugin {
 	 * Gets protocol version and returns it
 	 * @return protocol version of this player
 	 */
-	public static int getProtocolVersion(Player player) {
-		if (Bukkit.getPluginManager().isPluginEnabled("ProtocolSupport")){
+	public int getProtocolVersion(Player player) {
+		if (protocolsupport){
 			int version = getProtocolVersionPS(player);
 			//some PS versions return -1 on unsupported server versions instead of throwing exception
 			if (version != -1 && version < TAB.getInstance().getServerVersion().getNetworkId()) return version;
 		}
-		if (Bukkit.getPluginManager().isPluginEnabled("ViaVersion")) {
-			return getProtocolVersionVia(player);
+		if (viaversion) {
+			return getProtocolVersionVia(player, 0);
 		}
 		return TAB.getInstance().getServerVersion().getNetworkId();
 	}
@@ -108,14 +116,14 @@ public class Main extends JavaPlugin {
 	 * Returns protocol version of this player using ProtocolSupport
 	 * @return protocol version of this player using ProtocolSupport
 	 */
-	private static int getProtocolVersionPS(Player player){
+	private int getProtocolVersionPS(Player player){
 		try {
 			Object protocolVersion = Class.forName("protocolsupport.api.ProtocolSupportAPI").getMethod("getProtocolVersion", Player.class).invoke(null, player);
 			int version = (int) protocolVersion.getClass().getMethod("getId").invoke(protocolVersion);
 			TAB.getInstance().debug("ProtocolSupport returned protocol version " + version + " for " + player.getName() + "(online=" + player.isOnline() + ")");
 			return version;
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get protocol version of " + player.getName() + " using ProtocolSupport", e);
+		} catch (ReflectiveOperationException e) {
+			TAB.getInstance().getErrorManager().printError(String.format("Failed to get protocol version of %s using ProtocolSupport", player.getName()), e);
 			return TAB.getInstance().getServerVersion().getNetworkId();
 		}
 	}
@@ -124,13 +132,25 @@ public class Main extends JavaPlugin {
 	 * Returns protocol version of this player using ViaVersion
 	 * @return protocol version of this player using ViaVersion
 	 */
-	private static int getProtocolVersionVia(Player player){
+	private int getProtocolVersionVia(Player player, int retryLevel){
 		try {
+			if (retryLevel == 10) {
+				TAB.getInstance().debug("Failed to get protocol version of " + player.getName() + " after 10 retries");
+				return TAB.getInstance().getServerVersion().getNetworkId();
+			}
 			int version = Via.getAPI().getPlayerVersion(player.getUniqueId());
+			if (version == -1) {
+				if (!player.isOnline()) return TAB.getInstance().getServerVersion().getNetworkId();
+				Thread.sleep(5);
+				return getProtocolVersionVia(player, retryLevel + 1);
+			}
 			TAB.getInstance().debug("ViaVersion returned protocol version " + version + " for " + player.getName() + "(online=" + player.isOnline() + ")");
 			return version;
-		} catch (Exception e) {
-			TAB.getInstance().getErrorManager().printError("Failed to get protocol version of " + player.getName() + " using ViaVersion v" + Bukkit.getPluginManager().getPlugin("ViaVersion").getDescription().getVersion(), e);
+		} catch (InterruptedException e) {
+			Thread.currentThread().interrupt();
+			return -1;
+		} catch (Exception | NoClassDefFoundError e) {
+			TAB.getInstance().getErrorManager().printError(String.format("Failed to get protocol version of %s using ViaVersion v%s", player.getName(), Bukkit.getPluginManager().getPlugin("ViaVersion").getDescription().getVersion()), e);
 			return TAB.getInstance().getServerVersion().getNetworkId();
 		}
 	}
@@ -140,8 +160,8 @@ public class Main extends JavaPlugin {
 		@Override
 		public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
 			if (TAB.getInstance().isDisabled()) {
-				for (String message : TAB.getInstance().getDisabledCommand().execute(args, sender.hasPermission("tab.reload"), sender.hasPermission("tab.admin"))) {
-					sender.sendMessage(message.replace('&', '\u00a7'));
+				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;

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/event/TabLoadEvent.java

@@ -1,4 +1,4 @@
-package me.neznamy.tab.api.event;
+package me.neznamy.tab.platforms.bukkit.event;
 
 import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
@@ -7,13 +7,13 @@ import org.bukkit.event.HandlerList;
  * Bukkit event that is called each time TAB fully loads. This includes server startup, reload,
  * /tab reload and /plugman reload tab
  */
-public class BukkitTABLoadEvent extends Event {
+public class TabLoadEvent extends Event {
 
 	private static final HandlerList handlers = new HandlerList();
 
 	@Override
 	public HandlerList getHandlers(){
-		return handlers;
+		return getHandlerList();
 	}
 	
 	public static HandlerList getHandlerList() {

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/event/TabPlayerLoadEvent.java

@@ -0,0 +1,33 @@
+package me.neznamy.tab.platforms.bukkit.event;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import me.neznamy.tab.api.TabPlayer;
+
+/**
+ * Bukkit event that is called when player is successfully loaded after joining. This also includes plugin reloading.
+ */
+public class TabPlayerLoadEvent extends Event {
+
+	private static final HandlerList handlers = new HandlerList();
+
+	private final TabPlayer player;
+	
+	public TabPlayerLoadEvent(TabPlayer player) {
+		this.player = player;
+	}
+	
+	@Override
+	public HandlerList getHandlers(){
+		return getHandlerList();
+	}
+	
+	public static HandlerList getHandlerList() {
+		return handlers;
+	}
+	
+	public TabPlayer getPlayer() {
+		return player;
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/PerWorldPlayerlist.java

@@ -14,44 +14,32 @@ import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import me.neznamy.tab.api.TabFeature;
+import me.neznamy.tab.shared.TabConstants;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
-import me.neznamy.tab.shared.features.types.Loadable;
 
 /**
  * Per-world-playerlist feature handler
  */
 @SuppressWarnings("deprecation")
-public class PerWorldPlayerlist implements Loadable, Listener {
+public class PerWorldPlayerlist extends TabFeature implements Listener {
 	
 	//plugin instance
-	private JavaPlugin plugin;
+	private final JavaPlugin plugin;
 	
 	//config options
-	private boolean allowBypass;
-	private List<String> ignoredWorlds;
-	private Map<String, List<String>> sharedWorlds;
+	private final boolean allowBypass = TAB.getInstance().getConfiguration().getConfig().getBoolean("per-world-playerlist.allow-bypass-permission", false);
+	private final List<String> ignoredWorlds = TAB.getInstance().getConfiguration().getConfig().getStringList("per-world-playerlist.ignore-effect-in-worlds", Arrays.asList("ignoredworld", "build"));
+	private final Map<String, List<String>> sharedWorlds = TAB.getInstance().getConfiguration().getConfig().getConfigurationSection("per-world-playerlist.shared-playerlist-world-groups");
 
 	/**
 	 * Constructs new instance with given parameters and loads config options
 	 * @param plugin - plugin instance
-	 * @param tab - tab instance
 	 */
-	public PerWorldPlayerlist(JavaPlugin plugin, TAB tab) {
+	public PerWorldPlayerlist(JavaPlugin plugin) {
+		super("Per world playerlist", null);
 		this.plugin = plugin;
-		allowBypass = tab.getConfiguration().getConfig().getBoolean("per-world-playerlist.allow-bypass-permission", false);
-		ignoredWorlds = tab.getConfiguration().getConfig().getStringList("per-world-playerlist.ignore-effect-in-worlds", Arrays.asList("ignoredworld", "build"));
-		sharedWorlds = tab.getConfiguration().getConfig().getConfigurationSection("per-world-playerlist.shared-playerlist-world-groups");
-		for (Entry<String, List<String>> group : sharedWorlds.entrySet()) {
-			if (group.getValue() == null) {
-				tab.getErrorManager().startupWarn("World group \"" + group + "\" in per-world-playerlist does not contain any worlds. You can just remove the group.");
-			} else if (group.getValue().size() == 1) {
-				tab.getErrorManager().startupWarn("World group \"" + group + "\" in per-world-playerlist only contain a single world (\"" + group.getValue().get(0) +
-						"\"), which has no effect and only makes config less readable. Delete the group entirely for a cleaner config.");
-			}
-		}
-		tab.debug(String.format("Loaded PerWorldPlayerlist feature with parameters allowBypass=%s, ignoredWorlds=%s, sharedWorlds=%s", allowBypass, ignoredWorlds, sharedWorlds));
+		TAB.getInstance().debug(String.format("Loaded PerWorldPlayerlist feature with parameters allowBypass=%s, ignoredWorlds=%s, sharedWorlds=%s", allowBypass, ignoredWorlds, sharedWorlds));
 		Bukkit.getPluginManager().registerEvents(this, plugin);
 	}
 	
@@ -74,14 +62,14 @@ public class PerWorldPlayerlist implements Loadable, Listener {
 	public void onJoin(PlayerJoinEvent e) {
 		long time = System.nanoTime();
 		checkPlayer(e.getPlayer());
-		TAB.getInstance().getCPUManager().addTime(TabFeature.PER_WORLD_PLAYERLIST, UsageType.PLAYER_JOIN_EVENT, System.nanoTime()-time);
+		TAB.getInstance().getCPUManager().addTime(getFeatureName(), TabConstants.CpuUsageCategory.PLAYER_JOIN, System.nanoTime()-time);
 	}
 	
 	@EventHandler
 	public void onWorldChange(PlayerChangedWorldEvent e) {
 		long time = System.nanoTime();
 		checkPlayer(e.getPlayer());
-		TAB.getInstance().getCPUManager().addTime(TabFeature.PER_WORLD_PLAYERLIST, UsageType.WORLD_SWITCH_EVENT, System.nanoTime()-time);
+		TAB.getInstance().getCPUManager().addTime(getFeatureName(), TabConstants.CpuUsageCategory.WORLD_SWITCH, System.nanoTime()-time);
 	}
 	
 	private void checkPlayer(Player p) {
@@ -96,7 +84,7 @@ public class PerWorldPlayerlist implements Loadable, Listener {
 	
 	private boolean shouldSee(Player viewer, Player target) {
 		if (target == viewer) return true;
-		if ((allowBypass && viewer.hasPermission("tab.bypass")) || ignoredWorlds.contains(viewer.getWorld().getName())) 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()) {

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/PetFix.java

@@ -1,53 +1,47 @@
 package me.neznamy.tab.platforms.bukkit.features;
 
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import me.neznamy.tab.api.TabFeature;
 import me.neznamy.tab.api.TabPlayer;
 import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
 import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
 import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherItem;
 import me.neznamy.tab.shared.TAB;
-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 {
+public class PetFix extends TabFeature {
+
+	//nms storage
+	private final NMSStorage nms = NMSStorage.getInstance();
 
 	//datawatcher position of pet owner field
-	private int petOwnerPosition;
+	private final int petOwnerPosition = getPetOwnerPosition();
 
 	//logger of last interacts to prevent feature not working on 1.16
-	private Map<String, Long> lastInteractFix = new HashMap<>();
-	
-	//nms storage
-	private NMSStorage nms;
-	
+	private final Map<String, Long> lastInteractFix = new HashMap<>();
+
 	/**
 	 * Constructs new instance with given parameter
-	 * @param nms
 	 */
-	public PetFix(NMSStorage nms) {
-		this.nms = nms;
-		petOwnerPosition = getPetOwnerPosition();
+	public PetFix() {
+		super("Pet name fix", null);
 		TAB.getInstance().debug("Loaded PetFix feature");
 	}
-	
+
 	/**
 	 * Returns position of pet owner field based on server version
 	 * @return position of pet owner field based on server version
 	 */
 	private int getPetOwnerPosition() {
 		if (nms.getMinorVersion() >= 17) {
-			//1.17.x
+			//1.17.x, 1.18.x
 			return 18;
 		} else if (nms.getMinorVersion() >= 15) {
 			//1.15.x, 1.16.x
@@ -63,77 +57,66 @@ public class PetFix implements RawPacketListener, QuitEventListener {
 			return 13;
 		}
 	}
-	
+
 	/**
 	 * Cancels a packet if previous one arrived with no delay to prevent double toggle on 1.16
-	 * @throws IllegalAccessException 
+	 * @throws ReflectiveOperationException 
 	 */
 	@Override
-	public Object onPacketReceive(TabPlayer sender, Object packet) throws IllegalAccessException {
-		if (nms.getClass("PacketPlayInUseEntity").isInstance(packet)) {
+	public boolean onPacketReceive(TabPlayer sender, Object packet) throws ReflectiveOperationException {
+		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;
+				return true;
 			}
-			if (isInteract(nms.getField("PacketPlayInUseEntity_ACTION").get(packet))) {
+			if (isInteract(nms.PacketPlayInUseEntity_ACTION.get(packet))) {
 				//this is the first packet, saving player so the next packet can be cancelled
 				lastInteractFix.put(sender.getName(), System.currentTimeMillis());
 			}
 		}
-		return packet;
+		return false;
 	}
-	
+
 	private boolean isInteract(Object action) {
 		if (nms.getMinorVersion() >= 17) {
-			return nms.getClass("PacketPlayInUseEntity$d").isInstance(action);
+			return nms.PacketPlayInUseEntity$d.isInstance(action);
 		} else {
 			return action.toString().equals("INTERACT");
 		}
 	}
-	
+
 	/**
 	 * Removes pet owner field from datawatcher
-	 * @throws IllegalAccessException 
-	 * @throws SecurityException 
-	 * @throws NoSuchMethodException 
-	 * @throws InvocationTargetException 
-	 * @throws InstantiationException 
+	 * @throws ReflectiveOperationException
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
-	public void onPacketSend(TabPlayer receiver, Object packet) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException, SecurityException, InstantiationException {
-		if (nms.getClass("PacketPlayOutEntityMetadata").isInstance(packet)) {
+	public void onPacketSend(TabPlayer receiver, Object packet) throws ReflectiveOperationException {
+		if (nms.PacketPlayOutEntityMetadata.isInstance(packet)) {
 			Object removedEntry = null;
-			List<Object> items = (List<Object>) nms.getField("PacketPlayOutEntityMetadata_LIST").get(packet);
+			List<Object> items = (List<Object>) nms.PacketPlayOutEntityMetadata_LIST.get(packet);
 			if (items == null) return;
 			for (Object item : items) {
-				if (nms.getField("DataWatcherObject_SLOT").getInt(nms.getField("DataWatcherItem_TYPE").get(item)) == petOwnerPosition) {
-					Object value = nms.getField("DataWatcherItem_VALUE").get(item);
+				if (item == null) continue;
+				if (nms.DataWatcherObject_SLOT.getInt(nms.DataWatcherItem_TYPE.get(item)) == petOwnerPosition) {
+					Object value = nms.DataWatcherItem_VALUE.get(item);
 					if (value instanceof java.util.Optional || value instanceof com.google.common.base.Optional) {
 						removedEntry = item;
-						break;
 					}
 				}
 			}
 			if (removedEntry != null) items.remove(removedEntry);
-		}
-		//<1.15
-		Field datawatcher = nms.getField("PacketPlayOutSpawnEntityLiving_DATAWATCHER");
-		if (nms.getClass("PacketPlayOutSpawnEntityLiving").isInstance(packet) && datawatcher != null) {
-			DataWatcher watcher = DataWatcher.fromNMS(datawatcher.get(packet));
+		} else if (nms.PacketPlayOutSpawnEntityLiving.isInstance(packet) && nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER != null) {
+			//<1.15
+			DataWatcher watcher = DataWatcher.fromNMS(nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER.get(packet));
 			DataWatcherItem petOwner = watcher.getItem(petOwnerPosition);
 			if (petOwner != null && (petOwner.getValue() instanceof java.util.Optional || petOwner.getValue() instanceof com.google.common.base.Optional)) {
 				watcher.removeValue(petOwnerPosition);
-				nms.setField(packet, "PacketPlayOutSpawnEntityLiving_DATAWATCHER", watcher.toNMS());
+				nms.setField(packet, nms.PacketPlayOutSpawnEntityLiving_DATAWATCHER, watcher.toNMS());
 			}
 		}
 	}
 
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.PET_NAME_FIX;
-	}
-
 	/**
 	 * Removing player data to not have a memory leak
 	 */

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/TabExpansion.java

@@ -1,16 +1,18 @@
 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.PlaceholderAPI;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.neznamy.tab.api.Property;
+import me.neznamy.tab.api.TabAPI;
 import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.BukkitPlatform;
-import me.neznamy.tab.shared.Property;
+import me.neznamy.tab.api.bossbar.BossBarManager;
+import me.neznamy.tab.api.scoreboard.Scoreboard;
+import me.neznamy.tab.api.scoreboard.ScoreboardManager;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.placeholders.Placeholder;
+import me.neznamy.tab.shared.features.scoreboard.ScoreboardManagerImpl;
 
 /**
  * TAB's expansion for PlaceholderAPI
@@ -18,8 +20,7 @@ import me.neznamy.tab.shared.placeholders.Placeholder;
 public class TabExpansion extends PlaceholderExpansion {
 
 	//plugin to take plugin.yml data from
-	private JavaPlugin plugin;
-	
+	private final JavaPlugin plugin;
 	
 	/**
 	 * Constructs new instance of the class and registers it
@@ -59,25 +60,47 @@ public class TabExpansion extends PlaceholderExpansion {
 	public String onPlaceholderRequest(Player player, String identifier){
 		if (player == null) return "";
 		TabPlayer p = TAB.getInstance().getPlayer(player.getUniqueId());
-		if (identifier.equals("scoreboard_visible")) {
-			return translate(p.isScoreboardVisible());
+		if ("scoreboard_visible".equals(identifier)) {
+			return translate(hasScoreboardVisible(p));
 		}
-		if (identifier.equals("bossbar_visible")) {
-			return translate(p.hasBossbarVisible());
+		if ("scoreboard_name".equals(identifier)) {
+			return getActiveScoreboard(p);
 		}
-		if (identifier.equals("ntpreview")) {
+		if ("bossbar_visible".equals(identifier)) {
+			return translate(hasBossBarVisible(p));
+		}
+		if ("ntpreview".equals(identifier)) {
 			return translate(p.isPreviewingNametag());
 		}
 		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 TAB.getInstance().getPlaceholderManager().getPlaceholder("%" + identifier.substring(12) + "%").getLastValue(p);
 		}
 		return getProperty(identifier, p);
 	}
 	
+	private boolean hasBossBarVisible(TabPlayer p) {
+		BossBarManager boss = (BossBarManager) TAB.getInstance().getFeatureManager().getFeature("bossbar");
+		if (boss == null) return false;
+		return boss.hasBossBarVisible(p);
+	}
+	
+	private boolean hasScoreboardVisible(TabPlayer p) {
+		ScoreboardManager scoreboard = (ScoreboardManager) TAB.getInstance().getFeatureManager().getFeature("scoreboard");
+		if (scoreboard == null) return false;
+		return scoreboard.hasScoreboardVisible(p);
+	}
+	
+	private String getActiveScoreboard(TabPlayer p) {
+		ScoreboardManagerImpl sb = (ScoreboardManagerImpl) TabAPI.getInstance().getScoreboardManager();
+		if (sb == null) return "";
+		Scoreboard active = sb.getActiveScoreboards().get(p);
+		if (active == null) return "";
+		return active.getName();
+	}
+	
 	private String translate(boolean b) {
 		return b ? "Enabled" : "Disabled";
 	}
@@ -89,10 +112,8 @@ public class TabExpansion extends PlaceholderExpansion {
 	 * @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().getPremiumConfig().getConfigurationSection("placeholder-output-replacements." + placeholder);
-		return Placeholder.findReplacement(replacements, output).replace("%value%", output);
+		String output = PlaceholderAPI.setPlaceholders(player, placeholder);
+		return TAB.getInstance().getPlaceholderManager().findReplacement(placeholder, output).replace("%value%", output);
 	}
 	
 	/**

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/WitherBossBar.java

@@ -1,5 +1,7 @@
 package me.neznamy.tab.platforms.bukkit.features;
 
+import java.util.Arrays;
+
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
@@ -10,58 +12,53 @@ import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import me.neznamy.tab.api.TabPlayer;
-import me.neznamy.tab.platforms.bukkit.BukkitPacketBuilder;
+import me.neznamy.tab.api.bossbar.BossBar;
+import me.neznamy.tab.platforms.bukkit.nms.PacketPlayOutEntityTeleport;
+import me.neznamy.tab.shared.TabConstants;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
-import me.neznamy.tab.shared.features.bossbar.BossBar;
-import me.neznamy.tab.shared.features.types.Loadable;
+import me.neznamy.tab.shared.features.bossbar.BossBarManagerImpl;
 
 /**
  * An additional class with additional code for <1.9 servers due to an entity being required
  */
-public class WitherBossBar implements Listener, Loadable {
+public class WitherBossBar extends BossBarManagerImpl implements Listener {
 
 	//distance of wither in blocks
-	private static final int WITHER_DISTANCE = 75;
-	
-	//main bossbar feature
-	private BossBar mainFeature;
+	private static final int WITHER_DISTANCE = 60;
 	
 	/**
 	 * Constructs a new instance of the class
-	 * @param mainFeature - main bossbar feature
+	 * @param plugin - plugin instance
 	 */
-	public WitherBossBar(TAB tab, JavaPlugin plugin) {
-		this.mainFeature = (BossBar) tab.getFeatureManager().getFeature("bossbar");
+	public WitherBossBar(JavaPlugin plugin) {
 		Bukkit.getPluginManager().registerEvents(this, plugin);
-		//bar disappears in client after ~1 second of not seeing boss entity
-		tab.getCPUManager().startRepeatingMeasuredTask(900, "refreshing bossbar", TabFeature.BOSSBAR, UsageType.TELEPORTING_ENTITY, this::teleport);
+		//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().getPlaceholderManager().registerPlayerPlaceholder("%location%", 100, p -> ((Player)p.getPlayer()).getLocation());
+		addUsedPlaceholders(Arrays.asList("%location%"));
 	}
 	
 	@Override
 	public void load() {
-		teleport();
-	}
-	
-	/**
-	 * Updates wither location for all players
-	 */
-	private void teleport() {
-		for (TabPlayer all : TAB.getInstance().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.getInstance().getPacketBuilder()).buildEntityTeleportPacket(l.getUniqueId().hashCode(), getWitherLocation(all)), TabFeature.BOSSBAR);
-				} catch (Exception e) {
-					TAB.getInstance().getErrorManager().printError("Failed to create PacketPlayOutEntityTeleport", e);
-				}
-			}
+		super.load();
+		for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+			refresh(p, false);
 		}
 	}
-
+	
+	@Override
+	public void refresh(TabPlayer p, boolean force) {
+		for (BossBar line : getRegisteredBossBars().values()) {
+			if (p.getVersion().getMinorVersion() > 8) continue; //sending VV packets to those
+			Location loc = ((Player) p.getPlayer()).getEyeLocation().add(((Player) p.getPlayer()).getEyeLocation().getDirection().normalize().multiply(WITHER_DISTANCE));
+			if (loc.getY() < 1) loc.setY(1);
+			p.sendCustomPacket(new PacketPlayOutEntityTeleport(line.getUniqueId().hashCode(), loc), TabConstants.PacketCategory.BOSSBAR_WITHER_TELEPORT);
+		}
+	}
+	
 	@Override
 	public void unload() {
+		super.unload();
 		HandlerList.unregisterAll(this);
 	}
 	
@@ -70,18 +67,6 @@ public class WitherBossBar implements Listener, Loadable {
 	 */
 	@EventHandler
 	public void onRespawn(PlayerRespawnEvent e) {
-		TAB.getInstance().getCPUManager().runMeasuredTask("processing PlayerRespawnEvent", TabFeature.BOSSBAR, UsageType.PLAYER_RESPAWN_EVENT, () -> mainFeature.detectBossBarsAndSend(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId())));
-	}
-	
-	/**
-	 * 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;
+		TAB.getInstance().getCPUManager().runMeasuredTask("processing PlayerRespawnEvent", this, TabConstants.CpuUsageCategory.PLAYER_RESPAWN, () -> detectBossBarsAndSend(TAB.getInstance().getPlayer(e.getPlayer().getUniqueId())));
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/unlimitedtags/BukkitArmorStand.java

@@ -1,49 +1,53 @@
 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.Property;
 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.NMSStorage;
+import me.neznamy.tab.api.chat.EnumChatFormat;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
+import me.neznamy.tab.api.protocol.TabPacket;
+import me.neznamy.tab.platforms.bukkit.nms.PacketPlayOutEntityDestroy;
+import me.neznamy.tab.platforms.bukkit.nms.PacketPlayOutEntityMetadata;
+import me.neznamy.tab.platforms.bukkit.nms.PacketPlayOutEntityTeleport;
+import me.neznamy.tab.platforms.bukkit.nms.PacketPlayOutSpawnEntityLiving;
 import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
-import me.neznamy.tab.shared.Property;
+import me.neznamy.tab.shared.TabConstants;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
-import me.neznamy.tab.shared.packets.IChatBaseComponent;
 
 /**
  * A class representing an armor stand attached to a player (if the feature is enabled)
  */
 public class BukkitArmorStand implements ArmorStand {
 
+	private static boolean alwaysVisible = TAB.getInstance().getConfiguration().isArmorStandsAlwaysVisible();
+	//entity id counter to pick unique entity IDs
+	private static int idCounter = 2000000000;
+
+	//nametag feature
+	private final NameTagX manager = (NameTagX) TAB.getInstance().getFeatureManager().getFeature("nametagx");
+
 	//owner of the armor stand
-	private TabPlayer owner;
+	private final TabPlayer owner;
 
 	//instance of Bukkit player
-	private Player player;
+	private final Player player;
 
 	//offset in blocks, 0 for original height
 	private double yOffset;
 
 	//entity ID of this armor stand
-	private int entityId;
+	private final int entityId = idCounter++;
 
 	//unique ID of this armor stand
-	private UUID uuid = UUID.randomUUID();
+	private final UUID uuid = UUID.randomUUID();
 
 	//sneaking flag of armor stands
 	private boolean sneaking;
@@ -51,17 +55,14 @@ public class BukkitArmorStand implements ArmorStand {
 	//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;
+	private final 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;
+	//entity destroy packet
+	private final PacketPlayOutEntityDestroy destroyPacket = new PacketPlayOutEntityDestroy(entityId);
 
 	/**
 	 * Constructs new instance with given parameters
@@ -70,14 +71,12 @@ public class BukkitArmorStand implements ArmorStand {
 	 * @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, boolean markerFor18x) {
-		this.entityId = entityId;
+	public BukkitArmorStand(TabPlayer owner, Property property, double yOffset, boolean staticOffset) {
 		this.owner = owner;
 		this.staticOffset = staticOffset;
 		player = (Player) owner.getPlayer();
 		this.yOffset = yOffset;
 		this.property = property;
-		this.markerFor18x = markerFor18x;
 		visible = getVisibility();
 	}
 
@@ -106,99 +105,63 @@ public class BukkitArmorStand implements ArmorStand {
 	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 (NMSStorage.getInstance().getMinorVersion() >= 15) {
-			return new Object[] {
-					getSpawnPacket(getArmorStandLocationFor(viewer), null),
-					getMetadataPacket(dataWatcher)
-			};
-		} else {
-			return new Object[] {
-					getSpawnPacket(getArmorStandLocationFor(viewer), dataWatcher)
-			};
+		for (TabPlayer all : owner.getArmorStandManager().getNearbyPlayers()) {
+			all.sendCustomPacket(getTeleportPacket(all), TabConstants.PacketCategory.UNLIMITED_NAMETAGS_OFFSET_CHANGE);
 		}
 	}
 
 	@Override
 	public void spawn(TabPlayer viewer) {
-		for (Object packet : getSpawnPackets(viewer)) {
-			viewer.sendPacket(packet, TabFeature.NAMETAGX);
+		for (TabPacket packet : getSpawnPackets(viewer)) {
+			viewer.sendCustomPacket(packet, TabConstants.PacketCategory.UNLIMITED_NAMETAGS_SPAWN);
 		}
 	}
 
-	/**
-	 * Returns location where armor stand should be for specified viewer
-	 * @param viewer - player to get location for
-	 * @return location of armor stand
-	 */
-	protected Location getArmorStandLocationFor(TabPlayer viewer) {
-		return viewer.getVersion().getMinorVersion() == 8 && !markerFor18x ? getLocation().clone().add(0,-2,0) : getLocation();
+	@Override
+	public void destroy() {
+		for (TabPlayer all : TAB.getInstance().getOnlinePlayers()) all.sendCustomPacket(destroyPacket, TabConstants.PacketCategory.UNLIMITED_NAMETAGS_DESPAWN);
 	}
-
+	
 	@Override
 	public void destroy(TabPlayer viewer) {
-		nearbyPlayers.remove(viewer);
-		viewer.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
+		viewer.sendCustomPacket(destroyPacket, TabConstants.PacketCategory.UNLIMITED_NAMETAGS_DESPAWN);
 	}
 
 	@Override
 	public void teleport() {
-		for (TabPlayer all : getNearbyPlayers()) {
-			all.sendPacket(getTeleportPacket(all), TabFeature.NAMETAGX);
+		for (TabPlayer all : owner.getArmorStandManager().getNearbyPlayers()) {
+			all.sendCustomPacket(getTeleportPacket(all), TabConstants.PacketCategory.UNLIMITED_NAMETAGS_TELEPORT);
 		}
 	}
 
 	@Override
 	public void teleport(TabPlayer viewer) {
-		viewer.sendPacket(getTeleportPacket(viewer), TabFeature.NAMETAGX);
+		if (!owner.getArmorStandManager().isNearby(viewer) && viewer != owner) {
+			owner.getArmorStandManager().spawn(viewer);
+		} else {
+			viewer.sendCustomPacket(getTeleportPacket(viewer), TabConstants.PacketCategory.UNLIMITED_NAMETAGS_TELEPORT);
+		}
 	}
 
 	@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().isArmorStandsAlwaysVisible()) {
+		for (TabPlayer viewer : owner.getArmorStandManager().getNearbyPlayers()) {
+			if (viewer.getVersion().getMinorVersion() == 14 && !alwaysVisible) {
 				//1.14.x client sided bug, despawning completely
 				if (sneaking) {
-					viewer.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
+					viewer.sendCustomPacket(destroyPacket, TabConstants.PacketCategory.UNLIMITED_NAMETAGS_SNEAK);
 				} 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();
-				}
+				respawn(viewer);
 			}
 		}
 	}
 
-	@Override
-	public void destroy() {
-		for (TabPlayer all : TAB.getInstance().getPlayers()) all.sendPacket(getDestroyPacket(), TabFeature.NAMETAGX);
-		nearbyPlayers.clear();
-	}
-
 	@Override
 	public void updateVisibility(boolean force) {
 		boolean visibility = getVisibility();
@@ -207,66 +170,27 @@ public class BukkitArmorStand implements ArmorStand {
 			updateMetadata();
 		}
 	}
-	
+
+	@Override
+	public int getEntityId() {
+		return entityId;
+	}
 
 	/**
 	 * Returns teleport packet for specified viewer
 	 * @param viewer - player to get location for
 	 * @return teleport packet
 	 */
-	protected 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
-	 */
-	protected 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
-	 */
-	protected 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
-	 */
-	protected 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);
-		}
+	public PacketPlayOutEntityTeleport getTeleportPacket(TabPlayer viewer) {
+		return new PacketPlayOutEntityTeleport(entityId, getArmorStandLocationFor(viewer));
 	}
 
 	/**
 	 * Updates armor stand's metadata
 	 */
-	protected void updateMetadata() {
-		for (TabPlayer viewer : getNearbyPlayers()) {
-			viewer.sendPacket(getMetadataPacket(createDataWatcher(property.getFormat(viewer), viewer)), TabFeature.NAMETAGX);
+	public void updateMetadata() {
+		for (TabPlayer viewer : owner.getArmorStandManager().getNearbyPlayers()) {
+			viewer.sendCustomPacket(new PacketPlayOutEntityMetadata(entityId, createDataWatcher(property.getFormat(viewer), viewer)), TabConstants.PacketCategory.UNLIMITED_NAMETAGS_METADATA);
 		}
 	}
 
@@ -274,24 +198,24 @@ public class BukkitArmorStand implements ArmorStand {
 	 * Returns general visibility rule for everyone with limited info
 	 * @return true if should be visible, false if not
 	 */
-	protected boolean getVisibility() {
-		if (((BukkitTabPlayer)owner).isDisguised() || (((NameTagX)TAB.getInstance().getFeatureManager().getFeature("nametagx")).getPlayersOnBoats().contains(owner))) return false;
-		if (TAB.getInstance().getConfiguration().isArmorStandsAlwaysVisible()) return true;
-		return !player.hasPotionEffect(PotionEffectType.INVISIBILITY) && player.getGameMode() != GameMode.SPECTATOR && !owner.hasHiddenNametag() && property.get().length() > 0;
+	public boolean getVisibility() {
+		if (owner.isDisguised() || manager.getVehicleManager().isOnBoat(owner)) return false;
+		if (alwaysVisible) return true;
+		return !owner.hasInvisibilityPotion() && owner.getGamemode() != 3 && !manager.hasHiddenNametag(owner) && 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
 	 */
-	protected Location getLocation() {
+	public 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 (NMSStorage.getInstance().getMinorVersion() >= 9) {
+			if (TAB.getInstance().getServerVersion().getMinorVersion() >= 9) {
 				y -= (sneaking ? 0.45 : 0.18);
 			} else {
 				y -= (sneaking ? 0.30 : 0.18);
@@ -311,36 +235,26 @@ public class BukkitArmorStand implements ArmorStand {
 			if (vehicle.getType().toString().contains("HORSE")) { //covering all 3 horse types
 				return vehicle.getLocation().getY() + 0.85;
 			}
-			if (vehicle.getType() == EntityType.DONKEY) {
+			if (vehicle.getType().toString().equals("DONKEY")) { //1.11+
 				return vehicle.getLocation().getY() + 0.525;
 			}
 			if (vehicle.getType() == EntityType.PIG) {
 				return vehicle.getLocation().getY() + 0.325;
 			}
-			if (vehicle.getType().toString().equals("STRIDER")) { //added in 1.16
+			if (vehicle.getType().toString().equals("STRIDER")) { //1.16+
 				return vehicle.getLocation().getY() + 1.15;
 			}
 		}
-        //1.13+ swimming or 1.9+ flying with elytra
-        if (isSwimming() || (NMSStorage.getInstance().getMinorVersion() >= 9 && player.isGliding())) {
-            return player.getLocation().getY()-1.22;
-        }
+		//1.13+ swimming or 1.9+ flying with elytra
+		if (isSwimming() || (TAB.getInstance().getServerVersion().getMinorVersion() >= 9 && player.isGliding())) {
+			return player.getLocation().getY()-1.22;
+		}
 		return player.getLocation().getY();
 	}
-	
+
 	private boolean isSwimming() {
-		if (NMSStorage.getInstance().getMinorVersion() >= 14 && player.getPose() == Pose.SWIMMING) return true;
-		return NMSStorage.getInstance().getMinorVersion() == 13 && player.isSwimming();
-	}
-
-	@Override
-	public int getEntityId() {
-		return entityId;
-	}
-
-	@Override
-	public void removeFromRegistered(TabPlayer viewer) {
-		nearbyPlayers.remove(viewer);
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 14 && player.getPose() == Pose.SWIMMING) return true;
+		return TAB.getInstance().getServerVersion().getMinorVersion() == 13 && player.isSwimming();
 	}
 
 	/**
@@ -349,7 +263,7 @@ public class BukkitArmorStand implements ArmorStand {
 	 * @param viewer - player to apply checks against
 	 * @return datawatcher for viewer
 	 */
-	protected DataWatcher createDataWatcher(String displayName, TabPlayer viewer) {
+	public DataWatcher createDataWatcher(String displayName, TabPlayer viewer) {
 		DataWatcher datawatcher = new DataWatcher();
 
 		byte flag = 32; //invisible
@@ -358,30 +272,69 @@ public class BukkitArmorStand implements ArmorStand {
 		datawatcher.helper().setCustomName(displayName, viewer.getVersion());
 
 		boolean visibility;
-		if (isNameVisiblyEmpty(displayName) || !((Player) viewer.getPlayer()).canSee(player) || owner.hasHiddenNametag(viewer.getUniqueId())) {
+		if (isNameVisiblyEmpty(displayName) || !((Player) viewer.getPlayer()).canSee(player) || manager.hasHiddenNametag(owner, viewer)) {
 			visibility = false;
 		} else {
 			visibility = visible;
 		}
 		datawatcher.helper().setCustomNameVisible(visibility);
 
-		if (viewer.getVersion().getMinorVersion() > 8 || markerFor18x) datawatcher.helper().setArmorStandFlags((byte)16);
+		if (viewer.getVersion().getMinorVersion() > 8 || manager.isMarkerFor18x()) datawatcher.helper().setArmorStandFlags((byte)16);
 		return datawatcher;
 	}
 
-	@Override
-	public Set<TabPlayer> getNearbyPlayers(){
-		synchronized (nearbyPlayers) {
-			return new HashSet<>(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;
+		if (displayName.length() == 0) return true;
+		if (!displayName.startsWith(EnumChatFormat.COLOR_STRING) && !displayName.startsWith("&") && !displayName.startsWith("#")) return false;
+		String text = IChatBaseComponent.fromColoredText(displayName).toRawText();
+		if (text.contains(" ")) text = text.replace(" ", "");
+		return text.length() == 0;
+	}
+
+	/**
+	 * 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 TabPacket[] getSpawnPackets(TabPlayer viewer) {
+		visible = getVisibility();
+		DataWatcher dataWatcher = createDataWatcher(property.getFormat(viewer), viewer);
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 15) {
+			return new TabPacket[] {
+					new PacketPlayOutSpawnEntityLiving(entityId, uuid, EntityType.ARMOR_STAND, getArmorStandLocationFor(viewer), null),
+					new PacketPlayOutEntityMetadata(entityId, dataWatcher)
+			};
+		} else {
+			return new TabPacket[] {
+					new PacketPlayOutSpawnEntityLiving(entityId, uuid, EntityType.ARMOR_STAND, getArmorStandLocationFor(viewer), dataWatcher),
+			};
+		}
+	}
+
+	/**
+	 * Returns location where armor stand should be for specified viewer
+	 * @param viewer - player to get location for
+	 * @return location of armor stand
+	 */
+	public Location getArmorStandLocationFor(TabPlayer viewer) {
+		return viewer.getVersion().getMinorVersion() == 8 && !manager.isMarkerFor18x() ? getLocation().clone().add(0,-2,0) : getLocation();
+	}
+
+	@Override
+	public void respawn(TabPlayer viewer) {
+		viewer.sendCustomPacket(destroyPacket, TabConstants.PacketCategory.UNLIMITED_NAMETAGS_DESPAWN);
+		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", manager, TabConstants.CpuUsageCategory.V1_8_0_BUG_COMPENSATION, spawn);
+		} else {
+			spawn.run();
+		}
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/unlimitedtags/EventListener.java

@@ -3,13 +3,13 @@ package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.event.player.PlayerToggleSneakEvent;
 
 import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.shared.TabConstants;
 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
@@ -17,7 +17,7 @@ import me.neznamy.tab.shared.cpu.UsageType;
 public class EventListener implements Listener {
 	
 	//the nametag feature handler
-	private NameTagX feature;
+	private final NameTagX feature;
 
 	/**
 	 * Constructs new instance with given parameters
@@ -34,8 +34,8 @@ public class EventListener implements Listener {
 	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
 	public void onSneak(PlayerToggleSneakEvent e) {
 		TabPlayer p = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
-		if (p == null || !p.isLoaded() || feature.isInDisabledWorld(p)) return;
-		TAB.getInstance().getCPUManager().runMeasuredTask("processing PlayerToggleSneakEvent", TabFeature.NAMETAGX, UsageType.PLAYER_TOGGLE_SNEAK_EVENT, () -> {
+		if (p == null || !p.isLoaded() || feature.isPlayerDisabled(p)) return;
+		TAB.getInstance().getCPUManager().runMeasuredTask("processing PlayerToggleSneakEvent", feature, TabConstants.CpuUsageCategory.PLAYER_SNEAK, () -> {
 			if (p.getArmorStandManager() != null) p.getArmorStandManager().sneak(e.isSneaking());
 		});
 	}
@@ -46,10 +46,37 @@ public class EventListener implements Listener {
 	 */
 	@EventHandler
 	public void onRespawn(PlayerRespawnEvent e) {
-		TAB.getInstance().getCPUManager().runMeasuredTask("processing PlayerRespawnEvent", TabFeature.NAMETAGX, UsageType.PLAYER_RESPAWN_EVENT, () -> {
+		TAB.getInstance().getCPUManager().runMeasuredTask("processing PlayerRespawnEvent", feature, TabConstants.CpuUsageCategory.PLAYER_RESPAWN, () -> {
 			TabPlayer respawned = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
-			if (feature.isInDisabledWorld(respawned)) return;
+			if (feature.isPlayerDisabled(respawned)) return;
 			respawned.getArmorStandManager().teleport();
 		});
 	}
+	
+	@EventHandler
+	public void onWorldChange(PlayerChangedWorldEvent e) {
+		TabPlayer p = TAB.getInstance().getPlayer(e.getPlayer().getUniqueId());
+		if (p == null) return;
+		long time = System.nanoTime();
+		String to = e.getPlayer().getWorld().getName();
+		if (feature.isDisabled(to)) {
+			if (!feature.getPlayersInDisabledUnlimitedWorlds().contains(p))
+				feature.getPlayersInDisabledUnlimitedWorlds().add(p);
+		} else {
+			feature.getPlayersInDisabledUnlimitedWorlds().remove(p);
+		}
+		//TODO delete the block below
+		TabPlayer[] nearby = p.getArmorStandManager().getNearbyPlayers();
+		p.getArmorStandManager().destroy();
+		feature.loadArmorStands(p);
+		feature.getVehicleManager().loadPassengers(p);
+		for (TabPlayer viewer : TAB.getInstance().getOnlinePlayers()) {
+			if (viewer.getArmorStandManager() != null) viewer.getArmorStandManager().destroy(p);
+			if (!to.equals(viewer.getWorld())) continue;
+			for (TabPlayer player : nearby) {
+				if (player == viewer) feature.spawnArmorStands(p, viewer, true);
+			}
+		}
+		TAB.getInstance().getCPUManager().addTime(feature, TabConstants.CpuUsageCategory.WORLD_SWITCH, System.nanoTime()-time);
+	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/unlimitedtags/LocationRefresher.java

@@ -0,0 +1,38 @@
+package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
+
+import java.util.Arrays;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import me.neznamy.tab.api.TabFeature;
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.shared.TAB;
+
+public class LocationRefresher extends TabFeature {
+
+	private final NameTagX feature;
+	
+	public LocationRefresher(NameTagX feature) {
+		super(feature.getFeatureName(), "Processing passengers / preview");
+		this.feature = feature;
+		TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder("%location0%", 50, p -> {
+			
+			if (!feature.getVehicleManager().getPlayersInVehicle().containsKey(p) && !p.isPreviewingNametag()) return null;
+			Location l = ((Player)p.getPlayer()).getLocation();
+			return l.getX()+l.getY()+l.getZ(); //less cpu usage than literal Location#toString() and then .equals() when comparing last value
+		});
+		addUsedPlaceholders(Arrays.asList("%location0%")); //making sure it's not the same one as in WiherBossBar
+	}
+	
+	@Override
+	public void refresh(TabPlayer p, boolean force) {
+		if (feature.getVehicleManager().getPlayersInVehicle().containsKey(p)) {
+			feature.getVehicleManager().processPassengers((Entity) p.getPlayer());
+		}
+		if (p.isPreviewingNametag()) {
+			p.getArmorStandManager().teleport(p);
+		}
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/unlimitedtags/NameTagX.java

@@ -3,209 +3,102 @@ package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Set;
 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.Property;
 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.PropertyUtils;
+import me.neznamy.tab.api.team.UnlimitedNametagManager;
 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.TabConstants;
+import me.neznamy.tab.shared.features.nametags.NameTag;
 
 /**
  * The core class for unlimited nametag mode
  */
-public class NameTagX extends NameTag {
+public class NameTagX extends NameTag implements UnlimitedNametagManager {
 
 	//config options
-	private boolean markerFor18x;
-	private boolean disableOnBoats;
-	private double spaceBetweenLines;
-	
-	//list of worlds with unlimited nametag mode disabled
-	protected List<String> disabledUnlimitedWorlds;
-	
-	//list of defined dynamic lines
-	private List<String> dynamicLines = Arrays.asList(PropertyUtils.BELOWNAME, PropertyUtils.NAMETAG, PropertyUtils.ABOVENAME);
-	
-	//map of defined static lines
-	private Map<String, Object> staticLines = new ConcurrentHashMap<>();
-
-	//entity id counter to pick unique entity IDs
-	private int idCounter = 2000000000;
+	private final boolean markerFor18x = TAB.getInstance().getConfiguration().getConfig().getBoolean("scoreboard-teams.unlimited-nametag-mode.use-marker-tag-for-1-8-x-clients", false);
+	private final boolean disableOnBoats = TAB.getInstance().getConfiguration().getConfig().getBoolean("scoreboard-teams.unlimited-nametag-mode.disable-on-boats", true);
+	private final double spaceBetweenLines = TAB.getInstance().getConfiguration().getConfig().getDouble("scoreboard-teams.unlimited-nametag-mode.space-between-lines", 0.22);
+	protected final List<String> disabledUnlimitedWorlds = TAB.getInstance().getConfiguration().getConfig().getStringList("scoreboard-teams.unlimited-nametag-mode.disable-in-worlds", new ArrayList<>());
+	private final List<String> dynamicLines = new ArrayList<>(TAB.getInstance().getConfiguration().getConfig().getStringList("scoreboard-teams.unlimited-nametag-mode.dynamic-lines", Arrays.asList(TabConstants.Property.ABOVENAME, TabConstants.Property.NAMETAG, TabConstants.Property.BELOWNAME, "another")));
+	private final Map<String, Object> staticLines = TAB.getInstance().getConfiguration().getConfig().getConfigurationSection("scoreboard-teams.unlimited-nametag-mode.static-lines");
 
 	//player data by entityId, used for better performance
-	private Map<Integer, TabPlayer> entityIdMap = new ConcurrentHashMap<>();
-	
-	//map of vehicles carrying players
-	private Map<Integer, List<Entity>> vehicles = new ConcurrentHashMap<>();
-	
+	private final Map<Integer, TabPlayer> entityIdMap = new ConcurrentHashMap<>();
+
 	//bukkit event listener
-	private EventListener eventListener;
+	private final EventListener eventListener = new EventListener(this);
 	
-	//list of players currently on boats
-	private List<TabPlayer> playersOnBoats = new ArrayList<>();
+	private final List<TabPlayer> playersInDisabledUnlimitedWorlds = new ArrayList<>();
+	private final String[] disabledUnlimitedWorldsArray = disabledUnlimitedWorlds.toArray(new String[0]);
+	private final boolean unlimitedWorldWhitelistMode = disabledUnlimitedWorlds.contains("WHITELIST");
 	
-	//list of players currently in a vehicle
-	private Map<TabPlayer, Entity> playersInVehicle = new ConcurrentHashMap<>();
+	private final List<TabPlayer> playersDisabledWithAPI = new ArrayList<>();
 	
-	private Map<TabPlayer, Location> playerLocations = new ConcurrentHashMap<>();
-	
-	private Set<TabPlayer> playersInDisabledUnlimitedWorlds = new HashSet<>();
+	private final VehicleRefresher vehicleManager = new VehicleRefresher(this);
 
 	/**
 	 * 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().getConfig().getBoolean("unlimited-nametag-prefix-suffix-mode.use-marker-tag-for-1-8-x-clients", false);
-		disableOnBoats = tab.getConfiguration().getConfig().getBoolean("unlimited-nametag-prefix-suffix-mode.disable-on-boats", true);
-		spaceBetweenLines = tab.getConfiguration().getConfig().getDouble("unlimited-nametag-prefix-suffix-mode.space-between-lines", 0.22);
-		disabledUnlimitedWorlds = tab.getConfiguration().getConfig().getStringList("disable-features-in-worlds.unlimited-nametags", Arrays.asList("disabledworld"));
-		if (tab.getConfiguration().getPremiumConfig() != null) {
-			List<String> realList = tab.getConfiguration().getPremiumConfig().getStringList("unlimited-nametag-mode-dynamic-lines", Arrays.asList(PropertyUtils.ABOVENAME, PropertyUtils.NAMETAG, PropertyUtils.BELOWNAME, "another"));
-			dynamicLines = new ArrayList<>();
-			dynamicLines.addAll(realList);
-			Collections.reverse(dynamicLines);
-			staticLines = tab.getConfiguration().getPremiumConfig().getConfigurationSection("unlimited-nametag-mode-static-lines");
-		}
-		refreshUsedPlaceholders();
-		eventListener = new EventListener(this);
+	public NameTagX(JavaPlugin plugin) {
+		Collections.reverse(dynamicLines);
 		Bukkit.getPluginManager().registerEvents(eventListener, plugin);
-		tab.getFeatureManager().registerFeature("nametagx-packet", new PacketListener(this, nms, tab));
-		tab.debug(String.format("Loaded Unlimited nametag feature with parameters markerFor18x=%s, disableOnBoats=%s, spaceBetweenLines=%s, disabledUnlimitedWorlds=%s",
+		TAB.getInstance().getFeatureManager().registerFeature("nametagx-packet", new PacketListener(this));
+		TAB.getInstance().getFeatureManager().registerFeature("nametagx-vehicle", vehicleManager);
+		TAB.getInstance().getFeatureManager().registerFeature("nametagx-location", new LocationRefresher(this));
+		TAB.getInstance().debug(String.format("Loaded Unlimited nametag feature with parameters markerFor18x=%s, disableOnBoats=%s, spaceBetweenLines=%s, disabledUnlimitedWorlds=%s",
 				markerFor18x, disableOnBoats, spaceBetweenLines, disabledUnlimitedWorlds));
 	}
 
 	@Override
 	public void load() {
-		super.load();
-		for (TabPlayer all : tab.getPlayers()) {
+		for (TabPlayer all : TAB.getInstance().getOnlinePlayers()) {
 			getEntityIdMap().put(((Player) all.getPlayer()).getEntityId(), all);
+			updateProperties(all);
 			loadArmorStands(all);
-			if (isDisabledWorld(disabledUnlimitedWorlds, all.getWorldName())) {
+			if (isDisabled(all.getWorld())) {
 				playersInDisabledUnlimitedWorlds.add(all);
 			}
-			if (isInDisabledWorld(all)) continue;
-			loadPassengers(all);
-			for (TabPlayer viewer : tab.getPlayers()) {
+			if (isPlayerDisabled(all)) continue;
+			vehicleManager.loadPassengers(all);
+			for (TabPlayer viewer : TAB.getInstance().getOnlinePlayers()) {
 				spawnArmorStands(all, viewer, false);
 			}
 		}
+		super.load();
 		startVisibilityRefreshTask();
-		startVehicleTickingTask();
 	}
 	
 	private void startVisibilityRefreshTask() {
-		tab.getCPUManager().startRepeatingMeasuredTask(500, "refreshing nametag visibility", getFeatureType(), UsageType.REFRESHING_NAMETAG_VISIBILITY_AND_COLLISION, () -> {
+		TAB.getInstance().getCPUManager().startRepeatingMeasuredTask(500, "refreshing nametag visibility", this, TabConstants.CpuUsageCategory.REFRESHING_NAMETAG_VISIBILITY, () -> {
 			
-			for (TabPlayer p : tab.getPlayers()) {
-				if (!p.isLoaded() || isInDisabledWorld(p)) continue;
+			for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
+				if (!p.isLoaded() || isPlayerDisabled(p)) continue;
 				p.getArmorStandManager().updateVisibility(false);
-				if (disableOnBoats) processBoats(p);
-				
 			}
 		});
 	}
-	
-	private void processBoats(TabPlayer p) {
-		boolean onBoat = ((Player)p.getPlayer()).getVehicle() != null && ((Player)p.getPlayer()).getVehicle().getType() == EntityType.BOAT;
-		if (onBoat) {
-			if (!getPlayersOnBoats().contains(p)) {
-				getPlayersOnBoats().add(p);
-				updateTeamData(p);
-			}
-		} else {
-			if (getPlayersOnBoats().contains(p)) {
-				getPlayersOnBoats().remove(p);
-				updateTeamData(p);
-			}
-		}
-	}
-	
-	private void startVehicleTickingTask() {
-		tab.getCPUManager().startRepeatingMeasuredTask(100, "ticking vehicles", TabFeature.NAMETAGX, UsageType.TICKING_VEHICLES, () -> {
-			
-			for (TabPlayer p : TAB.getInstance().getPlayers()) {
-				if (!p.isLoaded()) continue;
-				if (isInDisabledWorld(p)) {
-					playersInVehicle.remove(p);
-					playerLocations.remove(p);
-				} else {
-					processVehicles(p);
-					if (!playerLocations.containsKey(p) || !playerLocations.get(p).equals(((Player)p.getPlayer()).getLocation())) {
-						playerLocations.put(p, ((Player)p.getPlayer()).getLocation());
-						processPassengers((Entity) p.getPlayer());
-						//also updating position if player is previewing since we're here as the code would be same if we want to avoid listening to move event
-						if (p.isPreviewingNametag() && p.getArmorStandManager() != null) {
-							p.getArmorStandManager().teleport(p);
-						}
-					}
-				}
-			}
-		});
-	}
-	
-	/**
-	 * Checks for vehicle changes of player and sends packets if needed
-	 * @param p - player to check
-	 */
-	private void processVehicles(TabPlayer p) {
-		Entity vehicle = ((Player)p.getPlayer()).getVehicle();
-		if (playersInVehicle.containsKey(p) && vehicle == null) {
-			//vehicle exit
-			getVehicles().remove(playersInVehicle.get(p).getEntityId());
-			p.getArmorStandManager().teleport();
-			playersInVehicle.remove(p);
-		}
-		if (!playersInVehicle.containsKey(p) && vehicle != null) {
-			//vehicle enter
-			getVehicles().put(vehicle.getEntityId(), getPassengers(vehicle));
-			p.getArmorStandManager().teleport();
-			playersInVehicle.put(p, vehicle);
-		}
-	}
-	
-	/**
-	 * Teleports armor stands of all passengers on specified vehicle
-	 * @param vehicle - entity to check passengers of
-	 */
-	private void processPassengers(Entity vehicle) {
-		for (Entity passenger : getPassengers(vehicle)) {
-			if (passenger instanceof Player) {
-				TabPlayer pl = TAB.getInstance().getPlayer(passenger.getUniqueId());
-				pl.getArmorStandManager().teleport();
-			} else {
-				processPassengers(passenger);
-			}
-		}
-	}
 
 	@Override
 	public void unload() {
 		super.unload();
 		HandlerList.unregisterAll(eventListener);
-		for (TabPlayer p : tab.getPlayers()) {
+		for (TabPlayer p : TAB.getInstance().getOnlinePlayers()) {
 			if (p.getArmorStandManager() != null) p.getArmorStandManager().destroy();
 		}
 		getEntityIdMap().clear();
@@ -213,16 +106,14 @@ public class NameTagX extends NameTag {
 
 	@Override
 	public void onJoin(TabPlayer connectedPlayer) {
+		if (isDisabled(connectedPlayer.getWorld()) && !playersInDisabledUnlimitedWorlds.contains(connectedPlayer))
+			playersInDisabledUnlimitedWorlds.add(connectedPlayer);
 		super.onJoin(connectedPlayer);
 		getEntityIdMap().put(((Player) connectedPlayer.getPlayer()).getEntityId(), connectedPlayer);
 		loadArmorStands(connectedPlayer);
-		if (isDisabledWorld(disabledUnlimitedWorlds, connectedPlayer.getWorldName())) {
-			playersInDisabledUnlimitedWorlds.add(connectedPlayer);
-			return;
-		}
-		if (isInDisabledWorld(connectedPlayer)) return;
-		loadPassengers(connectedPlayer);
-		for (TabPlayer viewer : tab.getPlayers()) {
+		if (isPlayerDisabled(connectedPlayer)) return;
+		vehicleManager.loadPassengers(connectedPlayer);
+		for (TabPlayer viewer : TAB.getInstance().getOnlinePlayers()) {
 			spawnArmorStands(connectedPlayer, viewer, true);
 		}
 	}
@@ -239,57 +130,31 @@ public class NameTagX extends NameTag {
 		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();
-		getVehicles().put(vehicle.getEntityId(), getPassengers(vehicle));
-	}
-
 	@Override
 	public void onQuit(TabPlayer disconnectedPlayer) {
 		super.onQuit(disconnectedPlayer);
-		for (TabPlayer all : tab.getPlayers()) {
+		for (TabPlayer all : TAB.getInstance().getOnlinePlayers()) {
 			if (all.getArmorStandManager() != null) all.getArmorStandManager().unregisterPlayer(disconnectedPlayer);
 		}
 		getEntityIdMap().remove(((Player) disconnectedPlayer.getPlayer()).getEntityId());
-		playersInVehicle.remove(disconnectedPlayer);
-		playerLocations.remove(disconnectedPlayer);
 		playersInDisabledUnlimitedWorlds.remove(disconnectedPlayer);
-		tab.getCPUManager().runTaskLater(100, "processing onQuit", getFeatureType(), UsageType.PLAYER_QUIT_EVENT, () -> disconnectedPlayer.getArmorStandManager().destroy());
+		playersDisabledWithAPI.remove(disconnectedPlayer);
+		if (disconnectedPlayer.getArmorStandManager() != null) { //player was not loaded yet
+			disconnectedPlayer.getArmorStandManager().destroy();
+			TAB.getInstance().getCPUManager().runTaskLater(500, "processing onQuit", this, TabConstants.CpuUsageCategory.PLAYER_QUIT, () -> disconnectedPlayer.getArmorStandManager().destroy());
+		}
 	}
 
-	@Override
-	public void onWorldChange(TabPlayer p, String from, String to) {
-		super.onWorldChange(p, from, to);
-		if (isDisabledWorld(disabledWorlds, p.getWorldName())) {
-			playersInDisabledWorlds.add(p);
-		} else {
-			playersInDisabledWorlds.remove(p);
-		}
-		Set<TabPlayer> nearby = p.getArmorStandManager().getNearbyPlayers();
-		p.getArmorStandManager().destroy();
-		loadArmorStands(p);
-		loadPassengers(p);
-		for (TabPlayer viewer : tab.getPlayers()) {
-			viewer.getArmorStandManager().destroy(p);
-			if (nearby.contains(viewer) && to.equals(viewer.getWorldName())) spawnArmorStands(p, viewer, true);
-		}
-	}
-	
 	/**
 	 * 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) {
+	public 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 (isInDisabledWorld(owner)) return;
+		if (isPlayerDisabled(owner)) return;
 		if (getDistance(viewer, owner) <= 48) {
 			if (((Player)viewer.getPlayer()).canSee((Player)owner.getPlayer()) && !owner.isVanished()) owner.getArmorStandManager().spawn(viewer);
 			if (sendMutually && viewer.getArmorStandManager() != null && ((Player)owner.getPlayer()).canSee((Player)viewer.getPlayer()) 
@@ -303,18 +168,20 @@ public class NameTagX extends NameTag {
 	 */
 	public void loadArmorStands(TabPlayer pl) {
 		pl.setArmorStandManager(new ArmorStandManager());
-		pl.setProperty(PropertyUtils.NAMETAG, pl.getProperty(PropertyUtils.TAGPREFIX).getCurrentRawValue() + pl.getProperty(PropertyUtils.CUSTOMTAGNAME).getCurrentRawValue() + pl.getProperty(PropertyUtils.TAGSUFFIX).getCurrentRawValue());
+		pl.setProperty(this, TabConstants.Property.NAMETAG, pl.getProperty(TabConstants.Property.TAGPREFIX).getCurrentRawValue() 
+				+ pl.getProperty(TabConstants.Property.CUSTOMTAGNAME).getCurrentRawValue()
+				+ pl.getProperty(TabConstants.Property.TAGSUFFIX).getCurrentRawValue());
 		double height = 0;
 		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, false, markerFor18x));
+			pl.getArmorStandManager().addArmorStand(line, new BukkitArmorStand(pl, p, height, false));
 			height += spaceBetweenLines;
 		}
 		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, markerFor18x));
+			pl.getArmorStandManager().addArmorStand(line.getKey(), new BukkitArmorStand(pl, p, Double.parseDouble(line.getValue().toString()), true));
 		}
 		fixArmorStandHeights(pl);
 	}
@@ -324,7 +191,6 @@ public class NameTagX extends NameTag {
 	 * @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;
@@ -338,14 +204,14 @@ public class NameTagX extends NameTag {
 	@Override
 	public void refresh(TabPlayer refreshed, boolean force) {
 		super.refresh(refreshed, force);
-		if (isInDisabledWorld(refreshed)) return;
+		if (isPlayerDisabled(refreshed)) return;
 		if (force) {
 			refreshed.getArmorStandManager().destroy();
 			loadArmorStands(refreshed);
-			loadPassengers(refreshed);
-			for (TabPlayer viewer : tab.getPlayers()) {
+			vehicleManager.loadPassengers(refreshed);
+			for (TabPlayer viewer : TAB.getInstance().getOnlinePlayers()) {
 				if (viewer == refreshed) continue;
-				if (viewer.getWorldName().equals(refreshed.getWorldName())) {
+				if (viewer.getWorld().equals(refreshed.getWorld())) {
 					refreshed.getArmorStandManager().spawn(viewer);
 				}
 			}
@@ -368,74 +234,185 @@ public class NameTagX extends NameTag {
 	@Override
 	public void updateProperties(TabPlayer p) {
 		super.updateProperties(p);
-		p.loadPropertyFromConfig(PropertyUtils.CUSTOMTAGNAME, p.getName());
-		p.setProperty(PropertyUtils.NAMETAG, p.getProperty(PropertyUtils.TAGPREFIX).getCurrentRawValue() + p.getProperty(PropertyUtils.CUSTOMTAGNAME).getCurrentRawValue() + p.getProperty(PropertyUtils.TAGSUFFIX).getCurrentRawValue());
+		p.loadPropertyFromConfig(this, TabConstants.Property.CUSTOMTAGNAME, p.getName());
+		p.setProperty(this, TabConstants.Property.NAMETAG, p.getProperty(TabConstants.Property.TAGPREFIX).getCurrentRawValue() + p.getProperty(TabConstants.Property.CUSTOMTAGNAME).getCurrentRawValue() + p.getProperty(TabConstants.Property.TAGSUFFIX).getCurrentRawValue());
 		for (String property : dynamicLines) {
-			if (!property.equals(PropertyUtils.NAMETAG)) p.loadPropertyFromConfig(property);
+			if (!property.equals(TabConstants.Property.NAMETAG)) p.loadPropertyFromConfig(this, property);
 		}
 		for (String property : staticLines.keySet()) {
-			if (!property.equals(PropertyUtils.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 (NMSStorage.getInstance().getMinorVersion() >= 11) {
-			return vehicle.getPassengers();
-		} else {
-			if (vehicle.getPassenger() != null) {
-				return Arrays.asList(vehicle.getPassenger());
-			} else {
-				return new ArrayList<>();
-			}
+			if (!property.equals(TabConstants.Property.NAMETAG)) p.loadPropertyFromConfig(this, property);
 		}
 	}
 
 	@Override
-	public void refreshUsedPlaceholders() {
-		usedPlaceholders = new HashSet<>(tab.getConfiguration().getConfig().getUsedPlaceholderIdentifiersRecursive(PropertyUtils.TAGPREFIX, PropertyUtils.CUSTOMTAGNAME, PropertyUtils.TAGSUFFIX));
-		for (String line : dynamicLines) {
-			usedPlaceholders.addAll(tab.getConfiguration().getConfig().getUsedPlaceholderIdentifiersRecursive(line));
-		}
-		for (String line : staticLines.keySet()) {
-			usedPlaceholders.addAll(tab.getConfiguration().getConfig().getUsedPlaceholderIdentifiersRecursive(line));
-		}
-		for (TabPlayer p : tab.getPlayers()) {
-			usedPlaceholders.addAll(tab.getPlaceholderManager().getUsedPlaceholderIdentifiersRecursive(p.getProperty(PropertyUtils.TAGPREFIX).getCurrentRawValue(), 
-					p.getProperty(PropertyUtils.CUSTOMTAGNAME).getCurrentRawValue(), p.getProperty(PropertyUtils.TAGSUFFIX).getCurrentRawValue(),
-					p.getProperty(PropertyUtils.ABOVENAME).getCurrentRawValue(), p.getProperty(PropertyUtils.BELOWNAME).getCurrentRawValue()));
-		}
-	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.NAMETAGX;
+	public String getFeatureName() {
+		return "Unlimited Nametags";
 	}
 
 	@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) or feature is disabled
-		return (getPlayersOnBoats().contains(p) && !invisiblePlayers.contains(p.getName())) || isInDisabledWorld(p);
+		if (p.hasInvisibilityPotion()) return false; //1.8.x client sided bug
+		return vehicleManager.isOnBoat(p) || isPlayerDisabled(p);
 	}
 
 	public Map<Integer, TabPlayer> getEntityIdMap() {
 		return entityIdMap;
 	}
 
-	public Map<Integer, List<Entity>> getVehicles() {
-		return vehicles;
+	public boolean isDisabled(String world) {
+		boolean contains = contains(disabledUnlimitedWorldsArray, world);
+		if (unlimitedWorldWhitelistMode) contains = !contains;
+		return contains;
 	}
 
-	public List<TabPlayer> getPlayersOnBoats() {
-		return playersOnBoats;
+	public boolean isPlayerDisabled(TabPlayer p) {
+		return isDisabledPlayer(p) || playersInDisabledUnlimitedWorlds.contains(p) || hasTeamHandlingPaused(p) || hasDisabledArmorStands(p);
+	}
+
+	public boolean isMarkerFor18x() {
+		return markerFor18x;
+	}
+
+	public List<TabPlayer> getPlayersInDisabledUnlimitedWorlds() {
+		return playersInDisabledUnlimitedWorlds;
 	}
 	
-	public boolean isInDisabledWorld(TabPlayer p) {
-		return playersInDisabledWorlds.contains(p) || isDisabledWorld(disabledUnlimitedWorlds, p.getWorldName());
+	public VehicleRefresher getVehicleManager() {
+		return vehicleManager;
+	}
+	
+	@Override
+	public void pauseTeamHandling(TabPlayer player) {
+		if (teamHandlingPaused.contains(player)) return;
+		if (!isDisabledPlayer(player)) unregisterTeam(player);
+		teamHandlingPaused.add(player); //adding after, so unregisterTeam method runs
+		player.getArmorStandManager().destroy();
+	}
+	
+	@Override
+	public void resumeTeamHandling(TabPlayer player) {
+		if (!teamHandlingPaused.contains(player)) return;
+		teamHandlingPaused.remove(player); //removing before, so registerTeam method runs
+		if (!isDisabledPlayer(player)) registerTeam(player);
+		if (!isPlayerDisabled(player)) {
+			for (TabPlayer viewer : TAB.getInstance().getOnlinePlayers()) {
+				spawnArmorStands(player, viewer, false);
+			}
+		}
+	}
+
+	@Override
+	public void disableArmorStands(TabPlayer player) {
+		if (playersDisabledWithAPI.contains(player)) return;
+		playersDisabledWithAPI.add(player);
+		player.getArmorStandManager().destroy();
+		updateTeamData(player);
+	}
+
+	@Override
+	public void enableArmorStands(TabPlayer player) {
+		if (!playersDisabledWithAPI.contains(player)) return;
+		playersDisabledWithAPI.remove(player);
+		if (!isPlayerDisabled(player)) {
+			for (TabPlayer viewer : TAB.getInstance().getOnlinePlayers()) {
+				spawnArmorStands(player, viewer, false);
+			}
+		}
+		updateTeamData(player);
+	}
+
+	@Override
+	public boolean hasDisabledArmorStands(TabPlayer player) {
+		return playersDisabledWithAPI.contains(player);
+	}
+	
+	@Override
+	public void setPrefix(TabPlayer player, String prefix) {
+		player.getProperty(TabConstants.Property.TAGPREFIX).setTemporaryValue(prefix);
+		rebuildNametagLine(player);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void setSuffix(TabPlayer player, String suffix) {
+		player.getProperty(TabConstants.Property.TAGSUFFIX).setTemporaryValue(suffix);
+		rebuildNametagLine(player);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void resetPrefix(TabPlayer player) {
+		player.getProperty(TabConstants.Property.TAGPREFIX).setTemporaryValue(null);
+		rebuildNametagLine(player);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void resetSuffix(TabPlayer player) {
+		player.getProperty(TabConstants.Property.TAGSUFFIX).setTemporaryValue(null);
+		rebuildNametagLine(player);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void setName(TabPlayer player, String customname) {
+		player.getProperty(TabConstants.Property.CUSTOMTAGNAME).setTemporaryValue(customname);
+		rebuildNametagLine(player);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void setLine(TabPlayer player, String line, String value) {
+		player.getProperty(line).setTemporaryValue(value);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void resetName(TabPlayer player) {
+		player.getProperty(TabConstants.Property.CUSTOMTAGNAME).setTemporaryValue(null);
+		rebuildNametagLine(player);
+		player.forceRefresh();
+	}
+
+	@Override
+	public void resetLine(TabPlayer player, String line) {
+		player.getProperty(line).setTemporaryValue(null);
+		player.forceRefresh();
+	}
+
+	@Override
+	public String getCustomName(TabPlayer player) {
+		return player.getProperty(TabConstants.Property.CUSTOMTAGNAME).getTemporaryValue();
+	}
+
+	@Override
+	public String getCustomLineValue(TabPlayer player, String line) {
+		return player.getProperty(line).getTemporaryValue();
+	}
+
+	@Override
+	public String getOriginalName(TabPlayer player) {
+		return player.getProperty(TabConstants.Property.CUSTOMTAGNAME).getOriginalRawValue();
+	}
+
+	@Override
+	public String getOriginalLineValue(TabPlayer player, String line) {
+		return player.getProperty(line).getOriginalRawValue();
+	}
+	
+	private void rebuildNametagLine(TabPlayer player) {
+		player.setProperty(this, TabConstants.Property.NAMETAG, player.getProperty(TabConstants.Property.TAGPREFIX).getCurrentRawValue() + 
+				player.getProperty(TabConstants.Property.CUSTOMTAGNAME).getCurrentRawValue() + player.getProperty(TabConstants.Property.TAGSUFFIX).getCurrentRawValue());
+	}
+
+	public boolean isDisableOnBoats() {
+		return disableOnBoats;
+	}
+
+	@Override
+	public List<String> getDefinedLines() {
+		List<String> lines = new ArrayList<>(dynamicLines);
+		lines.addAll(staticLines.keySet());
+		return lines;
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/unlimitedtags/PacketListener.java

@@ -5,75 +5,73 @@ import java.util.List;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 
+import me.neznamy.tab.api.TabFeature;
 import me.neznamy.tab.api.TabPlayer;
 import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import me.neznamy.tab.shared.TabConstants;
 import me.neznamy.tab.shared.TAB;
-import me.neznamy.tab.shared.cpu.TabFeature;
-import me.neznamy.tab.shared.cpu.UsageType;
-import me.neznamy.tab.shared.features.types.packet.RawPacketListener;
 
 /**
  * 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 {
+public class PacketListener extends TabFeature {
 
 	//main feature
-	private NameTagX nameTagX;
+	private final NameTagX nameTagX;
 	
 	//nms storage
-	private NMSStorage nms;
-	
-	//tab instance
-	private TAB tab;
+	private final NMSStorage nms = NMSStorage.getInstance();
 
 	/**
 	 * 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) {
+	public PacketListener(NameTagX nameTagX) {
+		super(nameTagX.getFeatureName(), null);
 		this.nameTagX = nameTagX;
-		this.nms = nms;
-		this.tab = tab;
 	}
 
 	@Override
-	public Object onPacketReceive(TabPlayer sender, Object packet) throws IllegalAccessException {
-		if (sender.getVersion().getMinorVersion() == 8 && nms.getClass("PacketPlayInUseEntity").isInstance(packet)) {
-			int entityId = nms.getField("PacketPlayInUseEntity_ENTITY").getInt(packet);
+	public boolean onPacketReceive(TabPlayer sender, Object packet) throws ReflectiveOperationException {
+		if (sender.getVersion().getMinorVersion() == 8 && nms.PacketPlayInUseEntity.isInstance(packet)) {
+			int entityId = nms.PacketPlayInUseEntity_ENTITY.getInt(packet);
 			TabPlayer attacked = null;
-			for (TabPlayer all : tab.getPlayers()) {
+			for (TabPlayer all : TAB.getInstance().getOnlinePlayers()) {
 				if (all.isLoaded() && all.getArmorStandManager().hasArmorStandWithID(entityId)) {
 					attacked = all;
 					break;
 				}
 			}
 			if (attacked != null && attacked != sender) {
-				nms.setField(packet, "PacketPlayInUseEntity_ENTITY", ((Player) attacked.getPlayer()).getEntityId());
+				nms.setField(packet, nms.PacketPlayInUseEntity_ENTITY, ((Player) attacked.getPlayer()).getEntityId());
 			}
 		}
-		return packet;
+		return false;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
-	public void onPacketSend(TabPlayer receiver, Object packet) throws IllegalAccessException  {
+	public void onPacketSend(TabPlayer receiver, Object packet) throws ReflectiveOperationException {
 		if (receiver.getVersion().getMinorVersion() < 8) return;
-		//using bukkit player to check world due to old data on world change due to asynchronous processing & world name changing
-		String world = ((Player)receiver.getPlayer()).getWorld().getName();
-		if (!receiver.isLoaded() || nameTagX.getPlayersInDisabledWorlds().contains(receiver) || nameTagX.isDisabledWorld(nameTagX.disabledUnlimitedWorlds, world)) return;
-		if (nms.getClass("PacketPlayOutEntity").isInstance(packet) && !nms.getClass("PacketPlayOutEntityLook").isInstance(packet)) { //ignoring head rotation only packets
-			onEntityMove(receiver, nms.getField("PacketPlayOutEntity_ENTITYID").getInt(packet));
-		} else if (nms.getClass("PacketPlayOutEntityTeleport").isInstance(packet)) {
-			onEntityMove(receiver, nms.getField("PacketPlayOutEntityTeleport_ENTITYID").getInt(packet));
-		} else if (nms.getClass("PacketPlayOutNamedEntitySpawn").isInstance(packet)) {
-			onEntitySpawn(receiver, nms.getField("PacketPlayOutNamedEntitySpawn_ENTITYID").getInt(packet));
-		} else if (nms.getClass("PacketPlayOutEntityDestroy").isInstance(packet)) {
+		if (!receiver.isLoaded() || nameTagX.isDisabledPlayer(receiver) || nameTagX.getPlayersInDisabledUnlimitedWorlds().contains(receiver)) return;
+		if (nms.PacketPlayOutEntity.isInstance(packet) && !nms.PacketPlayOutEntityLook.isInstance(packet)) { //ignoring head rotation only packets
+			onEntityMove(receiver, nms.PacketPlayOutEntity_ENTITYID.getInt(packet));
+		} else if (nms.PacketPlayOutEntityTeleport.isInstance(packet)) {
+			onEntityMove(receiver, nms.PacketPlayOutEntityTeleport_ENTITYID.getInt(packet));
+		} else if (nms.PacketPlayOutNamedEntitySpawn.isInstance(packet)) {
+			onEntitySpawn(receiver, nms.PacketPlayOutNamedEntitySpawn_ENTITYID.getInt(packet));
+		} else if (nms.PacketPlayOutEntityDestroy.isInstance(packet)) {
 			if (nms.getMinorVersion() >= 17) {
-				onEntityDestroy(receiver, nms.getField("PacketPlayOutEntityDestroy_ENTITIES").getInt(packet));
+				Object entities = nms.PacketPlayOutEntityDestroy_ENTITIES.get(packet);
+				if (entities instanceof List) {
+					onEntityDestroy(receiver, (List<Integer>) entities);
+				} else {
+					//1.17.0
+					onEntityDestroy(receiver, (int) entities);
+				}
 			} else {
-				onEntityDestroy(receiver, (int[]) nms.getField("PacketPlayOutEntityDestroy_ENTITIES").get(packet));
+				onEntityDestroy(receiver, (int[]) nms.PacketPlayOutEntityDestroy_ENTITIES.get(packet));
 			}
 		}
 	}
@@ -83,40 +81,46 @@ public class PacketListener implements RawPacketListener {
 	 * @param receiver - packet receiver
 	 * @param entityId - entity that moved
 	 */
-	public void onEntityMove(TabPlayer receiver, int entityId) {
+	private void onEntityMove(TabPlayer receiver, int entityId) {
 		TabPlayer pl = nameTagX.getEntityIdMap().get(entityId);
 		List<Entity> vehicleList;
 		if (pl != null) {
 			//player moved
-			tab.getCPUManager().runMeasuredTask("processing EntityMove", getFeatureType(), UsageType.PACKET_ENTITY_MOVE, () -> pl.getArmorStandManager().teleport(receiver));
-		} else if ((vehicleList = nameTagX.getVehicles().get(entityId)) != null){
+			if (nameTagX.isPlayerDisabled(pl)) return;
+			TAB.getInstance().getCPUManager().runMeasuredTask("processing EntityMove", nameTagX, TabConstants.CpuUsageCategory.PACKET_ENTITY_MOVE, () -> pl.getArmorStandManager().teleport(receiver));
+		} else if ((vehicleList = nameTagX.getVehicleManager().getVehicles().get(entityId)) != null){
 			//a vehicle carrying something moved
 			for (Entity entity : vehicleList) {
 				TabPlayer passenger = nameTagX.getEntityIdMap().get(entity.getEntityId());
 				if (passenger != null && passenger.getArmorStandManager() != null) {
-					tab.getCPUManager().runMeasuredTask("processing EntityMove", getFeatureType(), UsageType.PACKET_ENTITY_MOVE, () -> passenger.getArmorStandManager().teleport(receiver));
+					TAB.getInstance().getCPUManager().runMeasuredTask("processing EntityMove", nameTagX, TabConstants.CpuUsageCategory.PACKET_ENTITY_MOVE_PASSENGER, () -> passenger.getArmorStandManager().teleport(receiver));
 				}
 			}
 		}
 	}
 	
-	public void onEntitySpawn(TabPlayer receiver, int entityId) {
+	private void onEntitySpawn(TabPlayer receiver, int entityId) {
 		TabPlayer spawnedPlayer = nameTagX.getEntityIdMap().get(entityId);
-		if (spawnedPlayer != null && spawnedPlayer.isLoaded()) {
-			tab.getCPUManager().runMeasuredTask("processing NamedEntitySpawn", getFeatureType(), UsageType.PACKET_NAMED_ENTITY_SPAWN, () -> spawnedPlayer.getArmorStandManager().spawn(receiver));
+		if (spawnedPlayer != null && spawnedPlayer.isLoaded() && !nameTagX.isPlayerDisabled(spawnedPlayer)) {
+			TAB.getInstance().getCPUManager().runMeasuredTask("processing NamedEntitySpawn", nameTagX, TabConstants.CpuUsageCategory.PACKET_ENTITY_SPAWN, () -> spawnedPlayer.getArmorStandManager().spawn(receiver));
 		}
 	}
 
-	public void onEntityDestroy(TabPlayer receiver, int... entities) {
+	private void onEntityDestroy(TabPlayer receiver, List<Integer> entities) {
 		for (int entity : entities) {
-			TabPlayer despawnedPlayer = nameTagX.getEntityIdMap().get(entity);
-			if (despawnedPlayer != null && despawnedPlayer.isLoaded()) 
-				tab.getCPUManager().runMeasuredTask("processing EntityDestroy", getFeatureType(), UsageType.PACKET_ENTITY_DESTROY, () -> despawnedPlayer.getArmorStandManager().destroy(receiver));
+			onEntityDestroy(receiver, entity);
 		}
 	}
-
-	@Override
-	public TabFeature getFeatureType() {
-		return TabFeature.NAMETAGX;
+	
+	private void onEntityDestroy(TabPlayer receiver, int... entities) {
+		for (int entity : entities) {
+			onEntityDestroy(receiver, entity);
+		}
+	}
+	
+	private void onEntityDestroy(TabPlayer receiver, int entity) {
+		TabPlayer despawnedPlayer = nameTagX.getEntityIdMap().get(entity);
+		if (despawnedPlayer != null && despawnedPlayer.isLoaded() && !nameTagX.isPlayerDisabled(despawnedPlayer)) 
+			TAB.getInstance().getCPUManager().runMeasuredTask("processing EntityDestroy", nameTagX, TabConstants.CpuUsageCategory.PACKET_ENTITY_DESTROY, () -> despawnedPlayer.getArmorStandManager().destroy(receiver));
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/features/unlimitedtags/VehicleRefresher.java

@@ -0,0 +1,122 @@
+package me.neznamy.tab.platforms.bukkit.features.unlimitedtags;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+
+import me.neznamy.tab.api.TabFeature;
+import me.neznamy.tab.api.TabPlayer;
+import me.neznamy.tab.shared.TAB;
+
+public class VehicleRefresher extends TabFeature {
+
+	//list of players currently in a vehicle
+	private final Map<TabPlayer, Entity> playersInVehicle = new ConcurrentHashMap<>();
+	
+	//map of vehicles carrying players
+	private final Map<Integer, List<Entity>> vehicles = new ConcurrentHashMap<>();
+	
+	//list of players currently on boats
+	private final List<TabPlayer> playersOnBoats = new ArrayList<>();
+	
+	private final NameTagX feature;
+		
+	public VehicleRefresher(NameTagX feature) {
+		super(feature.getFeatureName(), "Refreshing vehicles");
+		this.feature = feature;
+		addUsedPlaceholders(Arrays.asList("%vehicle%"));
+		TAB.getInstance().getPlaceholderManager().registerPlayerPlaceholder("%vehicle%", 100, p -> ((Player)p.getPlayer()).getVehicle());
+	}
+	
+	@Override
+	public void refresh(TabPlayer p, boolean force) {
+		if (feature.isPlayerDisabled(p)) return;
+		Entity vehicle = ((Player)p.getPlayer()).getVehicle();
+		if (playersInVehicle.containsKey(p) && vehicle == null) {
+			//vehicle exit
+			vehicles.remove(playersInVehicle.get(p).getEntityId());
+			p.getArmorStandManager().teleport();
+			playersInVehicle.remove(p);
+			if (feature.isDisableOnBoats() && playersOnBoats.contains(p)) {
+				playersOnBoats.remove(p);
+				feature.updateTeamData(p);
+			}
+		}
+		if (!playersInVehicle.containsKey(p) && vehicle != null) {
+			//vehicle enter
+			vehicles.put(vehicle.getEntityId(), getPassengers(vehicle));
+			p.getArmorStandManager().respawn(); //making teleport instant instead of showing teleport animation
+			playersInVehicle.put(p, vehicle);
+			if (feature.isDisableOnBoats() && vehicle.getType() == EntityType.BOAT) {
+				playersOnBoats.add(p);
+				feature.updateTeamData(p);
+			}
+		}
+	}
+
+	public boolean isOnBoat(TabPlayer p) {
+		return playersOnBoats.contains(p);
+	}
+
+	@Override
+	public void onQuit(TabPlayer disconnectedPlayer) {
+		if (playersInVehicle.containsKey(disconnectedPlayer)) vehicles.remove(playersInVehicle.get(disconnectedPlayer).getEntityId());
+		playersInVehicle.remove(disconnectedPlayer);
+		playersOnBoats.remove(disconnectedPlayer);
+	}
+	
+	public Map<Integer, List<Entity>> getVehicles() {
+		return vehicles;
+	}
+	
+	/**
+	 * 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 (TAB.getInstance().getServerVersion().getMinorVersion() >= 11) {
+			return vehicle.getPassengers();
+		} else {
+			if (vehicle.getPassenger() != null) {
+				return Arrays.asList(vehicle.getPassenger());
+			} else {
+				return new ArrayList<>();
+			}
+		}
+	}
+	
+	/**
+	 * Loads all passengers riding this player and adds them to vehicle list
+	 * @param p - player to load passengers of
+	 */
+	public void loadPassengers(TabPlayer p) {
+		if (((Entity) p.getPlayer()).getVehicle() == null) return;
+		Entity vehicle = ((Entity) p.getPlayer()).getVehicle();
+		vehicles.put(vehicle.getEntityId(), getPassengers(vehicle));
+	}
+	
+	/**
+	 * Teleports armor stands of all passengers on specified vehicle
+	 * @param vehicle - entity to check passengers of
+	 */
+	public void processPassengers(Entity vehicle) {
+		for (Entity passenger : getPassengers(vehicle)) {
+			if (passenger instanceof Player) {
+				TAB.getInstance().getPlayer(passenger.getUniqueId()).getArmorStandManager().teleport();
+			}
+			processPassengers(passenger);
+		}
+	}
+
+	public Map<TabPlayer, Entity> getPlayersInVehicle() {
+		return playersInVehicle;
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/NMSStorage.java

@@ -1,93 +1,261 @@
 package me.neznamy.tab.platforms.bukkit.nms;
 
+import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.UUID;
 
 import org.bukkit.Bukkit;
 
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.mojang.authlib.GameProfile;
+
 import io.netty.channel.Channel;
+import me.neznamy.tab.api.ProtocolVersion;
 import me.neznamy.tab.platforms.bukkit.Main;
 import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcherRegistry;
 import me.neznamy.tab.shared.TAB;
 
 @SuppressWarnings("rawtypes")
-public class NMSStorage {
+public final class NMSStorage {
 
 	//instance of this class
 	private static NMSStorage instance;
 
-	//data watcher registry
-	private DataWatcherRegistry dataWatcherRegistry;
-
 	//server package, such as "v1_16_R3"
-	private String serverPackage;
+	private final String serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
 
 	//server minor version such as "16"
-	private int minorVersion;
-
-	private Map<String, Class<?>> classes = new HashMap<>();
-	private Map<String, Constructor<?>> constructors = new HashMap<>();
-	private Map<String, Field> fields = new HashMap<>();
-	private Map<String, Method> methods = new HashMap<>();
-	private Map<String, Enum[]> enums = new HashMap<>();
+	private final int minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
+	
+	//another field due to fabric which uses 1.16 package on 1.17 server
+	private final ProtocolVersion serverVersion = ProtocolVersion.fromFriendlyName(Bukkit.getBukkitVersion().split("-")[0]);
+	
+	//base
+	private final Class<?> Packet = getNMSClass("net.minecraft.network.protocol.Packet", "Packet");
+	public final Class<?> EnumChatFormat = getNMSClass("net.minecraft.EnumChatFormat", "EnumChatFormat");
+	public final Class<?> EntityPlayer = getNMSClass("net.minecraft.server.level.EntityPlayer", "EntityPlayer");
+	private final Class<?> Entity = getNMSClass("net.minecraft.world.entity.Entity", "Entity");
+	private final Class<?> EntityLiving = getNMSClass("net.minecraft.world.entity.EntityLiving", "EntityLiving");
+	private final Class<?> NetworkManager = getNMSClass("net.minecraft.network.NetworkManager", "NetworkManager");
+	private final Class<?> PlayerConnection = getNMSClass("net.minecraft.server.network.PlayerConnection", "PlayerConnection");
+	public Constructor<?> newEntityArmorStand;
+	public final Field PING = getField(EntityPlayer, "ping", "latency", "field_71138_i", "field_13967", "e");
+	public final Field PLAYER_CONNECTION = getFields(EntityPlayer, PlayerConnection).get(0);
+	public Field NETWORK_MANAGER;
+	public Field CHANNEL;
+	public final Method getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".entity.CraftPlayer").getMethod("getHandle");
+	public final Method sendPacket = getMethods(PlayerConnection, void.class, Packet).get(0);
+	public Method getProfile;
+	public final Method World_getHandle = Class.forName("org.bukkit.craftbukkit." + serverPackage + ".CraftWorld").getMethod("getHandle");
+	public final Enum[] EnumChatFormat_values = getEnumValues(EnumChatFormat);
+	
+	//chat
+	public Class<?> ChatComponentText;
+	public Class<?> ChatHoverable;
+	public Class<?> EnumClickAction;
+	private Class<?> IChatBaseComponent;
+	public Constructor<?> newChatComponentText;
+	public Constructor<?> newChatClickable;
+	public Constructor<?> newChatModifier;
+	public Constructor<?> newChatHoverable;
+	public Field ChatBaseComponent_extra;
+	public Field ChatBaseComponent_modifier;
+	public Field ChatComponentText_text;
+	public Field ChatClickable_action;
+	public Field ChatClickable_value;
+	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 ChatHexColor_name;
+	public Field ChatHexColor_rgb;
+	public Field ChatModifier_color;
+	public Method ChatComponentText_addSibling;
+	public Method EnumHoverAction_a;
+	public Method ChatHoverable_getAction;
+	public Method ChatHexColor_ofInt;
+	public Method ChatHexColor_ofString;
+	public Method ChatHoverable_serialize;
+	public Method ChatHoverable_getValue;
+	public Method EnumHoverAction_fromJson;
+	public Method EnumHoverAction_fromLegacyComponent;
+	
+	//PacketPlayOutChat
+	public Class<?> ChatMessageType;
+	public Constructor<?> newPacketPlayOutChat;
+	public Enum[] ChatMessageType_values;
+	
+	//DataWatcher
+	private final Class<?> DataWatcher = getNMSClass("net.minecraft.network.syncher.DataWatcher", "DataWatcher");
+	private final Class<?> DataWatcherItem = getNMSClass("net.minecraft.network.syncher.DataWatcher$Item", "DataWatcher$Item", "DataWatcher$WatchableObject", "WatchableObject");
+	public Class<?> DataWatcherRegistry;
+	public final Constructor<?> newDataWatcher = DataWatcher.getConstructors()[0];
+	public Constructor<?> newDataWatcherObject;
+	public Field DataWatcherItem_TYPE;
+	public final Field DataWatcherItem_VALUE = getFields(DataWatcherItem, Object.class).get(0);
+	public Field DataWatcherObject_SLOT;
+	public Field DataWatcherObject_SERIALIZER;
+	public Method DataWatcher_REGISTER;
+	private DataWatcherRegistry registry;
+	
+	//PacketPlayOutSpawnEntityLiving
+	public final Class<?> PacketPlayOutSpawnEntityLiving = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutSpawnEntityLiving", "PacketPlayOutSpawnEntityLiving", "Packet24MobSpawn");
+	public Constructor<?> newPacketPlayOutSpawnEntityLiving;
+	public final Field PacketPlayOutSpawnEntityLiving_ENTITYID = getFields(PacketPlayOutSpawnEntityLiving, int.class).get(0);
+	public final Field PacketPlayOutSpawnEntityLiving_ENTITYTYPE = getFields(PacketPlayOutSpawnEntityLiving, int.class).get(1);
+	public final Field PacketPlayOutSpawnEntityLiving_YAW = getFields(PacketPlayOutSpawnEntityLiving, byte.class).get(0);
+	public final Field PacketPlayOutSpawnEntityLiving_PITCH = getFields(PacketPlayOutSpawnEntityLiving, byte.class).get(0);
+	public Field PacketPlayOutSpawnEntityLiving_UUID;
+	public Field PacketPlayOutSpawnEntityLiving_X;
+	public Field PacketPlayOutSpawnEntityLiving_Y;
+	public Field PacketPlayOutSpawnEntityLiving_Z;
+	public Field PacketPlayOutSpawnEntityLiving_DATAWATCHER;
+	
+	//PacketPlayOutEntityTeleport
+	public final Class<?> PacketPlayOutEntityTeleport = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntityTeleport", "PacketPlayOutEntityTeleport", "Packet34EntityTeleport");
+	public Constructor<?> newPacketPlayOutEntityTeleport;
+	public final Field PacketPlayOutEntityTeleport_ENTITYID = getFields(PacketPlayOutEntityTeleport, int.class).get(0);
+	public Field PacketPlayOutEntityTeleport_X;
+	public Field PacketPlayOutEntityTeleport_Y;
+	public Field PacketPlayOutEntityTeleport_Z;
+	public final Field PacketPlayOutEntityTeleport_YAW = getFields(PacketPlayOutEntityTeleport, byte.class).get(0);
+	public final Field PacketPlayOutEntityTeleport_PITCH = getFields(PacketPlayOutEntityTeleport, byte.class).get(1);
+	
+	//PacketPlayOutPlayerListHeaderFooter
+	public Constructor<?> newPacketPlayOutPlayerListHeaderFooter;
+	public Field PacketPlayOutPlayerListHeaderFooter_HEADER;
+	public Field PacketPlayOutPlayerListHeaderFooter_FOOTER;
+	
+	//other entity packets
+	public final Class<?> PacketPlayInUseEntity = getNMSClass("net.minecraft.network.protocol.game.PacketPlayInUseEntity", "PacketPlayInUseEntity", "Packet7UseEntity");
+	public Class<?> PacketPlayInUseEntity$d;
+	public Field PacketPlayInUseEntity_ENTITY;
+	public Field PacketPlayInUseEntity_ACTION;
+	
+	public final Class<?> PacketPlayOutEntity = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntity", "PacketPlayOutEntity", "Packet30Entity");
+	public final Field PacketPlayOutEntity_ENTITYID = getFields(PacketPlayOutEntity, int.class).get(0);
+	
+	public final Class<?> PacketPlayOutEntityDestroy = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntityDestroy", "PacketPlayOutEntityDestroy", "Packet29DestroyEntity");
+	public Constructor<?> newPacketPlayOutEntityDestroy;
+	public final Field PacketPlayOutEntityDestroy_ENTITIES = setAccessible(PacketPlayOutEntityDestroy.getDeclaredFields()[0]);
+	
+	public final Class<?> PacketPlayOutEntityLook = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutEntityLook", "PacketPlayOutEntity$PacketPlayOutEntityLook", "PacketPlayOutEntityLook", "Packet32EntityLook");
+	
+	public final Class<?> PacketPlayOutEntityMetadata = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntityMetadata", "PacketPlayOutEntityMetadata", "Packet40EntityMetadata");
+	public final Constructor<?> newPacketPlayOutEntityMetadata = PacketPlayOutEntityMetadata.getConstructor(int.class, DataWatcher, boolean.class);
+	public final Field PacketPlayOutEntityMetadata_LIST = getFields(PacketPlayOutEntityMetadata, List.class).get(0);
+	
+	public final Class<?> PacketPlayOutNamedEntitySpawn = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutNamedEntitySpawn", "PacketPlayOutNamedEntitySpawn", "Packet20NamedEntitySpawn");
+	public final Field PacketPlayOutNamedEntitySpawn_ENTITYID = getFields(PacketPlayOutNamedEntitySpawn, int.class).get(0);
+	
+	//PacketPlayOutPlayerInfo
+	public Class<?> PacketPlayOutPlayerInfo;
+	public Constructor<?> newPacketPlayOutPlayerInfo;
+	public Constructor<?> newPlayerInfoData;
+	public Field PacketPlayOutPlayerInfo_ACTION;
+	public Field PacketPlayOutPlayerInfo_PLAYERS;
+	public Method PlayerInfoData_getProfile;
+	public Method PlayerInfoData_getLatency;
+	public Method PlayerInfoData_getGamemode;
+	public Method PlayerInfoData_getDisplayName;
+	public Enum[] EnumPlayerInfoAction_values;
+	public Enum[] EnumGamemode_values;
+	
+	//scoreboard objectives
+	public final Class<?> PacketPlayOutScoreboardDisplayObjective = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardDisplayObjective", "PacketPlayOutScoreboardDisplayObjective", "Packet208SetScoreboardDisplayObjective");
+	public final Class<?> PacketPlayOutScoreboardObjective = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardObjective", "PacketPlayOutScoreboardObjective", "Packet206SetScoreboardObjective");
+	private final Class<?> Scoreboard = getNMSClass("net.minecraft.world.scores.Scoreboard", "Scoreboard");
+	private final Class<?> PacketPlayOutScoreboardScore = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardScore", "PacketPlayOutScoreboardScore", "Packet207SetScoreboardScore");
+	private final Class<?> ScoreboardObjective = getNMSClass("net.minecraft.world.scores.ScoreboardObjective", "ScoreboardObjective");
+	private final Class<?> ScoreboardScore = getNMSClass("net.minecraft.world.scores.ScoreboardScore", "ScoreboardScore");
+	private final Class<?> IScoreboardCriteria = getNMSClass("net.minecraft.world.scores.criteria.IScoreboardCriteria", "IScoreboardCriteria");
+	public Class<?> EnumScoreboardHealthDisplay;
+	public final Constructor<?> newScoreboardObjective = ScoreboardObjective.getConstructors()[0];
+	public final Constructor<?> newScoreboard = Scoreboard.getConstructor();
+	public final Constructor<?> newScoreboardScore = ScoreboardScore.getConstructor(Scoreboard, ScoreboardObjective, String.class);
+	public final Constructor<?> newPacketPlayOutScoreboardDisplayObjective = PacketPlayOutScoreboardDisplayObjective.getConstructor(int.class, ScoreboardObjective);
+	public Constructor<?> newPacketPlayOutScoreboardObjective;
+	public Constructor<?> newPacketPlayOutScoreboardScore_1_13;
+	public Constructor<?> newPacketPlayOutScoreboardScore_String;
+	public Constructor<?> newPacketPlayOutScoreboardScore;
+	public final Field PacketPlayOutScoreboardDisplayObjective_POSITION = getFields(PacketPlayOutScoreboardDisplayObjective, int.class).get(0);
+	public final Field PacketPlayOutScoreboardDisplayObjective_OBJECTIVENAME = getFields(PacketPlayOutScoreboardDisplayObjective, String.class).get(0);
+	public final Field PacketPlayOutScoreboardObjective_OBJECTIVENAME = getFields(PacketPlayOutScoreboardObjective, String.class).get(0);
+	public Field PacketPlayOutScoreboardObjective_METHOD;
+	public final Field IScoreboardCriteria_self = getFields(IScoreboardCriteria, IScoreboardCriteria).get(0);
+	public Field PacketPlayOutScoreboardObjective_RENDERTYPE;
+	public Field PacketPlayOutScoreboardObjective_DISPLAYNAME;
+	public final Method ScoreboardScore_setScore = getMethod(ScoreboardScore, new String[]{"setScore", "func_96647_c", "method_1128", "b"}, int.class);
+	public Enum[] EnumScoreboardHealthDisplay_values;
+	public Enum[] EnumScoreboardAction_values;
+	
+	//PacketPlayOutScoreboardTeam
+	public Class<?> PacketPlayOutScoreboardTeam;
+	public Constructor<?> newScoreboardTeam;
+	public Constructor<?> newPacketPlayOutScoreboardTeam;
+	public Field PacketPlayOutScoreboardTeam_NAME;
+	public Field PacketPlayOutScoreboardTeam_PLAYERS;
+	public Method ScoreboardTeam_getPlayerNameSet;
+	public Method ScoreboardTeam_setNameTagVisibility;
+	public Method ScoreboardTeam_setCollisionRule;
+	public Method ScoreboardTeam_setPrefix;
+	public Method ScoreboardTeam_setSuffix;
+	public Method ScoreboardTeam_setColor;
+	public Method ScoreboardTeam_setAllowFriendlyFire;
+	public Method ScoreboardTeam_setCanSeeFriendlyInvisibles;
+	public Method PacketPlayOutScoreboardTeam_of;
+	public Method PacketPlayOutScoreboardTeam_ofBoolean;
+	public Method PacketPlayOutScoreboardTeam_ofString;
+	public Enum[] EnumNameTagVisibility_values;
+	public Enum[] EnumTeamPush_values;
+	public Enum[] PacketPlayOutScoreboardTeam_PlayerAction_values;
 
 	/**
 	 * Creates new instance, initializes required NMS classes and fields
-	 * @throws NoSuchFieldException 
-	 * @throws SecurityException 
-	 * @throws NoSuchMethodException 
-	 * @throws ClassNotFoundException 
-	 * @throws InvocationTargetException 
-	 * @throws IllegalAccessException 
+	 * @throws ReflectiveOperationException
 	 */
-	public NMSStorage() throws NoSuchFieldException, NoSuchMethodException, SecurityException, ClassNotFoundException, IllegalAccessException, InvocationTargetException {
-		serverPackage = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-		minorVersion = Integer.parseInt(serverPackage.split("_")[1]);
-		classes.put("EnumChatFormat", getNMSClass("net.minecraft.EnumChatFormat", "EnumChatFormat"));
-		classes.put("EntityPlayer", getNMSClass("net.minecraft.server.level.EntityPlayer", "EntityPlayer"));
-		classes.put("Entity", getNMSClass("net.minecraft.world.entity.Entity", "Entity"));
-		classes.put("EntityLiving", getNMSClass("net.minecraft.world.entity.EntityLiving", "EntityLiving"));
-		classes.put("Packet", getNMSClass("net.minecraft.network.protocol.Packet", "Packet"));
-		classes.put("PlayerConnection", getNMSClass("net.minecraft.server.network.PlayerConnection", "PlayerConnection"));
-		classes.put("NetworkManager", getNMSClass("net.minecraft.network.NetworkManager", "NetworkManager"));
-		fields.put("PING", getField(getClass("EntityPlayer"), "ping", "latency", "e"));
-		fields.put("PLAYER_CONNECTION", getFields(getClass("EntityPlayer"), getClass("PlayerConnection")).get(0));
-		methods.put("getHandle", Class.forName("org.bukkit.craftbukkit." + serverPackage + ".entity.CraftPlayer").getMethod("getHandle"));
-		methods.put("sendPacket", getMethod(getClass("PlayerConnection"), new String[]{"sendPacket", "func_147359_a"}, getClass("Packet")));
+	public NMSStorage() throws ReflectiveOperationException {
 		if (minorVersion >= 7) {
-			fields.put("NETWORK_MANAGER", getFields(getClass("PlayerConnection"), getClass("NetworkManager")).get(0));
+			NETWORK_MANAGER = getFields(PlayerConnection, NetworkManager).get(0);
 		}
 		if (minorVersion >= 8) {
-			fields.put("CHANNEL", getFields(getClass("NetworkManager"), Channel.class).get(0));
-			methods.put("getProfile", getClass("EntityPlayer").getMethod("getProfile"));
+			CHANNEL = getFields(NetworkManager, Channel.class).get(0);
+			getProfile = getMethods(getNMSClass("net.minecraft.world.entity.player.EntityHuman", "EntityHuman"), GameProfile.class).get(0);
+			newEntityArmorStand = getNMSClass("net.minecraft.world.entity.decoration.EntityArmorStand", "EntityArmorStand")
+					.getConstructor(getNMSClass("net.minecraft.world.level.World", "World"), double.class, double.class, double.class);
 		}
 		initializeChatComponents();
 		initializeChatPacket();
 		initializeDataWatcher();
-		initializeEntitySpawnPacket();
-		initializeEntityTeleportPacket();
+		initializeEntityPackets();
 		initializeHeaderFooterPacket();
-		initializeOtherEntityPackets();
 		initializePlayerInfoPacket();
 		initializeScoreboardPackets();
-		initializeEnums();
+		try {
+			initializeTeamPackets();
+		} catch (ClassNotFoundException e) {
+			Bukkit.getConsoleSender().sendMessage(me.neznamy.tab.api.chat.EnumChatFormat.color("&c[TAB] Failed to load PacketPlayOutScoreboardTeam"));
+			//fabric with missing team packet
+		}
 	}
 
 	/**
 	 * Sets new instance
 	 * @param instance - new instance
 	 */
-	public static void setInstance(NMSStorage instance) {
+	public final static void setInstance(NMSStorage instance) {
 		NMSStorage.instance = instance;
 	}
 
@@ -95,277 +263,230 @@ public class NMSStorage {
 	 * Returns instance
 	 * @return instance
 	 */
-	public static NMSStorage getInstance() {
+	public final static NMSStorage getInstance() {
 		return instance;
 	}
 
-	private void initializeEnums() throws IllegalAccessException, InvocationTargetException, NoSuchMethodException, SecurityException {
-		for (String name : Arrays.asList("ChatMessageType", "EnumPlayerInfoAction", "EnumGamemode", "EnumScoreboardHealthDisplay", "EnumScoreboardAction", 
-				"PacketPlayOutScoreboardTeam_a", "EnumChatFormat", "EnumNameTagVisibility", "EnumTeamPush")) {
-			if (classes.containsKey(name)) enums.put(name, (Enum[]) getClass(name).getMethod("values").invoke(null));
-		}
-	}
-	
-	private void initializeChatComponents() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		if (minorVersion >= 7) {
-			classes.put("ChatBaseComponent", getNMSClass("net.minecraft.network.chat.ChatBaseComponent", "ChatBaseComponent"));
-			classes.put("ChatClickable", getNMSClass("net.minecraft.network.chat.ChatClickable", "ChatClickable"));
-			classes.put("ChatComponentText", getNMSClass("net.minecraft.network.chat.ChatComponentText", "ChatComponentText"));
-			classes.put("ChatHoverable", getNMSClass("net.minecraft.network.chat.ChatHoverable", "ChatHoverable"));
-			classes.put("ChatModifier", getNMSClass("net.minecraft.network.chat.ChatModifier", "ChatModifier"));
-			classes.put("ChatSerializer", getNMSClass("net.minecraft.network.chat.IChatBaseComponent$ChatSerializer", "IChatBaseComponent$ChatSerializer", "ChatSerializer"));
-			classes.put("EnumClickAction", getNMSClass("net.minecraft.network.chat.ChatClickable$EnumClickAction", "ChatClickable$EnumClickAction", "EnumClickAction"));
-			classes.put("EnumHoverAction", getNMSClass("net.minecraft.network.chat.ChatHoverable$EnumHoverAction", "ChatHoverable$EnumHoverAction", "EnumHoverAction"));
-			classes.put("IChatBaseComponent", getNMSClass("net.minecraft.network.chat.IChatBaseComponent", "IChatBaseComponent"));
-			constructors.put("ChatComponentText", getClass("ChatComponentText").getConstructor(String.class));
-			constructors.put("ChatClickable", getClass("ChatClickable").getConstructor(getClass("EnumClickAction"), String.class));
-			constructors.put("ChatHoverable", getClass("ChatHoverable").getConstructors()[0]);
-			fields.put("ChatBaseComponent_extra", getFields(getClass("ChatBaseComponent"), List.class).get(0));
-			fields.put("ChatBaseComponent_modifier", getFields(getClass("ChatBaseComponent"), getClass("ChatModifier")).get(0));
-			fields.put("ChatComponentText_text", getFields(getClass("ChatComponentText"), String.class).get(0));
-			fields.put("ChatClickable_action", getFields(getClass("ChatClickable"), getClass("EnumClickAction")).get(0));
-			fields.put("ChatClickable_value", getFields(getClass("ChatClickable"), String.class).get(0));
-			fields.put("ChatHoverable_action", getFields(getClass("ChatHoverable"), getClass("EnumHoverAction")).get(0));
-			List<Field> booleans = getFields(getClass("ChatModifier"), Boolean.class);
-			fields.put("ChatModifier_bold", booleans.get(0));
-			fields.put("ChatModifier_italic", booleans.get(1));
-			fields.put("ChatModifier_underlined", booleans.get(2));
-			fields.put("ChatModifier_strikethrough", booleans.get(3));
-			fields.put("ChatModifier_obfuscated", booleans.get(4));
-			fields.put("ChatModifier_clickEvent", getFields(getClass("ChatModifier"), getClass("ChatClickable")).get(0));
-			fields.put("ChatModifier_hoverEvent", getFields(getClass("ChatModifier"), getClass("ChatHoverable")).get(0));
-			methods.put("ChatComponentText_addSibling", getMethod(getClass("ChatComponentText"), new String[]{"addSibling", "a", "func_150257_a"}, getClass("IChatBaseComponent"))); //v1.7.R4+, v1.7.R3-
-			methods.put("ChatSerializer_DESERIALIZE", getMethod(getClass("ChatSerializer"), new String[]{"a", "func_150699_a"}, String.class));
-			methods.put("EnumClickAction_a", getMethod(getClass("EnumClickAction"), new String[]{"a", "func_150672_a"}, String.class));
-			methods.put("EnumHoverAction_a", getMethod(getClass("EnumHoverAction"), new String[]{"a", "func_150684_a"}, String.class));
-		}
+	private final void initializeChatComponents() throws ReflectiveOperationException {
+		if (minorVersion < 7) return;
+		Class<?> ChatBaseComponent = getNMSClass("net.minecraft.network.chat.ChatBaseComponent", "ChatBaseComponent");
+		Class<?> ChatClickable = getNMSClass("net.minecraft.network.chat.ChatClickable", "ChatClickable");
+		ChatComponentText = getNMSClass("net.minecraft.network.chat.ChatComponentText", "ChatComponentText");
+		ChatHoverable = getNMSClass("net.minecraft.network.chat.ChatHoverable", "ChatHoverable");
+		Class<?> ChatModifier = getNMSClass("net.minecraft.network.chat.ChatModifier", "ChatModifier");
+		EnumClickAction = getNMSClass("net.minecraft.network.chat.ChatClickable$EnumClickAction", "ChatClickable$EnumClickAction", "EnumClickAction");
+		Class<?> EnumHoverAction = getNMSClass("net.minecraft.network.chat.ChatHoverable$EnumHoverAction", "ChatHoverable$EnumHoverAction", "EnumHoverAction");
+		IChatBaseComponent = getNMSClass("net.minecraft.network.chat.IChatBaseComponent", "IChatBaseComponent");
+		newChatComponentText = ChatComponentText.getConstructor(String.class);
+		newChatClickable = ChatClickable.getConstructor(EnumClickAction, String.class);
+		ChatBaseComponent_extra = getFields(ChatBaseComponent, List.class).get(0);
+		ChatBaseComponent_modifier = getFields(ChatBaseComponent, ChatModifier).get(0);
+		ChatComponentText_text = getFields(ChatComponentText, String.class).get(0);
+		ChatClickable_action = getFields(ChatClickable, EnumClickAction).get(0);
+		ChatClickable_value = getFields(ChatClickable, String.class).get(0);
+		List<Field> booleans = getFields(ChatModifier, Boolean.class);
+		ChatModifier_bold = booleans.get(0);
+		ChatModifier_italic = booleans.get(1);
+		ChatModifier_underlined = booleans.get(2);
+		ChatModifier_strikethrough = booleans.get(3);
+		ChatModifier_obfuscated = booleans.get(4);
+		ChatModifier_clickEvent = getFields(ChatModifier, ChatClickable).get(0);
+		ChatModifier_hoverEvent = getFields(ChatModifier, ChatHoverable).get(0);
+		ChatComponentText_addSibling = getMethod(ChatComponentText, new String[]{"addSibling", "a", "func_150257_a", "method_10852"}, IChatBaseComponent);
+		EnumHoverAction_a = getMethod(EnumHoverAction, new String[]{"a", "func_150684_a", "method_27670"}, String.class);
+		ChatHoverable_getAction = getMethods(ChatHoverable, EnumHoverAction).get(0);
 		if (minorVersion >= 16) {
-			classes.put("ChatHexColor", getNMSClass("net.minecraft.network.chat.ChatHexColor", "ChatHexColor"));
-			constructors.put("ChatModifier", getConstructor(getClass("ChatModifier"), 10));
-			List<Field> list = getFields(getClass("ChatHexColor"), String.class);
-			fields.put("ChatHexColor_name", list.get(list.size()-1));
-			fields.put("ChatHexColor_rgb", getFields(getClass("ChatHexColor"), int.class).get(0));
-			fields.put("ChatHoverable_value", getFields(getClass("ChatHoverable"), Object.class).get(0));
-			fields.put("ChatModifier_color", getFields(getClass("ChatModifier"), getClass("ChatHexColor")).get(0));
-			methods.put("ChatHexColor_ofInt", getClass("ChatHexColor").getMethod("a", int.class));
-			methods.put("ChatHexColor_ofString", getClass("ChatHexColor").getMethod("a", String.class));
-		} else if (minorVersion >= 7) {
-			constructors.put("ChatModifier", getClass("ChatModifier").getConstructor());
-			fields.put("ChatHoverable_value", getFields(getClass("ChatHoverable"), getClass("IChatBaseComponent")).get(0));
-			fields.put("ChatModifier_color", getFields(getClass("ChatModifier"), getClass("EnumChatFormat")).get(0));
+			Class<?> ChatHexColor = getNMSClass("net.minecraft.network.chat.ChatHexColor", "ChatHexColor");
+			Class<?> MinecraftKey = getNMSClass("net.minecraft.resources.MinecraftKey", "MinecraftKey");
+			newChatModifier = setAccessible(ChatModifier.getDeclaredConstructor(ChatHexColor, Boolean.class, Boolean.class, Boolean.class, Boolean.class, Boolean.class, ChatClickable, ChatHoverable, String.class, MinecraftKey));
+			newChatHoverable = ChatHoverable.getConstructor(EnumHoverAction, Object.class);
+			List<Field> list = getFields(ChatHexColor, String.class);
+			ChatHexColor_name = list.get(list.size()-1);
+			ChatHexColor_rgb = getFields(ChatHexColor, int.class).get(0);
+			ChatModifier_color = getFields(ChatModifier, ChatHexColor).get(0);
+			ChatHexColor_ofInt = getMethods(ChatHexColor, ChatHexColor, int.class).get(0);
+			ChatHexColor_ofString = getMethods(ChatHexColor, ChatHexColor, String.class).get(0);
+			ChatHoverable_serialize = getMethods(ChatHoverable, JsonObject.class).get(0);
+			ChatHoverable_getValue = getMethods(ChatHoverable, Object.class, EnumHoverAction).get(0);
+			EnumHoverAction_fromJson = getMethods(EnumHoverAction, ChatHoverable, JsonElement.class).get(0);
+			EnumHoverAction_fromLegacyComponent = getMethods(EnumHoverAction, ChatHoverable, IChatBaseComponent).get(0);
+		} else {
+			newChatModifier = ChatModifier.getConstructor();
+			newChatHoverable = ChatHoverable.getConstructor(EnumHoverAction, IChatBaseComponent);
+			ChatModifier_color = getFields(ChatModifier, EnumChatFormat).get(0);
+			ChatHoverable_getValue = getMethods(ChatHoverable, IChatBaseComponent).get(0);
 		}
 	}
 	
-	private void initializeChatPacket() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		classes.put("PacketPlayOutChat", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutChat", "PacketPlayOutChat", "Packet3Chat"));
+	private final void initializeChatPacket() throws ReflectiveOperationException {
+		Class<?> PacketPlayOutChat = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutChat", "PacketPlayOutChat", "Packet3Chat");
 		if (minorVersion >= 12) {
-			classes.put("ChatMessageType", getNMSClass("net.minecraft.network.chat.ChatMessageType", "ChatMessageType"));
+			ChatMessageType = getNMSClass("net.minecraft.network.chat.ChatMessageType", "ChatMessageType");
+			ChatMessageType_values = getEnumValues(ChatMessageType);
 		}
 		if (minorVersion >= 16) {
-			constructors.put("PacketPlayOutChat", getClass("PacketPlayOutChat").getConstructor(getClass("IChatBaseComponent"), getClass("ChatMessageType"), UUID.class));
+			newPacketPlayOutChat = PacketPlayOutChat.getConstructor(IChatBaseComponent, ChatMessageType, UUID.class);
 		} else if (minorVersion >= 12) {
-			constructors.put("PacketPlayOutChat", getClass("PacketPlayOutChat").getConstructor(getClass("IChatBaseComponent"), getClass("ChatMessageType")));
+			newPacketPlayOutChat = PacketPlayOutChat.getConstructor(IChatBaseComponent, ChatMessageType);
 		} else if (minorVersion >= 8) {
-			constructors.put("PacketPlayOutChat", getClass("PacketPlayOutChat").getConstructor(getClass("IChatBaseComponent"), byte.class));
+			newPacketPlayOutChat = PacketPlayOutChat.getConstructor(IChatBaseComponent, byte.class);
 		} else if (minorVersion >= 7){
-			constructors.put("PacketPlayOutChat", getClass("PacketPlayOutChat").getConstructor(getClass("IChatBaseComponent")));
+			newPacketPlayOutChat = PacketPlayOutChat.getConstructor(IChatBaseComponent);
 		}
 	}
 	
-	private void initializeDataWatcher() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		classes.put("DataWatcher", getNMSClass("net.minecraft.network.syncher.DataWatcher", "DataWatcher"));
-		classes.put("DataWatcherItem", getNMSClass("net.minecraft.network.syncher.DataWatcher$Item", "DataWatcher$Item", "DataWatcher$WatchableObject", "WatchableObject"));
+	private final void initializeDataWatcher() throws ReflectiveOperationException {
+		if (minorVersion >= 9) {
+			Class<?> DataWatcherObject = getNMSClass("net.minecraft.network.syncher.DataWatcherObject", "DataWatcherObject");
+			DataWatcherRegistry = getNMSClass("net.minecraft.network.syncher.DataWatcherRegistry", "DataWatcherRegistry");
+			Class<?> DataWatcherSerializer = getNMSClass("net.minecraft.network.syncher.DataWatcherSerializer", "DataWatcherSerializer");
+			newDataWatcherObject = DataWatcherObject.getConstructor(int.class, DataWatcherSerializer);
+			DataWatcherItem_TYPE = getFields(DataWatcherItem, DataWatcherObject).get(0);
+			DataWatcherObject_SLOT = getFields(DataWatcherObject, int.class).get(0);
+			DataWatcherObject_SERIALIZER = getFields(DataWatcherObject, DataWatcherSerializer).get(0);
+			DataWatcher_REGISTER = getMethod(DataWatcher, new String[]{"register", "method_12784", "a"}, DataWatcherObject, Object.class);
+		} else {
+			DataWatcherItem_TYPE = getFields(DataWatcherItem, int.class).get(1);
+			DataWatcher_REGISTER = getMethod(DataWatcher, new String[]{"a", "func_75682_a"}, int.class, Object.class);
+		}
+		registry = new DataWatcherRegistry(this);
+	}
+	
+	private final void initializeEntityPackets() throws ReflectiveOperationException {
+		if (minorVersion >= 17 || serverVersion.getMinorVersion() >= 17) {
+			newPacketPlayOutSpawnEntityLiving = PacketPlayOutSpawnEntityLiving.getConstructor(EntityLiving);
+			newPacketPlayOutEntityTeleport = PacketPlayOutEntityTeleport.getConstructor(Entity);
+		} else {
+			newPacketPlayOutSpawnEntityLiving = PacketPlayOutSpawnEntityLiving.getConstructor();
+			newPacketPlayOutEntityTeleport = PacketPlayOutEntityTeleport.getConstructor();
+		}
+		if (minorVersion >= 17) {
+			PacketPlayInUseEntity$d = Class.forName("net.minecraft.network.protocol.game.PacketPlayInUseEntity$d");
+		}
+		try {
+			newPacketPlayOutEntityDestroy = PacketPlayOutEntityDestroy.getConstructor(int[].class);
+		} catch (NoSuchMethodException e) {
+			//1.17.0
+			newPacketPlayOutEntityDestroy = PacketPlayOutEntityDestroy.getConstructor(int.class);
+		}
 		if (minorVersion >= 7) {
-			constructors.put("DataWatcher", getClass("DataWatcher").getConstructor(getClass("Entity")));
-		} else {
-			constructors.put("DataWatcher", getClass("DataWatcher").getConstructor());
+			Class<?> EnumEntityUseAction = getNMSClass("net.minecraft.network.protocol.game.PacketPlayInUseEntity$EnumEntityUseAction", "PacketPlayInUseEntity$EnumEntityUseAction", "EnumEntityUseAction", "net.minecraft.class_2824$class_5906");
+			PacketPlayInUseEntity_ENTITY = getFields(PacketPlayInUseEntity, int.class).get(0);
+			PacketPlayInUseEntity_ACTION = getFields(PacketPlayInUseEntity, EnumEntityUseAction).get(0);
 		}
 		if (minorVersion >= 9) {
-			classes.put("DataWatcherObject", getNMSClass("net.minecraft.network.syncher.DataWatcherObject", "DataWatcherObject"));
-			classes.put("DataWatcherRegistry", getNMSClass("net.minecraft.network.syncher.DataWatcherRegistry", "DataWatcherRegistry"));
-			classes.put("DataWatcherSerializer", getNMSClass("net.minecraft.network.syncher.DataWatcherSerializer", "DataWatcherSerializer"));
-			constructors.put("DataWatcherObject", getClass("DataWatcherObject").getConstructor(int.class, getClass("DataWatcherSerializer")));
-			fields.put("DataWatcherItem_TYPE", getFields(getClass("DataWatcherItem"), getClass("DataWatcherObject")).get(0));
-			fields.put("DataWatcherItem_VALUE", getFields(getClass("DataWatcherItem"), Object.class).get(0));
-			fields.put("DataWatcherObject_SLOT", getFields(getClass("DataWatcherObject"), int.class).get(0));
-			fields.put("DataWatcherObject_SERIALIZER", getFields(getClass("DataWatcherObject"), getClass("DataWatcherSerializer")).get(0));
-			methods.put("DataWatcher_REGISTER", getClass("DataWatcher").getMethod("register", getClass("DataWatcherObject"), Object.class));
+			PacketPlayOutSpawnEntityLiving_UUID = getFields(PacketPlayOutSpawnEntityLiving, UUID.class).get(0);
+			PacketPlayOutSpawnEntityLiving_X = getFields(PacketPlayOutSpawnEntityLiving, double.class).get(0);
+			PacketPlayOutSpawnEntityLiving_Y = getFields(PacketPlayOutSpawnEntityLiving, double.class).get(1);
+			PacketPlayOutSpawnEntityLiving_Z = getFields(PacketPlayOutSpawnEntityLiving, double.class).get(2);
+			PacketPlayOutEntityTeleport_X = getFields(PacketPlayOutEntityTeleport, double.class).get(0);
+			PacketPlayOutEntityTeleport_Y = getFields(PacketPlayOutEntityTeleport, double.class).get(1);
+			PacketPlayOutEntityTeleport_Z = getFields(PacketPlayOutEntityTeleport, double.class).get(2);
 		} else {
-			fields.put("DataWatcherItem_TYPE", getFields(getClass("DataWatcherItem"), int.class).get(1));
-			fields.put("DataWatcherItem_VALUE", getFields(getClass("DataWatcherItem"), Object.class).get(0));
-			methods.put("DataWatcher_REGISTER", getMethod(getClass("DataWatcher"), new String[]{"a", "func_75682_a"}, int.class, Object.class));
-		}
-		dataWatcherRegistry = new DataWatcherRegistry(this, getClass("DataWatcherRegistry"));
-	}
-	
-	private void initializeEntitySpawnPacket() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		classes.put("PacketPlayOutSpawnEntityLiving", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutSpawnEntityLiving", "PacketPlayOutSpawnEntityLiving", "Packet24MobSpawn"));
-		constructors.put("PacketPlayOutSpawnEntityLiving", getClass("PacketPlayOutSpawnEntityLiving").getConstructor(getClass("EntityLiving")));
-		fields.put("PacketPlayOutSpawnEntityLiving_ENTITYID", getFields(getClass("PacketPlayOutSpawnEntityLiving"), int.class).get(0));
-		fields.put("PacketPlayOutSpawnEntityLiving_ENTITYTYPE", getFields(getClass("PacketPlayOutSpawnEntityLiving"), int.class).get(1));
-		fields.put("PacketPlayOutSpawnEntityLiving_YAW", getFields(getClass("PacketPlayOutSpawnEntityLiving"), byte.class).get(0));
-		fields.put("PacketPlayOutSpawnEntityLiving_PITCH", getFields(getClass("PacketPlayOutSpawnEntityLiving"), byte.class).get(0));
-		if (minorVersion >= 9) {
-			fields.put("PacketPlayOutSpawnEntityLiving_UUID", getFields(getClass("PacketPlayOutSpawnEntityLiving"), UUID.class).get(0));
-			fields.put("PacketPlayOutSpawnEntityLiving_X", getFields(getClass("PacketPlayOutSpawnEntityLiving"), double.class).get(0));
-			fields.put("PacketPlayOutSpawnEntityLiving_Y", getFields(getClass("PacketPlayOutSpawnEntityLiving"), double.class).get(1));
-			fields.put("PacketPlayOutSpawnEntityLiving_Z", getFields(getClass("PacketPlayOutSpawnEntityLiving"), double.class).get(2));
-		} else {
-			fields.put("PacketPlayOutSpawnEntityLiving_X", getFields(getClass("PacketPlayOutSpawnEntityLiving"), int.class).get(2));
-			fields.put("PacketPlayOutSpawnEntityLiving_Y", getFields(getClass("PacketPlayOutSpawnEntityLiving"), int.class).get(3));
-			fields.put("PacketPlayOutSpawnEntityLiving_Z", getFields(getClass("PacketPlayOutSpawnEntityLiving"), int.class).get(4));
+			PacketPlayOutSpawnEntityLiving_X = getFields(PacketPlayOutSpawnEntityLiving, int.class).get(2);
+			PacketPlayOutSpawnEntityLiving_Y = getFields(PacketPlayOutSpawnEntityLiving, int.class).get(3);
+			PacketPlayOutSpawnEntityLiving_Z = getFields(PacketPlayOutSpawnEntityLiving, int.class).get(4);
+			PacketPlayOutEntityTeleport_X = getFields(PacketPlayOutEntityTeleport, int.class).get(1);
+			PacketPlayOutEntityTeleport_Y = getFields(PacketPlayOutEntityTeleport, int.class).get(2);
+			PacketPlayOutEntityTeleport_Z = getFields(PacketPlayOutEntityTeleport, int.class).get(3);
 		}
 		if (minorVersion <= 14) {
-			fields.put("PacketPlayOutSpawnEntityLiving_DATAWATCHER", getFields(getClass("PacketPlayOutSpawnEntityLiving"), getClass("DataWatcher")).get(0));
-		}
-	}
-	
-	private void initializeEntityTeleportPacket() throws NoSuchMethodException, SecurityException, ClassNotFoundException {
-		classes.put("PacketPlayOutEntityTeleport", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntityTeleport", "PacketPlayOutEntityTeleport", "Packet34EntityTeleport"));
-		constructors.put("PacketPlayOutEntityTeleport", getClass("PacketPlayOutEntityTeleport").getConstructor(getClass("Entity")));
-		fields.put("PacketPlayOutEntityTeleport_ENTITYID", getFields(getClass("PacketPlayOutEntityTeleport"), int.class).get(0));
-		fields.put("PacketPlayOutEntityTeleport_YAW", getFields(getClass("PacketPlayOutEntityTeleport"), byte.class).get(0));
-		fields.put("PacketPlayOutEntityTeleport_PITCH", getFields(getClass("PacketPlayOutEntityTeleport"), byte.class).get(1));
-		if (minorVersion >= 9) {
-			fields.put("PacketPlayOutEntityTeleport_X", getFields(getClass("PacketPlayOutEntityTeleport"), double.class).get(0));
-			fields.put("PacketPlayOutEntityTeleport_Y", getFields(getClass("PacketPlayOutEntityTeleport"), double.class).get(1));
-			fields.put("PacketPlayOutEntityTeleport_Z", getFields(getClass("PacketPlayOutEntityTeleport"), double.class).get(2));
-		} else {
-			fields.put("PacketPlayOutEntityTeleport_X", getFields(getClass("PacketPlayOutEntityTeleport"), int.class).get(1));
-			fields.put("PacketPlayOutEntityTeleport_Y", getFields(getClass("PacketPlayOutEntityTeleport"), int.class).get(2));
-			fields.put("PacketPlayOutEntityTeleport_Z", getFields(getClass("PacketPlayOutEntityTeleport"), int.class).get(3));
-		}
-	}
-	
-	private void initializeHeaderFooterPacket() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		if (minorVersion >= 8) {
-			classes.put("PacketPlayOutPlayerListHeaderFooter", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerListHeaderFooter", "PacketPlayOutPlayerListHeaderFooter"));
-			fields.put("PacketPlayOutPlayerListHeaderFooter_HEADER", getFields(getClass("PacketPlayOutPlayerListHeaderFooter"), getClass("IChatBaseComponent")).get(0));
-			fields.put("PacketPlayOutPlayerListHeaderFooter_FOOTER", getFields(getClass("PacketPlayOutPlayerListHeaderFooter"), getClass("IChatBaseComponent")).get(1));
-			if (minorVersion >= 17) {
-				constructors.put("PacketPlayOutPlayerListHeaderFooter", getClass("PacketPlayOutPlayerListHeaderFooter").getConstructor(getClass("IChatBaseComponent"), getClass("IChatBaseComponent")));
-			} else {
-				constructors.put("PacketPlayOutPlayerListHeaderFooter", getClass("PacketPlayOutPlayerListHeaderFooter").getConstructor());
-			}
-		}
-	}
-	
-	private void initializeOtherEntityPackets() throws ClassNotFoundException, NoSuchMethodException {
-		classes.put("PacketPlayInUseEntity", getNMSClass("net.minecraft.network.protocol.game.PacketPlayInUseEntity", "PacketPlayInUseEntity", "Packet7UseEntity"));
-		classes.put("PacketPlayOutEntity", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntity", "PacketPlayOutEntity", "Packet30Entity"));
-		classes.put("PacketPlayOutEntityDestroy", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntityDestroy", "PacketPlayOutEntityDestroy", "Packet29DestroyEntity"));
-		classes.put("PacketPlayOutEntityLook", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutEntityLook", "PacketPlayOutEntity$PacketPlayOutEntityLook", "PacketPlayOutEntityLook", "Packet32EntityLook"));
-		classes.put("PacketPlayOutEntityMetadata", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutEntityMetadata", "PacketPlayOutEntityMetadata", "Packet40EntityMetadata"));
-		classes.put("PacketPlayOutNamedEntitySpawn", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutNamedEntitySpawn", "PacketPlayOutNamedEntitySpawn", "Packet20NamedEntitySpawn"));
-		constructors.put("PacketPlayOutEntityMetadata", getClass("PacketPlayOutEntityMetadata").getConstructor(int.class, getClass("DataWatcher"), boolean.class));
-		constructors.put("PacketPlayOutEntityDestroy", getConstructor(getClass("PacketPlayOutEntityDestroy"), 1));
-		fields.put("PacketPlayOutEntity_ENTITYID", getFields(getClass("PacketPlayOutEntity"), int.class).get(0));
-		fields.put("PacketPlayOutEntityMetadata_LIST", getFields(getClass("PacketPlayOutEntityMetadata"), List.class).get(0));
-		fields.put("PacketPlayOutNamedEntitySpawn_ENTITYID", getFields(getClass("PacketPlayOutNamedEntitySpawn"), int.class).get(0));
-		if (minorVersion >= 7) {
-			classes.put("EnumEntityUseAction", getNMSClass("net.minecraft.network.protocol.game.PacketPlayInUseEntity$EnumEntityUseAction", "PacketPlayInUseEntity$EnumEntityUseAction", "EnumEntityUseAction"));
-			fields.put("PacketPlayInUseEntity_ENTITY", getFields(getClass("PacketPlayInUseEntity"), int.class).get(0));
-			fields.put("PacketPlayInUseEntity_ACTION", getFields(getClass("PacketPlayInUseEntity"), getClass("EnumEntityUseAction")).get(0));
-		}
-		if (minorVersion >= 17) {
-			classes.put("PacketPlayInUseEntity$d", Class.forName("net.minecraft.network.protocol.game.PacketPlayInUseEntity$d"));
-			fields.put("PacketPlayOutEntityDestroy_ENTITIES", getFields(getClass("PacketPlayOutEntityDestroy"), int.class).get(0));
-		} else {
-			fields.put("PacketPlayOutEntityDestroy_ENTITIES", getFields(getClass("PacketPlayOutEntityDestroy"), int[].class).get(0));
-		}
-	}
-	
-	private void initializePlayerInfoPacket() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		if (minorVersion >= 8) {
-			classes.put("PacketPlayOutPlayerInfo", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo", "PacketPlayOutPlayerInfo"));
-			classes.put("EnumPlayerInfoAction", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "EnumPlayerInfoAction"));
-			classes.put("PlayerInfoData", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$PlayerInfoData", "PacketPlayOutPlayerInfo$PlayerInfoData", "PlayerInfoData"));
-			classes.put("EnumGamemode", getNMSClass("net.minecraft.world.level.EnumGamemode", "EnumGamemode", "WorldSettings$EnumGamemode"));
-			constructors.put("PacketPlayOutPlayerInfo", getClass("PacketPlayOutPlayerInfo").getConstructor(getClass("EnumPlayerInfoAction"), Array.newInstance(getClass("EntityPlayer"), 0).getClass()));
-			constructors.put("PlayerInfoData", getClass("PlayerInfoData").getConstructors()[0]);
-			fields.put("PacketPlayOutPlayerInfo_ACTION", getFields(getClass("PacketPlayOutPlayerInfo"), getClass("EnumPlayerInfoAction")).get(0));
-			fields.put("PacketPlayOutPlayerInfo_PLAYERS", getFields(getClass("PacketPlayOutPlayerInfo"), List.class).get(0));
-			methods.put("PlayerInfoData_getProfile", getClass("PlayerInfoData").getMethod("a"));
-			methods.put("PlayerInfoData_getLatency", getClass("PlayerInfoData").getMethod("b"));
-			methods.put("PlayerInfoData_getGamemode", getClass("PlayerInfoData").getMethod("c"));
-			methods.put("PlayerInfoData_getDisplayName", getClass("PlayerInfoData").getMethod("d"));
-		}
-	}
-	
-	private void initializeScoreboardPackets() throws ClassNotFoundException, NoSuchMethodException, SecurityException {
-		classes.put("PacketPlayOutScoreboardDisplayObjective", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardDisplayObjective", "PacketPlayOutScoreboardDisplayObjective", "Packet208SetScoreboardDisplayObjective"));
-		classes.put("PacketPlayOutScoreboardObjective", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardObjective", "PacketPlayOutScoreboardObjective", "Packet206SetScoreboardObjective"));
-		classes.put("PacketPlayOutScoreboardScore", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardScore", "PacketPlayOutScoreboardScore", "Packet207SetScoreboardScore"));
-		classes.put("PacketPlayOutScoreboardTeam", getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardTeam", "PacketPlayOutScoreboardTeam", "Packet209SetScoreboardTeam"));
-		classes.put("Scoreboard", getNMSClass("net.minecraft.world.scores.Scoreboard", "Scoreboard"));
-		classes.put("ScoreboardObjective", getNMSClass("net.minecraft.world.scores.ScoreboardObjective", "ScoreboardObjective"));
-		classes.put("ScoreboardTeam", getNMSClass("net.minecraft.world.scores.ScoreboardTeam", "ScoreboardTeam"));
-		classes.put("ScoreboardScore", getNMSClass("net.minecraft.world.scores.ScoreboardScore", "ScoreboardScore"));
-		classes.put("IScoreboardCriteria", getNMSClass("net.minecraft.world.scores.criteria.IScoreboardCriteria", "IScoreboardCriteria"));
-		constructors.put("ScoreboardObjective", getClass("ScoreboardObjective").getConstructors()[0]);
-		constructors.put("Scoreboard", getClass("Scoreboard").getConstructor());
-		constructors.put("ScoreboardTeam", getClass("ScoreboardTeam").getConstructor(getClass("Scoreboard"), String.class));
-		constructors.put("ScoreboardScore", getClass("ScoreboardScore").getConstructor(getClass("Scoreboard"), getClass("ScoreboardObjective"), String.class));
-		constructors.put("PacketPlayOutScoreboardDisplayObjective", getClass("PacketPlayOutScoreboardDisplayObjective").getConstructor(int.class, getClass("ScoreboardObjective")));
-		fields.put("PacketPlayOutScoreboardDisplayObjective_POSITION", getFields(getClass("PacketPlayOutScoreboardDisplayObjective"), int.class).get(0));
-		fields.put("PacketPlayOutScoreboardDisplayObjective_OBJECTIVENAME", getFields(getClass("PacketPlayOutScoreboardDisplayObjective"), String.class).get(0));
-		fields.put("PacketPlayOutScoreboardObjective_OBJECTIVENAME", getFields(getClass("PacketPlayOutScoreboardObjective"), String.class).get(0));
-		List<Field> list = getFields(getClass("PacketPlayOutScoreboardObjective"), int.class);
-		fields.put("PacketPlayOutScoreboardObjective_METHOD", list.get(list.size()-1));
-		fields.put("PacketPlayOutScoreboardTeam_NAME", getFields(getClass("PacketPlayOutScoreboardTeam"), String.class).get(0));
-		fields.put("PacketPlayOutScoreboardTeam_PLAYERS", getFields(getClass("PacketPlayOutScoreboardTeam"), Collection.class).get(0));
-		methods.put("ScoreboardTeam_getPlayerNameSet", getMethod(getClass("ScoreboardTeam"), new String[]{"getPlayerNameSet", "func_96670_d"}));
-		methods.put("ScoreboardScore_setScore", getMethod(getClass("ScoreboardScore"), new String[]{"setScore", "func_96647_c"}, int.class));
-		if (minorVersion >= 8) {
-			classes.put("EnumScoreboardHealthDisplay", getNMSClass("net.minecraft.world.scores.criteria.IScoreboardCriteria$EnumScoreboardHealthDisplay", "IScoreboardCriteria$EnumScoreboardHealthDisplay", "EnumScoreboardHealthDisplay"));
-			classes.put("EnumScoreboardAction", getNMSClass("net.minecraft.server.ScoreboardServer$Action", "ScoreboardServer$Action", "PacketPlayOutScoreboardScore$EnumScoreboardAction", "EnumScoreboardAction"));
-			classes.put("EnumNameTagVisibility", getNMSClass("net.minecraft.world.scores.ScoreboardTeamBase$EnumNameTagVisibility", "ScoreboardTeamBase$EnumNameTagVisibility", "EnumNameTagVisibility"));
-			fields.put("PacketPlayOutScoreboardObjective_RENDERTYPE", getFields(getClass("PacketPlayOutScoreboardObjective"), getClass("EnumScoreboardHealthDisplay")).get(0));
-			methods.put("ScoreboardTeam_setNameTagVisibility", getMethod(getClass("ScoreboardTeam"), new String[]{"setNameTagVisibility", "a"}, getClass("EnumNameTagVisibility")));
-		}
-		if (minorVersion >= 9) {
-			classes.put("EnumTeamPush", getNMSClass("net.minecraft.world.scores.ScoreboardTeamBase$EnumTeamPush", "ScoreboardTeamBase$EnumTeamPush"));
-			methods.put("ScoreboardTeam_setCollisionRule", getClass("ScoreboardTeam").getMethod("setCollisionRule", getClass("EnumTeamPush")));
-		}
-		if (minorVersion >= 13) {
-			constructors.put("PacketPlayOutScoreboardObjective", getClass("PacketPlayOutScoreboardObjective").getConstructor(getClass("ScoreboardObjective"), int.class));
-			constructors.put("PacketPlayOutScoreboardScore_1_13", getClass("PacketPlayOutScoreboardScore").getConstructor(getClass("EnumScoreboardAction"), String.class, String.class, int.class));
-			fields.put("PacketPlayOutScoreboardObjective_DISPLAYNAME", getFields(getClass("PacketPlayOutScoreboardObjective"), getClass("IChatBaseComponent")).get(0));
-			methods.put("ScoreboardTeam_setPrefix", getClass("ScoreboardTeam").getMethod("setPrefix", getClass("IChatBaseComponent")));
-			methods.put("ScoreboardTeam_setSuffix", getClass("ScoreboardTeam").getMethod("setSuffix", getClass("IChatBaseComponent")));
-			methods.put("ScoreboardTeam_setColor", getClass("ScoreboardTeam").getMethod("setColor", getClass("EnumChatFormat")));
-		} else {
-			constructors.put("PacketPlayOutScoreboardObjective", getClass("PacketPlayOutScoreboardObjective").getConstructor());
-			constructors.put("PacketPlayOutScoreboardScore_String", getClass("PacketPlayOutScoreboardScore").getConstructor(String.class));
-			fields.put("PacketPlayOutScoreboardObjective_DISPLAYNAME", getFields(getClass("PacketPlayOutScoreboardObjective"), String.class).get(1));
-			methods.put("ScoreboardTeam_setPrefix", getMethod(getClass("ScoreboardTeam"), new String[]{"setPrefix", "func_96666_b"}, String.class));
-			methods.put("ScoreboardTeam_setSuffix", getMethod(getClass("ScoreboardTeam"), new String[]{"setSuffix", "func_96662_c"}, String.class));
-			if (minorVersion >= 8) {
-				constructors.put("PacketPlayOutScoreboardScore", getClass("PacketPlayOutScoreboardScore").getConstructor(getClass("ScoreboardScore")));
-			} else {
-				constructors.put("PacketPlayOutScoreboardScore", getClass("PacketPlayOutScoreboardScore").getConstructor(getClass("ScoreboardScore"), int.class));
-			}
-		}
-		if (minorVersion >= 17) {
-			classes.put("PacketPlayOutScoreboardTeam_a", Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardTeam$a"));
-			methods.put("PacketPlayOutScoreboardTeam_of", getClass("PacketPlayOutScoreboardTeam").getMethod("a", getClass("ScoreboardTeam")));
-			methods.put("PacketPlayOutScoreboardTeam_ofBoolean", getClass("PacketPlayOutScoreboardTeam").getMethod("a", getClass("ScoreboardTeam"), boolean.class));
-			methods.put("PacketPlayOutScoreboardTeam_ofString", getClass("PacketPlayOutScoreboardTeam").getMethod("a", getClass("ScoreboardTeam"), String.class, getClass("PacketPlayOutScoreboardTeam_a")));
-		} else {
-			constructors.put("PacketPlayOutScoreboardTeam", getClass("PacketPlayOutScoreboardTeam").getConstructor(getClass("ScoreboardTeam"), int.class));
+			PacketPlayOutSpawnEntityLiving_DATAWATCHER = getFields(PacketPlayOutSpawnEntityLiving, DataWatcher).get(0);
 		}
 	}
 
-	/**
-	 * 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
-	 */
-	@SuppressWarnings("unused")
-	private void showMethods(Class<?> clazz) {
-		TAB.getInstance().getPlatform().sendConsoleMessage("--- " + clazz.getSimpleName() + " ---", false);
-		for (Method m : clazz.getMethods()) {
-			TAB.getInstance().getPlatform().sendConsoleMessage(m.getReturnType().getName() + " " + m.getName() + "(" + Arrays.toString(m.getParameterTypes()) + ")", false);
+	private final void initializeHeaderFooterPacket() throws ReflectiveOperationException {
+		if (minorVersion < 8) return;
+		Class<?> PacketPlayOutPlayerListHeaderFooter = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerListHeaderFooter", "PacketPlayOutPlayerListHeaderFooter");
+		PacketPlayOutPlayerListHeaderFooter_HEADER = getFields(PacketPlayOutPlayerListHeaderFooter, IChatBaseComponent).get(0);
+		PacketPlayOutPlayerListHeaderFooter_FOOTER = getFields(PacketPlayOutPlayerListHeaderFooter, IChatBaseComponent).get(1);
+		if (minorVersion >= 17 || serverVersion.getMinorVersion() >= 17) {
+			newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooter.getConstructor(IChatBaseComponent, IChatBaseComponent);
+		} else {
+			newPacketPlayOutPlayerListHeaderFooter = PacketPlayOutPlayerListHeaderFooter.getConstructor();
+		}
+	}
+
+	private final void initializePlayerInfoPacket() throws ReflectiveOperationException {
+		if (minorVersion < 8) return;
+		PacketPlayOutPlayerInfo = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo", "PacketPlayOutPlayerInfo");
+		Class<?> EnumPlayerInfoAction = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "PacketPlayOutPlayerInfo$EnumPlayerInfoAction", "EnumPlayerInfoAction", "net.minecraft.class_2703$class_5893");
+		Class<?> PlayerInfoData = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutPlayerInfo$PlayerInfoData", "PacketPlayOutPlayerInfo$PlayerInfoData", "PlayerInfoData");
+		Class<?> EnumGamemode = getNMSClass("net.minecraft.world.level.EnumGamemode", "EnumGamemode", "WorldSettings$EnumGamemode");
+		newPacketPlayOutPlayerInfo = PacketPlayOutPlayerInfo.getConstructor(EnumPlayerInfoAction, Array.newInstance(EntityPlayer, 0).getClass());
+		newPlayerInfoData = PlayerInfoData.getConstructors()[0];
+		PacketPlayOutPlayerInfo_ACTION = getFields(PacketPlayOutPlayerInfo, EnumPlayerInfoAction).get(0);
+		PacketPlayOutPlayerInfo_PLAYERS = getFields(PacketPlayOutPlayerInfo, List.class).get(0);
+		PlayerInfoData_getProfile = getMethods(PlayerInfoData, GameProfile.class).get(0);
+		PlayerInfoData_getLatency = getMethods(PlayerInfoData, int.class).get(0);
+		PlayerInfoData_getGamemode = getMethods(PlayerInfoData, EnumGamemode).get(0);
+		PlayerInfoData_getDisplayName = getMethods(PlayerInfoData, IChatBaseComponent).get(0);
+		EnumPlayerInfoAction_values = getEnumValues(EnumPlayerInfoAction);
+		EnumGamemode_values = getEnumValues(EnumGamemode);
+	}
+
+	private final void initializeScoreboardPackets() throws ReflectiveOperationException {
+		List<Field> list = getFields(PacketPlayOutScoreboardObjective, int.class);
+		PacketPlayOutScoreboardObjective_METHOD = list.get(list.size()-1);
+		Class<?> EnumScoreboardAction = null;
+		if (minorVersion >= 8) {
+			EnumScoreboardHealthDisplay = getNMSClass("net.minecraft.world.scores.criteria.IScoreboardCriteria$EnumScoreboardHealthDisplay", "IScoreboardCriteria$EnumScoreboardHealthDisplay", "EnumScoreboardHealthDisplay");
+			EnumScoreboardHealthDisplay_values = getEnumValues(EnumScoreboardHealthDisplay);
+			EnumScoreboardAction = getNMSClass("net.minecraft.server.ScoreboardServer$Action", "ScoreboardServer$Action", "PacketPlayOutScoreboardScore$EnumScoreboardAction", "EnumScoreboardAction");
+			EnumScoreboardAction_values = getEnumValues(EnumScoreboardAction);
+			PacketPlayOutScoreboardObjective_RENDERTYPE = getFields(PacketPlayOutScoreboardObjective, EnumScoreboardHealthDisplay).get(0);
+		}
+		if (minorVersion >= 13) {
+			newPacketPlayOutScoreboardObjective = PacketPlayOutScoreboardObjective.getConstructor(ScoreboardObjective, int.class);
+			newPacketPlayOutScoreboardScore_1_13 = PacketPlayOutScoreboardScore.getConstructor(EnumScoreboardAction, String.class, String.class, int.class);
+			PacketPlayOutScoreboardObjective_DISPLAYNAME = getFields(PacketPlayOutScoreboardObjective, IChatBaseComponent).get(0);
+		} else {
+			newPacketPlayOutScoreboardObjective = PacketPlayOutScoreboardObjective.getConstructor();
+			newPacketPlayOutScoreboardScore_String = PacketPlayOutScoreboardScore.getConstructor(String.class);
+			PacketPlayOutScoreboardObjective_DISPLAYNAME = getFields(PacketPlayOutScoreboardObjective, String.class).get(1);
+			if (minorVersion >= 8) {
+				newPacketPlayOutScoreboardScore = PacketPlayOutScoreboardScore.getConstructor(ScoreboardScore);
+			} else {
+				newPacketPlayOutScoreboardScore = PacketPlayOutScoreboardScore.getConstructor(ScoreboardScore, int.class);
+			}
+		}
+	}
+	
+	private final void initializeTeamPackets() throws ReflectiveOperationException {
+		PacketPlayOutScoreboardTeam = getNMSClass("net.minecraft.network.protocol.game.PacketPlayOutScoreboardTeam", "PacketPlayOutScoreboardTeam", "Packet209SetScoreboardTeam");
+		Class<?> ScoreboardTeam = getNMSClass("net.minecraft.world.scores.ScoreboardTeam", "ScoreboardTeam");
+		newScoreboardTeam = ScoreboardTeam.getConstructor(Scoreboard, String.class);
+		PacketPlayOutScoreboardTeam_NAME = getFields(PacketPlayOutScoreboardTeam, String.class).get(0);
+		PacketPlayOutScoreboardTeam_PLAYERS = getFields(PacketPlayOutScoreboardTeam, Collection.class).get(0);
+		ScoreboardTeam_getPlayerNameSet = getMethods(ScoreboardTeam, Collection.class).get(0);
+		ScoreboardTeam_setAllowFriendlyFire = getMethod(ScoreboardTeam, new String[]{"setAllowFriendlyFire", "a"}, boolean.class);
+		ScoreboardTeam_setCanSeeFriendlyInvisibles = getMethod(ScoreboardTeam, new String[]{"setCanSeeFriendlyInvisibles", "b"}, boolean.class);
+		if (minorVersion >= 8) {
+			Class<?> EnumNameTagVisibility = getNMSClass("net.minecraft.world.scores.ScoreboardTeamBase$EnumNameTagVisibility", "ScoreboardTeamBase$EnumNameTagVisibility", "EnumNameTagVisibility");
+			EnumNameTagVisibility_values = getEnumValues(EnumNameTagVisibility);
+			ScoreboardTeam_setNameTagVisibility = getMethod(ScoreboardTeam, new String[]{"setNameTagVisibility", "a", "method_1149"}, EnumNameTagVisibility);
+		}
+		if (minorVersion >= 9) {
+			Class<?> EnumTeamPush = getNMSClass("net.minecraft.world.scores.ScoreboardTeamBase$EnumTeamPush", "ScoreboardTeamBase$EnumTeamPush");
+			EnumTeamPush_values = getEnumValues(EnumTeamPush);
+			ScoreboardTeam_setCollisionRule = getMethods(ScoreboardTeam, void.class, EnumTeamPush).get(0);
+		}
+		if (minorVersion >= 13) {
+			ScoreboardTeam_setPrefix = getMethod(ScoreboardTeam, new String[]{"setPrefix", "method_1138", "b"}, IChatBaseComponent);
+			ScoreboardTeam_setSuffix = getMethod(ScoreboardTeam, new String[]{"setSuffix", "method_1139", "c"}, IChatBaseComponent);
+			ScoreboardTeam_setColor = getMethods(ScoreboardTeam, void.class, EnumChatFormat).get(0);
+		} else {
+			ScoreboardTeam_setPrefix = getMethod(ScoreboardTeam, new String[]{"setPrefix", "func_96666_b"}, String.class);
+			ScoreboardTeam_setSuffix = getMethod(ScoreboardTeam, new String[]{"setSuffix", "func_96662_c"}, String.class);
+		}
+		if (minorVersion >= 17 || serverVersion.getMinorVersion() >= 17) {
+			Class<?> PacketPlayOutScoreboardTeam_PlayerAction = Class.forName("net.minecraft.network.protocol.game.PacketPlayOutScoreboardTeam$a");
+			PacketPlayOutScoreboardTeam_of = getMethods(PacketPlayOutScoreboardTeam, PacketPlayOutScoreboardTeam, ScoreboardTeam).get(0);
+			PacketPlayOutScoreboardTeam_ofBoolean = getMethods(PacketPlayOutScoreboardTeam, PacketPlayOutScoreboardTeam, ScoreboardTeam, boolean.class).get(0);
+			PacketPlayOutScoreboardTeam_ofString = getMethods(PacketPlayOutScoreboardTeam, PacketPlayOutScoreboardTeam, ScoreboardTeam, String.class, PacketPlayOutScoreboardTeam_PlayerAction).get(0);
+			PacketPlayOutScoreboardTeam_PlayerAction_values = getEnumValues(PacketPlayOutScoreboardTeam_PlayerAction);
+		} else {
+			newPacketPlayOutScoreboardTeam = PacketPlayOutScoreboardTeam.getConstructor(ScoreboardTeam, int.class);
 		}
 	}
 
@@ -375,15 +496,18 @@ public class NMSStorage {
 	 * @return class for specified name(s)
 	 * @throws ClassNotFoundException if class does not exist
 	 */
-	private Class<?> getNMSClass(String... names) throws ClassNotFoundException {
+	private Class<?> getNMSClass(String fullPath_1_17, String... names) throws ClassNotFoundException {
+		if (minorVersion >= 17) {
+			return Class.forName(fullPath_1_17);
+		}
 		for (String name : names) {
 			try {
-				return getNMSClass(name);
+				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));
+		throw new ClassNotFoundException("No class found with possible names {modern = " + fullPath_1_17 + ", legacy = " + Arrays.toString(names) + "}");
 	}
 
 	/**
@@ -392,18 +516,18 @@ public class NMSStorage {
 	 * @return class from given name
 	 * @throws ClassNotFoundException if class was not found
 	 */
-	private Class<?> getNMSClass(String name) throws ClassNotFoundException {
-		if (minorVersion >= 17) {
-			return Class.forName(name);
-		} else {
+	private Class<?> getLegacyClass(String name) throws ClassNotFoundException {
+		try {
+			return Class.forName("net.minecraft.server." + serverPackage + "." + name);
+		} catch (ClassNotFoundException e) {
 			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
+				Class<?> clazz = Main.class.getClassLoader().loadClass("net.minecraft.server." + serverPackage + "." + name);
+				if (clazz != null) return clazz;
 				throw new ClassNotFoundException(name);
+			} catch (ClassNotFoundException e1) {
+				//fabric
+				return Class.forName(name);
 			}
 		}
 	}
@@ -419,12 +543,41 @@ public class NMSStorage {
 	private Method getMethod(Class<?> clazz, String[] names, Class<?>... parameterTypes) throws NoSuchMethodException {
 		for (String name : names) {
 			try {
-				return clazz.getMethod(name, parameterTypes);
-			} catch (Exception e) {
+				return getMethod(clazz, name, parameterTypes);
+			} catch (NoSuchMethodException e) {
 				//not the first method in array
 			}
 		}
-		throw new NoSuchMethodException("No method found with possible names " + Arrays.toString(names) + " in class " + clazz.getName());
+		throw new NoSuchMethodException("No method found with possible names " + Arrays.toString(names) + " with parameters " + Arrays.toString(parameterTypes) + " in class " + clazz.getName());
+	}
+	
+	private Method getMethod(Class<?> clazz, String name, Class<?>... parameterTypes) throws NoSuchMethodException {
+		List<Method> list = new ArrayList<>();
+		for (Method m : clazz.getMethods()) {
+			if (!m.getName().equals(name) || m.getParameterCount() != parameterTypes.length) continue;
+			Class<?>[] types = m.getParameterTypes();
+			boolean valid = true;
+			for (int i=0; i<types.length; i++) {
+				if (types[i] != parameterTypes[i]) valid = false;
+			}
+			if (valid) list.add(m);
+		}
+		if (!list.isEmpty()) return list.get(0);
+		throw new NoSuchMethodException("No method found with name " + name + " in class " + clazz.getName() + " with parameters " + Arrays.toString(parameterTypes));
+	}
+	
+	private List<Method> getMethods(Class<?> clazz, Class<?> returnType, Class<?>... parameterTypes){
+		List<Method> list = new ArrayList<>();
+		for (Method m : clazz.getDeclaredMethods()) {
+			if (m.getReturnType() != returnType || m.getParameterCount() != parameterTypes.length || !Modifier.isPublic(m.getModifiers())) continue;
+			Class<?>[] types = m.getParameterTypes();
+			boolean valid = true;
+			for (int i=0; i<types.length; i++) {
+				if (types[i] != parameterTypes[i]) valid = false;
+			}
+			if (valid) list.add(m);
+		}
+		return list;
 	}
 
 	/**
@@ -433,13 +586,12 @@ public class NMSStorage {
 	 * @param type - field type to check for
 	 * @return list of all fields with specified class type
 	 */
-	public List<Field> getFields(Class<?> clazz, Class<?> type){
+	private List<Field> getFields(Class<?> clazz, Class<?> type){
 		if (clazz == null) throw new IllegalArgumentException("Source class cannot be null");
 		List<Field> list = new ArrayList<>();
 		for (Field field : clazz.getDeclaredFields()) {
 			if (field.getType() == type) {
-				field.setAccessible(true);
-				list.add(field);
+				list.add(setAccessible(field));
 			}
 		}
 		return list;
@@ -455,26 +607,12 @@ public class NMSStorage {
 	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;
+				return setAccessible(f);
 			}
 		}
-		if (name.equals("ping")){
-			return getField(clazz, "field_71138_i"); //thermos
-		}
 		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");
-	}
-
 	private Field getField(Class<?> clazz, String... potentialNames) throws NoSuchFieldException {
 		for (String name : potentialNames) {
 			try {
@@ -485,36 +623,33 @@ public class NMSStorage {
 		}
 		throw new NoSuchFieldException("No field found in class " + clazz.getName() + " with potential names " + Arrays.toString(potentialNames));
 	}
+	
+	private Enum[] getEnumValues(Class<?> enumClass) {
+		if (enumClass == null) throw new IllegalArgumentException("Class cannot be null");
+		if (!enumClass.isEnum()) throw new IllegalArgumentException(enumClass.getName() + " is not an enum class");
+		try {
+			return (Enum[]) enumClass.getMethod("values").invoke(null);
+		} catch (ReflectiveOperationException e) {
+			//this should never happen
+			TAB.getInstance().getErrorManager().criticalError("Failed to load enum constants of " + enumClass.getName(), e);
+			return new Enum[0];
+		}
+	}
 
 	public int getMinorVersion() {
 		return minorVersion;
 	}
 
-	public Class<?> getClass(String name){
-		return classes.get(name);
-	}
-
-	public Constructor getConstructor(String name){
-		return constructors.get(name);
-	}
-
-	public Field getField(String name){
-		return fields.get(name);
-	}
-
-	public Method getMethod(String name) {
-		return methods.get(name);
-	}
-
-	public Enum[] getEnum(String name) {
-		return enums.get(name);
-	}
-
-	public void setField(Object obj, String field, Object value) throws IllegalAccessException {
-		fields.get(field).set(obj, value);
+	public void setField(Object obj, Field field, Object value) throws IllegalAccessException {
+		field.set(obj, value);
 	}
 
 	public DataWatcherRegistry getDataWatcherRegistry() {
-		return dataWatcherRegistry;
+		return registry;
+	}
+	
+	public <T extends AccessibleObject> T setAccessible(T o) {
+		o.setAccessible(true);
+		return o;
 	}
 }

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/PacketPlayOutEntityDestroy.java

@@ -0,0 +1,23 @@
+package me.neznamy.tab.platforms.bukkit.nms;
+
+import java.util.Arrays;
+
+import me.neznamy.tab.api.protocol.TabPacket;
+
+public class PacketPlayOutEntityDestroy implements TabPacket {
+
+	private final int[] entities;
+
+	public PacketPlayOutEntityDestroy(int... entities) {
+		this.entities = entities;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("PacketPlayOutEntityDestroy{entities=%s}", Arrays.toString(entities));
+	}
+
+	public int[] getEntities() {
+		return entities;
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/PacketPlayOutEntityMetadata.java

@@ -0,0 +1,29 @@
+package me.neznamy.tab.platforms.bukkit.nms;
+
+import me.neznamy.tab.api.protocol.TabPacket;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+
+public class PacketPlayOutEntityMetadata implements TabPacket {
+
+	private final int entityId;
+
+	private final DataWatcher dataWatcher;
+
+	public PacketPlayOutEntityMetadata(int entityId, DataWatcher dataWatcher) {
+		this.entityId = entityId;
+		this.dataWatcher = dataWatcher;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("PacketPlayOutEntityMetadata{entityId=%s,dataWatcher=%s}", entityId, dataWatcher);
+	}
+
+	public int getEntityId() {
+		return entityId;
+	}
+
+	public DataWatcher getDataWatcher() {
+		return dataWatcher;
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/PacketPlayOutEntityTeleport.java

@@ -0,0 +1,30 @@
+package me.neznamy.tab.platforms.bukkit.nms;
+
+import org.bukkit.Location;
+
+import me.neznamy.tab.api.protocol.TabPacket;
+
+public class PacketPlayOutEntityTeleport implements TabPacket {
+
+	private final int entityId;
+
+	private final Location location;
+
+	public PacketPlayOutEntityTeleport(int entityId, Location location) {
+		this.entityId = entityId;
+		this.location = location;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("PacketPlayOutEntityTeleport{entityId=%s,location=%s}", entityId, location);
+	}
+
+	public int getEntityId() {
+		return entityId;
+	}
+
+	public Location getLocation() {
+		return location;
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/PacketPlayOutSpawnEntityLiving.java

@@ -0,0 +1,56 @@
+package me.neznamy.tab.platforms.bukkit.nms;
+
+import java.util.UUID;
+
+import org.bukkit.Location;
+import org.bukkit.entity.EntityType;
+
+import me.neznamy.tab.api.protocol.TabPacket;
+import me.neznamy.tab.platforms.bukkit.nms.datawatcher.DataWatcher;
+
+public class PacketPlayOutSpawnEntityLiving implements TabPacket {
+
+	private final int entityId;
+
+	private final UUID uuid;
+
+	private final EntityType entityType;
+
+	private final Location location;
+
+	private final DataWatcher dataWatcher;
+
+	public PacketPlayOutSpawnEntityLiving(int entityId, UUID uuid, EntityType entityType, Location location, DataWatcher dataWatcher) {
+		this.entityId = entityId;
+		this.uuid = uuid;
+		this.entityType = entityType;
+		this.location = location;
+		this.dataWatcher = dataWatcher;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("PacketPlayOutSpawnEntityLiving{entityId=%s,uuid=%s,entityType=%s,location=%s,dataWatcher=%s}", 
+				entityId, uuid, entityType, location, dataWatcher);
+	}
+
+	public int getEntityId() {
+		return entityId;
+	}
+
+	public UUID getUniqueId() {
+		return uuid;
+	}
+
+	public EntityType getEntityType() {
+		return entityType;
+	}
+
+	public Location getLocation() {
+		return location;
+	}
+
+	public DataWatcher getDataWatcher() {
+		return dataWatcher;
+	}
+}

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/datawatcher/DataWatcher.java

@@ -1,6 +1,5 @@
 package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
 
-import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -13,10 +12,10 @@ import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
 public class DataWatcher {
 
 	//datawatcher data
-	private Map<Integer, DataWatcherItem> dataValues = new HashMap<>();
+	private final Map<Integer, DataWatcherItem> dataValues = new HashMap<>();
 	
 	//a helper for easier data write
-	private DataWatcherHelper helper = new DataWatcherHelper(this);
+	private final DataWatcherHelper helper = new DataWatcherHelper(this);
 
 	/**
 	 * Sets value into data values
@@ -55,26 +54,25 @@ public class DataWatcher {
 	/**
 	 * Converts the class into an instance of NMS.DataWatcher
 	 * @return an instance of NMS.DataWatcher with same data
-	 * @throws InvocationTargetException 
-	 * @throws IllegalAccessException 
-	 * @throws InstantiationException 
+	 * @throws ReflectiveOperationException
 	 */
-	public Object toNMS() throws InstantiationException, IllegalAccessException, InvocationTargetException {
+	public Object toNMS() throws ReflectiveOperationException {
 		NMSStorage nms = NMSStorage.getInstance();
 		Object nmsWatcher;
-		if (nms.getMinorVersion() >= 7) {
-			nmsWatcher = nms.getConstructor("DataWatcher").newInstance(new Object[] {null});
+		if (nms.newDataWatcher.getParameterCount() == 1) { //1.7+
+			Object[] args = new Object[] {null};
+			nmsWatcher = nms.newDataWatcher.newInstance(args);
 		} else {
-			nmsWatcher = nms.getConstructor("DataWatcher").newInstance();
+			nmsWatcher = nms.newDataWatcher.newInstance();
 		}
 		for (DataWatcherItem item : dataValues.values()) {
 			Object position;
 			if (nms.getMinorVersion() >= 9) {
-				position = nms.getConstructor("DataWatcherObject").newInstance(item.getType().getPosition(), item.getType().getClassType());
+				position = nms.newDataWatcherObject.newInstance(item.getType().getPosition(), item.getType().getClassType());
 			} else {
 				position = item.getType().getPosition();
 			}
-			nms.getMethod("DataWatcher_REGISTER").invoke(nmsWatcher, position, item.getValue());
+			nms.DataWatcher_REGISTER.invoke(nmsWatcher, position, item.getValue());
 		}
 		return nmsWatcher;
 	}
@@ -83,13 +81,10 @@ public class DataWatcher {
 	 * 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 SecurityException 
-	 * @throws NoSuchMethodException 
-	 * @throws InvocationTargetException 
-	 * @throws IllegalAccessException 
+	 * @throws ReflectiveOperationException
 	 */
 	@SuppressWarnings("unchecked")
-	public static DataWatcher fromNMS(Object nmsWatcher) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException, SecurityException{
+	public static DataWatcher fromNMS(Object nmsWatcher) throws ReflectiveOperationException {
 		DataWatcher watcher = new DataWatcher();
 		List<Object> items = (List<Object>) nmsWatcher.getClass().getMethod("c").invoke(nmsWatcher);
 		if (items != null) {

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/datawatcher/DataWatcherHelper.java

@@ -2,11 +2,11 @@ package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
 
 import java.util.Optional;
 
+import me.neznamy.tab.api.ProtocolVersion;
+import me.neznamy.tab.api.chat.IChatBaseComponent;
 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
@@ -17,10 +17,10 @@ public class DataWatcherHelper {
 	private final int armorStandFlagsPosition = getArmorStandFlagsPosition();
 
 	//original datawatcher to write to
-	private DataWatcher data;
+	private final DataWatcher data;
 	
 	//data watcher registry
-	private DataWatcherRegistry registry;
+	private final DataWatcherRegistry registry;
 	
 	/**
 	 * Constructs new instance of this class with given parent
@@ -36,16 +36,16 @@ public class DataWatcherHelper {
 	 * @return armor stand flags position based on server version
 	 */
 	private int getArmorStandFlagsPosition() {
-		if (NMSStorage.getInstance().getMinorVersion() >= 17) {
-			//1.17.x
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 17) {
+			//1.17.x, 1.18.x
 			return 15;
-		} else if (NMSStorage.getInstance().getMinorVersion() >= 15) {
+		} else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 15) {
 			//1.15.x, 1.16.x
 			return 14;
-		} else if (NMSStorage.getInstance().getMinorVersion() >= 14) {
+		} else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 14) {
 			//1.14.x
 			return 13;
-		} else if (NMSStorage.getInstance().getMinorVersion() >= 10) {
+		} else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 10) {
 			//1.10.x - 1.13.x
 			return 11;
 		} else {
@@ -68,18 +68,18 @@ public class DataWatcherHelper {
 	 * @param clientVersion - client version
 	 */
 	public void setCustomName(String customName, ProtocolVersion clientVersion) {
-		if (NMSStorage.getInstance().getMinorVersion() >= 13) {
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 13) {
 			try {
-				data.setValue(new DataWatcherObject(2, registry.getOptionalComponent()), Optional.ofNullable(((BukkitPacketBuilder)TAB.getInstance().getPacketBuilder()).toNMSComponent(IChatBaseComponent.optimizedComponent(customName), clientVersion)));
-			} catch (Exception e) {
+				data.setValue(new DataWatcherObject(2, registry.getOptionalComponent()), Optional.ofNullable(((BukkitPacketBuilder)TAB.getInstance().getPlatform().getPacketBuilder()).toNMSComponent(IChatBaseComponent.optimizedComponent(customName), clientVersion)));
+			} catch (ReflectiveOperationException e) {
 				TAB.getInstance().getErrorManager().printError("Failed to create component", e);
 			}
-		} else if (NMSStorage.getInstance().getMinorVersion() >= 8){
+		} else if (TAB.getInstance().getServerVersion().getMinorVersion() >= 8){
 			data.setValue(new DataWatcherObject(2, registry.getString()), customName);
 		} else {
 			//name length is limited to 64 characters on <1.8
 			String cutName = (customName.length() > 64 ? customName.substring(0, 64) : customName);
-			if (NMSStorage.getInstance().getMinorVersion() >= 6){
+			if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6){
 				data.setValue(new DataWatcherObject(10, registry.getString()), cutName);
 			} else {
 				data.setValue(new DataWatcherObject(5, registry.getString()), cutName);
@@ -93,7 +93,7 @@ public class DataWatcherHelper {
 	 * @param visible - if visible or not
 	 */
 	public void setCustomNameVisible(boolean visible) {
-		if (NMSStorage.getInstance().getMinorVersion() >= 9) {
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 9) {
 			data.setValue(new DataWatcherObject(3, registry.getBoolean()), visible);
 		} else {
 			data.setValue(new DataWatcherObject(3, registry.getByte()), (byte)(visible?1:0));
@@ -105,7 +105,7 @@ public class DataWatcherHelper {
 	 * @param health - health of entity
 	 */
 	public void setHealth(float health) {
-		if (NMSStorage.getInstance().getMinorVersion() >= 6) {
+		if (TAB.getInstance().getServerVersion().getMinorVersion() >= 6) {
 			data.setValue(new DataWatcherObject(6, registry.getFloat()), health);
 		} else {
 			data.setValue(new DataWatcherObject(16, registry.getInteger()), (int)health);

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/datawatcher/DataWatcherItem.java

@@ -1,14 +1,15 @@
 package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
 
 import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
+import me.neznamy.tab.shared.TAB;
 
 public class DataWatcherItem {
 	
 	//type of value (position + data type (1.9+))
-	private DataWatcherObject type;
+	private final DataWatcherObject type;
 	
 	//actual data value
-	private Object value;
+	private final Object value;
 	
 	/**
 	 * Constructs new instance of the object with given parameters
@@ -24,15 +25,15 @@ public class DataWatcherItem {
 	 * Returns and instance of this class from given NMS item
 	 * @param nmsItem - NMS item
 	 * @return instance of this class with same data
-	 * @throws IllegalAccessException 
+	 * @throws ReflectiveOperationException 
 	 */
-	public static DataWatcherItem fromNMS(Object nmsItem) throws IllegalAccessException {
+	public static DataWatcherItem fromNMS(Object nmsItem) throws ReflectiveOperationException {
 		NMSStorage nms = NMSStorage.getInstance();
-		if (NMSStorage.getInstance().getMinorVersion() >= 9) {
-			Object nmsObject = nms.getField("DataWatcherItem_TYPE").get(nmsItem);
-			return new DataWatcherItem(new DataWatcherObject(nms.getField("DataWatcherObject_SLOT").getInt(nmsObject), nms.getField("DataWatcherObject_SERIALIZER").get(nmsObject)), nms.getField("DataWatcherItem_VALUE").get(nmsItem));
+		if (TAB.getInstance().getServerVersion().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.getField("DataWatcherItem_TYPE").getInt(nmsItem), null), nms.getField("DataWatcherItem_VALUE").get(nmsItem));
+			return new DataWatcherItem(new DataWatcherObject(nms.DataWatcherItem_TYPE.getInt(nmsItem), null), nms.DataWatcherItem_VALUE.get(nmsItem));
 		}
 	}
 

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/datawatcher/DataWatcherObject.java

@@ -6,10 +6,10 @@ package me.neznamy.tab.platforms.bukkit.nms.datawatcher;
 public class DataWatcherObject {
 
 	//position in datawatcher
-	private int position;
+	private final int position;
 	
 	//value class type used since 1.9
-	private Object classType;
+	private final Object classType;
 
 	/**
 	 * Constructs a new instance of this class with given parameters

bukkit/src/main/java/me/neznamy/tab/platforms/bukkit/nms/datawatcher/DataWatcherRegistry.java

@@ -12,29 +12,72 @@ import me.neznamy.tab.platforms.bukkit.nms.NMSStorage;
  */
 public class DataWatcherRegistry {
 
-	//used registry types
 	private Object registryByte;
+	private Object registryShort;
 	private Object registryInteger;
 	private Object registryFloat;
 	private Object registryString;
-	private Object registryOptionalComponent;
+	private Object registryIChatBaseComponent;
+	private Object registryOptionalIChatBaseComponent;
+	private Object registryOptionalItemStack;
+	private Object registryItemStack;
+	private Object registryOptionalIBlockData;
 	private Object registryBoolean;
+	private Object registryParticleParam;
+	private Object registryVector3f;
+	private Object registryBlockPosition;
+	private Object registryOptionalBlockPosition;
+	private Object registryEnumDirection;
+	private Object registryOptionalUUID;
+	private Object registryNBTTagCompound;
+	private Object registryVillagerData;
+	private Object registryOptionalInt;
+	private Object registryEntityPose;
 
 	/**
 	 * Initializes required NMS classes and fields
 	 */
-	public DataWatcherRegistry(NMSStorage nms, Class<?> registry) {
+	public DataWatcherRegistry(NMSStorage nms) {
 		if (nms.getMinorVersion() >= 9) {
-			Map<String, Object> fields = getStaticFields(registry);
+			Map<String, Object> fields = getStaticFields(nms.DataWatcherRegistry, nms);
 			registryByte = fields.get("a");
 			registryInteger = fields.get("b");
 			registryFloat = fields.get("c");
 			registryString = fields.get("d");
+			registryIChatBaseComponent = fields.get("e");
 			if (nms.getMinorVersion() >= 13) {
-				registryOptionalComponent = fields.get("f");
+				registryOptionalIChatBaseComponent = fields.get("f");
+				registryItemStack = fields.get("g");
+				registryOptionalIBlockData = fields.get("h");
 				registryBoolean = fields.get("i");
+				registryParticleParam = fields.get("j");
+				registryVector3f = fields.get("k");
+				registryBlockPosition = fields.get("l");
+				registryOptionalBlockPosition = fields.get("m");
+				registryEnumDirection = fields.get("n");
+				registryOptionalUUID = fields.get("o");
+				registryNBTTagCompound = fields.get("p");
+				if (nms.getMinorVersion() >= 15) {
+					registryVillagerData = fields.get("q");
+					registryOptionalInt = fields.get("r");
+					registryEntityPose = fields.get("s");
+				}
 			} else {
+				registryOptionalIBlockData = fields.get("g");
 				registryBoolean = fields.get("h");
+				registryVector3f = fields.get("i");
+				registryBlockPosition = fields.get("j");
+				registryOptionalBlockPosition = fields.get("k");
+				registryEnumDirection = fields.get("l");
+				registryOptionalUUID = fields.get("m");
+				if (nms.getMinorVersion() >= 12) {
+					registryNBTTagCompound = fields.get("n");
+				}
+				if (nms.getMinorVersion() >= 11) {
+					registryItemStack = fields.get("f");
+				} else {
+					registryOptionalItemStack = fields.get("f");
+				}
 			}
 		}
 	}
@@ -44,14 +87,14 @@ public class DataWatcherRegistry {
 	 * @param clazz class to return field values from
 	 * @return map of values
 	 */
-	private Map<String, Object> getStaticFields(Class<?> clazz){
+	private Map<String, Object> getStaticFields(Class<?> clazz, NMSStorage nms){
 		Map<String, Object> fields = new HashMap<>();
-		if (clazz == null) return fields;
 		for (Field field : clazz.getDeclaredFields()) {
 			if (Modifier.isStatic(field.getModifiers())) {
+				nms.setAccessible(field);
 				try {
 					fields.put(field.getName(), field.get(null));
-				} catch (Exception e) {
+				} catch (IllegalAccessException e) {
 					//this will never happen
 				}
 			}
@@ -59,27 +102,87 @@ public class DataWatcherRegistry {
 		return fields;
 	}
 
-	public Object getBoolean() {
-		return registryBoolean;
-	}
-
 	public Object getByte() {
 		return registryByte;
 	}
-
-	public Object getFloat() {
-		return registryFloat;
+	
+	public Object getShort() {
+		return registryShort;
 	}
-
+	
 	public Object getInteger() {
 		return registryInteger;
 	}
-
+	
+	public Object getFloat() {
+		return registryFloat;
+	}
+	
 	public Object getString() {
 		return registryString;
 	}
-
+	
+	public Object getComponent() {
+		return registryIChatBaseComponent;
+	}
+	
 	public Object getOptionalComponent() {
-		return registryOptionalComponent;
+		return registryOptionalIChatBaseComponent;
+	}
+	
+	public Object getOptionalItemStack() {
+		return registryOptionalItemStack;
+	}
+	
+	public Object getItemStack() {
+		return registryItemStack;
+	}
+	
+	public Object getOptionalIBlockData() {
+		return registryOptionalIBlockData;
+	}
+	
+	public Object getBoolean() {
+		return registryBoolean;
+	}
+	
+	public Object getParticleParam() {
+		return registryParticleParam;
+	}
+	
+	public Object getVector3f() {
+		return registryVector3f;
+	}
+	
+	public Object getBlockPosition() {
+		return registryBlockPosition;
+	}
+	
+	public Object getOptionalBlockPosition() {
+		return registryOptionalBlockPosition;
+	}
+	
+	public Object getEnumDirection() {
+		return registryEnumDirection;
+	}
+	
+	public Object getOptionalUUID() {
+		return registryOptionalUUID;
+	}
+	
+	public Object getNBTTagCompound() {
+		return registryNBTTagCompound;
+	}
+	
+	public Object getVillagerData() {
+		return registryVillagerData;
+	}
+	
+	public Object getOptionalInt() {
+		return registryOptionalInt;
+	}
+	
+	public Object getEntityPose() {
+		return registryEntityPose;
 	}
 }