Java 类org.bukkit.enchantments.Enchantment 实例源码

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onEnchantItem(EnchantItemEvent event) {
    Map<Enchantment, Integer> adding = event.getEnchantsToAdd();
    Iterator<Map.Entry<Enchantment, Integer>> iterator = adding.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<Enchantment, Integer> entry = iterator.next();
        Enchantment enchantment = entry.getKey();
        int maxLevel = getMaxLevel(enchantment);
        if (entry.getValue() > maxLevel) {
            if (maxLevel > 0) {
                adding.put(enchantment, maxLevel);
            } else {
                iterator.remove();
            }
        }
    }
}

public EnchantedBookCustomItem(Material material, Config config, PlaceholderRegistry placeholders) {
    super(material, config, placeholders);
    storedEnchantments = new HashMap<>();

    if (config.has("stored-enchantments")) {
        Map<String, Object> stEnch = config.getMap("stored-enchantments");

        for(Map.Entry<String, Object> e : stEnch.entrySet()) {
            Enchantment ench = Enchantment.getByName(e.getKey().replace(' ', '_').toUpperCase(Locale.ENGLISH));
            if (ench == null)
                Uppercore.logger().severe("Cannot find enchantment: " + e.getKey());
            else
                storedEnchantments.put(ench, PlaceholderValue.intValue(e.getValue().toString()));
        }
    }
}

public static Enchantment getGlow() {
    if (glow != null)
        return glow;

    try {
        Field f = Enchantment.class.getDeclaredField("acceptingNew");
        f.setAccessible(true);
        f.set(null, true);
    } catch (Exception e) {
        e.printStackTrace();
    }

    glow = new EnchantGlow(255);
    Enchantment.registerEnchantment(glow);
    return glow;
}

@EventHandler
public void onQuit(PlayerQuitEvent event) {
    // Removing Speed Miner effect
    if(speedMiner.get(event.getPlayer().getName()) != null) {
        speedMiner.get(event.getPlayer().getName()).removeEnchantment(Enchantment.DIG_SPEED);
        event.getPlayer().removePotionEffect(PotionEffectType.FAST_DIGGING);
        event.getPlayer().removePotionEffect(PotionEffectType.SPEED);
        speedMiner.remove(event.getPlayer().getName());
    }
    // Removing Rainbow Miner effect
    if(rainbowMiner.get(event.getPlayer().getName()) != null) {
        rainbowMiner.get(event.getPlayer().getName()).removeEnchantment(Enchantment.LOOT_BONUS_BLOCKS);
        event.getPlayer().removePotionEffect(PotionEffectType.FAST_DIGGING);
        rainbowMiner.remove(event.getPlayer().getName());
    }
    // Removing Diamond Miner effect
    if(diamondMiner.get(event.getPlayer().getName()) != null) {
        diamondMiner.remove(event.getPlayer().getName());
    }
    // Quiting challenge in case player is doing it
    if(plugin.getChallenges().getChallenge(event.getPlayer()) > 0){
        plugin.getChallenges().quitChallenge(event.getPlayer());
    }
    plugin.getPlayerManager().saveData(event.getPlayer());
}

/**
 * Get the final {@link ItemStack} with all the attributes you have been adding
 *
 * @return the {@link ItemStack} of this {@link ItemBuilder}
 */
@Override
public ItemStack build() {
    ItemStack s = new ItemStack(this.getMaterial());
    s.setAmount(this.getAmount());
    s.setDurability(this.getDamage());
    LeatherArmorMeta m = (LeatherArmorMeta) s.getItemMeta();

    for (ItemFlag iflag : this.getAllItemflags()) {
        m.addItemFlags(iflag);
    }
    m.setDisplayName(this.getName());
    m.setLore(this.getLore());
    m.setColor(color);
    s.setItemMeta(m);
    for (Map.Entry<Enchantment, Integer> temp : this.getAllEnchantments().entrySet()) {
        s.addUnsafeEnchantment(temp.getKey(), temp.getValue());
    }
    return s;
}

CraftMetaItem(CraftMetaItem meta) {
    if (meta == null) {
        attributes = null;
        return;
    }

    this.displayName = meta.displayName;

    if (meta.hasLore()) {
        this.lore = new ArrayList<String>(meta.lore);
    }

    if (meta.hasEnchants()) {
        this.enchantments = new HashMap<Enchantment, Integer>(meta.enchantments);
    }

    this.repairCost = meta.repairCost;
    this.attributes = meta.attributes;
}

/**
 * Register all of our custom enchants.
 */
