MAIN KLASSE:

package de.crafterworld.nick;

import org.bukkit.plugin.java.*;
import net.milkbowl.vault.chat.*;
import java.io.*;
import java.util.*;
import org.bukkit.configuration.file.*;
import de.crafterworld.nick.command.*;
import org.bukkit.command.*;
import org.bukkit.event.*;
import de.crafterworld.nick.listener.*;
import org.bukkit.plugin.*;
import org.bukkit.*;
import org.bukkit.entity.*;
import de.crafterworld.nick.util.*;
import java.util.concurrent.*;
import java.sql.*;

public class NickAPI extends JavaPlugin
{
    private final ExecutorService executorService;
    private static NickAPI instance;
    private Chat chat;
    private AsyncMySQL mySQL;
    private File file;
    private FileConfiguration yamlConfiguration;
    private Map<String, String> nicked;

    public NickAPI() {
        this.executorService = Executors.newCachedThreadPool();
        this.file = new File(this.getDataFolder(), "config.yml");
        this.nicked = new HashMap<String, String>();
    }

    public void onEnable() {
        NickAPI.instance = this;
        if (!this.file.exists()) {
            this.saveResource("config.yml", false);
        }
        this.yamlConfiguration = (FileConfiguration)YamlConfiguration.loadConfiguration(this.file);
        (this.mySQL = new AsyncMySQL((Plugin)this, this.ms("host"), this.mi("port"), this.ms("user"), this.ms("password"), this.ms("database"))).update("CREATE TABLE IF NOT EXISTS `nick_nicks` (`id` int(11) unsigned NOT NULL AUTO_INCREMENT, `nick` varchar(64) NOT NULL DEFAULT '', `used_by` varchar(64) DEFAULT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;");
        this.getCommand("nick").setExecutor((CommandExecutor)new CommandNick(this));
        final PluginManager pm = Bukkit.getPluginManager();
        pm.registerEvents((Listener)new ListenerAsyncPlayerChat(this), (Plugin)this);
        pm.registerEvents((Listener)new ListenerPlayerJoin(this), (Plugin)this);
        pm.registerEvents((Listener)new ListenerPlayerLogin(this), (Plugin)this);
        pm.registerEvents((Listener)new ListenerPlayerQuit(this), (Plugin)this);
        if (Bukkit.getPluginManager().getPlugin("Vault") != null) {
            final RegisteredServiceProvider<Chat> chatProvider = (RegisteredServiceProvider<Chat>)this.getServer().getServicesManager().getRegistration((Class)Chat.class);
            if (chatProvider != null) {
                this.chat = (Chat)chatProvider.getProvider();
            }
        }
    }

    public void onDisable() {
        super.onDisable();
    }

    public static NickAPI getInstance() {
        return NickAPI.instance;
    }

    public AsyncMySQL getMySQL() {
        return this.mySQL;
    }

    public Chat getChat() {
        return this.chat;
    }

    public FileConfiguration getConfiguration() {
        return this.yamlConfiguration;
    }

    public Map<String, String> getNicked() {
        return this.nicked;
    }

    private String ms(final String string) {
        return this.yamlConfiguration.getString("mysql." + string);
    }

    private int mi(final String string) {
        return this.yamlConfiguration.getInt("mysql." + string);
    }

    public String getMessage(final String path) {
        return ChatColor.translateAlternateColorCodes('&', this.yamlConfiguration.getString("messages." + path));
    }

    public void nick(final Player player) {
        if (this.nicked.containsKey(player.getName())) {
            this.nick(player, this.nicked.get(player.getName()));
            player.sendMessage(this.getMessage("name").replace("{nick}", this.nicked.get(player)));
            return;
        }
        final PreparedStatement statement = this.mySQL.prepare("SELECT nick FROM nick_nicks WHERE used_by IS NULL ORDER BY RAND() LIMIT 1");
        String nickname;
        this.mySQL.query(statement, resultSet -> {
            try {
                if (resultSet.next()) {
                    nickname = resultSet.getString(1);
                    this.nick(player, nickname);
                    player.sendMessage(this.getMessage("nick").replace("{nick}", nickname));
                }
                else {
                    player.sendMessage(this.getMessage("noNicksAvailable"));
                }
            }
            catch (SQLException exc) {
                exc.printStackTrace();
            }
        });
    }

