Java 类org.bukkit.DyeColor 实例源码

/**
 * Constructor
 *
 * @param game Team based game instance
 * @param name Team's name
 * @param color Team's color
 * @param chatColor Team's color in chat
 */
public SurvivalTeam(SurvivalTeamGame game, String name, DyeColor color, ChatColor chatColor)
{
    this.game = game;
    this.teamName = name;
    this.chatColor = chatColor;
    this.icon = new ItemStack(Material.WOOL, 1, color.getData());
    this.maxSize = game.getPersonsPerTeam();

    this.invited = new ArrayList<>();
    this.players = new HashMap<>();

    SurvivalAPI.get().registerEvent(SurvivalAPI.EventType.WORLDLOADED, () ->
    {
        Scoreboard board = game.getScoreboard();

        this.team = board.registerNewTeam("meow" + chatColor.getChar());
        this.team.setDisplayName(name);
        this.team.setCanSeeFriendlyInvisibles(true);
        this.team.setPrefix(chatColor + "");
        this.team.setSuffix(ChatColor.RESET + "");
    });

}

@SuppressWarnings("unchecked")
public BannerCustomItem(Material material, Config config, PlaceholderRegistry placeholders) {
    super(material, config, placeholders);
    this.baseColor = config.getDye("baseColor");
    Collection<Map<String, Object>> rawPatterns = (Collection<Map<String, Object>>) config.getCollection("patterns");
    patterns = new ArrayList<>();
    if(rawPatterns != null) {
        for (Map<String, Object> p : rawPatterns) {
            Config sub = Config.wrap(p);
            DyeColor color = sub.getDyeRequired("color");
            PatternType type = PatternType.getByIdentifier(sub.getStringRequired("pattern"));
            if (type == null) {
                Uppercore.logger().severe("Cannot find pattern identifier \"" + p.get("pattern") + "\"");
                type = PatternType.BASE;
            }
            patterns.add(new Pattern(color, type));
        }
    }
}

private void registerInventory(Inventory inventory) {
    if (scannedChests.contains(inventory.getHolder())) {
        return;
    }
    scannedChests.add(inventory.getHolder());

    for (ItemStack itemStack : inventory) {
        if (itemStack != null && itemStack.getType() != null) {
            if (itemStack.getType() == Material.WOOL) {
                DyeColor dyeColor = ((Wool) itemStack.getData()).getColor();
                woolChests.put(inventory.getHolder(), dyeColor);
                fillInventoryWithWool(inventory, dyeColor);
            }
        }
    }
}

@EventHandler
public void onWoodBreak(BlockBreakEvent event) {
    final Block b = event.getBlock();
    if (b != null && (b.getType() == Material.LOG || b.getType() == Material.LOG_2)) {
        Material handType = event.getPlayer().getItemInHand().getType();
        if (handType == Material.WOOD_AXE || handType == Material.STONE_AXE || handType == Material.IRON_AXE || handType == Material.GOLD_AXE || handType == Material.DIAMOND_AXE) {
            dataMap.put(b, b.getData());
            b.setType(Material.WOOL);
            b.setData(DyeColor.BLACK.getWoolData());
            Player p = event.getPlayer();
            event.getPlayer().sendMessage("> +1 Woodcutting EXP");
            Location loc = b.getLocation();
            Vector v = p.getLocation().subtract(loc).toVector().normalize().multiply(0.5);
            DropManager.dropItem(new ItemStack(Material.LOG), loc, event.getPlayer().getUniqueId()).setVelocity(v);
            RScheduler.schedule(plugin, () -> {
                b.setType(Material.LOG);
                b.setData(dataMap.getOrDefault(b, (byte) 0));
            }, RTicks.seconds(2));
        }
    }
}