private static void registerEnchants() {

    // Tell bukkit it's ok to register new enchants.
    try {
        Field f = Enchantment.class.getDeclaredField("acceptingNew");
        f.setAccessible(true);
        f.set(null, true);
    } catch (Exception e) {
        e.printStackTrace();
    }

    // Register each enchant.
    for (CustomEnchant ce : CustomEnchant.values())
        Enchantment.registerEnchantment(ce.getEnchant());
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onPlayerInteract(PlayerInteractEvent event) {
    if (event.getAction() == Action.LEFT_CLICK_BLOCK && event.hasItem()) {
        // The player didn't click an enchantment table, Creative players will instantly destroy.
        Player player = event.getPlayer();
        if (event.getClickedBlock().getType() == Material.ENCHANTMENT_TABLE && player.getGameMode() != GameMode.CREATIVE) {

            // The player didn't click with an enchanted book.
            ItemStack stack = event.getItem();
            if (stack != null && stack.getType() == Material.ENCHANTED_BOOK) {
                ItemMeta meta = stack.getItemMeta();
                if (meta instanceof EnchantmentStorageMeta) {
                    EnchantmentStorageMeta enchantmentStorageMeta = (EnchantmentStorageMeta) meta;
                    for (Enchantment enchantment : enchantmentStorageMeta.getStoredEnchants().keySet()) {
                        enchantmentStorageMeta.removeStoredEnchant(enchantment);
                    }

                    event.setCancelled(true);
                    player.setItemInHand(EMPTY_BOOK);
                    player.sendMessage(ChatColor.GREEN + "You reverted this item to its original form.");
                }
            }
        }
    }
}

public void run(PAUser user, String label, String[] args) {
    if (args.length == 2) {
        ItemStack i = user.getPlayer().getInventory().getItemInHand();

        Enchantment enchantment;
        int level;

        if (!Utils.isInt(args[1])) return;
        enchantment = getEnchantment(args[0]);
        level = Integer.parseInt(args[1]);

        if (enchantment == null) return;

        i.addUnsafeEnchantment(enchantment, level);
    }
}

public static String serialize(ItemStack item) {
    String name = item.getType().name().toLowerCase();
    String data = "";
    if (item.getDurability() != (short) 0)
        data = ":" + item.getDurability();

    String amount = "";
    if (item.getAmount() > 1)
        amount = "," + item.getAmount();

    String ench = "";
    if (item.getEnchantments().size() > 0) {
        for (Entry<Enchantment, Integer> e : item.getEnchantments().entrySet()) {
            ench += e.getKey().getName().toLowerCase() + ":" + e.getValue() + ",";
        }
        ench = ench.substring(ench.length() - 1);
    }

    return name + data + amount + ench;     
}

@Override
public void start() {
    if (!kitsDir.exists()) {
        log.info("Kits dir doesn't exist, creating....");
        kitsDir.mkdirs();
    }

    File[] files = kitsDir.listFiles();
    if (files != null) {
        for (File file : files) {
            if (file.getName().endsWith(".json")) {
                availableKits.add(file.getName().replace(".json", ""));
            }
        }
    }
    log.info("There are " + availableKits.size() + " kits available.");

    // test stuff
    Kit kit = new Kit("DefaultKit");
    kit.addItem(0, new ItemBuilder(Material.STONE).name("Test Stone").build());
    kit.addItem(1, new ItemBuilder(Material.DIAMOND_SWORD).enchantment(Enchantment.DAMAGE_ALL, 5).name(ChatColor.RED + "Cool sword").amount(2).build());
    kit.addItem(2, new ItemBuilder(Material.LEATHER_BOOTS).enchantment(Enchantment.PROTECTION_EXPLOSIONS, 2).enchantment(Enchantment.PROTECTION_FALL, 5).name("Cool bots").amount(3).color(Color.RED).durability(10).lore("test").lore("Lore").build());
    createKit(kit);
    kit = loadKit("DefaultKit", new File(kitsDir, kit.getName() + ".json"));
    System.out.println(kit);
}

public static void setVale(Player player, int amount) throws SQLException {
    UUID uuid = player.getUniqueId();
    PreparedStatement stmt = plugin.getDb().getConnection().prepareStatement("UPDATE vale_eco SET amount = "+amount+" WHERE uuid = '"+uuid.toString()+"'");
    stmt.executeUpdate();

    ItemStack item = new ItemStack(Material.EMERALD, 1);
    ItemMeta meta = item.getItemMeta();
    meta.setDisplayName(ChatColor.GREEN.toString() + getVale(player) + (getVale(player)==1?" Vale":" Vales"));
    meta.addEnchant(Enchantment.LUCK, 1, true);
    meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
    item.setItemMeta(meta);
    if(plugin.getConfig().getString("valeitemininv").equals("true")){
        player.getInventory().setItem(8, item);
    }

}

public static ItemStack getRandomEnchant(List<Enchantment>enchants, int amount){
    ItemStack result = new ItemStack(Material.ENCHANTED_BOOK);
    List<Enchantment>left = new ArrayList<Enchantment>(enchants);
    EnchantmentStorageMeta meta = (EnchantmentStorageMeta) result.getItemMeta();
    if(amount > left.size())
        amount = left.size();
    for(int i = 0 ; i < amount && !left.isEmpty() ; i++){
        Enchantment e = VanillaPlusCore.getRandom(left);
        left.remove(e);
        int level = VanillaPlusCore.getRandom().nextInt(100);
        level = level % (e.getMaxLevel()+1-e.getStartLevel())+e.getStartLevel();
        meta.addStoredEnchant(e, level, false);
    }
    result.setItemMeta(meta);
    return result;
}

private void updateVoting(int slot) {
    Bukkit.getOnlinePlayers().forEach(player -> {
        ItemStack itemStack = player.getInventory().getItem(slot);
        itemStack.setAmount(getVotes(slot));
        if(votes.containsKey(player)) {
            for(int i=2; i<7; i++) {
                ItemStack temp = player.getInventory().getItem(i);
                if(temp != null) {
                    if(temp.getType() != Material.AIR) {
                        if(slots.get(i) != votes.get(player)) {
                            if(temp.getEnchantments().containsKey(Enchantment.DURABILITY)) {
                                temp.removeEnchantment(Enchantment.DURABILITY);
                            }
                            player.getInventory().setItem(i, temp);
                        } else {
                            temp.addUnsafeEnchantment(Enchantment.DURABILITY, 1);
                            player.getInventory().setItem(i, temp);
                        }
                    }
                }
            }
        }
    });
}

/**
 *
 * @param e BlockBreakEvent
 * @since 4.2.0
 */
@EventHandler
public void onBlockBreak(BlockBreakEvent e) {
    List<ItemStack> drops = new ArrayList<ItemStack>();
    ItemStack item = e.getPlayer().getInventory().getItemInMainHand();
    int fortune = 1;

    if (item != null) {
        if (item.getEnchantments().containsKey(Enchantment.LOOT_BONUS_BLOCKS) && !item.getEnchantments().containsKey(Enchantment.SILK_TOUCH)) {
            fortune = SlimefunStartup.randomize(item.getEnchantmentLevel(Enchantment.LOOT_BONUS_BLOCKS) + 2) - 1;
            if (fortune <= 0) fortune = 1;
            fortune = (e.getBlock().getType() == Material.LAPIS_ORE ? 4 + SlimefunStartup.randomize(5) : 1) * (fortune + 1);
        }

        if (!item.getEnchantments().containsKey(Enchantment.SILK_TOUCH) && e.getBlock().getType().toString().endsWith("_ORE")) {
            if (Talisman.checkFor(e, SlimefunItem.getByID("MINER_TALISMAN"))) {
                if (drops.isEmpty()) drops = (List<ItemStack>) e.getBlock().getDrops();
                for (ItemStack drop : new ArrayList<ItemStack>(drops)) {
                    if (!drop.getType().isBlock()) drops.add(new CustomItem(drop, fortune * 2));
                }
            }
        }
    }
}

/**
 * Applies the provided enchantment to the item.
 * @param enchantment
 * @param level
 * @return this
 */
public ItemBuilder enchant(Enchantment enchantment, int level)
{
    if(enchantment == null)
        return this;
    if(level <= 0)
    {
        enchantments.remove(enchantment);
        return this;
    }

    if(enchantments == null)
        enchantments = new HashMap<>();
    enchantments.put(enchantment, level);
    return this;
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onPlayerFish(PlayerFishEvent event) {
    double amount = event.getExpToDrop();
    if (amount > 0) {
        amount = Math.ceil(amount * SettingsYML.EXP_MULTIPLIER_FISHING);
        ProjectileSource projectileSource = event.getHook().getShooter();
        if (projectileSource instanceof Player) {
            ItemStack stack = ((Player) projectileSource).getItemInHand();
            int enchantmentLevel = stack.getEnchantmentLevel(Enchantment.LUCK);
            if (enchantmentLevel > 0L) {
                amount = Math.ceil(amount * (enchantmentLevel * SettingsYML.EXP_MULTIPLIER_LUCK_PER_LEVEL));
            }
        }

        event.setExpToDrop((int) amount);
    }
}

/**
 * Get the final {@link ItemStack} with all the attributes you have been adding
 *
 * @return the {@link ItemStack} out of this {@link ItemBuilder}
 */
public ItemStack build() {
    ItemStack s = new ItemStack(material);
    s.setAmount(amount);
    s.setDurability(damage);
    ItemMeta m = s.getItemMeta();

    for (ItemFlag iflag : itemflags)
        m.addItemFlags(iflag);
    m.setDisplayName(name);
    m.setLore(lore);
    s.setItemMeta(m);
    for (Map.Entry<Enchantment, Integer> temp : enchantments.entrySet())
        s.addUnsafeEnchantment(temp.getKey(), temp.getValue());

    for (ItemData id : getAllData())
        try {
            id.applyOn(s);
        } catch (WrongDataException e) {
            e.printStackTrace();
        }

    return s;
}

/**
 * Copy an inventory and open it for player
 *
 * @param i Inventory to open
 * @param p Player that needs the inventory
 */
public static void openFakeInv(Inventory i, OMGPlayer p) {
    Inventory fake = Bukkit.createInventory(p.bukkit, i.getSize(), i.getTitle());
    for (int slot = 0; slot < i.getContents().length; slot++) {
        ItemStack e = i.getContents()[slot];
        if (e != null) {
            e = e.clone();
            ItemMeta im = e.getItemMeta();
            im.addItemFlags(ItemFlag.HIDE_ATTRIBUTES);
            im.addItemFlags(ItemFlag.HIDE_ENCHANTS);
            if ((NBTParser.getTagCompound(e).hasKey("kitid") && NBTParser.getTagCompound(e).getString("kitid").equals(p.kit.name)) || (NBTParser.getTagCompound(e).hasKey("teamid") && NBTParser.getTagCompound(e).getString("teamid").equals(p.requestedTeam.id)))
                im.addEnchant(Enchantment.DURABILITY, 1, true);
            if (NBTParser.getTagCompound(e).hasKey("kitid")) {
                ItemStack finalE = e;
                OMGKit.kits.stream().filter(k -> k.getName().equals(NBTParser.getTagCompound(finalE).getString("kitid"))).forEach(k -> {
                    List<String> ss = im.hasLore() ? im.getLore() : new ArrayList<>();
                    ss.add(ChatColor.GREEN + "Can use: " + (OMGPI.g.player_hasKit(p, k) ? (ChatColor.GREEN + "YES") : (ChatColor.RED + "NO")));
                    im.setLore(ss);
                });
            }
            e.setItemMeta(im);
            fake.setItem(slot, e);
        }
    }
    p.bukkit.openInventory(fake);
}

private void initInv(String name){
    balanceFichas = Bukkit.createInventory(null, 9, ChatColor.AQUA + "Fichas");

    String cf1 = files.getDouble(name + "." + "FICHA_1") + " fichas";
    String cf2 = files.getDouble(name + "." + "FICHA_10") + " fichas";
    String cf3 = files.getDouble(name + "." + "FICHA_50") + " fichas";
    String cf4 = files.getDouble(name + "." + "FICHA_100") + " fichas";
    String cf5 = files.getDouble(name + "." + "FICHA_200") + " fichas";
    String cf6 = files.getDouble(name + "." + "FICHA_500") + " fichas";
    String cf7 = files.getDouble(name + "." + "BASURA_1") + " fichas";
    String cf8 = files.getDouble(name + "." + "BASURA_2") + " fichas";
    String cf9 = files.getDouble(name + "." + "BASURA_3") + " fichas";

    balanceFichas.setItem(0, new ItemMaker(Material.WOOL).setDisplayName(ChatColor.WHITE + "Ficha " + ChatColor.GREEN + "1$").setLores(ChatColor.GREEN + cf1).setDurability(f1).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(1, new ItemMaker(Material.WOOL).setDisplayName(ChatColor.WHITE + "Ficha " + ChatColor.AQUA + "10$").setLores(ChatColor.GREEN + cf2).setDurability(f2).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(2, new ItemMaker(Material.WOOL).setDisplayName(ChatColor.WHITE + "Ficha " + ChatColor.GOLD + "50$").setLores(ChatColor.GREEN + cf3).setDurability(f3).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(3, new ItemMaker(Material.WOOL).setDisplayName(ChatColor.WHITE + "Ficha " + ChatColor.YELLOW + "100$").setLores(ChatColor.GREEN + cf4).setDurability(f4).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(4, new ItemMaker(Material.WOOL).setDisplayName(ChatColor.WHITE + "Ficha " + ChatColor.RED + "200$").setLores(ChatColor.GREEN + cf5).setDurability(f5).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(5, new ItemMaker(Material.WOOL).setDisplayName(ChatColor.WHITE + "Ficha " + ChatColor.GRAY + "500$").setLores(ChatColor.GREEN + cf6).setDurability(f6).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(6, new ItemMaker(Material.ROTTEN_FLESH).setDisplayName(ChatColor.LIGHT_PURPLE + "Carne Podrida").setLores(ChatColor.GREEN + cf7).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(7, new ItemMaker(Material.STRING).setDisplayName(ChatColor.LIGHT_PURPLE + "Cuerda").setLores(ChatColor.GREEN + cf8).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
    balanceFichas.setItem(8, new ItemMaker(Material.DIRT).setDisplayName(ChatColor.LIGHT_PURPLE + "Tierra").setLores(ChatColor.GREEN + cf9).addUnsafeEnchant(Enchantment.ARROW_INFINITE, 1).build());
}

public static ItemStack formButton(Faction faction, Resource resource) {
    ItemStack icon = resource.getIcon();
    ItemMeta meta = icon.getItemMeta();
    SaturationLevel level = faction.isResourceSaturated(resource);
    if (level == SaturationLevel.SURPLUS) {
        meta.addEnchant(Enchantment.LUCK, 1, true);
        meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
    }
    meta.setDisplayName(level.getColor() + resource.getName());
    ArrayList<String> lore = new ArrayList<>();
    lore.add(ProgressBar.getBar((double) faction.getSaturatedResources().get(resource)));
    lore.add(level.getColor().toString() + faction.getSaturatedResources().get(resource) + "%");
    String population = String.valueOf(faction.getPopulation());
    String units = String.valueOf(faction.getDemand(resource));
    lore.add(FMessage.POPULATION_REQUIRED.getMessage(population, units, resource.getName()));
    lore.add(FMessage.POPULATION_GRANTING1.getMessage());
    lore.add(FMessage.POPULATION_GRANTING2.getMessage(String.valueOf(faction.getConsumableResources().get(resource)), resource.getName()));
    meta.setLore(lore);
    icon.setItemMeta(meta);
    return icon;
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onEnchantItem(EnchantItemEvent event) {
    Map<Enchantment, Integer> adding = event.getEnchantsToAdd();
    Iterator<Map.Entry<Enchantment, Integer>> iterator = adding.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<Enchantment, Integer> entry = iterator.next();
        Enchantment enchantment = entry.getKey();
        int maxLevel = getMaxLevel(enchantment);
        if (entry.getValue() > maxLevel) {
            if (maxLevel > 0) {
                adding.put(enchantment, maxLevel);
            } else {
                iterator.remove();
            }
        }
    }
}

public static long calcSurvivalFastBreak(ItemStack tool, Material block) {
    if (isInstantBreak(block) || (tool.getType() == Material.SHEARS && block == Material.LEAVES)) {
        return 0;
    }
    double bhardness = BlockHardness.getBlockHardness(block);
    double thardness = ToolHardness.getToolHardness(tool.getType());
    long enchantlvl = (long) tool.getEnchantmentLevel(Enchantment.DIG_SPEED);

    long result = Math.round((bhardness * thardness) * 0.10 * 10000);

    if (enchantlvl > 0) {
        result /= enchantlvl * enchantlvl + 1L;
    }

    result = result > 25000 ? 25000 : result < 0 ? 0 : result;

    if (isQuickCombo(tool, block)) {
        result = result / 2;
    }

    return result;
}

public Map<Enchantment, Integer> parseEnchantments(Element el, String name) throws InvalidXMLException {
    Map<Enchantment, Integer> enchantments = Maps.newHashMap();

    Node attr = Node.fromAttr(el, name, StringUtils.pluralize(name));
    if(attr != null) {
        Iterable<String> enchantmentTexts = Splitter.on(";").split(attr.getValue());
        for(String enchantmentText : enchantmentTexts) {
            int level = 1;
            List<String> parts = Lists.newArrayList(Splitter.on(":").limit(2).split(enchantmentText));
            Enchantment enchant = XMLUtils.parseEnchantment(attr, parts.get(0));
            if(parts.size() > 1) {
                level = XMLUtils.parseNumber(attr, parts.get(1), Integer.class);
            }
            enchantments.put(enchant, level);
        }
    }

    for(Element elEnchantment : el.getChildren(name)) {
        Pair<Enchantment, Integer> entry = parseEnchantment(elEnchantment);
        enchantments.put(entry.first, entry.second);
    }

    return enchantments;
}

@Before
public void setUp() {
    MockitoAnnotations.initMocks(this);

    //Tool Stubbs
    doReturn(0).when(tool).getEnchantmentLevel(Enchantment.LOOT_BONUS_BLOCKS);
    doReturn(Material.DIAMOND_PICKAXE).when(tool).getType();
    doReturn((short) 0).when(tool).getDurability(); 
    doReturn(true).when(tool).hasItemMeta();
    doReturn(itemMeta).when(tool).getItemMeta();

    doReturn(tool).when(inventory).getItemInMainHand(); 
    doReturn(inventory).when(player).getInventory(); 

    doReturn(true).when(tool).hasItemMeta();
    doReturn(itemMeta).when(tool).getItemMeta();
    when(tool.getDurability()).thenReturn((short) 5);

    lore = new ArrayList<String>();
    lore.add(ChatColor.GOLD + "Explosive I");
    doReturn(lore).when(itemMeta).getLore();
    doReturn(true).when(itemMeta).hasLore();
}

@EventHandler
public void onCraftItem(CraftItemEvent event)
{
    if (event.getRecipe().getResult().getType() == Material.DIAMOND_PICKAXE)
    {
        ItemStack pickaxe = new ItemStack(Material.DIAMOND_PICKAXE, 1);
        pickaxe.addEnchantment(Enchantment.DIG_SPEED, 3);

        event.getInventory().setResult(pickaxe);

        this.plugin.getServer().getScheduler().runTaskLater(this.plugin, () ->
        {
            for (ItemStack stack : event.getWhoClicked().getInventory().getContents())
                if (stack != null && stack.getType() == Material.DIAMOND_PICKAXE && !stack.containsEnchantment(Enchantment.DIG_SPEED))
                    stack.addEnchantment(Enchantment.DIG_SPEED, 3);
        }, 5L);
    }
}

private void addCategoriesToInventory(Inventory inventory, Player player) {
    for (MerchantCategory category : this.categories) {
        if (category.getMaterial() == null) {
            Main.getInstance()
                    .getServer()
                    .getConsoleSender()
                    .sendMessage(
                            ChatWriter
                                    .pluginMessage(ChatColor.RED
                                            + "Careful: Not supported material in shop category '"
                                            + category.getName() + "'"));
        } else if ((player == null)
                || (player.hasPermission(category.getPermission()))) {
            ItemStack is = new ItemStack(category.getMaterial(), 1);
            ItemMeta im = is.getItemMeta();

            if ((this.currentCategory != null)
                    && (this.currentCategory.equals(category))) {
                im.addEnchant(Enchantment.DAMAGE_ALL, 1, true);
            }

            im.setDisplayName(category.getName());
            im.setLore(category.getLores());
            is.setItemMeta(im);

            inventory.addItem(new ItemStack[] { is });
        }
    }
}

@Override
public Map<Enchantment, Integer> getEnchants() {
    Map<Enchantment, Integer> map = new HashMap<>();
    this.enchantments.forEachEntry( new TObjectIntProcedure<Enchantment>() {
        @Override
        public boolean execute( Enchantment enchantment, int i ) {
            map.put( enchantment, i );
            return true;
        }
    } );
    return map;
}

/**
 * Adds an unsafe enchantment
 * @param e the {@link Enchantment} to be added
 * @param val the Enchantment's level
 * @return this ItemBuilder
 */
public ItemBuilder enchant( Enchantment e, int val){
    Validate.notNull( e , "Enchantment is null");
    Validate.notNull( val , "Enchantment Level is null");
    item.addUnsafeEnchantment( e, val );
    return this;
}

public void processMeta(Player player, ItemMeta meta) {
    if (displayName != null)
        meta.setDisplayName(displayName.resolve(player, placeholders));
    meta.setLore(lore.stream().map(m -> m.resolve(player, placeholders)).collect(Collectors.toList()));
    meta.addItemFlags(flags.toArray(new ItemFlag[0]));
    for (Map.Entry<Enchantment, PlaceholderValue<Integer>> ench : enchantments.entrySet())
        meta.addEnchant(ench.getKey(), ench.getValue().resolve(player), true);
}

public ItemStack getItem(Material m, String name, int amount, HashMap<Enchantment, Integer> enchantments, boolean showEnchantments) {
    ItemStack i = new ItemStack(m, amount);
    ItemMeta im = i.getItemMeta();
    for(Enchantment e : enchantments.keySet()) {
        im.addEnchant(e, enchantments.get(e), true);
    }
    if (!showEnchantments) {
        im.addItemFlags(ItemFlag.HIDE_ENCHANTS);
    }
    im.setDisplayName(name);
    i.setItemMeta(im);
    return i;
}

public void setItems(Player p) {
    p.getInventory().setItem(0, new ItemMaker(Material.BOW).addEnchant(Enchantment.ARROW_INFINITE, 1).setUnbreakable().build());

    p.getInventory().setItem(4, new ItemMaker(Material.POTION).setDisplayName("Guerrillero").build());
    p.getInventory().setItem(5, new ItemMaker(Material.SOUL_SAND).setDisplayName("Cadenas").build());

    p.getInventory().setItem(8, new ItemMaker(Material.BLAZE_POWDER).setDisplayName("Fenix").build());

    p.getInventory().setItem(9, new ItemMaker(Material.ARROW).build());

    p.getInventory().setHelmet(new ItemMaker(Material.CHAINMAIL_HELMET).build());
    p.getInventory().setChestplate(new ItemMaker(Material.CHAINMAIL_CHESTPLATE).build());
    p.getInventory().setLeggings(new ItemMaker(Material.CHAINMAIL_LEGGINGS).build());
    p.getInventory().setBoots(new ItemMaker(Material.CHAINMAIL_BOOTS).build());
}

public static ItemStack createItem(Material material, String name, List<String> lore, List<Enchantment> enchantments) {
    ItemStack itemStack = createItem(material, name, lore);
    for (Enchantment enchantment : enchantments) {
        if (itemStack.getEnchantments().containsKey(enchantment)) {
            itemStack.getEnchantments().put(enchantment, itemStack.getEnchantmentLevel(enchantment));
        } else {
            itemStack.getEnchantments().put(enchantment, 1);
        }
    }
    return itemStack;
}

public static ItemStack createItem(Material material, List<Enchantment> enchantments) {
    ItemStack itemStack = createItem(material);
    for (Enchantment enchantment : enchantments) {
        if (itemStack.getEnchantments().containsKey(enchantment)) {
            itemStack.getEnchantments().put(enchantment, itemStack.getEnchantmentLevel(enchantment));
        } else {
            itemStack.addEnchantment(enchantment, 1);
        }
    }
    return itemStack;
}

@Override
public int getEnchantmentLevel(Enchantment ench) {
    Validate.notNull(ench, "Cannot find null enchantment");
    if (handle == null) {
        return 0;
    }
    return net.minecraft.enchantment.EnchantmentHelper.getEnchantmentLevel(ench.getId(), handle);
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onBlockBreak(final BlockBreakEvent event) {
    final Player player = event.getPlayer();
    if(player.getGameMode() == GameMode.CREATIVE) {
        return;
    }
    if(player.getItemInHand().getEnchantments().containsKey(Enchantment.SILK_TOUCH)) return;;
    final Block block = event.getBlock();
    final Location blockLocation = block.getLocation();
    if(block.getType() == FoundDiamondsListener.SEARCH_TYPE && this.foundLocations.add(blockLocation.toString())) {
        int count = 1;
        for(int x = -5; x < 5; ++x) {
            for(int y = -5; y < 5; ++y) {
                for(int z = -5; z < 5; ++z) {
                    final Block otherBlock = blockLocation.clone().add((double) x, (double) y, (double) z).getBlock();
                    if(!otherBlock.equals(block) && otherBlock.getType() == FoundDiamondsListener.SEARCH_TYPE && this.foundLocations.add(otherBlock.getLocation().toString())) {
                        ++count;
                    }
                }
            }
        }

        String message;
        for(Player on : Bukkit.getOnlinePlayers()) {
            if(plugin.getFactionManager().getPlayerFaction(player.getUniqueId()) != null) {
                 message = plugin.getFactionManager().getPlayerFaction(player.getUniqueId()).getRelation(on).toChatColour() + player.getName() + ChatColor.GRAY + " has found " + ChatColor.AQUA + count + ChatColor.GRAY + " diamond(s).";
                on.sendMessage(message);
            }else{
                message = ChatColor.AQUA + "[" + ChatColor.GRAY + "♠" + ChatColor.AQUA + "]" + ChatColor.GRAY + " " + ChatColor.AQUA + player.getName() + ChatColor.GRAY + " has just spotted " + ChatColor.BLUE + count + ChatColor.GRAY +" diamonds!";
                on.sendMessage(message);
            }
        }
    }
}

public ItemBuilder enchant(Object... args) {
    metaProcessors.add(meta ->
            new VarargsParser(args).parse(section ->
                    meta.addEnchant(
                            section.<Enchantment>get(0),
                            section.<Integer>get(1),
                            false
                    )));
    return this;
}

private void addEnchantments(String enchantments, String level, ItemStack is) {
    try {
    if (enchantments == null || level == null)
        return;

    ArrayList<String> enchants = new ArrayList<String>(Arrays.asList(enchantments.split("!")));
    ArrayList<String> levels = new ArrayList<String>(Arrays.asList(level.split("!")));

    if (enchantments.isEmpty())
        return;

    for (int i = 0; i < enchants.size(); i++) {
        if (!enchants.get(i).equalsIgnoreCase(" ") && !enchants.get(i).equalsIgnoreCase("")) {
            if (is.getType() == Material.ENCHANTED_BOOK) {
                EnchantmentStorageMeta meta = (EnchantmentStorageMeta) is.getItemMeta();
                meta.addStoredEnchant(Enchantment.getByName(enchants.get(i)), Integer.parseInt(levels.get(i)), true);

                is.setItemMeta(meta);
            } else
                is.addEnchantment(Enchantment.getByName(enchants.get(i)), Integer.parseInt(levels.get(i)));
        }
    }

    enchants.clear();
    levels.clear();
    } catch(Exception e) {
        if(e instanceof java.lang.IllegalArgumentException) {
        Logger.ERROR.log("couldn't add enchantment " + enchantments + " level " + level + " to " + is.getType().toString());
        Logger.ERROR.log("Cause: java.lang.IllegalArgumentException");
        } else {
        e.printStackTrace();
        }
    }
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onConsume(PlayerInteractEvent e) {
    SurvivalUser u = PASurvival.getPlayer(e.getPlayer());

    if (e.getItem() == null) return;

    if (e.getItem().getType() == Material.BREAD && e.getItem().hasItemMeta()) {
        if (e.getItem().getEnchantments().keySet().contains(Enchantment.ARROW_DAMAGE)) {
            String name = ChatColor.stripColor(e.getItem().getItemMeta().getDisplayName());
            ItemStack i = u.getPlayer().getInventory().getItemInMainHand();

            if (u.getPlayer().getFoodLevel() >= 20) return;

            if (name.equalsIgnoreCase("Bocadillo de Jamón")) {
                if (u.getPlayer().getFoodLevel() + 5 > 20) {
                    u.getPlayer().setFoodLevel(20);
                } else {
                    u.getPlayer().setFoodLevel(u.getPlayer().getFoodLevel() + 5);
                }
                u.getPlayer().setSaturation(3F);
                i.setAmount(i.getAmount() - 1);
                u.getPlayer().getInventory().setItemInMainHand(i);
            }

            if (name.equalsIgnoreCase("Hamburguesa Artesana")) {
                if (u.getPlayer().getFoodLevel() + 6 > 20) {
                    u.getPlayer().setFoodLevel(20);
                } else {
                    u.getPlayer().setFoodLevel(u.getPlayer().getFoodLevel() + 6);
                }
                u.getPlayer().setSaturation(4F);
                i.setAmount(i.getAmount() - 1);
                u.getPlayer().getInventory().setItemInMainHand(i);
            }
        }
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onBlockBreak(final BlockBreakEvent event) {
    Player player = event.getPlayer();
    if (player.getGameMode() != GameMode.CREATIVE) {
        if (player.hasPermission("hcf.listener.autosmeltore")) {
            ItemStack stack = player.getItemInHand();
            if (stack != null && stack.getType() != Material.AIR
                    && !stack.containsEnchantment(Enchantment.SILK_TOUCH)) {
                Block block = event.getBlock();
                Material dropType = null;
                switch (block.getType()) {
                    case IRON_ORE: {
                        dropType = Material.IRON_INGOT;
                        break;
                    }
                    case GOLD_ORE: {
                        dropType = Material.GOLD_INGOT;
                        break;
                    }
                    default: {
                        return;
                    }
                }
                 Location location = block.getLocation();
                 World world = location.getWorld();
                 ItemStack drop = new ItemStack(dropType, 1);
                world.dropItemNaturally(location, drop);
                block.setType(Material.AIR);
                block.getState().update();
            }
        }
    }
}