Nick.java

package me.the_red_freak.setskin.util;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.craftbukkit.v1_11_R1.CraftServer;
import org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_11_R1.inventory.CraftItemStack;
import org.bukkit.craftbukkit.v1_11_R1.util.CraftChatMessage;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;

import com.mojang.authlib.GameProfile;

import me.the_red_freak.setskin.main.Main;
import net.minecraft.server.v1_11_R1.EntityPlayer;
import net.minecraft.server.v1_11_R1.EnumGamemode;
import net.minecraft.server.v1_11_R1.EnumItemSlot;
import net.minecraft.server.v1_11_R1.PacketPlayOutEntityDestroy;
import net.minecraft.server.v1_11_R1.PacketPlayOutEntityEquipment;
import net.minecraft.server.v1_11_R1.PacketPlayOutHeldItemSlot;
import net.minecraft.server.v1_11_R1.PacketPlayOutNamedEntitySpawn;
import net.minecraft.server.v1_11_R1.PacketPlayOutPlayerInfo;
import net.minecraft.server.v1_11_R1.PacketPlayOutPlayerInfo.EnumPlayerInfoAction;
import net.minecraft.server.v1_11_R1.PacketPlayOutPlayerInfo.PlayerInfoData;
import net.minecraft.server.v1_11_R1.PacketPlayOutRespawn;
import net.minecraft.server.v1_11_R1.PlayerConnection;

public class Nick implements Listener {
    private static ExecutorService pool = Executors.newCachedThreadPool();
    private static Field modifiers = getField(Field.class, "modifiers");
    private static Field actionField = getField(PacketPlayOutPlayerInfo.class, "a");
    private static Field dataField = getField(PacketPlayOutPlayerInfo.class, "b");
    private static Field nameField = getField(GameProfile.class, "name");
    private static Field uuidField = getField(GameProfile.class, "id");

    public static void nick(final Player player, final String name) {
        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    GameProfile prof =

                            GameProfileBuilder.fetch(UUIDFetcher.getUUID(ChatColor.stripColor(name)));

                    EntityPlayer entity = ((CraftPlayer) player).getHandle();

                    nameField.set(prof, name);
                    uuidField.set(prof, player.getUniqueId());

                    PacketPlayOutEntityDestroy despawn = new PacketPlayOutEntityDestroy(entity.getId());
                    PacketPlayOutPlayerInfo removeProfile = new PacketPlayOutPlayerInfo();

                    setInfo(removeProfile, EnumPlayerInfoAction.REMOVE_PLAYER,
                            removeProfile.new PlayerInfoData(prof, -1, null, null));

                    PacketPlayOutPlayerInfo info = new PacketPlayOutPlayerInfo();

                    setInfo(info, EnumPlayerInfoAction.ADD_PLAYER, info.new PlayerInfoData(prof, entity.ping,
                            entity.playerInteractManager.getGameMode(), CraftChatMessage.fromString(name)[0]));

                    PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn(entity);

                    Set<PlayerConnection> players = Bukkit.getOnlinePlayers().stream()

                            .filter(Predicate.isEqual(player).negate()).map(CraftPlayer.class::cast)
                            .map(CraftPlayer::getHandle).map(p -> p.playerConnection).collect(Collectors.toSet());

                    players.forEach(c -> c.sendPacket(despawn));
                    players.forEach(c -> c.sendPacket(removeProfile));

                    synchronized (this) {
                        wait(125L);
                    }

                    players.forEach(c -> c.sendPacket(info));

                    players.forEach(c -> c.sendPacket(spawn));

                    List<Player> l = new ArrayList<Player>();
                    for (Player p : Bukkit.getOnlinePlayers()) {
                        l.add(p);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    @SuppressWarnings("deprecation")
    public static void updateSkin(Player p) {
        try {
            if (!p.isOnline())
                return;

            CraftPlayer cp = (CraftPlayer) p;
            EntityPlayer ep = cp.getHandle();
            int entId = ep.getId();

            PacketPlayOutPlayerInfo removeInfo = new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.REMOVE_PLAYER, ep);

            PacketPlayOutEntityDestroy removeEntity = new PacketPlayOutEntityDestroy(entId);

            PacketPlayOutNamedEntitySpawn addNamed = new PacketPlayOutNamedEntitySpawn(ep);

            PacketPlayOutPlayerInfo addInfo = new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.ADD_PLAYER, ep);

            PacketPlayOutRespawn respawn = new PacketPlayOutRespawn(
                    ep.getWorld().worldProvider.getDimensionManager().getDimensionID(), ep.getWorld().getDifficulty(),
                    ep.getWorld().worldData.getType(), EnumGamemode.getById(p.getGameMode().getValue()));

            PacketPlayOutEntityEquipment itemmainhand = new PacketPlayOutEntityEquipment(entId, EnumItemSlot.MAINHAND,
                    CraftItemStack.asNMSCopy(p.getInventory().getItemInMainHand()));
            PacketPlayOutEntityEquipment itemoffhand = new PacketPlayOutEntityEquipment(entId, EnumItemSlot.OFFHAND,
                    CraftItemStack.asNMSCopy(p.getInventory().getItemInOffHand()));

            PacketPlayOutEntityEquipment helmet = new PacketPlayOutEntityEquipment(entId, EnumItemSlot.HEAD,
                    CraftItemStack.asNMSCopy(p.getInventory().getHelmet()));

            PacketPlayOutEntityEquipment chestplate = new PacketPlayOutEntityEquipment(entId, EnumItemSlot.CHEST,
                    CraftItemStack.asNMSCopy(p.getInventory().getChestplate()));

            PacketPlayOutEntityEquipment leggings = new PacketPlayOutEntityEquipment(entId, EnumItemSlot.LEGS,
                    CraftItemStack.asNMSCopy(p.getInventory().getLeggings()));

            PacketPlayOutEntityEquipment boots = new PacketPlayOutEntityEquipment(entId, EnumItemSlot.FEET,
                    CraftItemStack.asNMSCopy(p.getInventory().getBoots()));

            PacketPlayOutHeldItemSlot slot = new PacketPlayOutHeldItemSlot(p.getInventory().getHeldItemSlot());

            for (Player pOnline : ((CraftServer) Bukkit.getServer()).getOnlinePlayers()) {
                final CraftPlayer craftOnline = (CraftPlayer) pOnline;
                PlayerConnection con = craftOnline.getHandle().playerConnection;
                if (pOnline.getName().equals(p.getName())) {
                    con.sendPacket(removeInfo);
                    con.sendPacket(addInfo);
                    con.sendPacket(respawn);
                    con.sendPacket(slot);
                    craftOnline.updateScaledHealth();
                    craftOnline.getHandle().triggerHealthUpdate();
                    craftOnline.updateInventory();
                    Bukkit.getScheduler().runTask(Main.getPlugin(Main.class), new Runnable() {

                        @Override
                        public void run() {
                            craftOnline.getHandle().updateAbilities();
                        }

                    });
                    continue;
                }
                if (pOnline.canSee(p)) {
                    con.sendPacket(removeEntity);
                    con.sendPacket(removeInfo);
                    con.sendPacket(addInfo);
                    con.sendPacket(addNamed);
                    con.sendPacket(itemmainhand);
                    con.sendPacket(itemoffhand);
                    con.sendPacket(helmet);
                    con.sendPacket(chestplate);
                    con.sendPacket(leggings);
                    con.sendPacket(boots);
                }
            }
        } catch (Exception e) {
        }

    }

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

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

}