public LobbySelector(WCLobby instance){
    gameSelector = iu.createInventory(9, "&cServidores");

    ItemStack glass = ItemUtils.coloredBlock(DyeColor.ORANGE, "&cWorld&8Crafteros", ItemUtils.ColoredBlock.FLAT_GLASS);

    //Glass
    for (int x = 1; x < 8; x++){
        gameSelector = iu.setItem(gameSelector, x + 9, glass);
        gameSelector = iu.setItem(gameSelector, x + (9 * 4), glass);
    }
    gameSelector = iu.setItem(gameSelector, 18, glass);
    gameSelector = iu.setItem(gameSelector, 27, glass);
    gameSelector = iu.setItem(gameSelector, 26, glass);
    gameSelector = iu.setItem(gameSelector, 35, glass);
    //



}

public MonumentWoolFactoryImpl(@Nullable Boolean required,
                               boolean visible,
                               TeamFactory owner,
                               ProximityMetric woolProximityMetric,
                               ProximityMetric monumentProximityMetric,
                               DyeColor color,
                               Vector location,
                               Region placement,
                               boolean craftable) {

    super(MonumentWoolFactory.makeName(color), required, visible, Optional.of(owner), woolProximityMetric, monumentProximityMetric);
    this.color = color;
    this.location = location;
    this.placement = placement;
    this.craftable = craftable;
    this.visible = visible;
    this.componentName = MonumentWoolFactory.makeComponentName(color);
}

/**
 * Test if the given ItemStack is strictly an enemy wool i.e. not also
 * a wool that the given team can capture.
 */
private boolean isDestroyableWool(ItemStack stack, Competitor team) {
    if(stack == null || stack.getType() != Material.WOOL) {
        return false;
    }

    DyeColor color = ((Wool) stack.getData()).getColor();
    boolean enemyOwned = false;

    for(Goal goal : team.getMatch().needMatchModule(GoalMatchModule.class).getGoals()) {
        if(goal instanceof MonumentWool) {
            MonumentWool wool = (MonumentWool) goal;
            if(wool.isVisible() && !wool.isPlaced() && wool.getDyeColor() == color) {
                if(wool.getOwner() == team) {
                    return false;
                } else {
                    enemyOwned = true;
                }
            }
        }
    }

    return enemyOwned;
}

@EventHandler
public void onProjectileHit(ProjectileHitEvent event)
{
    if (event.getEntity().getType() != EntityType.SNOWBALL || !event.getEntity().hasMetadata("paintball-ball") || !event.getEntity().getMetadata("paintball-ball").get(0).asString().equals(this.uuid.toString()))
        return;

    for (Block block : getNearbyBlocks(event.getEntity().getLocation(), 2))
    {
        if (block.getType() == Material.AIR || block.getType() == Material.SIGN || block.getType() == Material.SIGN_POST || block.getType() == Material.WALL_SIGN)
            continue;

        if (this.isBlockGloballyUsed(block.getLocation()))
            continue;

        SimpleBlock simpleBlock = new SimpleBlock(Material.STAINED_CLAY, DyeColor.values()[new Random().nextInt(DyeColor.values().length)].getWoolData());
        this.addBlockToUse(block.getLocation(), simpleBlock);

        block.setType(simpleBlock.getType());
        block.setData(simpleBlock.getData());
    }

    event.getEntity().remove();
}

@Override
public void change(Event e, Object[] delta, @NotNull Changer.ChangeMode mode) {
    Block b = block.getSingle(e);
    if (b == null) {
        return;
    }
    if (b.getType() == Material.BANNER) {
        Banner banner = ((Banner) b.getState());
        switch (mode) {
            case SET:
                Color c = (Color) delta[0];
                banner.setBaseColor(c.getWoolColor());
                break;
            case RESET:
                banner.setBaseColor(DyeColor.WHITE);
                break;
        }
        banner.update(true, false);
    }

}

@Override
public void change(Event e, Object[] delta, @NotNull Changer.ChangeMode mode) {
    ItemStack i = item.getSingle(e);
    if (i == null) {
        return;
    }
    if (i.getType() == Material.BANNER || i.getType() == Material.SHIELD) {
        BannerMeta meta = ((BannerMeta) i.getItemMeta());
        switch (mode) {
            case SET:
                Color c = (Color) delta[0];
                meta.setBaseColor(c.getWoolColor());
                break;
            case RESET:
                meta.setBaseColor(DyeColor.WHITE);
                break;
        }
        i.setItemMeta(meta);
    }
}

