fat meme

Pyuto Hub System/.classpath

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Eclipse Libraries/lombok.jar"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Pytuo Duo/Servers/Hub Server/PaperSpigot.jar"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Pytuo Duo/Servers/Hub Server/plugins/Ranks.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Pyuto Hub System/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Pyuto Hub System</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Pyuto Hub System/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+encoding//src/rip/pyuto/hub/selector/SelectorManager.java=UTF-8
+encoding//src/rip/pyuto/hub/tablist/TablistProvider.java=UTF-8

Pyuto Hub System/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

Pyuto Hub System/plugin.yml

@@ -0,0 +1,3 @@
+main: rip.pyuto.hub.Hub
+name: Hub
+version: 1.0

Pyuto Hub System/servers.yml

@@ -0,0 +1,4 @@
+servers:
+  Lobby:
+    host: 127.0.0.1
+    port: 25570

Pyuto Hub System/src/rip/pyuto/hub/Hub.java

@@ -0,0 +1,142 @@
+package rip.pyuto.hub;
+
+import java.io.File;
+import java.net.InetSocketAddress;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+
+import lombok.Getter;
+import rip.pyuto.hub.listeners.async.AsyncPlayerChatListener;
+import rip.pyuto.hub.listeners.entity.EntityDamageListener;
+import rip.pyuto.hub.listeners.inventory.InventoryClickListener;
+import rip.pyuto.hub.listeners.inventory.InventoryOpenListener;
+import rip.pyuto.hub.listeners.other.ExplosionPrimeListener;
+import rip.pyuto.hub.listeners.other.VehicleEnterListener;
+import rip.pyuto.hub.listeners.other.WeatherChangeListener;
+import rip.pyuto.hub.listeners.player.PlayerInteractListener;
+import rip.pyuto.hub.listeners.player.PlayerJoinListener;
+import rip.pyuto.hub.listeners.player.PlayerMoveListener;
+import rip.pyuto.hub.listeners.player.PlayerQuitListener;
+import rip.pyuto.hub.listeners.player.block.BlockBreakListener;
+import rip.pyuto.hub.listeners.player.block.BlockPlaceListener;
+import rip.pyuto.hub.listeners.player.useless.PlayerDropItemListener;
+import rip.pyuto.hub.listeners.player.useless.PlayerPickupItemListener;
+import rip.pyuto.hub.scoreboard.ScoreboardProvider;
+import rip.pyuto.hub.scoreboard.supplier.ScoreboardManager;
+import rip.pyuto.hub.selector.SelectorManager;
+import rip.pyuto.hub.tablist.TablistProvider;
+import rip.pyuto.hub.tablist.supplier.TablistManager;
+import rip.pyuto.hub.utils.ServerInfo;
+
+@Getter
+public class Hub extends JavaPlugin {
+
+	@Getter
+	private static Hub instance;
+
+	@Getter
+	private SelectorManager selectorManager;
+
+	private Map<String, ServerInfo> servers;	
+
+	public Hub() {
+		servers = new ConcurrentHashMap<>();
+	}
+
+	@Override
+	public void onLoad() {
+		Hub.instance = this;
+		selectorManager = new SelectorManager(this);
+	}
+
+	@Override
+	public void onEnable() {
+		Bukkit.getScheduler().runTaskTimer(this, selectorManager::updateInventory, 0, 20);
+		new ScoreboardManager(this, new ScoreboardProvider(this), ChatColor.DARK_GREEN.toString() + ChatColor.BOLD
+				+ "Pyuto" + ChatColor.GRAY + " - " + ChatColor.WHITE + "Hub");
+		new TablistManager(this, new TablistProvider(this), 1000);
+		Bukkit.getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
+		configuration: {
+			File file = new File(getDataFolder(), "servers.yml");
+			if (!file.exists()) {
+				saveResource("servers.yml", false);
+			}
+			ConfigurationSection configuration = YamlConfiguration.loadConfiguration(file)
+					.getConfigurationSection("servers");
+			for (String key : configuration.getKeys(false)) {
+				if (configuration.contains(key + ".host") && configuration.contains(key + ".port")) {
+					servers.put(key, new ServerInfo(new InetSocketAddress(configuration.getString(key + ".host"),
+							configuration.getInt(key + ".port"))));
+				}
+			}
+			break configuration;
+		}
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				servers.values().forEach(server -> server.ping(true));
+			}
+		}.runTaskTimerAsynchronously(this, 20L, 20L);
+		registerListeners();
+	}
+
+	private void registerListeners() {
+		new AsyncPlayerChatListener(this);
+		new EntityDamageListener(this);
+		new InventoryClickListener(this);
+		new InventoryOpenListener(this);
+		new ExplosionPrimeListener(this);
+		new VehicleEnterListener(this);
+		new WeatherChangeListener(this);
+		new BlockBreakListener(this);
+		new BlockPlaceListener(this);
+		new PlayerDropItemListener(this);
+		new PlayerPickupItemListener(this);
+		new PlayerInteractListener(this);
+		new PlayerJoinListener(this);
+		new PlayerMoveListener(this);
+		new PlayerQuitListener(this);
+	}
+
+	@Override
+	public void onDisable() {
+	}
+
+	public int getOnlineCount(String server) {
+		if (server == null || server.equalsIgnoreCase("ALL")) {
+			int online = 0;
+			for (int next : servers.values().stream().map(ServerInfo::getCurrentOnline).map(AtomicInteger::get)
+					.collect(Collectors.toSet())) {
+				if (next > 0)
+					online += next;
+			}
+			return online;
+		}
+		return getServer(server).getCurrentOnline().get();
+	}
+
+	public ServerInfo getServer(String name) {
+		return servers.get(name);
+	}
+
+	public void sendToServer(Player player, String server) {
+		ByteArrayDataOutput output = ByteStreams.newDataOutput();
+		output.writeUTF("ConnectOther");
+		output.writeUTF(player.getName());
+		output.writeUTF(server);
+		player.sendPluginMessage(this, "BungeeCord", output.toByteArray());
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/async/AsyncPlayerChatListener.java

@@ -0,0 +1,36 @@
+package rip.pyuto.hub.listeners.async;
+
+import org.bukkit.ChatColor;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+
+import rip.pyuto.hub.Hub;
+import rip.pyuto.ranks.Ranks;
+import rip.pyuto.ranks.rank.Rank;
+import rip.pyuto.ranks.user.RankUser;
+
+public class AsyncPlayerChatListener implements Listener {
+
+	private final Hub plugin;
+
+	public AsyncPlayerChatListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onChat(AsyncPlayerChatEvent event) {
+		RankUser user = Ranks.getInstance().getPlayerManager().getUserMap().get(event.getPlayer());
+		Rank rank = user.getRank();
+		StringBuilder builder = new StringBuilder();
+		if (rank != Rank.INMATE) {
+			builder.append(rank.getColor());
+			builder.append(ChatColor.GRAY).append("[").append(rank.getPrefix()).append(ChatColor.GRAY).append("] ");
+		}
+		builder.append(rank.getColor());
+		builder.append("%1$s").append(ChatColor.WHITE).append(" §7»§f %2$s");
+		event.setFormat(builder.toString());
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/entity/EntityDamageListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.entity;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class EntityDamageListener implements Listener {
+
+	private final Hub plugin;
+	
+	public EntityDamageListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onDamage(EntityDamageEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/inventory/InventoryClickListener.java

@@ -0,0 +1,37 @@
+package rip.pyuto.hub.listeners.inventory;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class InventoryClickListener implements Listener {
+
+	private final Hub plugin;
+
+	public InventoryClickListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onClick(InventoryClickEvent event) {
+		Player player = (Player) event.getWhoClicked();
+		event.setCancelled(true);
+		if (event.getCurrentItem() == null || (event.getCurrentItem().getType() == Material.AIR))
+			return;
+		if (event.getCurrentItem().getType() == Material.FIRE) {
+			plugin.sendToServer(player, "PRISON");
+			player.sendMessage(
+					ChatColor.GREEN + "Attempting to Send you to the " + ChatColor.DARK_GREEN.toString()
+							+ ChatColor.BOLD + "Flame Realm" + ChatColor.GREEN + " that has " + ChatColor.WHITE
+							+ plugin.getOnlineCount("PRISON") + " player(s)" + ChatColor.GREEN + " connected.");
+			player.closeInventory();
+		}
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/inventory/InventoryOpenListener.java

@@ -0,0 +1,24 @@
+package rip.pyuto.hub.listeners.inventory;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class InventoryOpenListener implements Listener {
+
+	private final Hub plugin;
+
+	public InventoryOpenListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onOpen(InventoryOpenEvent event) {
+		if (event.getInventory().getHolder() == null) return;
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/other/ExplosionPrimeListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.other;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class ExplosionPrimeListener implements Listener {
+
+	private final Hub plugin;
+
+	public ExplosionPrimeListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onPrime(ExplosionPrimeEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/other/VehicleEnterListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.other;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.vehicle.VehicleEnterEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class VehicleEnterListener implements Listener {
+
+	private final Hub plugin;
+	
+	public VehicleEnterListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onEnter(VehicleEnterEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/other/WeatherChangeListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.other;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.weather.WeatherChangeEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class WeatherChangeListener implements Listener {
+
+	private final Hub plugin;
+
+	public WeatherChangeListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onChange(WeatherChangeEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/PlayerInteractListener.java

@@ -0,0 +1,37 @@
+package rip.pyuto.hub.listeners.player;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class PlayerInteractListener implements Listener {
+
+	private final Hub plugin;
+
+	public PlayerInteractListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onInteract(PlayerInteractEvent event) {
+		Player player = event.getPlayer();
+		if (event.getAction() == Action.PHYSICAL && event.getClickedBlock().getType() == Material.SOIL) {
+			event.setCancelled(true);
+		}
+		if (player.getItemInHand() != null
+				&& (event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK)) {
+			if (player.getItemInHand().getType() == Material.SLIME_BALL) {
+				player.openInventory(plugin.getSelectorManager().selector);
+				player.playSound(player.getLocation(), Sound.ITEM_PICKUP, 1, 1);
+			}
+		}
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/PlayerJoinListener.java

@@ -0,0 +1,36 @@
+package rip.pyuto.hub.listeners.player;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import rip.pyuto.hub.Hub;
+import rip.pyuto.hub.utils.ItemStackBuilder;
+
+public class PlayerJoinListener implements Listener {
+
+	private final Hub plugin;
+
+	public PlayerJoinListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onJoin(PlayerJoinEvent event) {
+		Player player = event.getPlayer();
+		player.getInventory().setItem(4,
+				new ItemStackBuilder(Material.SLIME_BALL).setName(ChatColor.LIGHT_PURPLE + "Server Selector").build());
+		player.teleport(new Location(Bukkit.getWorld(player.getWorld().getName()), 0.5, 32.5, 0.5, 0, 0));
+		player.playSound(player.getLocation(), Sound.FIREWORK_BLAST, 1, 1);
+		player.setGameMode(GameMode.ADVENTURE);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/PlayerMoveListener.java

@@ -0,0 +1,29 @@
+package rip.pyuto.hub.listeners.player;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class PlayerMoveListener implements Listener {
+
+	private final Hub plugin;
+
+	public PlayerMoveListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onMove(PlayerMoveEvent event) {
+		Player player = event.getPlayer();
+		if (player.getLocation().getY() <= 15 || player.getLocation().getY() >= 125) {
+			player.teleport(new Location(Bukkit.getWorld(player.getWorld().getName()), 0.5, 32.5, 0.5, 0, 0));
+		}
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/PlayerQuitListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.player;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class PlayerQuitListener implements Listener {
+
+	private final Hub plugin;
+	
+	public PlayerQuitListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onQuit(PlayerQuitEvent event) {
+		event.getPlayer().getInventory().clear();
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/block/BlockBreakListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.player.block;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class BlockBreakListener implements Listener {
+
+	private final Hub plugin;
+	
+	public BlockBreakListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onBreak(BlockBreakEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/block/BlockPlaceListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.player.block;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class BlockPlaceListener implements Listener {
+	
+	private final Hub plugin;
+	
+	public BlockPlaceListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onPlace(BlockPlaceEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/useless/PlayerDropItemListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.player.useless;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerDropItemEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class PlayerDropItemListener implements Listener {
+
+	private final Hub plugin;
+	
+	public PlayerDropItemListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onDrop(PlayerDropItemEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/listeners/player/useless/PlayerPickupItemListener.java

@@ -0,0 +1,23 @@
+package rip.pyuto.hub.listeners.player.useless;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+
+import rip.pyuto.hub.Hub;
+
+public class PlayerPickupItemListener implements Listener {
+
+	private final Hub plugin;
+
+	public PlayerPickupItemListener(Hub plugin) {
+		this.plugin = plugin;
+		this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onPickup(PlayerPickupItemEvent event) {
+		event.setCancelled(true);
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/reflection/Reflection.java

@@ -0,0 +1,217 @@
+package rip.pyuto.hub.reflection;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.bukkit.Bukkit;
+
+public final class Reflection {
+
+	public interface ConstructorInvoker {
+
+		public Object invoke(Object... arguments);
+	}
+
+	public interface MethodInvoker {
+
+		public Object invoke(Object target, Object... arguments);
+	}
+
+	public interface FieldAccessor<T> {
+
+		public T get(Object target);
+
+		public void set(Object target, Object value);
+
+		public boolean hasField(Object target);
+	}
+
+	private static String OBC_PREFIX = Bukkit.getServer().getClass().getPackage().getName();
+	private static String NMS_PREFIX = OBC_PREFIX.replace("org.bukkit.craftbukkit", "net.minecraft.server");
+	private static String VERSION = OBC_PREFIX.replace("org.bukkit.craftbukkit", "").replace(".", "");
+
+	private static Pattern MATCH_VARIABLE = Pattern.compile("\\{([^\\}]+)\\}");
+
+	private Reflection() {
+	}
+
+	public static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType) {
+		return getField(target, name, fieldType, 0);
+	}
+
+	public static <T> FieldAccessor<T> getField(String className, String name, Class<T> fieldType) {
+		return getField(getClass(className), name, fieldType, 0);
+	}
+
+	public static <T> FieldAccessor<T> getField(Class<?> target, Class<T> fieldType, int index) {
+		return getField(target, null, fieldType, index);
+	}
+
+	public static <T> FieldAccessor<T> getField(String className, Class<T> fieldType, int index) {
+		return getField(getClass(className), fieldType, index);
+	}
+
+	private static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType, int index) {
+		for (final Field field : target.getDeclaredFields()) {
+			if ((name == null || field.getName().equals(name)) && fieldType.isAssignableFrom(field.getType())
+					&& index-- <= 0) {
+				field.setAccessible(true);
+
+				return new FieldAccessor<T>() {
+
+					@Override
+					@SuppressWarnings("unchecked")
+					public T get(Object target) {
+						try {
+							return (T) field.get(target);
+						} catch (IllegalAccessException e) {
+							throw new RuntimeException("Cannot access reflection.", e);
+						}
+					}
+
+					@Override
+					public void set(Object target, Object value) {
+						try {
+							field.set(target, value);
+						} catch (IllegalAccessException e) {
+							throw new RuntimeException("Cannot access reflection.", e);
+						}
+					}
+
+					@Override
+					public boolean hasField(Object target) {
+
+						return field.getDeclaringClass().isAssignableFrom(target.getClass());
+					}
+				};
+			}
+		}
+
+		if (target.getSuperclass() != null)
+			return getField(target.getSuperclass(), name, fieldType, index);
+
+		throw new IllegalArgumentException("Cannot find field with type " + fieldType);
+	}
+
+	public static MethodInvoker getMethod(String className, String methodName, Class<?>... params) {
+		return getTypedMethod(getClass(className), methodName, null, params);
+	}
+
+	public static MethodInvoker getMethod(Class<?> clazz, String methodName, Class<?>... params) {
+		return getTypedMethod(clazz, methodName, null, params);
+	}
+
+	public static MethodInvoker getTypedMethod(Class<?> clazz, String methodName, Class<?> returnType,
+			Class<?>... params) {
+		for (final Method method : clazz.getDeclaredMethods()) {
+			if ((methodName == null || method.getName().equals(methodName))
+					&& (returnType == null || method.getReturnType().equals(returnType))
+					&& Arrays.equals(method.getParameterTypes(), params)) {
+				method.setAccessible(true);
+
+				return new MethodInvoker() {
+
+					@Override
+					public Object invoke(Object target, Object... arguments) {
+						try {
+							return method.invoke(target, arguments);
+						} catch (Exception e) {
+							throw new RuntimeException("Cannot invoke method " + method, e);
+						}
+					}
+
+				};
+			}
+		}
+
+		if (clazz.getSuperclass() != null)
+			return getMethod(clazz.getSuperclass(), methodName, params);
+
+		throw new IllegalStateException(
+				String.format("Unable to find method %s (%s).", methodName, Arrays.asList(params)));
+	}
+
+	public static ConstructorInvoker getConstructor(String className, Class<?>... params) {
+		return getConstructor(getClass(className), params);
+	}
+
+	public static ConstructorInvoker getConstructor(Class<?> clazz, Class<?>... params) {
+		for (final Constructor<?> constructor : clazz.getDeclaredConstructors()) {
+			if (Arrays.equals(constructor.getParameterTypes(), params)) {
+				constructor.setAccessible(true);
+
+				return new ConstructorInvoker() {
+
+					@Override
+					public Object invoke(Object... arguments) {
+						try {
+							return constructor.newInstance(arguments);
+						} catch (Exception e) {
+							throw new RuntimeException("Cannot invoke constructor " + constructor, e);
+						}
+					}
+
+				};
+			}
+		}
+
+		throw new IllegalStateException(
+				String.format("Unable to find constructor for %s (%s).", clazz, Arrays.asList(params)));
+	}
+
+	public static Class<Object> getUntypedClass(String lookupName) {
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		Class<Object> clazz = (Class) getClass(lookupName);
+		return clazz;
+	}
+
+	public static Class<?> getClass(String lookupName) {
+		return getCanonicalClass(expandVariables(lookupName));
+	}
+
+	public static Class<?> getMinecraftClass(String name) {
+		return getCanonicalClass(NMS_PREFIX + "." + name);
+	}
+
+	public static Class<?> getCraftBukkitClass(String name) {
+		return getCanonicalClass(OBC_PREFIX + "." + name);
+	}
+
+	private static Class<?> getCanonicalClass(String canonicalName) {
+		try {
+			return Class.forName(canonicalName);
+		} catch (ClassNotFoundException e) {
+			throw new IllegalArgumentException("Cannot find " + canonicalName, e);
+		}
+	}
+
+	private static String expandVariables(String name) {
+		StringBuffer output = new StringBuffer();
+		Matcher matcher = MATCH_VARIABLE.matcher(name);
+
+		while (matcher.find()) {
+			String variable = matcher.group(1);
+			String replacement = "";
+
+			if ("nms".equalsIgnoreCase(variable))
+				replacement = NMS_PREFIX;
+			else if ("obc".equalsIgnoreCase(variable))
+				replacement = OBC_PREFIX;
+			else if ("version".equalsIgnoreCase(variable))
+				replacement = VERSION;
+			else
+				throw new IllegalArgumentException("Unknown variable: " + variable);
+
+			if (replacement.length() > 0 && matcher.end() < name.length() && name.charAt(matcher.end()) != '.')
+				replacement += ".";
+			matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
+		}
+
+		matcher.appendTail(output);
+		return output.toString();
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/scoreboard/ScoreboardProvider.java

@@ -0,0 +1,35 @@
+package rip.pyuto.hub.scoreboard;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import rip.pyuto.hub.Hub;
+import rip.pyuto.hub.scoreboard.supplier.ScoreboardEntryProvider;
+import rip.pyuto.ranks.utils.PlayerUtil;
+
+public class ScoreboardProvider implements ScoreboardEntryProvider {
+
+	private final Hub plugin;
+
+	public ScoreboardProvider(Hub plugin) {
+		this.plugin = plugin;
+	}
+
+	@Override
+	public List<String> getScoreboardEntries(Player player) {
+		List<String> lines = new ArrayList<>();
+		lines.add(ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "-----------------------");
+		lines.add(ChatColor.GREEN.toString() + ChatColor.BOLD + "Current Rank");
+		lines.add(PlayerUtil.getRankColor(player) + PlayerUtil.getRank(player).getPrefix());
+		lines.add("");
+		lines.add(ChatColor.GREEN.toString() + ChatColor.BOLD + "Online Players");
+		lines.add(plugin.getOnlineCount(null) + " player(s)");
+		lines.add("");
+		lines.add(ChatColor.BLUE + "store.arythium.cc");
+		lines.add(ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "-----------------------");
+		return lines;
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/scoreboard/supplier/PlayerScoreboard.java

@@ -0,0 +1,117 @@
+package rip.pyuto.hub.scoreboard.supplier;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.commons.lang.RandomStringUtils;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+import net.minecraft.server.v1_7_R4.PacketPlayOutScoreboardDisplayObjective;
+import net.minecraft.server.v1_7_R4.PacketPlayOutScoreboardObjective;
+import net.minecraft.server.v1_7_R4.PacketPlayOutScoreboardScore;
+import net.minecraft.server.v1_7_R4.PacketPlayOutScoreboardTeam;
+import net.minecraft.server.v1_7_R4.PlayerConnection;
+import rip.pyuto.hub.scoreboard.supplier.reflection.ReflectionConstants;
+
+public class PlayerScoreboard {
+
+	public static final String[] TEAM_NAMES;
+
+	private final Player player;
+	private final PlayerConnection connection;
+	private final String objectiveName;
+	private int lastSent = 0;
+	private boolean valid = true;
+
+	@SuppressWarnings("unchecked")
+	public PlayerScoreboard(Player player) {
+		this.player = player;
+		this.connection = ((CraftPlayer) player).getHandle().playerConnection;
+		this.objectiveName = "Sidebar-" + RandomStringUtils.random(8,
+				"aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789$_?*+-/()[]{}%!=&@<>~");
+		PacketPlayOutScoreboardObjective objective = new PacketPlayOutScoreboardObjective();
+		ReflectionConstants.SCOREBOARD_OBJECTIVE_NAME.set(objective, objectiveName);
+		ReflectionConstants.SCOREBOARD_OBJECTIVE_TITLE.set(objective, ScoreboardManager.getInstance().getTitle());
+		ReflectionConstants.SCOREBOARD_OBJECTIVE_ACTION.set(objective, 0);
+		connection.sendPacket(objective);
+		PacketPlayOutScoreboardDisplayObjective displayObjective = new PacketPlayOutScoreboardDisplayObjective();
+		ReflectionConstants.SCOREBOARD_DISPLAY_OBJECTIVE_NAME.set(displayObjective, objectiveName);
+		ReflectionConstants.SCOREBOARD_DISPLAY_OBJECTIVE_POSITION.set(displayObjective, 1);
+		connection.sendPacket(displayObjective);
+		for (int i = 0; i < 15; i++) {
+			PacketPlayOutScoreboardTeam team = new PacketPlayOutScoreboardTeam();
+			ReflectionConstants.SCOREBOARD_TEAM_NAME.set(team, TEAM_NAMES[i]);
+			((Collection<String>) ReflectionConstants.SCOREBOARD_TEAM_PLAYERS.get(team)).add(TEAM_NAMES[i]);
+			connection.sendPacket(team);
+		}
+	}
+
+	public void send() {
+		if (!valid)
+			return;
+		List<String> lines = ScoreboardManager.getInstance().getProvider().getScoreboardEntries(player);
+		if (lastSent != lines.size()) {
+			for (int i = 0; i < (15); i++) {
+				PacketPlayOutScoreboardScore score = new PacketPlayOutScoreboardScore();
+				ReflectionConstants.SCOREBOARD_SCORE_NAME.set(score, TEAM_NAMES[i]);
+				ReflectionConstants.SCOREBOARD_SCORE_OBJECTIVE.set(score, objectiveName);
+				ReflectionConstants.SCOREBOARD_SCORE_ACTION.set(score, 1);
+				connection.sendPacket(score);
+			}
+		}
+		for (int i = 0; i < Math.min(lines.size(), 15); i++) {
+			String line = lines.get(i);
+			String left = "", right = "";
+			if (line.length() < 17) {
+				left = line;
+			} else {
+				left = line.substring(0, 16);
+				right = line.substring(16, line.length());
+				if (left.endsWith("\u00a7")) {
+					left = left.substring(0, left.length() - 1);
+					right = "\u00a7" + right;
+				}
+				final String lastColors = ChatColor.getLastColors(left);
+				right = lastColors + right;
+			}
+			PacketPlayOutScoreboardTeam team = new PacketPlayOutScoreboardTeam();
+			ReflectionConstants.SCOREBOARD_TEAM_NAME.set(team, TEAM_NAMES[i]);
+			ReflectionConstants.SCOREBOARD_TEAM_PREFIX.set(team, left);
+			ReflectionConstants.SCOREBOARD_TEAM_SUFFIX.set(team, StringUtils.left(right, 16));
+			ReflectionConstants.SCOREBOARD_TEAM_ACTION.set(team, 2);
+			connection.sendPacket(team);
+			PacketPlayOutScoreboardScore score = new PacketPlayOutScoreboardScore();
+			ReflectionConstants.SCOREBOARD_SCORE_NAME.set(score, TEAM_NAMES[i]);
+			ReflectionConstants.SCOREBOARD_SCORE_SCORE.set(score, 15 - i);
+			ReflectionConstants.SCOREBOARD_SCORE_OBJECTIVE.set(score, objectiveName);
+			connection.sendPacket(score);
+		}
+		lastSent = lines.size();
+	}
+
+	public void clean() {
+		for (int i = 0; i < 15; i++) {
+			PacketPlayOutScoreboardTeam team = new PacketPlayOutScoreboardTeam();
+			ReflectionConstants.SCOREBOARD_TEAM_NAME.set(team, TEAM_NAMES[i]);
+			ReflectionConstants.SCOREBOARD_TEAM_ACTION.set(team, 4);
+			connection.sendPacket(team);
+		}
+		player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+		valid = false;
+	}
+
+	static {
+		TEAM_NAMES = new String[15];
+		ChatColor[] colors = ChatColor.values();
+		for (int i = 0; i < 15; i++) {
+			ChatColor left = colors[i];
+			ChatColor right = colors[15 - i];
+			TEAM_NAMES[i] = left.toString() + ChatColor.RESET + right.toString() + ChatColor.RESET;
+		}
+	}
+
+}

Pyuto Hub System/src/rip/pyuto/hub/scoreboard/supplier/ScoreboardEntryProvider.java

@@ -0,0 +1,11 @@
+package rip.pyuto.hub.scoreboard.supplier;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+
+public interface ScoreboardEntryProvider {
+	
+	public List<String> getScoreboardEntries(Player player);
+
+}

Pyuto Hub System/src/rip/pyuto/hub/scoreboard/supplier/ScoreboardManager.java

@@ -0,0 +1,101 @@
+package rip.pyuto.hub.scoreboard.supplier;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Stream;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import lombok.Getter;
+
+public class ScoreboardManager implements Listener {
+
+	@Getter
+	private static ScoreboardManager instance;
+
+	@Getter
+	private final ScoreboardEntryProvider provider;
+
+	@Getter
+	private final String title;
+
+	@Getter
+	private final Map<UUID, PlayerScoreboard> scoreboards;
+
+	private final JavaPlugin plugin;
+
+	public boolean debugging;
+
+	@SuppressWarnings("deprecation")
+	public ScoreboardManager(JavaPlugin plugin, ScoreboardEntryProvider provider, String title) {
+		ScoreboardManager.instance = this;
+		this.plugin = plugin;
+		this.provider = provider;
+		this.title = title;
+		this.scoreboards = new ConcurrentHashMap<>();
+		Bukkit.getPluginManager().registerEvents(this, plugin);
+		Stream.of(Bukkit.getOnlinePlayers()).forEach(player -> {
+			if (debugging) {
+				plugin.getLogger().info("[ScoreboardManager] Loaded scoreboard for " + player.getName() + "["
+						+ player.getUniqueId().toString() + "]");
+			}
+			UUID uniqueId = player.getUniqueId();
+			scoreboards.putIfAbsent(uniqueId, new PlayerScoreboard(player));
+		});
+		Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, this::update, 5, 5);
+	}
+
+	@EventHandler
+	public void onJoin(PlayerJoinEvent event) {
+		Player player = event.getPlayer();
+		UUID uniqueId = player.getUniqueId();
+		Bukkit.getScheduler().runTaskLater(plugin, () -> {
+			if (debugging) {
+				plugin.getLogger().info("[ScoreboardManager] Loaded scoreboard for " + player.getName() + "["
+						+ player.getUniqueId().toString() + "]");
+			}
+			scoreboards.putIfAbsent(uniqueId, new PlayerScoreboard(player));
+		}, 3l);
+	}
+
+	@EventHandler
+	public void onQuit(PlayerQuitEvent event) {
+		Player player = event.getPlayer();
+		UUID uniqueId = player.getUniqueId();
+		PlayerScoreboard scoreboard;
+		if ((scoreboard = scoreboards.remove(uniqueId)) != null) {
+			if (debugging) {
+				plugin.getLogger().info("[ScoreboardManager] Deleted scoreboard of " + player.getName() + "["
+						+ player.getUniqueId().toString() + "]");
+			}
+			scoreboard.clean();
+		}
+	}
+
+	@EventHandler
+	public void onDisable(PluginDisableEvent event) {
+		if (event.getPlugin() == plugin) {
+			scoreboards.forEach((id, board) -> {
+				board.clean();
+			});
+			scoreboards.clear();
+			HandlerList.unregisterAll(this);
+		}
+	}
+
+	public void update() {
+		scoreboards.forEach((id, board) -> {
+			board.send();
+		});
+	}
+
+}

Pyuto Hub System/src/rip/pyuto/hub/scoreboard/supplier/reflection/ReflectionConstants.java

@@ -0,0 +1,57 @@
+package rip.pyuto.hub.scoreboard.supplier.reflection;
+
+import java.util.Collection;
+
+import rip.pyuto.hub.reflection.Reflection;
+
+public class ReflectionConstants {
+
+	public static final Class<?> SCOREBOARD_OBJECTIVE_CLASS = Reflection
+			.getMinecraftClass("PacketPlayOutScoreboardObjective");
+	public static final Reflection.ConstructorInvoker SCOREBOARD_OBJECTIVE_CONSTRUCTOR = Reflection
+			.getConstructor(SCOREBOARD_OBJECTIVE_CLASS);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_OBJECTIVE_NAME = Reflection
+			.getField(SCOREBOARD_OBJECTIVE_CLASS, String.class, 0);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_OBJECTIVE_TITLE = Reflection
+			.getField(SCOREBOARD_OBJECTIVE_CLASS, String.class, 1);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_OBJECTIVE_ACTION = Reflection
+			.getField(SCOREBOARD_OBJECTIVE_CLASS, Integer.TYPE, 0);
+	public static final Class<?> SCOREBOARD_DISPLAY_OBJECTIVE_CLASS = Reflection
+			.getMinecraftClass("PacketPlayOutScoreboardDisplayObjective");
+	public static final Reflection.ConstructorInvoker SCOREBOARD_DISPLAY_OBJECTIVE_CONSTRUCTOR = Reflection
+			.getConstructor(SCOREBOARD_DISPLAY_OBJECTIVE_CLASS);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_DISPLAY_OBJECTIVE_NAME = Reflection
+			.getField(SCOREBOARD_DISPLAY_OBJECTIVE_CLASS, String.class, 0);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_DISPLAY_OBJECTIVE_POSITION = Reflection
+			.getField(SCOREBOARD_DISPLAY_OBJECTIVE_CLASS, Integer.TYPE, 0);
+	public static final Class<?> SCOREBOARD_TEAM_CLASS = Reflection.getMinecraftClass("PacketPlayOutScoreboardTeam");
+	public static final Reflection.ConstructorInvoker SCOREBOARD_TEAM_CONSTRUCTOR = Reflection
+			.getConstructor(SCOREBOARD_TEAM_CLASS);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_NAME = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 0);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_DISPLAY_NAME = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 1);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_PREFIX = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 2);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_SUFFIX = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 3);
+	@SuppressWarnings("rawtypes")
+	public static final Reflection.FieldAccessor<Collection> SCOREBOARD_TEAM_PLAYERS = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, Collection.class, 0);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_TEAM_ACTION = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, Integer.TYPE, 0);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_TEAM_OPTIONS = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, Integer.TYPE, 1);
+	public static final Class<?> SCOREBOARD_SCORE_CLASS = Reflection.getMinecraftClass("PacketPlayOutScoreboardScore");
+	public static final Reflection.ConstructorInvoker SCOREBOARD_SCORE_CONSTRUCTOR = Reflection
+			.getConstructor(SCOREBOARD_SCORE_CLASS);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_SCORE_NAME = Reflection
+			.getField(SCOREBOARD_SCORE_CLASS, String.class, 0);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_SCORE_OBJECTIVE = Reflection
+			.getField(SCOREBOARD_SCORE_CLASS, String.class, 1);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_SCORE_SCORE = Reflection
+			.getField(SCOREBOARD_SCORE_CLASS, Integer.TYPE, 0);
+	public static final Reflection.FieldAccessor<?> SCOREBOARD_SCORE_ACTION = Reflection
+			.getField(SCOREBOARD_SCORE_CLASS, Integer.TYPE, 1);
+
+}

Pyuto Hub System/src/rip/pyuto/hub/selector/SelectorManager.java

@@ -0,0 +1,35 @@
+package rip.pyuto.hub.selector;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.Inventory;
+
+import rip.pyuto.hub.Hub;
+import rip.pyuto.hub.utils.ItemStackBuilder;
+
+public class SelectorManager implements Listener {
+
+	private final Hub plugin;
+	public Inventory selector;
+
+	public SelectorManager(Hub plugin) {
+		this.plugin = plugin;
+		this.selector = Bukkit.createInventory(null, 27,
+				ChatColor.GOLD + "Select your journey..");
+	}
+
+	public void updateInventory() {
+		selector.setItem(13, new ItemStackBuilder(Material.FIRE)
+				.setName(ChatColor.DARK_GREEN.toString() + ChatColor.BOLD + "Fury Realm" + ChatColor.GRAY + " → "
+						+ plugin.getServer("PRISON").getStatus())
+				.addLore("",
+						ChatColor.GREEN + "Online Player(s)" + ChatColor.GRAY + " → " + ChatColor.WHITE
+								+ plugin.getServer("PRISON"),
+						"", "      §7Mine to success, but it doesn't",
+						"      §7just stop there; continue to freedom.", "",
+						ChatColor.YELLOW.toString() + ChatColor.ITALIC + "To connect, simply §lclick §e§oon this item.")
+				.build());
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/TablistProvider.java

@@ -0,0 +1,72 @@
+package rip.pyuto.hub.tablist;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+
+import rip.pyuto.hub.Hub;
+import rip.pyuto.hub.tablist.supplier.TablistEntrySupplier;
+import rip.pyuto.ranks.utils.PlayerUtil;
+
+public class TablistProvider implements TablistEntrySupplier {
+
+	private final Hub plugin;
+
+	public TablistProvider(Hub plugin) {
+		this.plugin = plugin;
+	}
+
+	@Override
+	public Table<Integer, Integer, String> getEntries(Player player) {
+		Table<Integer, Integer, String> tab = HashBasedTable.create();
+		tab.put(0, 1, ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "-----------------");
+		tab.put(1, 1, ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "-----------------");
+		tab.put(2, 1, ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------");
+		tab.put(1, 3,
+				ChatColor.DARK_GREEN.toString() + ChatColor.BOLD + "Pyuto" + ChatColor.GRAY + " → " + ChatColor.WHITE
+						+ Bukkit.getWorlds().stream()
+								.filter(world -> world.getEnvironment() == World.Environment.NORMAL).findFirst()
+								.orElse(Bukkit.getWorlds().get(0)).getName());
+		tab.put(0, 6, ChatColor.GREEN.toString() + ChatColor.BOLD + "Current Rank");
+		tab.put(0, 7, PlayerUtil.getRankColor(player) + PlayerUtil.getRank(player).getPrefix());
+		tab.put(2, 6, ChatColor.GREEN.toString() + ChatColor.BOLD + "Online Players");
+		tab.put(2, 7, plugin.getOnlineCount("ALL") + " player(s)");
+
+		tab.put(1, 8, ChatColor.DARK_GREEN.toString() + ChatColor.BOLD + "Flame Realm");
+		tab.put(1, 9, plugin.getOnlineCount("PRISON") + " player(s)");
+		tab.put(1, 10, plugin.getServer("PRISON").getStatus().toString());
+
+		tab.put(3, 7, ChatColor.DARK_RED.toString() + ChatColor.BOLD + "WARNING");
+		tab.put(3, 9, ChatColor.RED + "Please use 1.7.10");
+		tab.put(3, 10, ChatColor.RED + "for a better time");
+		tab.put(3, 11, ChatColor.RED + "and more of an op");
+		tab.put(3, 12, ChatColor.RED + "timal experience.");
+
+		tab.put(0, 10, ChatColor.GREEN.toString() + ChatColor.BOLD + "Hub #1");
+		tab.put(0, 11, plugin.getOnlineCount("Hub1") + " player(s)");
+		tab.put(0, 12, plugin.getServer("Hub1").getStatus().toString());
+
+		tab.put(2, 10, ChatColor.GREEN.toString() + ChatColor.BOLD + "Hub Restricted");
+		tab.put(2, 11, plugin.getOnlineCount("Hub-Restricted") + " player(s)");
+		tab.put(2, 12, plugin.getServer("Hub-Restricted").getStatus().toString());
+
+		tab.put(0, 18, ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "-----------------");
+		tab.put(1, 18, ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "-----------------");
+		tab.put(2, 18, ChatColor.GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------");
+		return tab;
+	}
+
+	@Override
+	public String getHeader(Player player) {
+		return null;
+	}
+
+	@Override
+	public String getFooter(Player player) {
+		return null;
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/ClientVersion.java

@@ -0,0 +1,21 @@
+package rip.pyuto.hub.tablist.supplier;
+
+import org.bukkit.entity.Player;
+
+import rip.pyuto.hub.tablist.supplier.reflection.ReflectionConstants;
+
+public enum ClientVersion {
+
+	v1_7, v1_8;
+
+	public static ClientVersion getVersion(Player player) {
+		Object handle = ReflectionConstants.GET_HANDLE_METHOD.invoke(player);
+		Object connection = ReflectionConstants.PLAYER_CONNECTION.get(handle);
+		Object manager = ReflectionConstants.NETWORK_MANAGER.get(connection);
+		Object version = ReflectionConstants.VERSION_METHOD.invoke(manager);
+		if (version instanceof Integer) {
+			return (int) version > 5 ? v1_8 : v1_7;
+		}
+		return v1_7;
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/Tablist.java

@@ -0,0 +1,207 @@
+package rip.pyuto.hub.tablist.supplier;
+
+import java.util.Arrays;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang.StringEscapeUtils;
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.spigotmc.ProtocolInjector;
+
+import com.google.common.collect.Table;
+
+import lombok.Getter;
+import net.minecraft.server.v1_7_R4.ChatSerializer;
+import net.minecraft.util.com.mojang.authlib.GameProfile;
+import net.minecraft.util.com.mojang.authlib.properties.Property;
+import rip.pyuto.hub.tablist.supplier.reflection.ReflectionConstants;
+
+public class Tablist {
+
+	public static final Object[] GAME_PROFILES;
+	public static final String[] TAB_NAMES;
+
+	public static String[] BLANK_SKIN = {
+			"eyJ0aW1lc3RhbXAiOjE0MTEyNjg3OTI3NjUsInByb2ZpbGVJZCI6IjNmYmVjN2RkMGE1ZjQwYmY5ZDExODg1YTU0NTA3MTEyIiwicHJvZmlsZU5hbWUiOiJsYXN0X3VzZXJuYW1lIiwidGV4dHVyZXMiOnsiU0tJTiI6eyJ1cmwiOiJodHRwOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlLzg0N2I1Mjc5OTg0NjUxNTRhZDZjMjM4YTFlM2MyZGQzZTMyOTY1MzUyZTNhNjRmMzZlMTZhOTQwNWFiOCJ9fX0=",
+			"u8sG8tlbmiekrfAdQjy4nXIcCfNdnUZzXSx9BE1X5K27NiUvE1dDNIeBBSPdZzQG1kHGijuokuHPdNi/KXHZkQM7OJ4aCu5JiUoOY28uz3wZhW4D+KG3dH4ei5ww2KwvjcqVL7LFKfr/ONU5Hvi7MIIty1eKpoGDYpWj3WjnbN4ye5Zo88I2ZEkP1wBw2eDDN4P3YEDYTumQndcbXFPuRRTntoGdZq3N5EBKfDZxlw4L3pgkcSLU5rWkd5UH4ZUOHAP/VaJ04mpFLsFXzzdU4xNZ5fthCwxwVBNLtHRWO26k/qcVBzvEXtKGFJmxfLGCzXScET/OjUBak/JEkkRG2m+kpmBMgFRNtjyZgQ1w08U6HHnLTiAiio3JswPlW5v56pGWRHQT5XWSkfnrXDalxtSmPnB5LmacpIImKgL8V9wLnWvBzI7SHjlyQbbgd+kUOkLlu7+717ySDEJwsFJekfuR6N/rpcYgNZYrxDwe4w57uDPlwNL6cJPfNUHV7WEbIU1pMgxsxaXe8WSvV87qLsR7H06xocl2C0JFfe2jZR4Zh3k9xzEnfCeFKBgGb4lrOWBu1eDWYgtKV67M2Y+B3W5pjuAjwAxn0waODtEn/3jKPbc/sxbPvljUCw65X+ok0UUN1eOwXV5l2EGzn05t3Yhwq19/GxARg63ISGE8CKw=" };
+
+	@Getter
+	private final ClientVersion version;
+
+	@Getter
+	private final Player player;
+
+	@Getter
+	private boolean initiated;
+
+	@SuppressWarnings("unchecked")
+	public Tablist(Player player) {
+		this.player = player;
+		this.version = ClientVersion.getVersion(player);
+		for (int i = 0; i < 80; i++) {
+			Object packet = ReflectionConstants.SCOREBOARD_TEAM_CONSTRUCTOR.invoke();
+			ReflectionConstants.SCOREBOARD_TEAM_NAME.set(packet, TAB_NAMES[i]);
+			ReflectionConstants.SCOREBOARD_TEAM_PLAYERS.get(packet).add(TAB_NAMES[i]);
+			sendPacket(player, packet);
+		}
+		addFakePlayers();
+		update();
+	}
+
+	public void sendPacket(Player player, Object packet) {
+		Object handle = ReflectionConstants.GET_HANDLE_METHOD.invoke(player);
+		Object connection = ReflectionConstants.PLAYER_CONNECTION.get(handle);
+		ReflectionConstants.SEND_PACKET.invoke(connection, packet);
+	}
+
+	@SuppressWarnings("unused")
+	public Tablist update() {
+		TablistManager manager = TablistManager.INSTANCE;
+		if (!initiated || manager == null)
+			return this;
+		Table<Integer, Integer, String> entries = manager.getSupplier().getEntries(player);
+		boolean useProfiles = version.ordinal() != 0;
+		int magic = useProfiles ? 4 : 3;
+		if (useProfiles) {
+			String header = manager.getSupplier().getHeader(player);
+			if (header == null) {
+				header = "";
+			}
+			String footer = manager.getSupplier().getFooter(player);
+			if (footer == null) {
+				footer = "";
+			}
+			ProtocolInjector.PacketTabHeader packet = new ProtocolInjector.PacketTabHeader(
+					ChatSerializer.a("{text:\"" + StringEscapeUtils.escapeJava(header) + "\"}"),
+					ChatSerializer.a("{text:\"" + StringEscapeUtils.escapeJava(footer) + "\"}"));
+			sendPacket(player, packet);
+		}
+		for (int i = 0; i < (magic * 20); i++) {
+			int x = i % magic;
+			int y = i / magic;
+			String text = entries.get(x, y);
+			if (text == null) {
+				text = "";
+			}
+			String name = TAB_NAMES[i];
+			String prefix = "", suffix = "";
+			if (text.length() < 17) {
+				prefix = text;
+			} else {
+				String left = text.substring(0, 16), right = text.substring(16, text.length());
+				if (left.endsWith("§")) {
+					left = left.substring(0, left.length() - 1);
+					right = "§" + right;
+				}
+				String last = ChatColor.getLastColors(left);
+				right = last + right;
+				prefix = left;
+				suffix = StringUtils.left(right, 16);
+			}
+			Object packet = ReflectionConstants.SCOREBOARD_TEAM_CONSTRUCTOR.invoke();
+			ReflectionConstants.SCOREBOARD_TEAM_NAME.set(packet, TAB_NAMES[i]);
+			ReflectionConstants.SCOREBOARD_TEAM_ACTION.set(packet, 2);
+			ReflectionConstants.SCOREBOARD_TEAM_PREFIX.set(packet, prefix);
+			ReflectionConstants.SCOREBOARD_TEAM_SUFFIX.set(packet, suffix);
+			sendPacket(player, packet);
+		}
+		return this;
+	}
+
+	@SuppressWarnings("deprecation")
+	public Tablist hideRealPlayers() {
+		if (!initiated)
+			return this;
+		boolean useProfiles = version.ordinal() != 0;
+		Stream.of(Bukkit.getOnlinePlayers()).forEach(other -> {
+			if (!player.canSee(other))
+				return;
+			Object packet = ReflectionConstants.TAB_PACKET_CONSTRUCTOR.invoke();
+			if (useProfiles) {
+				Object profile = ReflectionConstants.GET_PROFILE_METHOD.invoke(other);
+				ReflectionConstants.TAB_PACKET_PROFILE.set(packet, profile);
+			} else {
+				ReflectionConstants.TAB_PACKET_NAME.set(packet, other.getName());
+			}
+			ReflectionConstants.TAB_PACKET_ACTION.set(packet, 4);
+			sendPacket(player, packet);
+		});
+		return this;
+	}
+
+	public Tablist hideFakePlayers() {
+		if (!initiated)
+			return this;
+		boolean useProfiles = version.ordinal() != 0;
+		Arrays.stream(GAME_PROFILES).forEach(other -> {
+			Object packet = ReflectionConstants.TAB_PACKET_CONSTRUCTOR.invoke();
+			if (useProfiles) {
+				ReflectionConstants.TAB_PACKET_PROFILE.set(packet, other);
+			} else {
+				String name = ReflectionConstants.GAME_PROFILE_NAME.get(other);
+				ReflectionConstants.TAB_PACKET_NAME.set(packet, name);
+			}
+			ReflectionConstants.TAB_PACKET_ACTION.set(packet, 4);
+			sendPacket(player, packet);
+		});
+		return this;
+	}
+
+	@SuppressWarnings("unused")
+	public Tablist addFakePlayers() {
+		if (initiated)
+			return this;
+		boolean useProfiles = version.ordinal() != 0;
+		int magic = useProfiles ? 4 : 3;
+		for (int i = 0; i < (magic * 20); i++) {
+			int x = i % magic;
+			int y = i / magic;
+			Object packet = ReflectionConstants.TAB_PACKET_CONSTRUCTOR.invoke();
+			Object profile = GAME_PROFILES[i];
+			if (useProfiles) {
+				ReflectionConstants.TAB_PACKET_PROFILE.set(packet, profile);
+			} else {
+				String name = ReflectionConstants.GAME_PROFILE_NAME.get(profile);
+				ReflectionConstants.TAB_PACKET_NAME.set(packet, name);
+			}
+			ReflectionConstants.TAB_PACKET_ACTION.set(packet, 0);
+			sendPacket(player, packet);
+		}
+		initiated = true;
+		return this;
+	}
+
+	public void clear() {
+		for (int i = 0; i < 80; i++) {
+			Object packet = ReflectionConstants.SCOREBOARD_TEAM_CONSTRUCTOR.invoke();
+			ReflectionConstants.SCOREBOARD_TEAM_NAME.set(packet, TAB_NAMES[i]);
+			ReflectionConstants.SCOREBOARD_TEAM_ACTION.set(packet, 4);
+			sendPacket(player, packet);
+		}
+	}
+
+	static {
+		GAME_PROFILES = new Object[80];
+		TAB_NAMES = new String[80];
+		for (int i = 0; i < 80; i++) {
+			int x = i % 4;
+			int y = i / 4;
+			String name = (x > 9 ? ("§" + String.valueOf(x).toCharArray()[0] + "§" + String.valueOf(x).toCharArray()[1])
+					: "§0§" + x)
+					+ (y > 9 ? ("§" + String.valueOf(y).toCharArray()[0] + "§" + String.valueOf(y).toCharArray()[1])
+							: "§0§" + String.valueOf(y).toCharArray()[0])
+					+ ChatColor.DARK_AQUA;
+			UUID id = UUID.randomUUID();
+			GameProfile profile = new GameProfile(id, name);
+			profile.getProperties().put("textures", new Property("textures",
+					"eyJ0aW1lc3RhbXAiOjE0MTEyNjg3OTI3NjUsInByb2ZpbGVJZCI6IjNmYmVjN2RkMGE1ZjQwYmY5ZDExODg1YTU0NTA3MTEyIiwicHJvZmlsZU5hbWUiOiJsYXN0X3VzZXJuYW1lIiwidGV4dHVyZXMiOnsiU0tJTiI6eyJ1cmwiOiJodHRwOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlLzg0N2I1Mjc5OTg0NjUxNTRhZDZjMjM4YTFlM2MyZGQzZTMyOTY1MzUyZTNhNjRmMzZlMTZhOTQwNWFiOCJ9fX0=",
+					"u8sG8tlbmiekrfAdQjy4nXIcCfNdnUZzXSx9BE1X5K27NiUvE1dDNIeBBSPdZzQG1kHGijuokuHPdNi/KXHZkQM7OJ4aCu5JiUoOY28uz3wZhW4D+KG3dH4ei5ww2KwvjcqVL7LFKfr/ONU5Hvi7MIIty1eKpoGDYpWj3WjnbN4ye5Zo88I2ZEkP1wBw2eDDN4P3YEDYTumQndcbXFPuRRTntoGdZq3N5EBKfDZxlw4L3pgkcSLU5rWkd5UH4ZUOHAP/VaJ04mpFLsFXzzdU4xNZ5fthCwxwVBNLtHRWO26k/qcVBzvEXtKGFJmxfLGCzXScET/OjUBak/JEkkRG2m+kpmBMgFRNtjyZgQ1w08U6HHnLTiAiio3JswPlW5v56pGWRHQT5XWSkfnrXDalxtSmPnB5LmacpIImKgL8V9wLnWvBzI7SHjlyQbbgd+kUOkLlu7+717ySDEJwsFJekfuR6N/rpcYgNZYrxDwe4w57uDPlwNL6cJPfNUHV7WEbIU1pMgxsxaXe8WSvV87qLsR7H06xocl2C0JFfe2jZR4Zh3k9xzEnfCeFKBgGb4lrOWBu1eDWYgtKV67M2Y+B3W5pjuAjwAxn0waODtEn/3jKPbc/sxbPvljUCw65X+ok0UUN1eOwXV5l2EGzn05t3Yhwq19/GxARg63ISGE8CKw="));
+			TAB_NAMES[i] = name;
+			GAME_PROFILES[i] = profile;
+		}
+	}
+
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/TablistEntrySupplier.java

@@ -0,0 +1,15 @@
+package rip.pyuto.hub.tablist.supplier;
+
+import org.bukkit.entity.Player;
+
+import com.google.common.collect.Table;
+
+public interface TablistEntrySupplier {
+
+	Table<Integer, Integer, String> getEntries(Player player);
+	
+	String getHeader(Player player);
+	
+	String getFooter(Player player);
+	
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/TablistManager.java

@@ -0,0 +1,132 @@
+package rip.pyuto.hub.tablist.supplier;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Stream;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+
+public class TablistManager implements Listener {
+
+	public static TablistManager INSTANCE;
+
+	@Getter
+	private final JavaPlugin plugin;
+
+	private final Map<UUID, Tablist> tablists;
+
+	@Setter
+	@NonNull
+	@Getter
+	private TablistEntrySupplier supplier;
+
+	private int updateTaskId = -1;
+
+	@SuppressWarnings("deprecation")
+	public TablistManager(@NonNull JavaPlugin plugin, @NonNull TablistEntrySupplier supplier, long updateTime) {
+		boolean startUpdater = true;
+		if (TablistManager.INSTANCE != null) {
+			for (int i = 0; i < 7; i++) {
+				Bukkit.getLogger().warning("");
+			}
+			Bukkit.getLogger().warning("WARNING! AN INSTANCE OF TABLISTMANAGER ALREADY EXISTS!");
+			Bukkit.getLogger()
+					.warning("IT IS RECOMMENDED TO ONLY USE ONE OTHERWISE IT CAN CAUSE FLICKERING AND OTHER ISSUES!");
+			for (int i = 0; i < 7; i++) {
+				Bukkit.getLogger().warning("");
+			}
+		}
+		updateTime: {
+			long remainder = updateTime % 50l;
+			if (remainder != 0l) {
+				updateTime = updateTime - remainder;
+				Bukkit.getLogger().info("FIXING UPDATE TIME TO VALID TICK-COUNT...");
+			}
+			break updateTime;
+		}
+		if (updateTime < 50l) {
+			startUpdater = false;
+			for (int i = 0; i < 7; i++) {
+				Bukkit.getLogger().warning("");
+			}
+			Bukkit.getLogger().warning("WARNING! TABLIST UPDATE TASK NOT STARTED!");
+			Bukkit.getLogger().warning("REASON: UPDATE TIME IS TOO SHORT.");
+			for (int i = 0; i < 7; i++) {
+				Bukkit.getLogger().warning("");
+			}
+		}
+		TablistManager.INSTANCE = this;
+		this.tablists = new ConcurrentHashMap<>();
+		this.supplier = supplier;
+		this.plugin = plugin;
+		if (startUpdater) {
+			updateTaskId = Bukkit.getScheduler()
+					.runTaskTimerAsynchronously(plugin, new TablistUpdateTask(), updateTime / 50, updateTime / 50)
+					.getTaskId();
+		}
+		Bukkit.getPluginManager().registerEvents(this, plugin);
+		Stream.of(Bukkit.getOnlinePlayers()).forEach(player -> {
+			getTablist(player, true);
+		});
+	}
+
+	@Deprecated
+	public Tablist getTablist(Player player) {
+		return getTablist(player, false);
+	}
+
+	@Deprecated
+	public Tablist getTablist(Player player, boolean create) {
+		UUID uniqueId = player.getUniqueId();
+		Tablist tablist = tablists.get(uniqueId);
+		if (tablist == null && create) {
+			tablists.put(uniqueId, tablist = new Tablist(player));
+		}
+		return tablist;
+	}
+
+	@SuppressWarnings("unused")
+	@EventHandler
+	public void onJoin(PlayerJoinEvent event) {
+		Player player = event.getPlayer();
+		Tablist tablist = getTablist(player, true);
+	}
+
+	@EventHandler
+	public void onDisable(PluginDisableEvent event) {
+		if (event.getPlugin() == plugin) {
+			tablists.forEach((id, tablist) -> {
+				tablist.hideFakePlayers().clear();
+			});
+			tablists.clear();
+			HandlerList.unregisterAll(this);
+			if (updateTaskId != -1) {
+				Bukkit.getScheduler().cancelTask(updateTaskId);
+			}
+		}
+	}
+
+	@EventHandler
+	public void onQuit(PlayerQuitEvent event) {
+		Player player = event.getPlayer();
+		UUID uniqueId = player.getUniqueId();
+		Tablist tablist;
+		if ((tablist = tablists.remove(uniqueId)) != null) {
+			tablist.hideFakePlayers().clear();
+		}
+	}
+
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/TablistUpdateTask.java

@@ -0,0 +1,22 @@
+package rip.pyuto.hub.tablist.supplier;
+
+import java.util.stream.Stream;
+
+import org.bukkit.Bukkit;
+
+public class TablistUpdateTask implements Runnable {
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public void run() {
+		TablistManager manager = TablistManager.INSTANCE;
+		if (manager == null)
+			return;
+		Stream.of(Bukkit.getOnlinePlayers()).forEach(player -> {
+			Tablist tablist = manager.getTablist(player);
+			if (tablist != null) {
+				tablist.hideRealPlayers().update();
+			}
+		});
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/reflection/Reflection.java

@@ -0,0 +1,213 @@
+package rip.pyuto.hub.tablist.supplier.reflection;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.bukkit.Bukkit;
+
+public final class Reflection {
+
+	public interface ConstructorInvoker {
+		public Object invoke(Object... arguments);
+	}
+
+	public interface MethodInvoker {
+		public Object invoke(Object target, Object... arguments);
+	}
+
+	public interface FieldAccessor<T> {
+		public T get(Object target);
+
+		public void set(Object target, Object value);
+
+		public boolean hasField(Object target);
+	}
+
+	private static String OBC_PREFIX = Bukkit.getServer().getClass().getPackage().getName();
+	private static String NMS_PREFIX = OBC_PREFIX.replace("org.bukkit.craftbukkit", "net.minecraft.server");
+	private static String VERSION = OBC_PREFIX.replace("org.bukkit.craftbukkit", "").replace(".", "");
+
+	private static Pattern MATCH_VARIABLE = Pattern.compile("\\{([^\\}]+)\\}");
+
+	private Reflection() {
+
+	}
+
+	public static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType) {
+		return getField(target, name, fieldType, 0);
+	}
+
+	public static <T> FieldAccessor<T> getField(String className, String name, Class<T> fieldType) {
+		return getField(getClass(className), name, fieldType, 0);
+	}
+
+	public static <T> FieldAccessor<T> getField(Class<?> target, Class<T> fieldType, int index) {
+		return getField(target, null, fieldType, index);
+	}
+
+	public static <T> FieldAccessor<T> getField(String className, Class<T> fieldType, int index) {
+		return getField(getClass(className), fieldType, index);
+	}
+
+	private static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType, int index) {
+		for (final Field field : target.getDeclaredFields()) {
+			if ((name == null || field.getName().equals(name)) && fieldType.isAssignableFrom(field.getType())
+					&& index-- <= 0) {
+				field.setAccessible(true);
+				return new FieldAccessor<T>() {
+
+					@Override
+					@SuppressWarnings("unchecked")
+					public T get(Object target) {
+						try {
+							return (T) field.get(target);
+						} catch (IllegalAccessException e) {
+							throw new RuntimeException("Cannot access reflection.", e);
+						}
+					}
+
+					@Override
+					public void set(Object target, Object value) {
+						try {
+							field.set(target, value);
+						} catch (IllegalAccessException e) {
+							throw new RuntimeException("Cannot access reflection.", e);
+						}
+					}
+
+					@Override
+					public boolean hasField(Object target) {
+						return field.getDeclaringClass().isAssignableFrom(target.getClass());
+					}
+				};
+			}
+		}
+
+		// Search in parent classes
+		if (target.getSuperclass() != null)
+			return getField(target.getSuperclass(), name, fieldType, index);
+
+		throw new IllegalArgumentException("Cannot find field with type " + fieldType);
+	}
+
+	public static MethodInvoker getMethod(String className, String methodName, Class<?>... params) {
+		return getTypedMethod(getClass(className), methodName, null, params);
+	}
+
+	public static MethodInvoker getMethod(Class<?> clazz, String methodName, Class<?>... params) {
+		return getTypedMethod(clazz, methodName, null, params);
+	}
+
+	public static MethodInvoker getTypedMethod(Class<?> clazz, String methodName, Class<?> returnType,
+			Class<?>... params) {
+		for (final Method method : clazz.getDeclaredMethods()) {
+			if ((methodName == null || method.getName().equals(methodName))
+					&& (returnType == null || method.getReturnType().equals(returnType))
+					&& Arrays.equals(method.getParameterTypes(), params)) {
+				method.setAccessible(true);
+
+				return new MethodInvoker() {
+
+					@Override
+					public Object invoke(Object target, Object... arguments) {
+						try {
+							return method.invoke(target, arguments);
+						} catch (Exception e) {
+							throw new RuntimeException("Cannot invoke method " + method, e);
+						}
+					}
+
+				};
+			}
+		}
+
+		if (clazz.getSuperclass() != null)
+			return getMethod(clazz.getSuperclass(), methodName, params);
+
+		throw new IllegalStateException(
+				String.format("Unable to find method %s (%s).", methodName, Arrays.asList(params)));
+	}
+
+	public static ConstructorInvoker getConstructor(String className, Class<?>... params) {
+		return getConstructor(getClass(className), params);
+	}
+
+	public static ConstructorInvoker getConstructor(Class<?> clazz, Class<?>... params) {
+		for (final Constructor<?> constructor : clazz.getDeclaredConstructors()) {
+			if (Arrays.equals(constructor.getParameterTypes(), params)) {
+				constructor.setAccessible(true);
+
+				return new ConstructorInvoker() {
+
+					@Override
+					public Object invoke(Object... arguments) {
+						try {
+							return constructor.newInstance(arguments);
+						} catch (Exception e) {
+							throw new RuntimeException("Cannot invoke constructor " + constructor, e);
+						}
+					}
+
+				};
+			}
+		}
+
+		throw new IllegalStateException(
+				String.format("Unable to find constructor for %s (%s).", clazz, Arrays.asList(params)));
+	}
+
+	public static Class<Object> getUntypedClass(String lookupName) {
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		Class<Object> clazz = (Class) getClass(lookupName);
+		return clazz;
+	}
+
+	public static Class<?> getClass(String lookupName) {
+		return getCanonicalClass(expandVariables(lookupName));
+	}
+
+	public static Class<?> getMinecraftClass(String name) {
+		return getCanonicalClass(NMS_PREFIX + "." + name);
+	}
+
+	public static Class<?> getCraftBukkitClass(String name) {
+		return getCanonicalClass(OBC_PREFIX + "." + name);
+	}
+
+	private static Class<?> getCanonicalClass(String canonicalName) {
+		try {
+			return Class.forName(canonicalName);
+		} catch (ClassNotFoundException e) {
+			throw new IllegalArgumentException("Cannot find " + canonicalName, e);
+		}
+	}
+
+	private static String expandVariables(String name) {
+		StringBuffer output = new StringBuffer();
+		Matcher matcher = MATCH_VARIABLE.matcher(name);
+
+		while (matcher.find()) {
+			String variable = matcher.group(1);
+			String replacement = "";
+
+			if ("nms".equalsIgnoreCase(variable))
+				replacement = NMS_PREFIX;
+			else if ("obc".equalsIgnoreCase(variable))
+				replacement = OBC_PREFIX;
+			else if ("version".equalsIgnoreCase(variable))
+				replacement = VERSION;
+			else
+				throw new IllegalArgumentException("Unknown variable: " + variable);
+			if (replacement.length() > 0 && matcher.end() < name.length() && name.charAt(matcher.end()) != '.')
+				replacement += ".";
+			matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
+		}
+
+		matcher.appendTail(output);
+		return output.toString();
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/tablist/supplier/reflection/ReflectionConstants.java

@@ -0,0 +1,84 @@
+package rip.pyuto.hub.tablist.supplier.reflection;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.UUID;
+
+import net.minecraft.server.v1_7_R4.EnumProtocol;;
+
+public class ReflectionConstants {
+
+	public static final Class<?> TAB_PACKET_CLASS = Reflection.getMinecraftClass("PacketPlayOutPlayerInfo");
+	public static final Reflection.ConstructorInvoker TAB_PACKET_CONSTRUCTOR = Reflection
+			.getConstructor(TAB_PACKET_CLASS);
+	public static final Reflection.FieldAccessor<Integer> TAB_PACKET_ACTION = Reflection.getField(TAB_PACKET_CLASS,
+			int.class, 5);
+
+	public static final Reflection.FieldAccessor<String> TAB_PACKET_NAME = Reflection.getField(TAB_PACKET_CLASS,
+			String.class, 0);
+
+	public static final Class<Object> GAME_PROFILE_CLASS = getUntypedClasses(
+			"net.minecraft.util.com.mojang.authlib.GameProfile", "com.mojang.authlib.GameProfile");
+	public static final Reflection.ConstructorInvoker GAME_PROFILE_CONSTRUCTOR = Reflection
+			.getConstructor(GAME_PROFILE_CLASS, UUID.class, String.class);
+	public static final Reflection.FieldAccessor<String> GAME_PROFILE_NAME = Reflection.getField(GAME_PROFILE_CLASS,
+			String.class, 0);
+	public static final Reflection.FieldAccessor<Object> TAB_PACKET_PROFILE = Reflection.getField(TAB_PACKET_CLASS,
+			GAME_PROFILE_CLASS, 0);
+
+	public static final Class<?> CRAFT_PLAYER_CLASS = Reflection.getCraftBukkitClass("entity.CraftPlayer");
+	public static final Class<?> NMS_PACKET_CLASS = Reflection.getMinecraftClass("Packet");
+	public static final Class<?> NMS_PLAYER_CLASS = Reflection.getMinecraftClass("EntityPlayer");
+	public static final Class<?> PLAYER_CONNECTION_CLASS = Reflection.getMinecraftClass("PlayerConnection");
+	public static final Class<?> NETWORK_MANAGER_CLASS = Reflection.getMinecraftClass("NetworkManager");
+	public static final Reflection.MethodInvoker GET_HANDLE_METHOD = Reflection.getMethod(CRAFT_PLAYER_CLASS,
+			"getHandle");
+	public static final Reflection.MethodInvoker GET_PROFILE_METHOD = Reflection.getMethod(CRAFT_PLAYER_CLASS,
+			"getProfile");
+	public static final Reflection.MethodInvoker VERSION_METHOD = Reflection.getMethod(NETWORK_MANAGER_CLASS,
+			"getVersion");
+	public static final Reflection.MethodInvoker SEND_PACKET = Reflection.getMethod(PLAYER_CONNECTION_CLASS,
+			"sendPacket", NMS_PACKET_CLASS);
+	public static final Reflection.FieldAccessor<?> PLAYER_CONNECTION = Reflection.getField(NMS_PLAYER_CLASS,
+			PLAYER_CONNECTION_CLASS, 0);
+	public static final Reflection.FieldAccessor<?> NETWORK_MANAGER = Reflection.getField(PLAYER_CONNECTION_CLASS,
+			NETWORK_MANAGER_CLASS, 0);
+	public static final Class<?> SCOREBOARD_TEAM_CLASS = Reflection.getMinecraftClass("PacketPlayOutScoreboardTeam");
+	public static final Reflection.ConstructorInvoker SCOREBOARD_TEAM_CONSTRUCTOR = Reflection
+			.getConstructor(SCOREBOARD_TEAM_CLASS);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_NAME = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 0);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_DISPLAY_NAME = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 1);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_PREFIX = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 2);
+	public static final Reflection.FieldAccessor<String> SCOREBOARD_TEAM_SUFFIX = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, String.class, 3);
+	@SuppressWarnings("rawtypes")
+	public static final Reflection.FieldAccessor<Collection> SCOREBOARD_TEAM_PLAYERS = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, Collection.class, 0);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_TEAM_ACTION = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, Integer.TYPE, 0);
+	public static final Reflection.FieldAccessor<Integer> SCOREBOARD_TEAM_OPTIONS = Reflection
+			.getField(SCOREBOARD_TEAM_CLASS, Integer.TYPE, 1);
+
+	// packet registry
+	public static final Class<?> ENUM_PROTOCOL_CLASS = Reflection.getMinecraftClass("EnumProtocol");
+	public static final Reflection.FieldAccessor<?> ENUM_PROTOCOL_PLAY = Reflection.getField(ENUM_PROTOCOL_CLASS,
+			ENUM_PROTOCOL_CLASS, 1);
+	@SuppressWarnings("rawtypes")
+	public static final Reflection.FieldAccessor<Map> ENUM_PROTOCOL_REGISTRY = Reflection.getField(ENUM_PROTOCOL_CLASS,
+			Map.class, 0);
+
+	public static Class<Object> getUntypedClasses(String... lookupNames) {
+		EnumProtocol.class.getName();
+		for (String lookupName : lookupNames) {
+			try {
+				return Reflection.getUntypedClass(lookupName);
+			} catch (IllegalArgumentException e) {
+				continue;
+			}
+		}
+		throw new IllegalArgumentException("No class found in selection given");
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/utils/ItemStackBuilder.java

@@ -0,0 +1,65 @@
+package rip.pyuto.hub.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Color;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+
+public class ItemStackBuilder {
+
+	private ItemStack itemStack;
+	private ItemMeta itemMeta;
+
+	public ItemStackBuilder(Material material) {
+		itemStack = new ItemStack(material);
+		itemMeta = itemStack.getItemMeta();
+	}
+
+	public ItemStackBuilder amount(int amount) {
+		itemStack.setAmount(amount);
+		return this;
+	}
+
+	public ItemStackBuilder setName(String displayName) {
+		itemMeta.setDisplayName(displayName);
+		return this;
+	}
+
+	public ItemStackBuilder color(int hex) {
+		if (itemMeta instanceof LeatherArmorMeta) {
+			((LeatherArmorMeta) itemMeta).setColor(Color.fromRGB(hex));
+		}
+		return this;
+	}
+
+	public ItemStackBuilder addLore(String... strings) {
+		List<String> loreArray = new ArrayList<>();
+		for (String loreBit : strings) {
+			loreArray.add(ChatColor.WHITE + loreBit);
+		}
+		itemMeta.setLore(loreArray);
+		return this;
+	}
+
+	public ItemStackBuilder enchant(Enchantment enchanement, int level, boolean ignoreLevelRestriction) {
+		itemMeta.addEnchant(enchanement, level, ignoreLevelRestriction);
+		return this;
+	}
+
+	public ItemStackBuilder durability(int durability) {
+		itemStack.setDurability((short) durability);
+		return this;
+	}
+
+	public ItemStack build() {
+		ItemStack clonedStack = itemStack.clone();
+		clonedStack.setItemMeta(itemMeta.clone());
+		return clonedStack;
+	}
+}

Pyuto Hub System/src/rip/pyuto/hub/utils/ServerInfo.java

@@ -0,0 +1,73 @@
+package rip.pyuto.hub.utils;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+
+import org.bukkit.ChatColor;
+
+import lombok.Getter;
+
+public class ServerInfo {
+
+	private static final ExecutorService EXECUTOR;
+
+	@Getter
+	private InetSocketAddress address;
+
+	@Getter
+	private final AtomicInteger maximumOnline, currentOnline;
+
+	@Getter
+	private final AtomicReference<String> status;
+
+	public ServerInfo(InetSocketAddress address) {
+		this.address = address;
+		this.maximumOnline = new AtomicInteger();
+		this.currentOnline = new AtomicInteger();
+		this.status = new AtomicReference<>("OFFLINE");
+	}
+
+	@Override
+	public String toString() {
+		return currentOnline.get() + "/" + maximumOnline.get();
+	}
+
+	public void ping(boolean async) {
+		Consumer<Runnable> executor = async ? (runnable) -> EXECUTOR.execute(runnable) : Runnable::run;
+		executor.accept(() -> {
+			try (Socket socket = new Socket(address.getAddress(), address.getPort());
+					DataOutputStream output = new DataOutputStream(socket.getOutputStream());
+					DataInputStream input = new DataInputStream(socket.getInputStream())) {
+				output.write(0xFE);
+				int next = -1;
+				String result = "";
+				while ((next = input.read()) != -1) {
+					if (next != 0 && next != 16 && next != 255 && next != 23 && next != 24) {
+						result += (char) next;
+					}
+				}
+				String[] data = result.split("§");
+				String predictedStatus = data[0].toLowerCase().contains("whitelisted")
+						? ChatColor.YELLOW + "Whitelisted"
+						: ChatColor.GREEN + "Online";
+				status.set(predictedStatus);
+				currentOnline.set(Integer.valueOf(data[1]));
+				maximumOnline.set(Integer.valueOf(data[2]));
+			} catch (IOException exception) {
+				status.set(ChatColor.RED + "Offline");
+			}
+		});
+	}
+
+	static {
+		EXECUTOR = Executors.newFixedThreadPool(2);
+	}
+}

Pyuto Ranks System/.classpath

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Eclipse Libraries/lombok.jar"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Eclipse Libraries/mongo-java-driver-3.8.0.jar"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Pytuo Duo/Servers/Hub Server/plugins/Mongo.jar"/>
+	<classpathentry kind="lib" path="C:/Users/computer/Desktop/Pytuo Duo/Servers/Hub Server/PaperSpigot.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Pyuto Ranks System/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Pyuto Ranks System</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Pyuto Ranks System/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//src/rip/pyuto/ranks/commands/RankBaseCommand.java=UTF-8

Pyuto Ranks System/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

Pyuto Ranks System/plugin.yml

@@ -0,0 +1,5 @@
+main: rip.pyuto.ranks.Ranks
+name: Ranks
+version: 1.0
+commands:
+  rank: