Examples with Keyed org.bukkit.Keyed used on opensource projects

Example 1 with Keyed

use of org.bukkit.Keyed in project Denizen-For-Bukkit by DenizenScript.

the class InventoryTag method registerTags.

public static void registerTags() {
    AbstractFlagTracker.registerFlagHandlers(tagProcessor);
    PropertyParser.registerPropertyTagHandlers(InventoryTag.class, tagProcessor);
    // <--[tag]
    // @attribute <InventoryTag.empty_slots>
    // @returns ElementTag(Number)
    // @description
    // Returns the number of empty slots in an inventory.
    // -->
    tagProcessor.registerTag(ElementTag.class, "empty_slots", (attribute, object) -> {
        InventoryTag dummyInv;
        if (object.inventory.getType() == InventoryType.PLAYER) {
            ItemStack[] contents = object.getStorageContents();
            dummyInv = new InventoryTag(contents.length);
            if (contents.length != dummyInv.getSize()) {
                contents = Arrays.copyOf(contents, dummyInv.getSize());
            }
            dummyInv.setContents(contents);
        } else {
            dummyInv = object;
        }
        int full = dummyInv.count(null, true);
        return new ElementTag(dummyInv.getSize() - full);
    });
    // <--[tag]
    // @attribute <InventoryTag.can_fit[<item>|...]>
    // @returns ElementTag(Boolean)
    // @description
    // Returns whether the inventory can fit an item.
    // -->
    tagProcessor.registerTag(ElementTag.class, "can_fit", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        List<ItemTag> items = attribute.paramAsType(ListTag.class).filter(ItemTag.class, attribute.context, !attribute.hasAlternative());
        if (items == null || items.isEmpty()) {
            return null;
        }
        InventoryType type = object.inventory.getType();
        InventoryTag dummyInv = new InventoryTag(type == InventoryType.PLAYER ? InventoryType.CHEST : type, AdvancedTextImpl.instance.getTitle(object.inventory));
        ItemStack[] contents = object.getStorageContents();
        if (dummyInv.getInventoryType() == InventoryType.CHEST) {
            dummyInv.setSize(contents.length);
        }
        if (contents.length != dummyInv.getSize()) {
            contents = Arrays.copyOf(contents, dummyInv.getSize());
        }
        dummyInv.setContents(contents);
        // -->
        if (attribute.startsWith("count", 2)) {
            ItemStack toAdd = items.get(0).getItemStack().clone();
            // Technically nothing stops us from ridiculous numbers in an ItemStack amount.
            int totalCount = 64 * 64 * 4;
            toAdd.setAmount(totalCount);
            List<ItemStack> leftovers = dummyInv.addWithLeftovers(0, true, toAdd);
            int result = 0;
            if (leftovers.size() > 0) {
                result += leftovers.get(0).getAmount();
            }
            attribute.fulfill(1);
            return new ElementTag(totalCount - result);
        }
        // -->
        if ((attribute.startsWith("quantity", 2) || attribute.startsWith("qty", 2)) && attribute.hasContext(2)) {
            if (attribute.startsWith("qty", 2)) {
                Deprecations.qtyTags.warn(attribute.context);
            }
            int qty = attribute.getIntContext(2);
            ItemTag itemZero = new ItemTag(items.get(0).getItemStack().clone());
            itemZero.setAmount(qty);
            items.set(0, itemZero);
            attribute.fulfill(1);
        }
        // NOTE: Could just also convert items to an array and pass it all in at once...
        for (ItemTag itm : items) {
            List<ItemStack> leftovers = dummyInv.addWithLeftovers(0, true, itm.getItemStack().clone());
            if (!leftovers.isEmpty()) {
                return new ElementTag(false);
            }
        }
        return new ElementTag(true);
    });
    // <--[tag]
    // @attribute <InventoryTag.include[<item>|...]>
    // @returns InventoryTag
    // @description
    // Returns a copy of the InventoryTag with items added.
    // -->
    tagProcessor.registerTag(InventoryTag.class, "include", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        List<ItemTag> items = ListTag.getListFor(attribute.getParamObject(), attribute.context).filter(ItemTag.class, attribute.context);
        InventoryTag dummyInv = new InventoryTag(object.inventory.getType(), AdvancedTextImpl.instance.getTitle(object.inventory));
        if (object.inventory.getType() == InventoryType.CHEST) {
            dummyInv.setSize(object.inventory.getSize());
        }
        dummyInv.setContents(object.getContents());
        if (object.idHolder instanceof ScriptTag) {
            dummyInv.idType = "script";
            dummyInv.idHolder = object.idHolder;
        }
        trackTemporaryInventory(dummyInv);
        // -->
        if ((attribute.startsWith("quantity", 2) || attribute.startsWith("qty", 2)) && attribute.hasContext(2)) {
            if (attribute.startsWith("qty", 2)) {
                Deprecations.qtyTags.warn(attribute.context);
            }
            int qty = attribute.getIntContext(2);
            ItemTag itemZero = new ItemTag(items.get(0).getItemStack().clone());
            itemZero.setAmount(qty);
            items.set(0, itemZero);
            attribute.fulfill(1);
        }
        for (ItemTag item : items) {
            dummyInv.add(0, item.getItemStack().clone());
        }
        return dummyInv;
    });
    // <--[tag]
    // @attribute <InventoryTag.exclude_item[<item_matcher>]>
    // @returns InventoryTag
    // @description
    // Returns a copy of the InventoryTag with all matching items excluded.
    // -->
    tagProcessor.registerTag(InventoryTag.class, "exclude_item", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        String matcher = attribute.getParam();
        InventoryTag dummyInv = new InventoryTag(object.inventory.getType(), AdvancedTextImpl.instance.getTitle(object.inventory));
        if (object.inventory.getType() == InventoryType.CHEST) {
            dummyInv.setSize(object.inventory.getSize());
        }
        dummyInv.setContents(object.getContents());
        if (object.idHolder instanceof ScriptTag) {
            dummyInv.idType = "script";
            dummyInv.idHolder = object.idHolder;
        }
        trackTemporaryInventory(dummyInv);
        int quantity = Integer.MAX_VALUE;
        // -->
        if (attribute.startsWith("quantity", 2) && attribute.hasContext(2)) {
            quantity = attribute.getIntContext(2);
            attribute.fulfill(1);
        }
        for (int slot = 0; slot < dummyInv.inventory.getSize(); slot++) {
            ItemStack item = dummyInv.inventory.getItem(slot);
            if (item != null && BukkitScriptEvent.tryItem(new ItemTag(item), matcher)) {
                quantity -= item.getAmount();
                if (quantity >= 0) {
                    dummyInv.inventory.setItem(slot, null);
                } else {
                    item = item.clone();
                    item.setAmount(-quantity);
                    dummyInv.inventory.setItem(slot, item);
                }
                if (quantity <= 0) {
                    break;
                }
            }
        }
        return dummyInv;
    });
    tagProcessor.registerTag(InventoryTag.class, "exclude", (attribute, object) -> {
        Deprecations.inventoryNonMatcherTags.warn(attribute.context);
        if (!attribute.hasParam()) {
            return null;
        }
        List<ItemTag> items = ListTag.getListFor(attribute.getParamObject(), attribute.context).filter(ItemTag.class, attribute.context);
        InventoryTag dummyInv = new InventoryTag(object.inventory.getType(), AdvancedTextImpl.instance.getTitle(object.inventory));
        if (object.inventory.getType() == InventoryType.CHEST) {
            dummyInv.setSize(object.inventory.getSize());
        }
        dummyInv.setContents(object.getContents());
        if (object.idHolder instanceof ScriptTag) {
            dummyInv.idType = "script";
            dummyInv.idHolder = object.idHolder;
        }
        trackTemporaryInventory(dummyInv);
        if ((attribute.startsWith("quantity", 2) || attribute.startsWith("qty", 2)) && attribute.hasContext(2)) {
            if (attribute.startsWith("qty", 2)) {
                Deprecations.qtyTags.warn(attribute.context);
            }
            int qty = attribute.getIntContext(2);
            ItemTag itemZero = new ItemTag(items.get(0).getItemStack().clone());
            itemZero.setAmount(qty);
            items.set(0, itemZero);
            attribute.fulfill(1);
        }
        for (ItemTag item : items) {
            dummyInv.inventory.removeItem(item.getItemStack().clone());
        }
        return dummyInv;
    });
    // <--[tag]
    // @attribute <InventoryTag.is_empty>
    // @returns ElementTag(Boolean)
    // @description
    // Returns whether the inventory is empty.
    // -->
    tagProcessor.registerTag(ElementTag.class, "is_empty", (attribute, object) -> {
        boolean empty = true;
        for (ItemStack item : object.getStorageContents()) {
            if (item != null && item.getType() != Material.AIR) {
                empty = false;
                break;
            }
        }
        return new ElementTag(empty);
    });
    // <--[tag]
    // @attribute <InventoryTag.is_full>
    // @returns ElementTag(Boolean)
    // @description
    // Returns whether the inventory is completely full.
    // -->
    tagProcessor.registerTag(ElementTag.class, "is_full", (attribute, object) -> {
        boolean full = true;
        for (ItemStack item : object.getStorageContents()) {
            if ((item == null) || (item.getType() == Material.AIR) || (item.getAmount() < item.getMaxStackSize())) {
                full = false;
                break;
            }
        }
        return new ElementTag(full);
    });
    // <--[tag]
    // @attribute <InventoryTag.contains_item[<matcher>]>
    // @returns ElementTag(Boolean)
    // @description
    // Returns whether the inventory contains any item that matches the specified item matcher.
    // Uses the system behind <@link language Advanced Script Event Matching>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "contains_item", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        int qty = 1;
        String matcher = attribute.getParam();
        // -->
        if (attribute.startsWith("quantity", 2) && attribute.hasContext(2)) {
            qty = attribute.getIntContext(2);
            attribute.fulfill(1);
        }
        int found_items = 0;
        for (ItemStack item : object.getContents()) {
            if (item != null) {
                if (BukkitScriptEvent.tryItem(new ItemTag(item), matcher)) {
                    found_items += item.getAmount();
                    if (found_items >= qty) {
                        break;
                    }
                }
            }
        }
        return new ElementTag(found_items >= qty);
    });
    tagProcessor.registerTag(ElementTag.class, "contains", (attribute, object) -> {
        // -->
        if (attribute.startsWith("display", 2)) {
            if (!attribute.hasContext(2)) {
                return null;
            }
            String search_string = attribute.getContext(2);
            boolean strict = false;
            if (CoreUtilities.toLowerCase(search_string).startsWith("strict:") && search_string.length() > 7) {
                strict = true;
                search_string = search_string.substring(7);
            }
            if (search_string.length() == 0) {
                return null;
            }
            int qty = 1;
            // -->
            if ((attribute.startsWith("quantity", 3) || attribute.startsWith("qty", 3)) && attribute.hasContext(3)) {
                if (attribute.startsWith("qty", 3)) {
                    Deprecations.qtyTags.warn(attribute.context);
                }
                qty = attribute.getIntContext(3);
                attribute.fulfill(1);
            }
            int found_items = 0;
            if (strict) {
                for (ItemStack item : object.getContents()) {
                    if (item == null || !item.hasItemMeta()) {
                        continue;
                    }
                    ItemMeta meta = item.getItemMeta();
                    if (item.getType() == Material.WRITTEN_BOOK && ((BookMeta) meta).getTitle().equalsIgnoreCase(search_string)) {
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break;
                        }
                    } else if (meta.hasDisplayName() && meta.getDisplayName().equalsIgnoreCase(search_string)) {
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break;
                        }
                    }
                }
            } else {
                for (ItemStack item : object.getContents()) {
                    if (item == null || !item.hasItemMeta()) {
                        continue;
                    }
                    ItemMeta meta = item.getItemMeta();
                    if (item.getType() == Material.WRITTEN_BOOK && CoreUtilities.toLowerCase(((BookMeta) meta).getTitle()).contains(CoreUtilities.toLowerCase(search_string))) {
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break;
                        }
                    } else if (meta.hasDisplayName() && CoreUtilities.toLowerCase(meta.getDisplayName()).contains(CoreUtilities.toLowerCase(search_string))) {
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break;
                        }
                    }
                }
            }
            attribute.fulfill(1);
            return new ElementTag(found_items >= qty);
        }
        // -->
        if (attribute.startsWith("lore", 2)) {
            if (!attribute.hasContext(2)) {
                return null;
            }
            String search_string = attribute.getContext(2);
            boolean strict = false;
            if (CoreUtilities.toLowerCase(search_string).startsWith("strict:")) {
                strict = true;
                search_string = search_string.substring("strict:".length());
            }
            if (search_string.length() == 0) {
                return null;
            }
            ListTag lore = ListTag.valueOf(search_string, attribute.context);
            int qty = 1;
            // -->
            if ((attribute.startsWith("quantity", 3) || attribute.startsWith("qty", 3)) && attribute.hasContext(3)) {
                if (attribute.startsWith("qty", 3)) {
                    Deprecations.qtyTags.warn(attribute.context);
                }
                qty = attribute.getIntContext(3);
                attribute.fulfill(1);
            }
            int found_items = 0;
            if (strict) {
                strict_items: for (ItemStack item : object.getContents()) {
                    if (item == null || !item.hasItemMeta()) {
                        continue;
                    }
                    ItemMeta meta = item.getItemMeta();
                    if (meta.hasLore()) {
                        List<String> item_lore = meta.getLore();
                        if (lore.size() != item_lore.size()) {
                            continue;
                        }
                        for (int i = 0; i < item_lore.size(); i++) {
                            if (!lore.get(i).equalsIgnoreCase(item_lore.get(i))) {
                                continue strict_items;
                            }
                        }
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break;
                        }
                    }
                }
            } else {
                for (ItemStack item : object.getContents()) {
                    if (item == null || !item.hasItemMeta()) {
                        continue;
                    }
                    ItemMeta meta = item.getItemMeta();
                    if (meta.hasLore()) {
                        List<String> item_lore = meta.getLore();
                        int loreCount = 0;
                        lines: for (String line : lore) {
                            for (String item_line : item_lore) {
                                if (CoreUtilities.toLowerCase(item_line).contains(CoreUtilities.toLowerCase(line))) {
                                    loreCount++;
                                    continue lines;
                                }
                            }
                        }
                        if (loreCount == lore.size()) {
                            found_items += item.getAmount();
                            if (found_items >= qty) {
                                break;
                            }
                        }
                    }
                }
            }
            attribute.fulfill(1);
            return new ElementTag(found_items >= qty);
        }
        if (attribute.startsWith("scriptname", 2)) {
            Deprecations.inventoryNonMatcherTags.warn(attribute.context);
            if (!attribute.hasContext(2)) {
                return null;
            }
            ListTag scrNameList = attribute.contextAsType(2, ListTag.class);
            HashSet<String> scrNames = new HashSet<>();
            for (String name : scrNameList) {
                scrNames.add(CoreUtilities.toLowerCase(name));
            }
            int qty = 1;
            if ((attribute.startsWith("quantity", 3) || attribute.startsWith("qty", 3)) && attribute.hasContext(3)) {
                if (attribute.startsWith("qty", 3)) {
                    Deprecations.qtyTags.warn(attribute.context);
                }
                qty = attribute.getIntContext(3);
                attribute.fulfill(1);
            }
            int found_items = 0;
            for (ItemStack item : object.getContents()) {
                if (item != null) {
                    String itemName = new ItemTag(item).getScriptName();
                    if (itemName != null && scrNames.contains(CoreUtilities.toLowerCase(itemName))) {
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break;
                        }
                    }
                }
            }
            attribute.fulfill(1);
            return new ElementTag(found_items >= qty);
        }
        if (attribute.startsWith("flagged", 2)) {
            Deprecations.inventoryNonMatcherTags.warn(attribute.context);
            if (!attribute.hasContext(2)) {
                return null;
            }
            ListTag scrNameList = attribute.contextAsType(2, ListTag.class);
            String[] flags = scrNameList.toArray(new String[0]);
            int qty = 1;
            if (attribute.startsWith("quantity", 3) && attribute.hasContext(3)) {
                qty = attribute.getIntContext(3);
                attribute.fulfill(1);
            }
            int found_items = 0;
            for (ItemStack item : object.getContents()) {
                if (item != null) {
                    ItemTag itemTag = new ItemTag(item);
                    for (String flag : flags) {
                        if (itemTag.getFlagTracker().hasFlag(flag)) {
                            found_items += item.getAmount();
                            break;
                        }
                    }
                    if (found_items >= qty) {
                        break;
                    }
                }
            }
            attribute.fulfill(1);
            return new ElementTag(found_items >= qty);
        }
        if (attribute.startsWith("nbt", 2)) {
            Deprecations.itemNbt.warn(attribute.context);
            if (!attribute.hasContext(2)) {
                return null;
            }
            String keyName = attribute.getContext(2);
            int qty = 1;
            if ((attribute.startsWith("quantity", 3) || attribute.startsWith("qty", 3)) && attribute.hasContext(3)) {
                if (attribute.startsWith("qty", 3)) {
                    Deprecations.qtyTags.warn(attribute.context);
                }
                qty = attribute.getIntContext(3);
                attribute.fulfill(1);
            }
            int found_items = 0;
            for (ItemStack item : object.getContents()) {
                if (CustomNBT.hasCustomNBT(item, keyName, CustomNBT.KEY_DENIZEN)) {
                    found_items += item.getAmount();
                    if (found_items >= qty) {
                        break;
                    }
                }
            }
            attribute.fulfill(1);
            return new ElementTag(found_items >= qty);
        }
        if (attribute.startsWith("material", 2)) {
            Deprecations.inventoryNonMatcherTags.warn(attribute.context);
            if (!attribute.hasContext(2)) {
                return null;
            }
            List<MaterialTag> materials = attribute.contextAsType(2, ListTag.class).filter(MaterialTag.class, attribute.context);
            int qty = 1;
            if ((attribute.startsWith("quantity", 3) || attribute.startsWith("qty", 3)) && attribute.hasContext(3)) {
                if (attribute.startsWith("qty", 3)) {
                    Deprecations.qtyTags.warn(attribute.context);
                }
                qty = attribute.getIntContext(3);
                attribute.fulfill(1);
            }
            int found_items = 0;
            mainLoop: for (ItemStack item : object.getContents()) {
                if (item == null) {
                    continue;
                }
                for (MaterialTag material : materials) {
                    if (item.getType() == material.getMaterial() && !(new ItemTag(item).isItemscript())) {
                        found_items += item.getAmount();
                        if (found_items >= qty) {
                            break mainLoop;
                        }
                    }
                }
            }
            attribute.fulfill(1);
            return new ElementTag(found_items >= qty);
        }
        if (!attribute.hasParam()) {
            return null;
        }
        ListTag list = attribute.paramAsType(ListTag.class);
        if (list.isEmpty()) {
            return null;
        }
        int qty = 1;
        Deprecations.inventoryNonMatcherTags.warn(attribute.context);
        if ((attribute.startsWith("quantity", 2) || attribute.startsWith("qty", 2)) && attribute.hasContext(2)) {
            if (attribute.startsWith("qty", 2)) {
                Deprecations.qtyTags.warn(attribute.context);
            }
            qty = attribute.getIntContext(2);
            attribute.fulfill(1);
        }
        List<ItemTag> contains = list.filter(ItemTag.class, attribute.context, !attribute.hasAlternative());
        if (contains.size() == list.size()) {
            for (ItemTag item : contains) {
                if (!object.containsItem(item, qty)) {
                    return new ElementTag(false);
                }
            }
            return new ElementTag(true);
        }
        return new ElementTag(false);
    });
    tagProcessor.registerTag(ElementTag.class, "contains_any", (attribute, object) -> {
        Deprecations.inventoryNonMatcherTags.warn(attribute.context);
        if (!attribute.hasParam()) {
            return null;
        }
        ListTag list = attribute.paramAsType(ListTag.class);
        if (list.isEmpty()) {
            return null;
        }
        int qty = 1;
        if ((attribute.startsWith("quantity", 2) || attribute.startsWith("qty", 2)) && attribute.hasContext(2)) {
            if (attribute.startsWith("qty", 2)) {
                Deprecations.qtyTags.warn(attribute.context);
            }
            qty = attribute.getIntContext(2);
            attribute.fulfill(1);
        }
        List<ItemTag> contains = list.filter(ItemTag.class, attribute.context, !attribute.hasAlternative());
        if (!contains.isEmpty()) {
            for (ItemTag item : contains) {
                if (object.containsItem(item, qty)) {
                    return new ElementTag(true);
                }
            }
        }
        return new ElementTag(false);
    });
    // <--[tag]
    // @attribute <InventoryTag.first_empty>
    // @returns ElementTag(Number)
    // @description
    // Returns the location of the first empty slot.
    // Returns -1 if the inventory is full.
    // -->
    tagProcessor.registerTag(ElementTag.class, "first_empty", (attribute, object) -> {
        int val = object.firstEmpty(0);
        return new ElementTag(val >= 0 ? (val + 1) : -1);
    });
    // <--[tag]
    // @attribute <InventoryTag.find_item[<matcher>]>
    // @returns ElementTag(Number)
    // @description
    // Returns the location of the first slot that contains an item that matches the given item matcher.
    // Returns -1 if there's no match.
    // Uses the system behind <@link language Advanced Script Event Matching>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "find_item", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        String matcher = attribute.getParam();
        for (int i = 0; i < object.inventory.getSize(); i++) {
            ItemStack item = object.inventory.getItem(i);
            if (item != null) {
                if (BukkitScriptEvent.tryItem(new ItemTag(item), matcher)) {
                    return new ElementTag(i + 1);
                }
            }
        }
        return new ElementTag(-1);
    });
    // <--[tag]
    // @attribute <InventoryTag.find_all_items[<matcher>]>
    // @returns ListTag
    // @description
    // Returns a list of the location of all slots that contains an item that matches the given item matcher.
    // Returns an empty list if there's no match.
    // Uses the system behind <@link language Advanced Script Event Matching>.
    // -->
    tagProcessor.registerTag(ListTag.class, "find_all_items", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        ListTag result = new ListTag();
        String matcher = attribute.getParam();
        for (int i = 0; i < object.inventory.getSize(); i++) {
            ItemStack item = object.inventory.getItem(i);
            if (item != null) {
                if (BukkitScriptEvent.tryItem(new ItemTag(item), matcher)) {
                    result.addObject(new ElementTag(i + 1));
                }
            }
        }
        return result;
    });
    tagProcessor.registerTag(ElementTag.class, "find", (attribute, object) -> {
        Deprecations.inventoryNonMatcherTags.warn(attribute.context);
        if (attribute.startsWith("material", 2)) {
            ListTag list = attribute.contextAsType(2, ListTag.class);
            if (list == null) {
                return null;
            }
            HashSet<Material> materials = new HashSet<>();
            for (ObjectTag obj : list.objectForms) {
                materials.add(obj.asType(MaterialTag.class, attribute.context).getMaterial());
            }
            int slot = -1;
            for (int i = 0; i < object.inventory.getSize(); i++) {
                if (object.inventory.getItem(i) != null && materials.contains(object.inventory.getItem(i).getType())) {
                    slot = i + 1;
                    break;
                }
            }
            attribute.fulfill(1);
            return new ElementTag(slot);
        }
        if (attribute.startsWith("scriptname", 2)) {
            String scrname = attribute.contextAsType(2, ItemTag.class).getScriptName();
            if (scrname == null) {
                return null;
            }
            int slot = -1;
            for (int i = 0; i < object.inventory.getSize(); i++) {
                if (object.inventory.getItem(i) != null && scrname.equalsIgnoreCase(new ItemTag(object.inventory.getItem(i)).getScriptName())) {
                    slot = i + 1;
                    break;
                }
            }
            attribute.fulfill(1);
            return new ElementTag(slot);
        }
        if (!attribute.hasParam() || !ItemTag.matches(attribute.getParam())) {
            return null;
        }
        ItemTag item = attribute.paramAsType(ItemTag.class);
        item.setAmount(1);
        int slot = -1;
        for (int i = 0; i < object.inventory.getSize(); i++) {
            if (object.inventory.getItem(i) != null) {
                ItemTag compare_to = new ItemTag(object.inventory.getItem(i).clone());
                compare_to.setAmount(1);
                if (item.identify().equalsIgnoreCase(compare_to.identify())) {
                    slot = i + 1;
                    break;
                }
            }
        }
        return new ElementTag(slot);
    });
    tagProcessor.registerTag(ElementTag.class, "find_imperfect", (attribute, object) -> {
        Deprecations.inventoryNonMatcherTags.warn(attribute.context);
        if (!attribute.hasParam() || !ItemTag.matches(attribute.getParam())) {
            return null;
        }
        ItemTag item = attribute.paramAsType(ItemTag.class);
        item.setAmount(1);
        int slot = -1;
        for (int i = 0; i < object.inventory.getSize(); i++) {
            if (object.inventory.getItem(i) != null) {
                ItemTag compare_to = new ItemTag(object.inventory.getItem(i).clone());
                compare_to.setAmount(1);
                if (item.identify().equalsIgnoreCase(compare_to.identify()) || item.getScriptName().equalsIgnoreCase(compare_to.getScriptName())) {
                    slot = i + 1;
                    break;
                }
            }
        }
        return new ElementTag(slot);
    });
    // <--[tag]
    // @attribute <InventoryTag.id_type>
    // @returns ElementTag
    // @description
    // Returns Denizen's type ID for this inventory (player, location, etc.).
    // -->
    tagProcessor.registerTag(ElementTag.class, "id_type", (attribute, object) -> {
        return new ElementTag(object.idType);
    });
    // <--[tag]
    // @attribute <InventoryTag.note_name>
    // @returns ElementTag
    // @description
    // Gets the name of a noted InventoryTag. If the inventory isn't noted, this is null.
    // -->
    tagProcessor.registerTag(ElementTag.class, "note_name", (attribute, object) -> {
        String noteName = NoteManager.getSavedId(object);
        if (noteName == null) {
            return null;
        }
        return new ElementTag(noteName);
    }, "notable_name");
    // <--[tag]
    // @attribute <InventoryTag.location>
    // @returns LocationTag
    // @description
    // Returns the location of this inventory's holder.
    // -->
    tagProcessor.registerTag(LocationTag.class, "location", (attribute, object) -> {
        return object.getLocation();
    });
    // <--[tag]
    // @attribute <InventoryTag.quantity_item[(<matcher>)]>
    // @returns ElementTag(Number)
    // @description
    // Returns the combined quantity of itemstacks that match an item matcher if one is specified,
    // or the combined quantity of all itemstacks if one is not.
    // Uses the system behind <@link language Advanced Script Event Matching>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "quantity_item", (attribute, object) -> {
        String matcher = attribute.hasParam() ? attribute.getParam() : null;
        int found_items = 0;
        for (ItemStack item : object.getContents()) {
            if (item != null) {
                if (matcher == null || BukkitScriptEvent.tryItem(new ItemTag(item), matcher)) {
                    found_items += item.getAmount();
                }
            }
        }
        return new ElementTag(found_items);
    });
    tagProcessor.registerTag(ElementTag.class, "quantity", (attribute, object) -> {
        Deprecations.inventoryNonMatcherTags.warn(attribute.context);
        if (attribute.startsWith("scriptname", 2)) {
            if (!attribute.hasContext(2)) {
                return null;
            }
            String scriptName = attribute.getContext(2);
            attribute.fulfill(1);
            return new ElementTag(object.countByScriptName(scriptName));
        }
        if (attribute.startsWith("flagged", 2)) {
            if (!attribute.hasContext(2)) {
                return null;
            }
            String flag = attribute.getContext(2);
            attribute.fulfill(1);
            return new ElementTag(object.countByFlag(flag));
        }
        if (attribute.startsWith("material", 2)) {
            if (!attribute.hasContext(2) || !MaterialTag.matches(attribute.getContext(2))) {
                return null;
            }
            MaterialTag material = attribute.contextAsType(2, MaterialTag.class);
            attribute.fulfill(1);
            return new ElementTag(object.countByMaterial(material.getMaterial()));
        }
        if (attribute.hasParam() && ItemTag.matches(attribute.getParam())) {
            return new ElementTag(object.count(attribute.paramAsType(ItemTag.class).getItemStack(), false));
        } else {
            return new ElementTag(object.count(null, false));
        }
    }, "qty");
    // <--[tag]
    // @attribute <InventoryTag.stacks[(<item>)]>
    // @returns ElementTag(Number)
    // @description
    // Returns the number of itemstacks that match an item if one is specified, or the number of all itemstacks if one is not.
    // -->
    tagProcessor.registerTag(ElementTag.class, "stacks", (attribute, object) -> {
        if (attribute.hasParam() && ItemTag.matches(attribute.getParam())) {
            return new ElementTag(object.count(attribute.paramAsType(ItemTag.class).getItemStack(), true));
        } else {
            return new ElementTag(object.count(null, true));
        }
    });
    // <--[tag]
    // @attribute <InventoryTag.slot[<#>|...]>
    // @returns ObjectTag
    // @description
    // If one slot is specified, returns the ItemTag in the specified slot.
    // If more than one slot is specified, returns a ListTag(ItemTag) of the item in each given slot.
    // -->
    tagProcessor.registerTag(ObjectTag.class, "slot", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        ListTag slots = ListTag.getListFor(attribute.getParamObject(), attribute.context);
        if (slots.isEmpty()) {
            if (!attribute.hasAlternative()) {
                Debug.echoError("Cannot get a list of zero slots.");
            }
            return null;
        } else if (slots.size() == 1) {
            int slot = SlotHelper.nameToIndexFor(attribute.getParam(), object.getInventory().getHolder());
            if (slot < 0) {
                slot = 0;
            } else if (slot > object.getInventory().getSize() - 1) {
                slot = object.getInventory().getSize() - 1;
            }
            return new ItemTag(object.getInventory().getItem(slot));
        } else {
            ListTag result = new ListTag();
            for (String slotText : slots) {
                int slot = SlotHelper.nameToIndexFor(slotText, object.getInventory().getHolder());
                if (slot < 0) {
                    slot = 0;
                } else if (slot > object.getInventory().getSize() - 1) {
                    slot = object.getInventory().getSize() - 1;
                }
                result.addObject(new ItemTag(object.getInventory().getItem(slot)));
            }
            return result;
        }
    });
    // <--[tag]
    // @attribute <InventoryTag.inventory_type>
    // @returns ElementTag
    // @description
    // Returns the type of the inventory (e.g. "PLAYER", "CRAFTING", "HORSE").
    // -->
    tagProcessor.registerTag(ElementTag.class, "inventory_type", (attribute, object) -> {
        return new ElementTag(object.inventory instanceof HorseInventory ? "HORSE" : object.getInventory().getType().name());
    });
    // <--[tag]
    // @attribute <InventoryTag.equipment_map>
    // @returns MapTag
    // @description
    // Returns a MapTag containing the inventory's equipment.
    // Output keys for players are boots, leggings,  chestplate, helmet.
    // Output keys for horses are saddle, armor.
    // Air items will be left out of the map.
    // -->
    tagProcessor.registerTag(MapTag.class, "equipment_map", (attribute, object) -> {
        return object.getEquipmentMap();
    });
    // <--[tag]
    // @attribute <InventoryTag.equipment>
    // @returns ListTag(ItemTag)
    // @description
    // Returns the equipment of an inventory as a list of items.
    // For players, the order is boots|leggings|chestplate|helmet.
    // For horses, the order is saddle|armor.
    // -->
    tagProcessor.registerTag(ListTag.class, "equipment", (attribute, object) -> {
        return object.getEquipment();
    });
    // <--[tag]
    // @attribute <InventoryTag.matrix>
    // @returns ListTag(ItemTag)
    // @mechanism InventoryTag.matrix
    // @description
    // Returns the items currently in a crafting inventory's matrix.
    // -->
    tagProcessor.registerTag(ListTag.class, "matrix", (attribute, object) -> {
        if (!(object.inventory instanceof CraftingInventory)) {
            return null;
        }
        ListTag recipeList = new ListTag();
        for (ItemStack item : ((CraftingInventory) object.inventory).getMatrix()) {
            if (item != null) {
                recipeList.addObject(new ItemTag(item));
            } else {
                recipeList.addObject(new ItemTag(Material.AIR));
            }
        }
        return recipeList;
    });
    // <--[tag]
    // @attribute <InventoryTag.recipe>
    // @returns ElementTag
    // @description
    // Returns the recipe ID for the recipe currently formed in a crafting inventory.
    // Returns a list in the Namespace:Key format, for example "minecraft:stick".
    // -->
    tagProcessor.registerTag(ElementTag.class, "recipe", (attribute, object) -> {
        Recipe recipe;
        if ((object.inventory instanceof CraftingInventory)) {
            recipe = ((CraftingInventory) object.inventory).getRecipe();
        } else {
            return null;
        }
        if (recipe == null) {
            return null;
        }
        return new ElementTag(((Keyed) recipe).getKey().toString());
    });
    // <--[tag]
    // @attribute <InventoryTag.craftable_quantity>
    // @returns ElementTag(Number)
    // @description
    // Returns the quantity of items that would be received if this crafting inventory were fully crafted (eg via a shift click).
    // -->
    tagProcessor.registerTag(ElementTag.class, "craftable_quantity", (attribute, object) -> {
        Recipe recipe;
        if ((object.inventory instanceof CraftingInventory)) {
            recipe = ((CraftingInventory) object.inventory).getRecipe();
        } else {
            return null;
        }
        if (recipe == null) {
            return null;
        }
        return new ElementTag(RecipeHelper.getMaximumOutputQuantity(recipe, (CraftingInventory) object.inventory) * recipe.getResult().getAmount());
    });
    // <--[tag]
    // @attribute <InventoryTag.result>
    // @returns ItemTag
    // @mechanism InventoryTag.result
    // @description
    // Returns the item currently in the result section of a crafting inventory or furnace inventory.
    // -->
    tagProcessor.registerTag(ItemTag.class, "result", (attribute, object) -> {
        ItemStack result;
        if ((object.inventory instanceof CraftingInventory)) {
            result = ((CraftingInventory) object.inventory).getResult();
        } else if ((object.inventory instanceof FurnaceInventory)) {
            result = ((FurnaceInventory) object.inventory).getResult();
        } else {
            return null;
        }
        if (result == null) {
            return null;
        }
        return new ItemTag(result);
    });
    // <--[tag]
    // @attribute <InventoryTag.anvil_repair_cost>
    // @returns ElementTag(Number)
    // @mechanism InventoryTag.anvil_repair_cost
    // @description
    // Returns the current repair cost on an anvil.
    // -->
    tagProcessor.registerTag(ElementTag.class, "anvil_repair_cost", (attribute, object) -> {
        if (!(object.inventory instanceof AnvilInventory)) {
            return null;
        }
        return new ElementTag(((AnvilInventory) object.inventory).getRepairCost());
    });
    // <--[tag]
    // @attribute <InventoryTag.anvil_max_repair_cost>
    // @returns ElementTag(Number)
    // @mechanism InventoryTag.anvil_max_repair_cost
    // @description
    // Returns the maximum repair cost on an anvil.
    // -->
    tagProcessor.registerTag(ElementTag.class, "anvil_max_repair_cost", (attribute, object) -> {
        if (!(object.inventory instanceof AnvilInventory)) {
            return null;
        }
        return new ElementTag(((AnvilInventory) object.inventory).getMaximumRepairCost());
    });
    // <--[tag]
    // @attribute <InventoryTag.anvil_rename_text>
    // @returns ElementTag
    // @description
    // Returns the current entered renaming text on an anvil.
    // -->
    tagProcessor.registerTag(ElementTag.class, "anvil_rename_text", (attribute, object) -> {
        if (!(object.inventory instanceof AnvilInventory)) {
            return null;
        }
        return new ElementTag(((AnvilInventory) object.inventory).getRenameText(), true);
    });
    // <--[tag]
    // @attribute <InventoryTag.fuel>
    // @returns ItemTag
    // @mechanism InventoryTag.fuel
    // @description
    // Returns the item currently in the fuel section of a furnace or brewing stand inventory.
    // -->
    tagProcessor.registerTag(ItemTag.class, "fuel", (attribute, object) -> {
        if (object.getInventory() instanceof FurnaceInventory) {
            return new ItemTag(((FurnaceInventory) object.getInventory()).getFuel());
        }
        if (object.getInventory() instanceof BrewerInventory) {
            return new ItemTag(((BrewerInventory) object.getInventory()).getFuel());
        }
        return null;
    });
    // <--[tag]
    // @attribute <InventoryTag.input>
    // @returns ItemTag
    // @mechanism InventoryTag.input
    // @description
    // Returns the item currently in the smelting slot of a furnace inventory, or the ingredient slot of a brewing stand inventory.
    // -->
    tagProcessor.registerTag(ItemTag.class, "input", (attribute, object) -> {
        if (object.getInventory() instanceof FurnaceInventory) {
            return new ItemTag(((FurnaceInventory) object.getInventory()).getSmelting());
        }
        if (object.getInventory() instanceof BrewerInventory) {
            return new ItemTag(((BrewerInventory) object.getInventory()).getIngredient());
        }
        return null;
    });
    tagProcessor.registerFutureTagDeprecation("input", "smelting");
    // <--[tag]
    // @attribute <InventoryTag.advanced_matches[<matcher>]>
    // @returns ElementTag(Boolean)
    // @group element checking
    // @description
    // Returns whether the inventory matches some matcher text, using the system behind <@link language Advanced Script Event Matching>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "advanced_matches", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        return new ElementTag(BukkitScriptEvent.tryInventory(object, attribute.getParam()));
    });
    // <--[tag]
    // @attribute <InventoryTag.viewers>
    // @returns ListTag(PlayerTag)
    // @description
    // Returns a list of players viewing the inventory.
    // -->
    tagProcessor.registerTag(ListTag.class, "viewers", (attribute, object) -> {
        ListTag list = new ListTag();
        for (HumanEntity viewer : object.getInventory().getViewers()) {
            if (!EntityTag.isNPC(viewer) && viewer instanceof Player) {
                list.addObject(new PlayerTag((Player) viewer));
            }
        }
        return list;
    });
}

Example 2 with Keyed

use of org.bukkit.Keyed in project Denizen-For-Bukkit by DenizenScript.

the class ItemTag method registerTags.

public static void registerTags() {
    AbstractFlagTracker.registerFlagHandlers(tagProcessor);
    PropertyParser.registerPropertyTagHandlers(ItemTag.class, tagProcessor);
    // <--[tag]
    // @attribute <ItemTag.repairable>
    // @returns ElementTag(Boolean)
    // @group properties
    // @description
    // Returns whether the item can be repaired.
    // If this returns true, it will enable access to:
    // <@link mechanism ItemTag.durability>,
    // <@link tag ItemTag.max_durability>, and <@link tag ItemTag.durability>.
    // Note that due to odd design choices in Spigot, this is effectively true for all items, even though the durability value of most items is locked at zero.
    // -->
    tagProcessor.registerTag(ElementTag.class, "repairable", (attribute, object) -> {
        return new ElementTag(ItemDurability.describes(object));
    });
    // <--[tag]
    // @attribute <ItemTag.is_book>
    // @returns ElementTag(Boolean)
    // @group properties
    // @description
    // Returns whether the item is considered an editable book.
    // If this returns true, it will enable access to:
    // <@link mechanism ItemTag.book>,
    // <@link tag ItemTag.book_author>, <@link tag ItemTag.book_title>, and <@link tag ItemTag.book_pages>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "is_book", (attribute, object) -> {
        return new ElementTag(ItemBook.describes(object));
    });
    // <--[tag]
    // @attribute <ItemTag.is_colorable>
    // @returns ElementTag(Boolean)
    // @group properties
    // @description
    // Returns whether the item can have a custom color.
    // If this returns true, it will enable access to:
    // <@link mechanism ItemTag.color>, and <@link tag ItemTag.color>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "is_colorable", (attribute, object) -> {
        return new ElementTag(ItemColor.describes(object));
    });
    tagProcessor.registerTag(ElementTag.class, "is_dyeable", (attribute, object) -> {
        return new ElementTag(ItemColor.describes(object));
    });
    // <--[tag]
    // @attribute <ItemTag.is_firework>
    // @returns ElementTag(Boolean)
    // @group properties
    // @description
    // Returns whether the item is a firework.
    // If this returns true, it will enable access to:
    // <@link mechanism ItemTag.firework>, and <@link tag ItemTag.firework>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "is_firework", (attribute, object) -> {
        return new ElementTag(ItemFirework.describes(object));
    });
    // <--[tag]
    // @attribute <ItemTag.has_inventory>
    // @returns ElementTag(Boolean)
    // @group properties
    // @description
    // Returns whether the item has an inventory.
    // If this returns true, it will enable access to:
    // <@link mechanism ItemTag.inventory_contents>, and <@link tag ItemTag.inventory_contents>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "has_inventory", (attribute, object) -> {
        return new ElementTag(ItemInventory.describes(object));
    });
    // <--[tag]
    // @attribute <ItemTag.is_lockable>
    // @returns ElementTag(Boolean)
    // @group properties
    // @description
    // Returns whether the item is lockable.
    // If this returns true, it will enable access to:
    // <@link mechanism ItemTag.lock>, and <@link tag ItemTag.lock>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "is_lockable", (attribute, object) -> {
        return new ElementTag(ItemLock.describes(object));
    });
    // <--[tag]
    // @attribute <ItemTag.material>
    // @returns MaterialTag
    // @mechanism ItemTag.material
    // @group conversion
    // @description
    // Returns the MaterialTag that is the basis of the item.
    // EG, a stone with lore and a display name, etc. will return only "m@stone".
    // -->
    tagProcessor.registerTag(ObjectTag.class, "material", (attribute, object) -> {
        if (attribute.getAttribute(2).equals("formatted")) {
            return object;
        }
        if (object.getItemMeta() instanceof BlockStateMeta) {
            if (object.getBukkitMaterial() == Material.SHIELD) {
                MaterialTag material = new MaterialTag(Material.SHIELD);
                material.setModernData(((BlockStateMeta) object.getItemMeta()).getBlockState().getBlockData());
                return material;
            }
            return new MaterialTag(((BlockStateMeta) object.getItemMeta()).getBlockState());
        }
        return object.getMaterial();
    });
    // <--[tag]
    // @attribute <ItemTag.json>
    // @returns ElementTag
    // @group conversion
    // @description
    // Returns the item converted to a raw JSON object with one layer of escaping for network transmission.
    // EG, via /tellraw.
    // Generally, prefer tags like <@link tag ElementTag.on_hover.type> with type 'show_item'.
    // -->
    tagProcessor.registerTag(ElementTag.class, "json", (attribute, object) -> {
        return new ElementTag(NMSHandler.getItemHelper().getJsonString(object.item));
    });
    // <--[tag]
    // @attribute <ItemTag.meta_type>
    // @returns ElementTag
    // @group conversion
    // @description
    // Returns the name of the Bukkit item meta type that applies to this item.
    // This is for debugging purposes.
    // -->
    tagProcessor.registerTag(ElementTag.class, "meta_type", (attribute, object) -> {
        return new ElementTag(object.getItemMeta().getClass().getName());
    });
    // <--[tag]
    // @attribute <ItemTag.bukkit_serial>
    // @returns ElementTag
    // @group conversion
    // @description
    // Returns a YAML text section representing the Bukkit serialization of the item, under subkey "item".
    // -->
    tagProcessor.registerTag(ElementTag.class, "bukkit_serial", (attribute, object) -> {
        YamlConfiguration config = new YamlConfiguration();
        config.set("item", object.getItemStack());
        return new ElementTag(config.saveToString());
    });
    // <--[tag]
    // @attribute <ItemTag.simple>
    // @returns ElementTag
    // @group conversion
    // @description
    // Returns a simple reusable item identification for this item, with minimal extra data.
    // -->
    tagProcessor.registerTag(ElementTag.class, "simple", (attribute, object) -> {
        return new ElementTag(object.identifySimple());
    });
    // <--[tag]
    // @attribute <ItemTag.recipe_ids[(<type>)]>
    // @returns ListTag
    // @description
    // If the item is a scripted item, returns a list of all recipe IDs created by the item script.
    // Others, returns a list of all recipe IDs that the server lists as capable of crafting the item.
    // Returns a list in the Namespace:Key format, for example "minecraft:gold_nugget".
    // Optionally, specify a recipe type (CRAFTING, FURNACE, COOKING, BLASTING, SHAPED, SHAPELESS, SMOKING, STONECUTTING)
    // to limit to just recipes of that type.
    // -->
    tagProcessor.registerTag(ListTag.class, "recipe_ids", (attribute, object) -> {
        String type = attribute.hasParam() ? CoreUtilities.toLowerCase(attribute.getParam()) : null;
        ItemScriptContainer container = object.isItemscript() ? ItemScriptHelper.getItemScriptContainer(object.getItemStack()) : null;
        ListTag list = new ListTag();
        for (Recipe recipe : Bukkit.getRecipesFor(object.getItemStack())) {
            if (!Utilities.isRecipeOfType(recipe, type)) {
                continue;
            }
            if (recipe instanceof Keyed) {
                NamespacedKey key = ((Keyed) recipe).getKey();
                if (key.getNamespace().equalsIgnoreCase("denizen")) {
                    if (container != ItemScriptHelper.recipeIdToItemScript.get(key.toString())) {
                        continue;
                    }
                } else if (container != null) {
                    continue;
                }
                list.add(key.toString());
            }
        }
        return list;
    });
    // <--[tag]
    // @attribute <ItemTag.formatted>
    // @returns ElementTag
    // @group formatting
    // @description
    // Returns the formatted material name of the item to be used in a sentence.
    // Correctly uses singular and plural forms of item names, among other things.
    // -->
    tagProcessor.registerTag(ElementTag.class, "formatted", (attribute, object) -> {
        return new ElementTag(object.formattedName());
    });
    // <--[tag]
    // @attribute <ItemTag.advanced_matches[<matcher>]>
    // @returns ElementTag(Boolean)
    // @group element checking
    // @description
    // Returns whether the item matches some matcher text, using the system behind <@link language Advanced Script Event Matching>.
    // -->
    tagProcessor.registerTag(ElementTag.class, "advanced_matches", (attribute, object) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        return new ElementTag(BukkitScriptEvent.tryItem(object, attribute.getParam()));
    });
}