@Override
public void addItems() {
    overlay = true; // We're creating the overlay.
    toBottom();
    if (playerPage > 1) // Add previous page button.
        addItem(Material.EMPTY_MAP, ChatColor.GRAY + "Previous Page",
                "Click here to return to the previous page.").anyClick( e -> setPage(playerPage - 1));

    fillGlass(DyeColor.GRAY);
    if (playerPage < maxPages()) {
        // Add "Next Page" Button
        skipSlots(-1); // Go back an item.
        addItem(Material.EMPTY_MAP, ChatColor.GRAY + "Next Page", "Click here to advance to the next page.")
                .anyClick(e -> setPage(playerPage + 1));
    }

    skipSlots(-8);
    addCustomOverlay();

    setTitle(this.title + " (" + playerPage + " / " + maxPages() + ")"); // Update the title to show the page.
    overlay = false; // We're no longer creating the overlay.
}

@Override
public void addItems() {

    Arrays.stream(Punishments.PunishmentType.values()).forEach(pt ->
        addItem(pt.getIcon(), ChatColor.YELLOW + Utils.capitalize(pt.name()),
                "Click here to punish this", "player for " + ChatColor.YELLOW + pt.getDisplay() + ChatColor.GRAY + ".").anyClick(e -> {
                    target.punish(pt, getPlayer());
                    close();
        }));

    if (!target.getPunishments().isEmpty()) {
        nextRow();
        fillGlass(DyeColor.LIME);
        target.getPunishments().forEach(p ->
            addItem(p.getItem()).anyClick(e ->
                Callbacks.promptConfirm(getPlayer(), () -> {
                    p.setValid(!p.isValid());
                    getPlayer().sendMessage(ChatColor.GRAY + "Punishment toggled.");
                    target.writeData();
                    reconstruct();
                }, null)));
    }
}

public static DyeColor parseDye(String s) {
    if (s == null) return DyeColor.BLACK;
    try {
        return DyeColor.valueOf(s.toUpperCase(Locale.ENGLISH));
    } catch (IllegalArgumentException e) {
        throw new InvalidConfigException("Cannot find dye color: \"" + s + "\"");
    }
}

public WoolObjective(String name, DyeColor color, MatchTeam owner, Region podium) {
    this.name = name;
    this.color = color.getWoolData();
    this.owner = owner;
    this.podium = podium;
    this.chatColor = ColorConverter.convertDyeColorToChatColor(color);
}

private void fillInventoryWithWool(Inventory inventory, DyeColor dyeColor) {
    Wool wool = new Wool(dyeColor);

    for (int i = 0; i < inventory.getSize(); i++) {
        inventory.setItem(i, new ItemStack(wool.getItemType(), 1, (short) 0, wool.getData()));
    }
}

public static ChatColor convertDyeColorToChatColor(DyeColor dye) {
    switch (dye) {
        case WHITE:
            return ChatColor.WHITE;
        case ORANGE:
            return ChatColor.GOLD;
        case MAGENTA:
            return ChatColor.LIGHT_PURPLE;
        case LIGHT_BLUE:
            return ChatColor.BLUE;
        case YELLOW:
            return ChatColor.YELLOW;
        case LIME:
            return ChatColor.GREEN;
        case PINK:
            return ChatColor.RED;
        case GRAY:
            return ChatColor.DARK_GRAY;
        case SILVER:
            return ChatColor.GRAY;
        case CYAN:
            return ChatColor.DARK_AQUA;
        case PURPLE:
            return ChatColor.DARK_PURPLE;
        case BLUE:
            return ChatColor.DARK_BLUE;
        case BROWN:
            return ChatColor.GOLD;
        case GREEN:
            return ChatColor.DARK_GREEN;
        case RED:
            return ChatColor.DARK_RED;
        case BLACK:
            return ChatColor.BLACK;
    }

    return ChatColor.WHITE;
}

