Examples with InventoryType org.bukkit.event.inventory.InventoryType used on opensource projects

Example 11 with InventoryType

use of org.bukkit.event.inventory.InventoryType in project MassiveCore by MassiveCraft.

the class InventoryUtil method isEquipping.

// -------------------------------------------- //
// EVENT INTERPRETATION > EQUIPPING
// -------------------------------------------- //
/**
 * This method will return the ItemStack the player is trying to equip.
 * If the click event would not result in equipping something null will be returned.
 * Note that this algorithm is not perfect. It's an adequate guess.
 *
 * @param event The InventoryClickEvent to analyze.
 * @return The ItemStack the player is trying to equip.
 */
public static ItemStack isEquipping(InventoryClickEvent event) {
    boolean isShiftClick = event.isShiftClick();
    InventoryType inventoryType = event.getInventory().getType();
    SlotType slotType = event.getSlotType();
    ItemStack cursor = event.getCursor();
    ItemStack currentItem = event.getCurrentItem();
    if (isShiftClick) {
        if (inventoryType != InventoryType.CRAFTING)
            return null;
        if (slotType == SlotType.CRAFTING)
            return null;
        if (slotType == SlotType.ARMOR)
            return null;
        if (slotType == SlotType.RESULT)
            return null;
        if (currentItem.getType() == Material.AIR)
            return null;
        return currentItem;
    } else {
        if (slotType == SlotType.ARMOR) {
            return cursor;
        }
        return null;
    }
}

Example 12 with InventoryType

use of org.bukkit.event.inventory.InventoryType in project Essentials by EssentialsX.

the class EssentialsPlayerListener method onInventoryCloseEvent.

@EventHandler(priority = EventPriority.MONITOR)
public void onInventoryCloseEvent(final InventoryCloseEvent event) {
    Player refreshPlayer = null;
    final Inventory top = event.getView().getTopInventory();
    final InventoryType type = top.getType();
    if (type == InventoryType.PLAYER) {
        final User user = ess.getUser((Player) event.getPlayer());
        user.setInvSee(false);
        refreshPlayer = user.getBase();
    } else if (type == InventoryType.ENDER_CHEST) {
        final User user = ess.getUser((Player) event.getPlayer());
        user.setEnderSee(false);
        refreshPlayer = user.getBase();
    } else if (type == InventoryType.WORKBENCH) {
        final User user = ess.getUser((Player) event.getPlayer());
        if (user.isRecipeSee()) {
            user.setRecipeSee(false);
            event.getView().getTopInventory().clear();
            refreshPlayer = user.getBase();
        }
    } else if (type == InventoryType.CHEST && top.getSize() == 9) {
        final InventoryHolder invHolder = top.getHolder();
        if (invHolder != null && invHolder instanceof HumanEntity) {
            final User user = ess.getUser((Player) event.getPlayer());
            user.setInvSee(false);
            refreshPlayer = user.getBase();
        }
    }
    if (refreshPlayer != null) {
        final Player player = refreshPlayer;
        ess.scheduleSyncDelayedTask(new Runnable() {

            @Override
            public void run() {
                player.updateInventory();
            }
        }, 1);
    }
}

Example 13 with InventoryType

use of org.bukkit.event.inventory.InventoryType in project Denizen-For-Bukkit by DenizenScript.

the class InventoryTag method internalGetInventoryFor.