    private void nick(final Player player, final String nickname) {
        final PreparedStatement statement = this.mySQL.prepare("UPDATE nick_nicks SET used_by = ? WHERE nick = ?");
        try {
            statement.setString(1, player.getUniqueId().toString());
            statement.setString(2, nickname);
        }
        catch (SQLException exc) {
            exc.printStackTrace();
        }
        this.mySQL.update(statement);
        this.nicked.put(player.getName(), nickname);
        Util.nick(player, nickname);
    }

    public void unnick(final Player player) {
        final PreparedStatement statement = this.mySQL.prepare("UPDATE nick_nicks SET used_by = NULL WHERE nick = ?");
        try {
            statement.setString(1, this.nicked.get(player.getName()));
        }
        catch (SQLException exc) {
            exc.printStackTrace();
        }
        this.mySQL.update(statement);
        this.nicked.remove(player.getName());
        Util.nick(player, player.getName());
        player.sendMessage(this.getMessage("unnick"));
    }

    public boolean isNickedSync(final Player player) {
        return this.nicked.containsKey(player.getName());
    }

    public Future<Boolean> isNicked(final Player player) {
        final PreparedStatement statement;
        ResultSet resultSet;
        return this.executorService.submit(() -> {
            statement = this.mySQL.prepare("SELECT nick FROM nick_nicks WHERE used_by = ?");
            try {
                statement.setString(1, player.getUniqueId().toString());
                resultSet = this.mySQL.getMySQL().query(statement);
                if (resultSet.next()) {
                    this.nicked.put(player.getName(), resultSet.getString(1));
                    return true;
                }
            }
            catch (SQLException exc) {
                exc.printStackTrace();
            }
            return false;
        });
    }
}

-------------------------------------------------------------------------------------------------------------------------------
NICK COMMAND:

package de.crafterworld.nick.command;

import de.crafterworld.nick.*;
import org.bukkit.command.*;
import org.bukkit.entity.*;

public class CommandNick implements CommandExecutor
{
    private NickAPI plugin;

    public CommandNick(final NickAPI plugin) {
        this.plugin = plugin;
    }

    public boolean onCommand(final CommandSender commandSender, final Command command, final String label, final String[] args) {
        if (!(commandSender instanceof Player)) {
            commandSender.sendMessage(this.plugin.getMessage("playerOnly"));
            return true;
        }
        final Player player = (Player)commandSender;
        player.sendMessage("DEBUG only nick");
        this.plugin.nick(player);
        return true;
    }
}
 -------------------------------------------------------------------------------------------------------------------------------------
ASyncChat Event:

package de.crafterworld.nick.listener;

import de.crafterworld.nick.*;
import org.bukkit.event.player.*;
import net.md_5.bungee.api.*;
import org.bukkit.entity.*;
import org.bukkit.event.*;

public class ListenerAsyncPlayerChat implements Listener
{
    private NickAPI plugin;

    public ListenerAsyncPlayerChat(final NickAPI plugin) {
        this.plugin = plugin;
    }

    @EventHandler(priority = EventPriority.HIGHEST)
    public void event(final AsyncPlayerChatEvent event) {
        final Player player = event.getPlayer();
        String prefix = "§a";
        String name = player.getName();
        if (this.plugin.getChat() != null && this.plugin.getNicked().get(name) == null) {
            prefix = ChatColor.translateAlternateColorCodes('&', this.plugin.getChat().getPlayerPrefix(player)) + " ";
        }
        if (this.plugin.getNicked().containsKey(player.getName())) {
            name = this.plugin.getNicked().get(player.getName());
        }
        event.setFormat(prefix + name + "§7: §f" + event.getMessage());
    }
}

-------------------------------------------------------------------------------------------------------------------------
Join:


import de.crafterworld.nick.*;
import org.bukkit.event.player.*;
import org.bukkit.*;
import org.bukkit.entity.*;
import java.util.concurrent.*;
import org.bukkit.event.*;

public class ListenerPlayerJoin implements Listener
{
    private NickAPI plugin;

    public ListenerPlayerJoin(final NickAPI plugin) {
        this.plugin = plugin;
    }

    @EventHandler(priority = EventPriority.HIGHEST)
    public void event(final PlayerJoinEvent event) throws ExecutionException, InterruptedException {
        final Player player = event.getPlayer();
        event.setJoinMessage((String)null);
        if (this.plugin.getConfiguration().getBoolean("modifyEvents.join")) {
            String name = player.getName();
            if (this.plugin.getNicked().get(name) != null) {
                name = this.plugin.getNicked().get(name);
                player.sendMessage(this.plugin.getMessage("name").replace("{nick}", name));
            }
            else {
                player.sendMessage("Nicht genickt? :c");
            }
            Bukkit.broadcastMessage(this.plugin.getMessage("join").replace("{player}", name));
        }
    }
}
--------------------------------------------------------------------------------------------------------
Login:


import de.crafterworld.nick.*;
import org.bukkit.event.player.*;
import org.bukkit.*;
import org.bukkit.entity.*;
import java.util.*;
import java.util.concurrent.*;
import org.bukkit.event.*;

public class ListenerPlayerLogin implements Listener
{
    private NickAPI plugin;

    public ListenerPlayerLogin(final NickAPI plugin) {
        this.plugin = plugin;
    }

    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
    public void event(final PlayerLoginEvent event) throws ExecutionException, InterruptedException {
        final Player player = event.getPlayer();
        if (this.plugin.isNicked(player).get()) {
            this.plugin.nick(player);
        }
        for (final String nicked : this.plugin.getNicked().keySet()) {
            if (Bukkit.getPlayer(nicked) != null && Bukkit.getPlayer(nicked).equals(player)) {
                return;
            }
            this.plugin.nick(Bukkit.getPlayer(nicked));
        }
    }
}

--------------------------------------------------------------------------------------------------------------------------------------
Kwit:

package de.crafterworld.nick.listener;

import de.crafterworld.nick.*;
import org.bukkit.event.player.*;
import org.bukkit.*;
import org.bukkit.entity.*;
import java.util.concurrent.*;
import org.bukkit.event.*;

public class ListenerPlayerQuit implements Listener
{
    private NickAPI plugin;

    public ListenerPlayerQuit(final NickAPI plugin) {
        this.plugin = plugin;
    }

    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
    public void event(final PlayerQuitEvent event) throws ExecutionException, InterruptedException {
        final Player player = event.getPlayer();
        event.setQuitMessage((String)null);
        if (this.plugin.getConfiguration().getBoolean("modifyEvents.quit")) {
            String name = player.getName();
            if (this.plugin.isNickedSync(player)) {
                name = this.plugin.getNicked().get(name);
            }
            Bukkit.broadcastMessage(this.plugin.getMessage("quit").replace("{player}", name));
        }
    }
}
---------------------------------------------------------------------------------------------------------------------------------
ASynchMYSQL:


import org.bukkit.plugin.*;
import java.util.concurrent.*;
import java.util.function.*;
import org.bukkit.*;
import java.sql.*;

public class AsyncMySQL
{
    private ExecutorService executor;
    private Plugin plugin;
    private MySQL sql;