public static DyeColor convertChatColorToDyeColor(ChatColor chatColor) {
    switch (chatColor) {
        case WHITE:
            return DyeColor.WHITE;
        case AQUA:
            return DyeColor.LIGHT_BLUE;
        case GOLD:
            return DyeColor.ORANGE;
        case LIGHT_PURPLE:
            return DyeColor.MAGENTA;
        case YELLOW:
            return DyeColor.YELLOW;
        case GREEN:
            return DyeColor.LIME;
        case RED:
            return DyeColor.RED;
        case GRAY:
            return DyeColor.SILVER;
        case DARK_GRAY:
            return DyeColor.GRAY;
        case DARK_AQUA:
            return DyeColor.CYAN;
        case DARK_PURPLE:
            return DyeColor.PURPLE;
        case DARK_BLUE:
            return DyeColor.BLUE;
        case BLUE:
            return DyeColor.BLUE;
        case DARK_GREEN:
            return DyeColor.GREEN;
        case DARK_RED:
            return DyeColor.RED;
        case BLACK:
            return DyeColor.BLACK;
    }

    return DyeColor.WHITE;
}

@Override
public void play(PAUser u) {
    if (isInCooldown(u, getName())) return;

    final Sheep o = (Sheep) spawnEntity(u.getLoc(), EntityType.SHEEP);
    o.setAdult();
    o.setColor(DyeColor.values()[r.nextInt(DyeColor.values().length)]);
    o.setCustomName(Utils.colorize("&dOveja Fiestera"));
    o.setCustomNameVisible(true);
    o.setNoDamageTicks(Integer.MAX_VALUE);
    o.setVelocity(u.getPlayer().getLocation().getDirection().multiply(2));

    PAServer.users.forEach(h -> h.sendSound(Sounds.SHEEP_IDLE));

    bt = plugin.getServer().getScheduler().runTaskTimer(plugin, () -> {
        ColorParser dc = ColorParser.values()[r.nextInt(ColorParser.values().length)];
        o.setColor(dc.getDyeColor());
        o.setCustomName(Utils.colorize(dc.getChatColor() + "Oveja Fiestera"));

        if (count <= 0) {
            PAServer.users.forEach(h -> h.sendSound(Sounds.EXPLODE));
            ParticleEffect.EXPLOSION_HUGE.send(plugin.getServer().getOnlinePlayers(), o.getLocation(), 0, 0, 0, 1, 20, 50);
            o.remove();
            bt.cancel();
            return;
        }
        count--;
    }, 0, 20);
}

public void tickPoison() {
    poisonTicks--;
    Location loc = entity.getLocation().add(0, entity.getEyeHeight() * 0.6, 0);
    BlockData data = new BlockData(Material.STAINED_CLAY, (byte) DyeColor.BLUE.getWoolData());
    RParticles.showWithData(ParticleEffect.BLOCK_CRACK, loc, data, 10);
    double multiplier = 0.001;
    switch (poisonTier) {
        default:
        case 1:
            multiplier = 0.01;
            break;
        case 2:
            multiplier = 0.015;
            break;
        case 3:
            multiplier = 0.020;
            break;
        case 4:
            multiplier = 0.030;
            break;
        case 5:
            multiplier = 0.050;
            break;
    }
    int amount = (int) (multiplier * hp);
    if (amount < 1)
        amount = 1;
    damage(amount, null, DamageType.ENVIRONMENTAL_INSTANT);
}

@SuppressWarnings("deprecation")
@Override
public void setCollarColor(DyeColor dc){
       if (((IWolfPet) pet).isTamed()) {
        this.datawatcher.set(COLLAR_COLOR, Integer.valueOf(EnumColor.fromColorIndex(dc.getWoolData()).getInvColorIndex()));
       }
   }

