Hide enchantments on worn inventory, but keep them enabled otherwise.

ExampleMod.java

package com.comphenix.example;

import java.util.Arrays;

import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.CraftingInventory;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryView;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.plugin.java.JavaPlugin;
import com.comphenix.protocol.Packets;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.ConnectionSide;
import com.comphenix.protocol.events.PacketAdapter;
import com.comphenix.protocol.events.PacketContainer;
import com.comphenix.protocol.events.PacketEvent;
import com.comphenix.protocol.reflect.PrettyPrinter;

public class ExampleMod extends JavaPlugin implements Listener {    
    @Override
    public void onEnable() {
        // Start event listening
        getServer().getPluginManager().registerEvents(this, this);
        
        // Hide all enchantments
        ProtocolLibrary.getProtocolManager().addPacketListener(
                new PacketAdapter(this, ConnectionSide.SERVER_SIDE,
                    Packets.Server.SET_SLOT, Packets.Server.WINDOW_ITEMS) {
                    
            @Override
            public void onPacketSending(PacketEvent event) {
                PacketContainer packet = event.getPacket();

                // Item packets
                switch (event.getPacketID()) {
                    case Packets.Server.SET_SLOT: // Set slot
                        int slotIndex = packet.getIntegers().read(1);
                        
                        if (isValidSlot(slotIndex)) {
                            removeEnchantments(packet.getItemModifier().read(0));
                        }
                        break;

                    case Packets.Server.WINDOW_ITEMS: // Set Window Items
                        ItemStack[] elements = packet.getItemArrayModifier().read(0);

                        for (int i = 0; i < elements.length; i++) {
                            if (elements[i] != null && isValidSlot(i)) {
                                removeEnchantments(elements[i]);
                            }
                        }
                        break;
                }   
            }
        });
    }

    private PlayerInventory getPlayerInventory(InventoryView view) {
        if (view.getTopInventory() instanceof PlayerInventory)
            return (PlayerInventory) view.getTopInventory();
        else if (view.getBottomInventory() instanceof PlayerInventory)
            return (PlayerInventory) view.getBottomInventory();
        else
            return null;
    }
    
    @EventHandler
    public void onInventoryClickEvent(InventoryClickEvent e) throws IllegalAccessException {
        final PlayerInventory playerInventory = getPlayerInventory(e.getView());
        
        if (playerInventory != null) {
            final ItemStack[] preArmor = playerInventory.getArmorContents();

            // See if the armor has changed
            getServer().getScheduler().scheduleSyncDelayedTask(this, new Runnable() {
                @SuppressWarnings("deprecation")
                @Override
                public void run() {
                    final ItemStack[] postArmor = playerInventory.getArmorContents();
                    
                    if (!Arrays.deepEquals(preArmor, postArmor)) {
                        System.out.println("Updating inventory.");
                        
                        // Update the inventory entirely
                        if (playerInventory.getHolder() instanceof Player) {
                            Player player = (Player) playerInventory.getHolder();
                            // Ensure that the inventory is updated
                            player.updateInventory();
                            
                            if (hasItem(player.getItemOnCursor())) {
                                player.setItemOnCursor(player.getItemOnCursor().clone());
                            }
                        } else {
                            throw new IllegalStateException("Unable to update a non-player.");
                        }
                    }
                }
            });
        }
    }
    
    private boolean hasItem(ItemStack stack) {
        return stack != null && stack.getType() != Material.AIR;
    }
    
    /**
     * Determine if this the enchantments, if any, should be removed from the item in this slot.
     * @param slotIndex - index of the slot.
     * @return TRUE if we should, FALSE otherwise.
     */
    private boolean isValidSlot(int slotIndex) {
        // Armor slot
        return (slotIndex >= 5 && slotIndex < 9);
    }
    
    private void removeEnchantments(ItemStack stack) {
        if (stack == null)
            return;

        Object[] copy = stack.getEnchantments().keySet().toArray();

        for (Object enchantment : copy) {
            stack.removeEnchantment((Enchantment) enchantment);
        }
    }
}