public static InventoryTag internalGetInventoryFor(TagContext context, List<String> properties) {
    String typeName = properties.get(0);
    String holder = null;
    int size = -1;
    for (String property : properties) {
        if (property.startsWith("holder=")) {
            holder = ObjectFetcher.unescapeProperty(property.substring("holder=".length()));
        } else if (property.startsWith("script_name=")) {
            holder = ObjectFetcher.unescapeProperty(property.substring("script_name=".length()));
            typeName = "script";
        } else if (property.startsWith("uniquifier=")) {
            String idText = property.substring("uniquifier=".length());
            if (!ArgumentHelper.matchesInteger(idText)) {
                return null;
            }
            long id = Long.parseLong(idText);
            InventoryTag fixedResult = InventoryTrackerSystem.idTrackedInventories.get(id);
            if (fixedResult != null) {
                trackTemporaryInventory(fixedResult);
                return fixedResult;
            }
        } else if (property.startsWith("size=")) {
            String sizeText = property.substring("size=".length());
            if (!ArgumentHelper.matchesInteger(sizeText)) {
                return null;
            }
            size = Integer.parseInt(sizeText);
        }
    }
    if (holder != null) {
        switch(typeName) {
            case "player":
            case "enderchest":
            case "workbench":
            case "crafting":
                PlayerTag player = PlayerTag.valueOf(holder, context);
                if (player == null) {
                    if (context == null || context.showErrors()) {
                        Debug.echoError("Invalid inventory player '" + holder + "'");
                    }
                    return null;
                }
                switch(typeName) {
                    case "player":
                        return player.getInventory();
                    case "enderchest":
                        return player.getEnderChest();
                    case "workbench":
                        return player.getWorkbench();
                    case "crafting":
                        Inventory opened = player.getPlayerEntity().getOpenInventory().getTopInventory();
                        if (opened instanceof CraftingInventory) {
                            return new InventoryTag(opened, player.getPlayerEntity());
                        } else {
                            return player.getInventory();
                        }
                }
                break;
            case "npc":
                NPCTag npc = NPCTag.valueOf(holder, context);
                if (npc == null) {
                    if (context == null || context.showErrors()) {
                        Debug.echoError("Invalid inventory npc '" + holder + "'");
                    }
                    return null;
                }
                return npc.getDenizenInventory();
            case "entity":
                EntityTag entity = EntityTag.valueOf(holder, context);
                if (entity == null) {
                    if (context == null || context.showErrors()) {
                        Debug.echoError("Invalid inventory entity '" + holder + "'");
                    }
                    return null;
                }
                return entity.getInventory();
            case "location":
                LocationTag location = LocationTag.valueOf(holder, context);
                if (location == null) {
                    if (context == null || context.showErrors()) {
                        Debug.echoError("Invalid inventory location '" + holder + "'");
                    }
                    return null;
                }
                return location.getInventory();
        }
    }
    InventoryTag result = null;
    if (typeName.equals("generic")) {
        if (holder != null && !new ElementTag(holder).matchesEnum(InventoryType.class)) {
            if (context == null || context.showErrors()) {
                Debug.echoError("Unknown inventory type '" + holder + "'");
            }
            return null;
        }
        InventoryType type = holder == null ? InventoryType.CHEST : InventoryType.valueOf(holder.toUpperCase());
        if (size == -1 || type != InventoryType.CHEST) {
            result = new InventoryTag(type);
        } else {
            result = new InventoryTag(size);
        }
    } else if (typeName.equals("script") && holder != null) {
        ScriptTag script = ScriptTag.valueOf(holder, context);
        if (script == null || !(script.getContainer() instanceof InventoryScriptContainer)) {
            if (context == null || context.showErrors()) {
                Debug.echoError("Unknown inventory script '" + holder + "'");
            }
            return null;
        }
        result = ((InventoryScriptContainer) script.getContainer()).getInventoryFrom(context);
        if (size != -1) {
            result.setSize(size);
        }
    }
    if (result == null && holder != null) {
        ScriptTag script = ScriptTag.valueOf(holder, context);
        if (script != null && (script.getContainer() instanceof InventoryScriptContainer)) {
            result = ((InventoryScriptContainer) script.getContainer()).getInventoryFrom(context);
        }
    }
    if (result == null && new ElementTag(typeName).matchesEnum(InventoryType.class)) {
        InventoryType type = InventoryType.valueOf(typeName.toUpperCase());
        if (size == -1 || type != InventoryType.CHEST) {
            result = new InventoryTag(type);
        } else {
            result = new InventoryTag(size);
        }
    }
    if (result == null) {
        if (context == null || context.showErrors()) {
            Debug.echoError("Unknown inventory idType '" + typeName + "'");
        }
        return null;
    }
    internalApplyPropertySet(result, context, properties);
    return result;
}

Example 14 with InventoryType

use of org.bukkit.event.inventory.InventoryType 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 15 with InventoryType

use of org.bukkit.event.inventory.InventoryType in project Denizen-For-Bukkit by DenizenScript.

the class InventoryScriptContainer method getInventoryFrom.