public static ItemStack createClay(String displayname, List<String> lore, DyeColor dye) {
    ItemStack item = new ItemStack(Material.STAINED_CLAY, 1, dye.getWoolData());
    ItemMeta meta = item.getItemMeta();
    meta.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS, ItemFlag.HIDE_ATTRIBUTES,
            ItemFlag.HIDE_DESTROYS, ItemFlag.HIDE_ENCHANTS, ItemFlag.HIDE_PLACED_ON, ItemFlag.HIDE_UNBREAKABLE);
    meta.setDisplayName(displayname);
    ArrayList<String> colorLore = new ArrayList<>();
    if (lore != null) {
        lore.forEach(str -> colorLore.add(Utils.colorize(str)));
        meta.setLore(colorLore);
    }

    item.setItemMeta(meta);
    return item;
}

public static ItemStack createBanner(String name, List<String> lore, DyeColor color){
    ItemStack banner = new ItemStack(Material.BANNER);
    BannerMeta itemMeta = (BannerMeta) banner.getItemMeta();
    itemMeta.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS, ItemFlag.HIDE_ATTRIBUTES,
            ItemFlag.HIDE_DESTROYS, ItemFlag.HIDE_ENCHANTS, ItemFlag.HIDE_PLACED_ON, ItemFlag.HIDE_UNBREAKABLE);
    ArrayList<String> colorLore = new ArrayList<>();
    if (lore != null) {
        lore.forEach(str -> colorLore.add(Utils.colorize(str)));
        itemMeta.setLore(colorLore);
    }
    itemMeta.setBaseColor(color);
    itemMeta.setDisplayName(name);
    banner.setItemMeta(itemMeta);
    return banner;
}

@SuppressWarnings("deprecation")
@Override
public void onInteract(PlayerInteractEvent e, Entity en) {
    ElevatorInstance ei = ((ElevatorInstance) CustomBlockInstance.getBlockInstance((ArmorStand) en));
    if (e.getItem() != null && e.getItem().getType() == Material.INK_SACK) {
        ei.setColor(ei.getColor().mixColors(DyeColor.getByDyeData(e.getItem().getData().getData()).getFireworkColor()));
    }
}

static String makeColorName(DyeColor color) {
    String[] name = StringUtils.split(color.toString(), '_');
    for (int i = 0; i < name.length; i++) {
        name[i] = (i > 0 ? " " : "") + StringUtils.capitalize(name[i].toLowerCase());
    }
    return StringUtils.join(name);
}

@Override
public ChatColor renderSidebarStatusColor(@Nullable Competitor competitor, Party viewer) {
    if(getDyeColor() == DyeColor.BLUE) {
        return ChatColor.DARK_BLUE; // DARK_BLUE looks ok on sidebar, but not in chat
    } else {
        return BukkitUtils.toChatColor(this.getDyeColor());
    }
}

@SuppressWarnings("deprecation")
@Override
public void setCollarColor(DyeColor dc){
       if (((IWolfPet) pet).isTamed()) {
        this.datawatcher.set(COLLAR_COLOR, Integer.valueOf(EnumColor.fromColorIndex(dc.getWoolData()).getInvColorIndex()));
       }
   }

@SuppressWarnings("deprecation")
@Override
   public void setCollarColor(DyeColor dc) {
       if (((IWolfPet) pet).isTamed()) {
        this.datawatcher.watch(20, (byte) EnumColor.fromColorIndex(dc.getWoolData()).getInvColorIndex());
       }
   }