    public AsyncMySQL(final Plugin owner, final String host, final int port, final String user, final String password, final String database) {
        try {
            this.sql = new MySQL(host, port, user, password, database);
            this.executor = Executors.newCachedThreadPool();
            this.plugin = owner;
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void update(final PreparedStatement statement) {
        this.executor.execute(() -> this.sql.queryUpdate(statement));
    }

    public void update(final String statement) {
        this.executor.execute(() -> this.sql.queryUpdate(statement));
    }

    public void query(final PreparedStatement statement, final Consumer<ResultSet> consumer) {
        final ResultSet result;
        this.executor.execute(() -> {
            result = this.sql.query(statement);
            Bukkit.getScheduler().runTask(this.plugin, () -> consumer.accept(result));
        });
    }

    public void query(final String statement, final Consumer<ResultSet> consumer) {
        final ResultSet result;
        this.executor.execute(() -> {
            result = this.sql.query(statement);
            Bukkit.getScheduler().runTask(this.plugin, () -> consumer.accept(result));
        });
    }

    public PreparedStatement prepare(final String query) {
        try {
            return this.sql.getConnection().prepareStatement(query);
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public MySQL getMySQL() {
        return this.sql;
    }

    public static class MySQL
    {
        private String host;
        private String user;
        private String password;
        private String database;
        private int port;
        private Connection conn;

        public MySQL(final String host, final int port, final String user, final String password, final String database) throws Exception {
            this.host = host;
            this.port = port;
            this.user = user;
            this.password = password;
            this.database = database;
            this.openConnection();
        }

        public void queryUpdate(final String query) {
            this.checkConnection();
            try (final PreparedStatement statement = this.conn.prepareStatement(query)) {
                this.queryUpdate(statement);
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }

        public void queryUpdate(final PreparedStatement statement) {
            this.checkConnection();
            try {
                statement.executeUpdate();
            }
            catch (Exception e) {
                e.printStackTrace();
                try {
                    statement.close();
                }
                catch (Exception e) {
                    e.printStackTrace();
                }
            }
            finally {
                try {
                    statement.close();
                }
                catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        }

        public ResultSet query(final String query) {
            this.checkConnection();
            try {
                return this.query(this.conn.prepareStatement(query));
            }
            catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

        public ResultSet query(final PreparedStatement statement) {
            this.checkConnection();
            try {
                return statement.executeQuery();
            }
            catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

        public Connection getConnection() {
            return this.conn;
        }

        private void checkConnection() {
            try {
                if (this.conn == null || !this.conn.isValid(10) || this.conn.isClosed()) {
                    this.openConnection();
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }

        public Connection openConnection() throws Exception {
            Class.forName("com.mysql.jdbc.Driver");
            return this.conn = DriverManager.getConnection("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.database, this.user, this.password);
        }

        public void closeConnection() {
            try {
                this.conn.close();
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
            finally {
                this.conn = null;
            }
        }
    }
}
 ------------------------------------------------------------------------------------------------------------------------------------
GameProfil:


import com.mojang.authlib.*;
import com.mojang.util.*;
import java.net.*;
import java.io.*;
import org.yaml.snakeyaml.external.biz.base64Coder.*;
import java.lang.reflect.*;
import com.mojang.authlib.properties.*;
import java.util.*;
import com.google.gson.*;

public class GameProfileBuilder
{
    private static final String SERVICE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/%s?unsigned=false";
    private static final String JSON_SKIN = "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"}}}";
    private static final String JSON_CAPE = "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"},\"CAPE\":{\"url\":\"%s\"}}}";
    private static Gson gson;
    private static HashMap<UUID, CachedProfile> cache;
    private static long cacheTime;

    public static GameProfile fetch(final UUID uuid) throws IOException {
        return fetch(uuid, false);
    }

    public static GameProfile fetch(final UUID uuid, final boolean forceNew) throws IOException {
        if (!forceNew && GameProfileBuilder.cache.containsKey(uuid) && GameProfileBuilder.cache.get(uuid).isValid()) {
            return GameProfileBuilder.cache.get(uuid).profile;
        }
        final HttpURLConnection connection = (HttpURLConnection)new URL(String.format("https://sessionserver.mojang.com/session/minecraft/profile/%s?unsigned=false", UUIDTypeAdapter.fromUUID(uuid))).openConnection();
        connection.setReadTimeout(5000);
        if (connection.getResponseCode() == 200) {
            final String json = new BufferedReader(new InputStreamReader(connection.getInputStream())).readLine();
            final GameProfile result = (GameProfile)GameProfileBuilder.gson.fromJson(json, (Class)GameProfile.class);
            GameProfileBuilder.cache.put(uuid, new CachedProfile(result));
            return result;
        }
        if (!forceNew && GameProfileBuilder.cache.containsKey(uuid)) {
            return GameProfileBuilder.cache.get(uuid).profile;
        }
        final JsonObject error = (JsonObject)new JsonParser().parse(new BufferedReader(new InputStreamReader(connection.getErrorStream())).readLine());
        throw new IOException(error.get("error").getAsString() + ": " + error.get("errorMessage").getAsString());
    }

    public static GameProfile getProfile(final UUID uuid, final String name, final String skin) {
        return getProfile(uuid, name, skin, null);
    }

    public static GameProfile getProfile(final UUID uuid, final String name, final String skinUrl, final String capeUrl) {
        final GameProfile profile = new GameProfile(uuid, name);
        final boolean cape = capeUrl != null && !capeUrl.isEmpty();
        final List<Object> args = new ArrayList<Object>();
        args.add(System.currentTimeMillis());
        args.add(UUIDTypeAdapter.fromUUID(uuid));
        args.add(name);
        args.add(skinUrl);
        if (cape) {
            args.add(capeUrl);
        }
        profile.getProperties().put((Object)"textures", (Object)new Property("textures", Base64Coder.encodeString(String.format(cape ? GameProfileBuilder.JSON_CAPE : GameProfileBuilder.JSON_SKIN, args.toArray(new Object[args.size()])))));
        return profile;
    }

    public static void setCacheTime(final long time) {
        GameProfileBuilder.cacheTime = time;
    }

    static {
        GameProfileBuilder.gson = new GsonBuilder().disableHtmlEscaping().registerTypeAdapter((Type)UUID.class, (Object)new UUIDTypeAdapter()).registerTypeAdapter((Type)GameProfile.class, (Object)new GameProfileSerializer()).registerTypeAdapter((Type)PropertyMap.class, (Object)new PropertyMap.Serializer()).create();
        GameProfileBuilder.cache = new HashMap<UUID, CachedProfile>();
        GameProfileBuilder.cacheTime = -1L;
    }

    private static class GameProfileSerializer implements JsonSerializer<GameProfile>, JsonDeserializer<GameProfile>
    {
        public GameProfile deserialize(final JsonElement json, final Type type, final JsonDeserializationContext context) throws JsonParseException {
            final JsonObject object = (JsonObject)json;
            final UUID id = object.has("id") ? ((UUID)context.deserialize(object.get("id"), (Type)UUID.class)) : null;
            final String name = object.has("name") ? object.getAsJsonPrimitive("name").getAsString() : null;
            final GameProfile profile = new GameProfile(id, name);
            if (object.has("properties")) {
                for (final Map.Entry<String, Property> prop : ((PropertyMap)context.deserialize(object.get("properties"), (Type)PropertyMap.class)).entries()) {
                    profile.getProperties().put((Object)prop.getKey(), (Object)prop.getValue());
                }
            }
            return profile;
        }

        public JsonElement serialize(final GameProfile profile, final Type type, final JsonSerializationContext context) {
            final JsonObject result = new JsonObject();
            if (profile.getId() != null) {
                result.add("id", context.serialize((Object)profile.getId()));
            }
            if (profile.getName() != null) {
                result.addProperty("name", profile.getName());
            }
            if (!profile.getProperties().isEmpty()) {
                result.add("properties", context.serialize((Object)profile.getProperties()));
            }
            return (JsonElement)result;
        }
    }

    private static class CachedProfile
    {
        private long timestamp;
        private GameProfile profile;

        public CachedProfile(final GameProfile profile) {
            this.timestamp = System.currentTimeMillis();
            this.profile = profile;
        }

        public boolean isValid() {
            return GameProfileBuilder.cacheTime < 0L || System.currentTimeMillis() - this.timestamp < GameProfileBuilder.cacheTime;
        }
    }
}

------------------------------------------------------------------------------------------------------------------------------------
UUIDFetcher:


import java.util.function.*;
import java.net.*;
import java.io.*;
import com.mojang.util.*;
import com.google.gson.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;

public class UUIDFetcher
{
    public static final long FEBRUARY_2015 = 1422748800000L;
    private static Gson gson;
    private static final String UUID_URL = "https://api.mojang.com/users/profiles/minecraft/%s?at=%d";
    private static final String NAME_URL = "https://api.mojang.com/user/profiles/%s/names";
    private static Map<String, UUID> uuidCache;
    private static Map<UUID, String> nameCache;
    private static ExecutorService pool;
    private String name;
    private UUID id;

    public static void getUUID(final String name, final Consumer<UUID> action) {
        UUIDFetcher.pool.execute(() -> action.accept(getUUID(name)));
    }

    public static UUID getUUID(final String name) {
        return getUUIDAt(name, System.currentTimeMillis());
    }

    public static void getUUIDAt(final String name, final long timestamp, final Consumer<UUID> action) {
        UUIDFetcher.pool.execute(() -> action.accept(getUUIDAt(name, timestamp)));
    }

    public static UUID getUUIDAt(String name, final long timestamp) {
        name = name.toLowerCase();
        if (UUIDFetcher.uuidCache.containsKey(name)) {
            return UUIDFetcher.uuidCache.get(name);
        }
        try {
            final HttpURLConnection connection = (HttpURLConnection)new URL(String.format("https://api.mojang.com/users/profiles/minecraft/%s?at=%d", name, timestamp / 1000L)).openConnection();
            connection.setReadTimeout(5000);
            final UUIDFetcher data = (UUIDFetcher)UUIDFetcher.gson.fromJson((Reader)new BufferedReader(new InputStreamReader(connection.getInputStream())), (Class)UUIDFetcher.class);
            UUIDFetcher.uuidCache.put(name, data.id);
            UUIDFetcher.nameCache.put(data.id, data.name);
            return data.id;
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void getName(final UUID uuid, final Consumer<String> action) {
        UUIDFetcher.pool.execute(() -> action.accept(getName(uuid)));
    }

    public static String getName(final UUID uuid) {
        if (UUIDFetcher.nameCache.containsKey(uuid)) {
            return UUIDFetcher.nameCache.get(uuid);
        }
        try {
            final HttpURLConnection connection = (HttpURLConnection)new URL(String.format("https://api.mojang.com/user/profiles/%s/names", UUIDTypeAdapter.fromUUID(uuid))).openConnection();
            connection.setReadTimeout(5000);
            final UUIDFetcher[] nameHistory = (UUIDFetcher[])UUIDFetcher.gson.fromJson((Reader)new BufferedReader(new InputStreamReader(connection.getInputStream())), (Class)UUIDFetcher[].class);
            final UUIDFetcher currentNameData = nameHistory[nameHistory.length - 1];
            UUIDFetcher.uuidCache.put(currentNameData.name.toLowerCase(), uuid);
            UUIDFetcher.nameCache.put(uuid, currentNameData.name);
            return currentNameData.name;
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    static {
        UUIDFetcher.gson = new GsonBuilder().registerTypeAdapter((Type)UUID.class, (Object)new UUIDTypeAdapter()).create();
        UUIDFetcher.uuidCache = new HashMap<String, UUID>();
        UUIDFetcher.nameCache = new HashMap<UUID, String>();
        UUIDFetcher.pool = Executors.newCachedThreadPool();
    }
}

-----------------------------------------------------------------------------------------------------------------------------------
Util:


import org.bukkit.entity.*;
import org.bukkit.craftbukkit.v1_8_R3.entity.*;
import org.bukkit.craftbukkit.v1_8_R3.util.*;
import org.bukkit.*;
import java.util.function.*;
import java.util.stream.*;
import com.mojang.authlib.*;
import net.minecraft.server.v1_8_R3.*;
import java.util.*;
import java.lang.reflect.*;
import java.util.concurrent.*;

public class Util
{
    private static ExecutorService pool;
    private static Field modifiers;
    private static Field actionField;
    private static Field dataField;
    private static Field nameField;
    private static Field uuidField;

    public static void nick(final Player player, final String name) {
        Util.pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    final GameProfile prof = GameProfileBuilder.fetch(UUIDFetcher.getUUID(ChatColor.stripColor(name)));
                    Util.nameField.set(prof, name);
                    Util.uuidField.set(prof, player.getUniqueId());
                    final EntityPlayer entity = ((CraftPlayer)player).getHandle();
                    final PacketPlayOutEntityDestroy despawn = new PacketPlayOutEntityDestroy(new int[] { entity.getId() });
                    final PacketPlayOutPlayerInfo x0;
                    final PacketPlayOutPlayerInfo removeProfile = x0 = new PacketPlayOutPlayerInfo();
                    final PacketPlayOutPlayerInfo.EnumPlayerInfoAction remove_PLAYER = PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER;
                    final PacketPlayOutPlayerInfo.PlayerInfoData[] x2 = { null };
                    final int n = 0;
                    final PacketPlayOutPlayerInfo packetPlayOutPlayerInfo = removeProfile;
                    packetPlayOutPlayerInfo.getClass();
                    x2[n] = new PacketPlayOutPlayerInfo.PlayerInfoData(packetPlayOutPlayerInfo, entity.getProfile(), -1, (WorldSettings.EnumGamemode)null, (IChatBaseComponent)null);
                    setInfo(x0, remove_PLAYER, x2);
                    final PacketPlayOutPlayerInfo x3;
                    final PacketPlayOutPlayerInfo info = x3 = new PacketPlayOutPlayerInfo();
                    final PacketPlayOutPlayerInfo.EnumPlayerInfoAction add_PLAYER = PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER;
                    final PacketPlayOutPlayerInfo.PlayerInfoData[] x4 = { null };
                    final int n2 = 0;
                    final PacketPlayOutPlayerInfo packetPlayOutPlayerInfo2 = info;
                    packetPlayOutPlayerInfo2.getClass();
                    x4[n2] = new PacketPlayOutPlayerInfo.PlayerInfoData(packetPlayOutPlayerInfo2, prof, entity.ping, entity.playerInteractManager.getGameMode(), CraftChatMessage.fromString(name)[0]);
                    setInfo(x3, add_PLAYER, x4);
                    final PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn((EntityHuman)entity);
                    final Set<PlayerConnection> players = Bukkit.getOnlinePlayers().stream().filter(Predicate.isEqual(player).negate()).map((Function<? super Object, ?>)CraftPlayer.class::cast).map((Function<? super Object, ?>)CraftPlayer::getHandle).map(p -> p.playerConnection).collect((Collector<? super Object, ?, Set<PlayerConnection>>)Collectors.toSet());
                    players.forEach(c -> c.sendPacket((Packet)despawn));
                    players.forEach(c -> c.sendPacket((Packet)removeProfile));
                    synchronized (this) {
                        this.wait(125L);
                    }
                    players.forEach(c -> c.sendPacket((Packet)info));
                    players.forEach(c -> c.sendPacket((Packet)spawn));
                }
                catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    private static PacketPlayOutPlayerInfo setInfo(final PacketPlayOutPlayerInfo packet, final PacketPlayOutPlayerInfo.EnumPlayerInfoAction action, final PacketPlayOutPlayerInfo.PlayerInfoData... data) {
        try {
            Util.actionField.set(packet, action);
            Util.dataField.set(packet, Arrays.asList(data));
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        return packet;
    }

    private static Field getField(final Class<?> clazz, final String name) {
        try {
            final Field field = clazz.getDeclaredField(name);
            field.setAccessible(true);
            if (Modifier.isFinal(field.getModifiers())) {
                Util.modifiers.set(field, field.getModifiers() & 0xFFFFFFEF);
            }
            return field;
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    static {
        Util.pool = Executors.newCachedThreadPool();
        Util.modifiers = getField(Field.class, "modifiers");
        Util.actionField = getField(PacketPlayOutPlayerInfo.class, "a");
        Util.dataField = getField(PacketPlayOutPlayerInfo.class, "b");
        Util.nameField = getField(GameProfile.class, "name");
        Util.uuidField = getField(GameProfile.class, "id");
    }
}
-----------------------------------------------------------------------------------------------------------------------------------