public InventoryTag getInventoryFrom(TagContext context) {
    InventoryTag inventory;
    context = (context == null ? CoreUtilities.basicContext : context).clone();
    ScriptTag thisScript = new ScriptTag(this);
    context.script = thisScript;
    context.debug = context.debug && shouldDebug();
    try {
        InventoryType type = InventoryType.CHEST;
        if (contains("inventory", String.class)) {
            try {
                type = InventoryType.valueOf(getString("inventory").toUpperCase());
            } catch (IllegalArgumentException ex) {
                Debug.echoError(this, "Invalid inventory type specified. Assuming \"CHEST\" (" + ex.getMessage() + ")");
            }
        } else {
            Debug.echoError(this, "Inventory script '" + getName() + "' does not specify an inventory type. Assuming \"CHEST\".");
        }
        if (type == InventoryType.PLAYER) {
            Debug.echoError(this, "Inventory type 'player' is not valid for inventory scripts - defaulting to 'CHEST'.");
            type = InventoryType.CHEST;
        }
        int size = 0;
        if (contains("size", String.class)) {
            if (type != InventoryType.CHEST) {
                Debug.echoError(this, "You can only set the size of chest inventories!");
            } else {
                String sizeText = TagManager.tag(getString("size"), context);
                if (!ArgumentHelper.matchesInteger(sizeText)) {
                    Debug.echoError(this, "Invalid (not-a-number) size value.");
                } else {
                    size = Integer.parseInt(sizeText);
                }
                if (size == 0) {
                    Debug.echoError(this, "Inventory size can't be 0. Assuming default of inventory type...");
                }
                if (size % 9 != 0) {
                    size = (int) Math.ceil(size / 9.0) * 9;
                    Debug.echoError(this, "Inventory size must be a multiple of 9! Rounding up to " + size + "...");
                }
                if (size < 0) {
                    size = size * -1;
                    Debug.echoError(this, "Inventory size must be a positive number! Inverting to " + size + "...");
                }
            }
        }
        if (size == 0) {
            if (contains("slots", List.class) && type == InventoryType.CHEST) {
                size = getStringList("slots").size() * 9;
            } else {
                size = type.getDefaultSize();
            }
        }
        String title = contains("title", String.class) ? TagManager.tag(getString("title"), context) : null;
        if (type == InventoryType.CHEST) {
            inventory = new InventoryTag(size, title != null ? title : "Chest");
        } else {
            if (title == null) {
                inventory = new InventoryTag(type);
            } else {
                inventory = new InventoryTag(type, title);
            }
        }
        inventory.idType = "script";
        inventory.idHolder = thisScript;
        boolean[] filledSlots = new boolean[size];
        if (contains("slots", List.class)) {
            ItemStack[] finalItems = new ItemStack[size];
            int itemsAdded = 0;
            for (String items : getStringList("slots")) {
                items = TagManager.tag(items, context).trim();
                if (items.isEmpty()) {
                    continue;
                }
                if (!items.startsWith("[") || !items.endsWith("]")) {
                    Debug.echoError(this, "Invalid slots line: [" + items + "]... Ignoring it");
                    continue;
                }
                String[] itemsInLine = items.substring(1, items.length() - 1).split("\\[?\\]?\\s+\\[", -1);
                for (String item : itemsInLine) {
                    if (item.isEmpty()) {
                        finalItems[itemsAdded++] = new ItemStack(Material.AIR);
                        continue;
                    }
                    filledSlots[itemsAdded] = true;
                    if (contains("definitions." + item, String.class)) {
                        ItemTag def = ItemTag.valueOf(TagManager.tag(getString("definitions." + item), context), context);
                        if (def == null) {
                            Debug.echoError(this, "Invalid definition '" + item + "'... Ignoring it and assuming 'AIR'");
                            finalItems[itemsAdded] = new ItemStack(Material.AIR);
                        } else {
                            finalItems[itemsAdded] = def.getItemStack();
                        }
                    } else {
                        try {
                            ItemTag itemTag = ItemTag.valueOf(item, context);
                            if (itemTag == null) {
                                finalItems[itemsAdded] = new ItemStack(Material.AIR);
                                Debug.echoError(this, "Invalid slot item: [" + item + "]... ignoring it and assuming 'AIR'");
                            } else {
                                finalItems[itemsAdded] = itemTag.getItemStack();
                            }
                        } catch (Exception ex) {
                            Debug.echoError(this, "Invalid slot item: [" + item + "]...");
                            Debug.echoError(ex);
                        }
                    }
                    itemsAdded++;
                }
            }
            inventory.setContents(finalItems);
        }
        if (containsScriptSection("procedural items")) {
            List<ScriptEntry> entries = getEntries(context.getScriptEntryData(), "procedural items");
            if (!entries.isEmpty()) {
                InstantQueue queue = new InstantQueue("INV_SCRIPT_ITEM_PROC");
                queue.addEntries(entries);
                if (contains("definitions", Map.class)) {
                    YamlConfiguration section = getConfigurationSection("definitions");
                    for (StringHolder string : section.getKeys(false)) {
                        String definition = string.str;
                        queue.addDefinition(definition, section.getString(definition));
                    }
                }
                queue.procedural = true;
                queue.start();
                if (queue.determinations != null) {
                    ListTag list = ListTag.getListFor(queue.determinations.getObject(0), context);
                    if (list != null) {
                        int x = 0;
                        for (ItemTag item : list.filter(ItemTag.class, context, true)) {
                            while (x < filledSlots.length && filledSlots[x]) {
                                x++;
                            }
                            if (x >= filledSlots.length || filledSlots[x]) {
                                break;
                            }
                            inventory.setSlots(x, item.getItemStack());
                            filledSlots[x] = true;
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        Debug.echoError(this, "Woah! An exception has been called while building this inventory script!");
        Debug.echoError(e);
        inventory = null;
    }
    if (inventory != null) {
        InventoryTag.trackTemporaryInventory(inventory);
    }
    return inventory;
}