public FlagDefinitionImpl(@Nullable String name,
                          @Nullable Boolean required,
                          boolean visible,
                          @Nullable DyeColor color,
                          Post defaultPost,
                          Optional<TeamFactory> owner,
                          double pointsPerCapture,
                          double pointsPerSecond,
                          Filter pickupFilter,
                          Filter dropFilter,
                          Filter captureFilter,
                          @Nullable Kit pickupKit,
                          @Nullable Kit dropKit,
                          @Nullable Kit carryKit,
                          boolean multiCarrier,
                          @Nullable BaseComponent carryMessage,
                          boolean dropOnWater,
                          boolean showBeam,
                          ProximityMetric flagProximityMetric,
                          ProximityMetric netProximityMetric) {

    // We can't use the owner field in OwnedGoal because our owner
    // is a reference that can't be resolved until after parsing.
    super(makeName(name, color), required, visible, owner, flagProximityMetric, netProximityMetric);

    this.color = color;
    this.defaultPost = defaultPost;
    this.pointsPerCapture = pointsPerCapture;
    this.pointsPerSecond = pointsPerSecond;
    this.pickupFilter = pickupFilter;
    this.dropFilter = dropFilter;
    this.captureFilter = captureFilter;
    this.pickupKit = pickupKit;
    this.dropKit = dropKit;
    this.carryKit = carryKit;
    this.multiCarrier = multiCarrier;
    this.carryMessage = carryMessage;
    this.dropOnWater = dropOnWater;
    this.showBeam = showBeam;
}

@Override
protected void configure() {
    NumberFactory.numberTypes().forEach(type -> bindNumber((Class) type));

    bindPrimitiveParser(Boolean.class).to(BooleanParser.class);
    bindPrimitiveParser(String.class).to(StringParser.class);
    bindPrimitiveParser(Duration.class).to(DurationParser.class);
    bindPrimitiveParser(ImVector.class).to(new TypeLiteral<VectorParser<Double>>(){});
    bindPrimitiveParser(Vector.class).to((TypeLiteral) new TypeLiteral<PrimitiveParser<ImVector>>(){});
    bindPrimitiveParser(Team.OptionStatus.class).to(TeamRelationParser.class);
    bindPrimitiveParser(MessageTemplate.class).to(MessageTemplateParser.class);
    bindPrimitiveParser(Material.class).to(MaterialParser.class);
    bindPrimitiveParser(MaterialData.class).to(MaterialDataParser.class);
    bindPrimitiveParser(Attribute.class).to(AttributeParser.class);

    bind(PercentageParser.class);
    bind(PercentagePropertyFactory.class);

    install(new EnumPropertyManifest<ChatColor>(){});
    install(new EnumPropertyManifest<EntityType>(){});
    install(new EnumPropertyManifest<DyeColor>(){});
    // etc...

    install(new PropertyManifest<>(Boolean.class));
    install(new PropertyManifest<>(String.class));
    install(new PropertyManifest<>(Duration.class, DurationProperty.class));
    install(new PropertyManifest<>(ImVector.class));
    install(new PropertyManifest<>(Vector.class));
    install(new PropertyManifest<>(MessageTemplate.class, MessageTemplateProperty.class));
}

public static ChatColor dyeColorToChatColor(DyeColor dyeColor) {
    ChatColor chatColor = DYE_CHAT_MAP.get(dyeColor);
    if (chatColor != null) {
        return chatColor;
    } else {
        return ChatColor.WHITE;
    }
}

public static ItemStack createBanner(String name, List<String> lore, DyeColor color) {
    ItemStack banner = new ItemStack(Material.BANNER);
    BannerMeta itemMeta = (BannerMeta) banner.getItemMeta();
    itemMeta.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS, ItemFlag.HIDE_ATTRIBUTES,
            ItemFlag.HIDE_DESTROYS, ItemFlag.HIDE_ENCHANTS, ItemFlag.HIDE_PLACED_ON, ItemFlag.HIDE_UNBREAKABLE);
    ArrayList<String> colorLore = new ArrayList<>();
    if (lore != null) {
        lore.forEach(str -> colorLore.add(Utils.colorize(str)));
        itemMeta.setLore(colorLore);
    }
    itemMeta.setBaseColor(color);
    itemMeta.setDisplayName(name);
    banner.setItemMeta(itemMeta);
    return banner;
}

public ItemBuilder dyeBanner(DyeColor color) {
    if (! (meta instanceof BannerMeta))
        return this;

    stack.setDurability(color.getDyeData());
    return this;
}

@SuppressWarnings("deprecation")
@Override
public void setCollarColor(DyeColor dc){
    if(((IWolfPet) pet).isTamed()){
        this.datawatcher.set(COLLAR_COLOR, Integer.valueOf(EnumColor.fromColorIndex(dc.getWoolData()).getInvColorIndex()));
    }
}

@NotNull
@Override
protected ItemStack[] get(Event event) {
    ItemStack banner = new ItemStack(type);
    BannerMeta meta = (BannerMeta) banner.getItemMeta();
    meta.setBaseColor(CollectionUtils.getRandom(DyeColor.values()));
    for (int i = 0; i < new Random().nextInt(7); i++)
        meta.addPattern(new Pattern(CollectionUtils.getRandom(DyeColor.values()),
            CollectionUtils.getRandom(PatternType.values())
        ));
    banner.setItemMeta(meta);
    return new ItemStack[]{banner};
}

@Override
public void setDyeColor(DyeColor color){
       byte b0 = this.datawatcher.getByte(16);

    byte b = Byte.valueOf((byte) (b0 & 240 | color.ordinal() & 15));
       this.datawatcher.watch(16, b);
   }

public static char colorToMnc(@NotNull DyeColor color) {
    for (char c : StringUtils.alphabetLetters()) {
        if (colorFromMnc(c) == color) {
            return c;
        }
    }
    return 0;
}

@EventHandler(priority=EventPriority.HIGHEST, ignoreCancelled=true)
public void onInvOpen(InventoryClickEvent event) {
    Bukkit.getScheduler().scheduleSyncDelayedTask(ProtocolSupportLegacySupport.getInstance(), () -> {
        Inventory topinv = event.getWhoClicked().getOpenInventory().getTopInventory();
        if (!(topinv instanceof EnchantingInventory)) {
            return;
        }
        EnchantingInventory enchinv = (EnchantingInventory) topinv;
        Player player = (Player) event.getWhoClicked();
        int lapisEnchAmount = enchinv.getSecondary() != null ? enchinv.getSecondary().getAmount() : 0;
        ItemStack[] contents = player.getInventory().getStorageContents();
        for (int i = 0; i < contents.length; i++) {
            ItemStack itemstack = contents[i];
            if (lapis.isSimilar(itemstack)) {
                int lapisPlayerAmount = Math.min(itemstack.getAmount(), Material.INK_SACK.getMaxStackSize() - lapisEnchAmount);
                itemstack.setAmount(itemstack.getAmount() - lapisPlayerAmount);
                if (itemstack.getAmount() == 0) {
                    contents[i] = null;
                }
                lapisEnchAmount += lapisPlayerAmount;
                if (lapisEnchAmount == Material.INK_SACK.getMaxStackSize()) {
                    break;
                }
            }
        }
        player.getInventory().setStorageContents(contents);
        if (lapisEnchAmount != 0) {
            enchinv.setSecondary(new Dye(DyeColor.BLUE).toItemStack(lapisEnchAmount));
        }
        player.updateInventory();
    });
}

@Override
public void read(DataInputStream input) throws IOException {
    super.read(input);

    boolean hasBaseColor = input.readBoolean();
    if(hasBaseColor) {
        getValue().setBaseColor(DyeColor.getByDyeData(input.readByte()));
    }

    ArrayListStorage<PatternStorage> patternStorage = new ArrayListStorage<>(null);
    patternStorage.read(input);

    getValue().setPatterns(patternStorage.getValue().stream().map(PatternStorage::getValue).collect(Collectors.toList()));
}

@Override
public void read(DataInputStream input) throws IOException {
    DyeColor color = DyeColor.getByDyeData(input.readByte());
    PatternType patternType = PatternType.getByIdentifier(input.readUTF());

    setValue(new Pattern(color, patternType));
}

public ItemToggle(String name, String desc, boolean enabled, DyeColor enabledColor) {
    super(new ItemStack(Material.INK_SACK));
    this.toggled = enabled;
    this.trueColor = enabledColor;
    this.toggleName = name;
    this.description = desc;
    anyClick(e -> {
        toggle();
        e.getGUI().reconstruct();
    });
}