Examples with Attribute com.denizenscript.denizencore.tags.Attribute used on opensource projects

Example 1 with Attribute

use of com.denizenscript.denizencore.tags.Attribute in project Denizen-For-Bukkit by DenizenScript.

the class AreaContainmentObject method registerTags.

static <T extends AreaContainmentObject> void registerTags(Class<T> type, ObjectTagProcessor<T> processor) {
    // <--[tag]
    // @attribute <AreaObject.bounding_box>
    // @returns CuboidTag
    // @description
    // Returns a cuboid approximately representing the maximal bounding box of the area (anything this cuboid does not contain, is also not contained by the area, but not vice versa).
    // For single-member CuboidTags, this tag returns a copy of the cuboid.
    // -->
    processor.registerTag(CuboidTag.class, "bounding_box", (attribute, area) -> {
        return area.getCuboidBoundary();
    });
    // <--[tag]
    // @attribute <AreaObject.world>
    // @returns WorldTag
    // @description
    // Returns the area's world.
    // -->
    processor.registerTag(WorldTag.class, "world", (attribute, area) -> {
        return area.getWorld();
    });
    // <--[tag]
    // @attribute <AreaObject.players>
    // @returns ListTag(PlayerTag)
    // @description
    // Gets a list of all players currently within the area.
    // -->
    processor.registerTag(ListTag.class, "players", (attribute, area) -> {
        ListTag result = new ListTag();
        for (Player player : Bukkit.getOnlinePlayers()) {
            if (area.doesContainLocation(player.getLocation())) {
                result.addObject(PlayerTag.mirrorBukkitPlayer(player));
            }
        }
        return result;
    });
    // -->
    if (Depends.citizens != null) {
        processor.registerTag(ListTag.class, "npcs", (attribute, area) -> {
            ListTag result = new ListTag();
            for (NPC npc : CitizensAPI.getNPCRegistry()) {
                NPCTag dnpc = new NPCTag(npc);
                if (area.doesContainLocation(dnpc.getLocation())) {
                    result.addObject(dnpc);
                }
            }
            return result;
        });
    }
    // <--[tag]
    // @attribute <AreaObject.entities[(<matcher>)]>
    // @returns ListTag(EntityTag)
    // @description
    // Gets a list of all entities currently within the area, with an optional search parameter for the entity.
    // -->
    processor.registerTag(ListTag.class, "entities", (attribute, area) -> {
        String matcher = attribute.hasParam() ? attribute.getParam() : null;
        ListTag entities = new ListTag();
        for (Entity ent : area.getCuboidBoundary().getEntitiesPossiblyWithinForTag()) {
            if (area.doesContainLocation(ent.getLocation())) {
                EntityTag current = new EntityTag(ent);
                if (matcher == null || BukkitScriptEvent.tryEntity(current, matcher)) {
                    entities.addObject(current.getDenizenObject());
                }
            }
        }
        return entities;
    });
    // <--[tag]
    // @attribute <AreaObject.living_entities>
    // @returns ListTag(EntityTag)
    // @description
    // Gets a list of all living entities currently within the area.
    // This includes Players, mobs, NPCs, etc., but excludes dropped items, experience orbs, etc.
    // -->
    processor.registerTag(ListTag.class, "living_entities", (attribute, area) -> {
        ListTag result = new ListTag();
        for (Entity ent : area.getCuboidBoundary().getEntitiesPossiblyWithinForTag()) {
            if (ent instanceof LivingEntity && area.doesContainLocation(ent.getLocation()) && !EntityTag.isCitizensNPC(ent)) {
                result.addObject(new EntityTag(ent).getDenizenObject());
            }
        }
        return result;
    });
    // <--[tag]
    // @attribute <AreaObject.contains[<location>]>
    // @returns ElementTag(Boolean)
    // @description
    // Returns a boolean indicating whether the specified location is inside this area.
    // -->
    processor.registerTag(ElementTag.class, "contains", (attribute, area) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        LocationTag loc = attribute.paramAsType(LocationTag.class);
        if (loc == null) {
            return null;
        }
        return new ElementTag(area.doesContainLocation(loc));
    }, "contains_location");
    // <--[tag]
    // @attribute <AreaObject.blocks[(<matcher>)]>
    // @returns ListTag(LocationTag)
    // @description
    // Returns each block location within the area.
    // Optionally, specify a material match to only return locations with that block type.
    // -->
    processor.registerTag(ListTag.class, "blocks", (attribute, area) -> {
        if (attribute.hasParam()) {
            NMSHandler.getChunkHelper().changeChunkServerThread(area.getWorld().getWorld());
            try {
                String matcher = attribute.getParam();
                Predicate<Location> predicate = (l) -> BukkitScriptEvent.tryMaterial(l.getBlock().getType(), matcher);
                return area.getBlocks(predicate);
            } finally {
                NMSHandler.getChunkHelper().restoreServerThread(area.getWorld().getWorld());
            }
        }
        return area.getBlocks(null);
    }, "get_blocks");
    // <--[tag]
    // @attribute <AreaObject.spawnable_blocks[(<matcher>)]>
    // @returns ListTag(LocationTag)
    // @description
    // Returns each LocationTag within the area that is safe for players or similar entities to spawn in.
    // Optionally, specify a material matcher to only return locations with that block type.
    // Uses the same spawnable check as <@link tag LocationTag.is_spawnable>
    // -->
    processor.registerTag(ListTag.class, "spawnable_blocks", (attribute, area) -> {
        NMSHandler.getChunkHelper().changeChunkServerThread(area.getWorld().getWorld());
        try {
            if (attribute.hasParam()) {
                String matcher = attribute.getParam();
                Predicate<Location> predicate = (l) -> SpawnableHelper.isSpawnable(l) && BukkitScriptEvent.tryMaterial(l.getBlock().getRelative(0, -1, 0).getType(), matcher);
                return area.getBlocks(predicate);
            }
            return area.getBlocks(SpawnableHelper::isSpawnable);
        } finally {
            NMSHandler.getChunkHelper().restoreServerThread(area.getWorld().getWorld());
        }
    }, "get_spawnable_blocks");
    // <--[tag]
    // @attribute <AreaObject.blocks_flagged[<flag_name>]>
    // @returns ListTag(LocationTag)
    // @description
    // Gets a list of all block locations with a specified flag within the area.
    // Searches the internal flag lists, rather than through all possible blocks.
    // -->
    processor.registerTag(ListTag.class, "blocks_flagged", (attribute, area) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        return area.getBlocksFlagged(CoreUtilities.toLowerCase(attribute.getParam()), attribute);
    });
    // <--[tag]
    // @attribute <AreaObject.shell>
    // @returns ListTag(LocationTag)
    // @description
    // Returns each block location on the 3D outer shell of the area.
    // This tag is useful for displaying particles or blocks to mark the boundary of the area.
    // -->
    processor.registerTag(ListTag.class, "shell", (attribute, area) -> {
        return area.getShell();
    });
    // <--[tag]
    // @attribute <AreaObject.is_within[<cuboid>]>
    // @returns ElementTag(Boolean)
    // @description
    // Returns whether this area is fully inside another cuboid.
    // -->
    processor.registerTag(ElementTag.class, "is_within", (attribute, area) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        CuboidTag cub2 = attribute.paramAsType(CuboidTag.class);
        if (cub2 == null) {
            return null;
        }
        CuboidTag cuboid = area instanceof CuboidTag ? (CuboidTag) area : area.getCuboidBoundary();
        if (cub2 != null) {
            boolean contains = true;
            for (CuboidTag.LocationPair pair2 : cuboid.pairs) {
                boolean contained = false;
                for (CuboidTag.LocationPair pair : cub2.pairs) {
                    if (!pair.low.getWorld().getName().equalsIgnoreCase(pair2.low.getWorld().getName())) {
                        return new ElementTag(false);
                    }
                    if (pair2.low.getX() >= pair.low.getX() && pair2.low.getY() >= pair.low.getY() && pair2.low.getZ() >= pair.low.getZ() && pair2.high.getX() <= pair.high.getX() && pair2.high.getY() <= pair.high.getY() && pair2.high.getZ() <= pair.high.getZ()) {
                        contained = true;
                        break;
                    }
                }
                if (!contained) {
                    contains = false;
                    break;
                }
            }
            return new ElementTag(contains);
        }
        return null;
    });
    // <--[tag]
    // @attribute <AreaObject.with_world[<world>]>
    // @returns AreaObject
    // @description
    // Returns a copy of the area, with the specified world.
    // -->
    processor.registerTag(type, "with_world", (attribute, area) -> {
        if (!attribute.hasParam()) {
            return null;
        }
        WorldTag world = attribute.paramAsType(WorldTag.class);
        if (world == null) {
            return null;
        }
        return (T) area.withWorld(world);
    });
}

Example 2 with Attribute

use of com.denizenscript.denizencore.tags.Attribute in project Denizen-For-Bukkit by DenizenScript.

the class ItemAttributeModifiers method adjust.

@Override
public void adjust(Mechanism mechanism) {
    // -->
    if (mechanism.matches("attribute_modifiers") && mechanism.requireObject(MapTag.class)) {
        Multimap<org.bukkit.attribute.Attribute, AttributeModifier> metaMap = LinkedHashMultimap.create();
        MapTag map = mechanism.valueAsType(MapTag.class);
        for (Map.Entry<StringHolder, ObjectTag> mapEntry : map.map.entrySet()) {
            org.bukkit.attribute.Attribute attr = org.bukkit.attribute.Attribute.valueOf(mapEntry.getKey().str.toUpperCase());
            for (ObjectTag listValue : CoreUtilities.objectToList(mapEntry.getValue(), mechanism.context)) {
                metaMap.put(attr, EntityAttributeModifiers.modiferForMap(attr, (MapTag) listValue));
            }
        }
        ItemMeta meta = item.getItemMeta();
        meta.setAttributeModifiers(metaMap);
        item.setItemMeta(meta);
    }
    // -->
    if (mechanism.matches("add_attribute_modifiers") && mechanism.requireObject(MapTag.class)) {
        ItemMeta meta = item.getItemMeta();
        MapTag input = mechanism.valueAsType(MapTag.class);
        for (Map.Entry<StringHolder, ObjectTag> subValue : input.map.entrySet()) {
            org.bukkit.attribute.Attribute attr = org.bukkit.attribute.Attribute.valueOf(subValue.getKey().str.toUpperCase());
            for (ObjectTag listValue : CoreUtilities.objectToList(subValue.getValue(), mechanism.context)) {
                meta.addAttributeModifier(attr, EntityAttributeModifiers.modiferForMap(attr, (MapTag) listValue));
            }
        }
        item.setItemMeta(meta);
    }
    // -->
    if (mechanism.matches("remove_attribute_modifiers") && mechanism.requireObject(ListTag.class)) {
        ItemMeta meta = item.getItemMeta();
        ArrayList<String> inputList = new ArrayList<>(mechanism.valueAsType(ListTag.class));
        for (String toRemove : new ArrayList<>(inputList)) {
            if (new ElementTag(toRemove).matchesEnum(org.bukkit.attribute.Attribute.class)) {
                inputList.remove(toRemove);
                org.bukkit.attribute.Attribute attr = org.bukkit.attribute.Attribute.valueOf(toRemove.toUpperCase());
                meta.removeAttributeModifier(attr);
            }
        }
        for (String toRemove : inputList) {
            UUID id = UUID.fromString(toRemove);
            Multimap<org.bukkit.attribute.Attribute, AttributeModifier> metaMap = meta.getAttributeModifiers();
            for (org.bukkit.attribute.Attribute attribute : metaMap.keys()) {
                for (AttributeModifier modifer : metaMap.get(attribute)) {
                    if (modifer.getUniqueId().equals(id)) {
                        meta.removeAttributeModifier(attribute, modifer);
                        break;
                    }
                }
            }
        }
        item.setItemMeta(meta);
    }
}

Example 3 with Attribute

use of com.denizenscript.denizencore.tags.Attribute in project Denizen-For-Bukkit by DenizenScript.

the class ItemAttributeModifiers method getAttributeModifiers.

public MapTag getAttributeModifiers() {
    ItemMeta meta = item.getItemMeta();
    if (meta == null) {
        return null;
    }
    MapTag map = new MapTag();
    Multimap<org.bukkit.attribute.Attribute, AttributeModifier> metaMap = meta.getAttributeModifiers();
    if (metaMap == null) {
        return map;
    }
    for (org.bukkit.attribute.Attribute attribute : metaMap.keys()) {
        Collection<AttributeModifier> modifiers = metaMap.get(attribute);
        if (modifiers.isEmpty()) {
            continue;
        }
        ListTag subList = new ListTag();
        for (AttributeModifier modifier : modifiers) {
            subList.addObject(EntityAttributeModifiers.mapify(modifier));
        }
        map.putObject(attribute.name(), subList);
    }
    return map;
}

Example 4 with Attribute

use of com.denizenscript.denizencore.tags.Attribute in project Denizen-For-Bukkit by DenizenScript.

the class ServerTagBase method serverTag.

public void serverTag(ReplaceableTagEvent event) {
    if (!event.matches("server", "global") || event.replaced()) {
        return;
    }
    if (event.matches("global")) {
        Deprecations.globalTagName.warn(event.getScriptEntry());
    }
    Attribute attribute = event.getAttributes().fulfill(1);
    if (attribute.startsWith("economy")) {
        if (Depends.economy == null) {
            attribute.echoError("No economy loaded! Have you installed Vault and a compatible economy plugin?");
            return;
        }
        attribute = attribute.fulfill(1);
        // -->
        if (attribute.startsWith("format") && attribute.hasParam()) {
            double amount = attribute.getDoubleParam();
            event.setReplacedObject(new ElementTag(Depends.economy.format(amount)).getObjectAttribute(attribute.fulfill(1)));
            return;
        }
        // -->
        if (attribute.startsWith("currency_name") && attribute.hasParam()) {
            double amount = attribute.getDoubleParam();
            event.setReplacedObject(new ElementTag(amount == 1 ? Depends.economy.currencyNameSingular() : Depends.economy.currencyNamePlural()).getObjectAttribute(attribute.fulfill(1)));
            return;
        }
        // -->
        if (attribute.startsWith("currency_plural")) {
            event.setReplacedObject(new ElementTag(Depends.economy.currencyNamePlural()).getObjectAttribute(attribute.fulfill(1)));
            return;
        }
        // -->
        if (attribute.startsWith("currency_singular")) {
            event.setReplacedObject(new ElementTag(Depends.economy.currencyNameSingular()).getObjectAttribute(attribute.fulfill(1)));
            return;
        }
        return;
    }
    // -->
    if (attribute.startsWith("slot_id") && attribute.hasParam()) {
        int slotId = SlotHelper.nameToIndex(attribute.getParam(), null);
        if (slotId != -1) {
            event.setReplacedObject(new ElementTag(slotId).getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if (attribute.startsWith("parse_bukkit_item") && attribute.hasParam()) {
        YamlConfiguration config = new YamlConfiguration();
        try {
            config.loadFromString(attribute.getParam());
            ItemStack item = config.getItemStack("item");
            if (item != null) {
                event.setReplacedObject(new ItemTag(item).getObjectAttribute(attribute.fulfill(1)));
            }
        } catch (Exception ex) {
            Debug.echoError(ex);
        }
        return;
    }
    // -->
    if (attribute.startsWith("recipe_ids") || attribute.startsWith("list_recipe_ids")) {
        listDeprecateWarn(attribute);
        String type = attribute.hasParam() ? CoreUtilities.toLowerCase(attribute.getParam()) : null;
        ListTag list = new ListTag();
        Iterator<Recipe> recipeIterator = Bukkit.recipeIterator();
        while (recipeIterator.hasNext()) {
            Recipe recipe = recipeIterator.next();
            if (Utilities.isRecipeOfType(recipe, type) && recipe instanceof Keyed) {
                list.add(((Keyed) recipe).getKey().toString());
            }
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("recipe_items") && attribute.hasParam()) {
        NamespacedKey key = Utilities.parseNamespacedKey(attribute.getParam());
        Recipe recipe = NMSHandler.getItemHelper().getRecipeById(key);
        if (recipe == null) {
            return;
        }
        ListTag result = new ListTag();
        Consumer<RecipeChoice> addChoice = (choice) -> {
            if (choice == null) {
                result.addObject(new ItemTag(Material.AIR));
            } else {
                if (choice instanceof RecipeChoice.ExactChoice) {
                    result.addObject(new ItemTag(choice.getItemStack()));
                } else {
                    result.add("material:" + choice.getItemStack().getType().name());
                }
            }
        };
        if (recipe instanceof ShapedRecipe) {
            for (String row : ((ShapedRecipe) recipe).getShape()) {
                for (char column : row.toCharArray()) {
                    addChoice.accept(((ShapedRecipe) recipe).getChoiceMap().get(column));
                }
            }
        } else if (recipe instanceof ShapelessRecipe) {
            for (RecipeChoice choice : ((ShapelessRecipe) recipe).getChoiceList()) {
                addChoice.accept(choice);
            }
        } else if (recipe instanceof CookingRecipe<?>) {
            addChoice.accept(((CookingRecipe) recipe).getInputChoice());
        }
        event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("recipe_shape") && attribute.hasParam()) {
        NamespacedKey key = Utilities.parseNamespacedKey(attribute.getParam());
        Recipe recipe = NMSHandler.getItemHelper().getRecipeById(key);
        if (!(recipe instanceof ShapedRecipe)) {
            return;
        }
        String[] shape = ((ShapedRecipe) recipe).getShape();
        event.setReplacedObject(new ElementTag(shape[0].length() + "x" + shape.length).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("recipe_type") && attribute.hasParam()) {
        NamespacedKey key = Utilities.parseNamespacedKey(attribute.getParam());
        Recipe recipe = NMSHandler.getItemHelper().getRecipeById(key);
        if (recipe == null) {
            return;
        }
        event.setReplacedObject(new ElementTag(Utilities.getRecipeType(recipe)).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("recipe_result") && attribute.hasParam()) {
        NamespacedKey key = Utilities.parseNamespacedKey(attribute.getParam());
        Recipe recipe = NMSHandler.getItemHelper().getRecipeById(key);
        if (recipe == null) {
            return;
        }
        event.setReplacedObject(new ItemTag(recipe.getResult()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("scoreboards")) {
        ListTag result = new ListTag();
        for (String board : ScoreboardHelper.scoreboardMap.keySet()) {
            result.addObject(new ElementTag(board));
        }
        event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    if (attribute.startsWith("scoreboard")) {
        Scoreboard board;
        String name = "main";
        if (attribute.hasParam()) {
            name = attribute.getParam();
            board = ScoreboardHelper.getScoreboard(name);
        } else {
            board = ScoreboardHelper.getMain();
        }
        attribute = attribute.fulfill(1);
        // -->
        if (attribute.startsWith("exists")) {
            event.setReplacedObject(new ElementTag(board != null).getObjectAttribute(attribute.fulfill(1)));
            return;
        }
        if (board == null) {
            attribute.echoError("Scoreboard '" + name + "' does not exist.");
            return;
        }
        // -->
        if (attribute.startsWith("objectives")) {
            ListTag list = new ListTag();
            for (Objective objective : board.getObjectives()) {
                list.add(objective.getName());
            }
            event.setReplacedObject((list).getObjectAttribute(attribute.fulfill(1)));
        }
        if (attribute.startsWith("objective") && attribute.hasParam()) {
            Objective objective = board.getObjective(attribute.getParam());
            if (objective == null) {
                attribute.echoError("Scoreboard objective '" + attribute.getParam() + "' does not exist.");
                return;
            }
            attribute = attribute.fulfill(1);
            // -->
            if (attribute.startsWith("criteria")) {
                event.setReplacedObject(new ElementTag(objective.getCriteria()).getObjectAttribute(attribute.fulfill(1)));
            }
            // -->
            if (attribute.startsWith("display_name")) {
                event.setReplacedObject(new ElementTag(objective.getDisplayName()).getObjectAttribute(attribute.fulfill(1)));
            }
            // -->
            if (attribute.startsWith("display_slot")) {
                if (objective.getDisplaySlot() == null) {
                    return;
                }
                event.setReplacedObject(new ElementTag(objective.getDisplaySlot().name()).getObjectAttribute(attribute.fulfill(1)));
            }
        }
        // -->
        if (attribute.startsWith("team_names")) {
            ListTag result = new ListTag();
            for (Team team : board.getTeams()) {
                result.add(team.getName());
            }
            event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
        }
        if (attribute.startsWith("team") && attribute.hasParam()) {
            Team team = board.getTeam(attribute.getParam());
            if (team == null) {
                attribute.echoError("Scoreboard team '" + attribute.getParam() + "' does not exist.");
                return;
            }
            attribute = attribute.fulfill(1);
            // -->
            if (attribute.startsWith("members")) {
                event.setReplacedObject(new ListTag(team.getEntries()).getObjectAttribute(attribute.fulfill(1)));
            }
            return;
        }
    }
    // -->
    if (attribute.startsWith("object_is_valid")) {
        ObjectTag o = ObjectFetcher.pickObjectFor(attribute.getParam(), new BukkitTagContext(null, null, null, false, null));
        event.setReplacedObject(new ElementTag(!(o == null || o instanceof ElementTag)).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("has_whitelist")) {
        event.setReplacedObject(new ElementTag(Bukkit.hasWhitelist()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("whitelisted_players")) {
        ListTag result = new ListTag();
        for (OfflinePlayer player : Bukkit.getWhitelistedPlayers()) {
            result.addObject(new PlayerTag(player));
        }
        event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("has_flag")) {
        event.setReplacedObject(DenizenCore.serverFlagMap.doHasFlagTag(attribute).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("flag_expiration")) {
        TimeTag exp = DenizenCore.serverFlagMap.doFlagExpirationTag(attribute);
        if (exp != null) {
            event.setReplacedObject(exp.getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if (attribute.startsWith("flag")) {
        ObjectTag flag = DenizenCore.serverFlagMap.doFlagTag(attribute);
        if (flag != null) {
            event.setReplacedObject(flag.getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if (attribute.startsWith("list_flags")) {
        event.setReplacedObject(DenizenCore.serverFlagMap.doListFlagsTag(attribute).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("flag_map")) {
        event.setReplacedObject(DenizenCore.serverFlagMap.doFlagMapTag(attribute).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("gamerules")) {
        ListTag allGameRules = new ListTag();
        for (GameRule rule : GameRule.values()) {
            allGameRules.add(rule.getName());
        }
        event.setReplacedObject(allGameRules.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if ((attribute.startsWith("traits") || attribute.startsWith("list_traits")) && Depends.citizens != null) {
        listDeprecateWarn(attribute);
        ListTag allTraits = new ListTag();
        for (TraitInfo trait : CitizensAPI.getTraitFactory().getRegisteredTraits()) {
            allTraits.add(trait.getTraitName());
        }
        event.setReplacedObject(allTraits.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("commands") || attribute.startsWith("list_commands")) {
        listDeprecateWarn(attribute);
        CommandScriptHelper.init();
        ListTag list = new ListTag(CommandScriptHelper.knownCommands.keySet());
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("command_plugin")) {
        PluginCommand cmd = Bukkit.getPluginCommand(attribute.getParam());
        if (cmd != null) {
            event.setReplacedObject(new PluginTag(cmd.getPlugin()).getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if (attribute.startsWith("color_names")) {
        ListTag list = new ListTag();
        for (String color : ColorTag.colorsByName.keySet()) {
            list.add(color);
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("art_types")) {
        listDeprecateWarn(attribute);
        ListTag list = new ListTag();
        for (Art art : Art.values()) {
            list.add(art.name());
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("advancement_types") || attribute.startsWith("list_advancements")) {
        if (attribute.matches("list_advancements")) {
            Debug.echoError("list_advancements is deprecated: use advancement_types");
        }
        listDeprecateWarn(attribute);
        ListTag list = new ListTag();
        Bukkit.advancementIterator().forEachRemaining((adv) -> {
            list.add(adv.getKey().toString());
        });
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("nbt_attribute_types") || attribute.startsWith("list_nbt_attribute_types")) {
        listDeprecateWarn(attribute);
        ListTag list = new ListTag();
        for (org.bukkit.attribute.Attribute attribType : org.bukkit.attribute.Attribute.values()) {
            list.add(attribType.name());
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("damage_causes") || attribute.startsWith("list_damage_causes")) {
        listDeprecateWarn(attribute);
        ListTag list = new ListTag();
        for (EntityDamageEvent.DamageCause damageCause : EntityDamageEvent.DamageCause.values()) {
            list.add(damageCause.name());
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("teleport_causes")) {
        ListTag list = new ListTag();
        for (PlayerTeleportEvent.TeleportCause teleportCause : PlayerTeleportEvent.TeleportCause.values()) {
            list.add(teleportCause.name());
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("biome_types") || attribute.startsWith("list_biome_types")) {
        listDeprecateWarn(attribute);
        ListTag allBiomes = new ListTag();
        for (Biome biome : Biome.values()) {
            if (biome != Biome.CUSTOM) {
                allBiomes.addObject(new BiomeTag(biome));
            }
        }
        event.setReplacedObject(allBiomes.getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("list_biomes")) {
        Deprecations.serverListBiomeNames.warn(attribute.context);
        ListTag allBiomes = new ListTag();
        for (Biome biome : Biome.values()) {
            allBiomes.add(biome.name());
        }
        event.setReplacedObject(allBiomes.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("enchantments")) {
        ListTag enchants = new ListTag();
        for (Enchantment ench : Enchantment.values()) {
            enchants.addObject(new EnchantmentTag(ench));
        }
        event.setReplacedObject(enchants.getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("enchantment_types") || attribute.startsWith("list_enchantments")) {
        Deprecations.echantmentTagUpdate.warn(attribute.context);
        if (attribute.matches("list_enchantments")) {
            Debug.echoError("list_enchantments is deprecated: use enchantment_types");
        }
        listDeprecateWarn(attribute);
        ListTag enchants = new ListTag();
        for (Enchantment e : Enchantment.values()) {
            enchants.add(e.getName());
        }
        event.setReplacedObject(enchants.getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("enchantment_keys") || attribute.startsWith("list_enchantment_keys")) {
        Deprecations.echantmentTagUpdate.warn(attribute.context);
        listDeprecateWarn(attribute);
        ListTag enchants = new ListTag();
        for (Enchantment e : Enchantment.values()) {
            enchants.add(e.getKey().getKey());
        }
        event.setReplacedObject(enchants.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("entity_types") || attribute.startsWith("list_entity_types")) {
        listDeprecateWarn(attribute);
        ListTag allEnt = new ListTag();
        for (EntityType entity : EntityType.values()) {
            if (entity != EntityType.UNKNOWN) {
                allEnt.add(entity.name());
            }
        }
        event.setReplacedObject(allEnt.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("material_types") || attribute.startsWith("list_material_types")) {
        listDeprecateWarn(attribute);
        ListTag allMats = new ListTag();
        for (Material mat : Material.values()) {
            allMats.addObject(new MaterialTag(mat));
        }
        event.setReplacedObject(allMats.getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("list_materials")) {
        Deprecations.serverListMaterialNames.warn(attribute.context);
        ListTag allMats = new ListTag();
        for (Material mat : Material.values()) {
            allMats.add(mat.name());
        }
        event.setReplacedObject(allMats.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("sound_types") || attribute.startsWith("list_sounds")) {
        if (attribute.matches("list_sounds")) {
            Debug.echoError("list_sounds is deprecated: use sound_types");
        }
        listDeprecateWarn(attribute);
        ListTag sounds = new ListTag();
        for (Sound s : Sound.values()) {
            sounds.add(s.toString());
        }
        event.setReplacedObject(sounds.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("particle_types") || attribute.startsWith("list_particles")) {
        if (attribute.matches("list_particles")) {
            Debug.echoError("list_particles is deprecated: use particle_types");
        }
        listDeprecateWarn(attribute);
        ListTag particleTypes = new ListTag();
        for (Particle particle : Particle.values()) {
            particleTypes.add(particle.toString());
        }
        event.setReplacedObject(particleTypes.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("effect_types") || attribute.startsWith("list_effects")) {
        if (attribute.matches("list_effects")) {
            Debug.echoError("list_effects is deprecated: use effect_types");
        }
        listDeprecateWarn(attribute);
        ListTag effectTypes = new ListTag();
        for (Effect effect : Effect.values()) {
            effectTypes.add(effect.toString());
        }
        event.setReplacedObject(effectTypes.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("pattern_types") || attribute.startsWith("list_patterns")) {
        if (attribute.matches("list_patterns")) {
            Debug.echoError("list_patterns is deprecated: use pattern_types");
        }
        listDeprecateWarn(attribute);
        ListTag allPatterns = new ListTag();
        for (PatternType pat : PatternType.values()) {
            allPatterns.add(pat.toString());
        }
        event.setReplacedObject(allPatterns.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("potion_effect_types") || attribute.startsWith("list_potion_effects")) {
        if (attribute.matches("list_potion_effects")) {
            Debug.echoError("list_potion_effects is deprecated: use potion_effect_types");
        }
        listDeprecateWarn(attribute);
        ListTag statuses = new ListTag();
        for (PotionEffectType effect : PotionEffectType.values()) {
            if (effect != null) {
                statuses.add(effect.getName());
            }
        }
        event.setReplacedObject(statuses.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("potion_types") || attribute.startsWith("list_potion_types")) {
        listDeprecateWarn(attribute);
        ListTag potionTypes = new ListTag();
        for (PotionType type : PotionType.values()) {
            potionTypes.add(type.toString());
        }
        event.setReplacedObject(potionTypes.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("tree_types") || attribute.startsWith("list_tree_types")) {
        listDeprecateWarn(attribute);
        ListTag allTrees = new ListTag();
        for (TreeType tree : TreeType.values()) {
            allTrees.add(tree.name());
        }
        event.setReplacedObject(allTrees.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("map_cursor_types") || attribute.startsWith("list_map_cursor_types")) {
        listDeprecateWarn(attribute);
        ListTag mapCursors = new ListTag();
        for (MapCursor.Type cursor : MapCursor.Type.values()) {
            mapCursors.add(cursor.toString());
        }
        event.setReplacedObject(mapCursors.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("world_types") || attribute.startsWith("list_world_types")) {
        listDeprecateWarn(attribute);
        ListTag worldTypes = new ListTag();
        for (WorldType world : WorldType.values()) {
            worldTypes.add(world.toString());
        }
        event.setReplacedObject(worldTypes.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("statistic_types") || attribute.startsWith("list_statistics")) {
        listDeprecateWarn(attribute);
        if (attribute.matches("list_statistics")) {
            Debug.echoError("list_statistics is deprecated: use statistic_types");
        }
        Statistic.Type type = null;
        if (attribute.hasParam()) {
            type = Statistic.Type.valueOf(attribute.getParam().toUpperCase());
        }
        ListTag statisticTypes = new ListTag();
        for (Statistic stat : Statistic.values()) {
            if (type == null || type == stat.getType()) {
                statisticTypes.add(stat.toString());
            }
        }
        event.setReplacedObject(statisticTypes.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("structure_types") || attribute.startsWith("list_structure_types")) {
        listDeprecateWarn(attribute);
        event.setReplacedObject(new ListTag(StructureType.getStructureTypes().keySet()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("notes") || attribute.startsWith("list_notables") || attribute.startsWith("notables")) {
        listDeprecateWarn(attribute);
        ListTag allNotables = new ListTag();
        if (attribute.hasParam()) {
            String type = CoreUtilities.toLowerCase(attribute.getParam());
            for (Map.Entry<String, Class> typeClass : NoteManager.namesToTypes.entrySet()) {
                if (type.equals(CoreUtilities.toLowerCase(typeClass.getKey()))) {
                    for (Object notable : NoteManager.getAllType(typeClass.getValue())) {
                        allNotables.addObject((ObjectTag) notable);
                    }
                    break;
                }
            }
        } else {
            for (Notable notable : NoteManager.nameToObject.values()) {
                allNotables.addObject((ObjectTag) notable);
            }
        }
        event.setReplacedObject(allNotables.getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("statistic_type") && attribute.hasParam()) {
        Statistic statistic;
        try {
            statistic = Statistic.valueOf(attribute.getParam().toUpperCase());
        } catch (IllegalArgumentException ex) {
            attribute.echoError("Statistic '" + attribute.getParam() + "' does not exist: " + ex.getMessage());
            return;
        }
        event.setReplacedObject(new ElementTag(statistic.getType().name()).getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("enchantment_max_level") && attribute.hasParam()) {
        Deprecations.echantmentTagUpdate.warn(attribute.context);
        EnchantmentTag ench = EnchantmentTag.valueOf(attribute.getParam(), attribute.context);
        if (ench == null) {
            attribute.echoError("Enchantment '" + attribute.getParam() + "' does not exist.");
            return;
        }
        event.setReplacedObject(new ElementTag(ench.enchantment.getMaxLevel()).getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("enchantment_start_level") && attribute.hasParam()) {
        Deprecations.echantmentTagUpdate.warn(attribute.context);
        EnchantmentTag ench = EnchantmentTag.valueOf(attribute.getParam(), attribute.context);
        if (ench == null) {
            attribute.echoError("Enchantment '" + attribute.getParam() + "' does not exist.");
            return;
        }
        event.setReplacedObject(new ElementTag(ench.enchantment.getStartLevel()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("started_time")) {
        event.setReplacedObject(new TimeTag(DenizenCore.startTime).getObjectAttribute(attribute.fulfill(1)));
    }
    if (attribute.startsWith("start_time")) {
        Deprecations.timeTagRewrite.warn(attribute.context);
        event.setReplacedObject(new DurationTag(DenizenCore.startTime / 50).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("disk_free")) {
        File folder = Denizen.getInstance().getDataFolder();
        event.setReplacedObject(new ElementTag(folder.getUsableSpace()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("disk_total")) {
        File folder = Denizen.getInstance().getDataFolder();
        event.setReplacedObject(new ElementTag(folder.getTotalSpace()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("disk_usage")) {
        File folder = Denizen.getInstance().getDataFolder();
        event.setReplacedObject(new ElementTag(folder.getTotalSpace() - folder.getFreeSpace()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("ram_allocated")) {
        event.setReplacedObject(new ElementTag(Runtime.getRuntime().totalMemory()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("ram_max")) {
        event.setReplacedObject(new ElementTag(Runtime.getRuntime().maxMemory()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("ram_free")) {
        event.setReplacedObject(new ElementTag(Runtime.getRuntime().freeMemory()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("ram_usage")) {
        event.setReplacedObject(new ElementTag(Runtime.getRuntime().maxMemory() - Runtime.getRuntime().freeMemory()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("available_processors")) {
        event.setReplacedObject(new ElementTag(Runtime.getRuntime().availableProcessors()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("current_tick")) {
        event.setReplacedObject(new ElementTag(TickScriptEvent.instance.ticks).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("delta_time_since_start")) {
        event.setReplacedObject(new DurationTag(TickScriptEvent.instance.ticks).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("real_time_since_start")) {
        event.setReplacedObject(new DurationTag((System.currentTimeMillis() - serverStartTimeMillis) / 1000.0).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("current_time_millis")) {
        event.setReplacedObject(new ElementTag(System.currentTimeMillis()).getObjectAttribute(attribute.fulfill(1)));
    }
    // -->
    if (attribute.startsWith("selected_npc")) {
        NPC npc = ((Citizens) Bukkit.getPluginManager().getPlugin("Citizens")).getNPCSelector().getSelected(Bukkit.getConsoleSender());
        if (npc == null) {
            return;
        } else {
            event.setReplacedObject(new NPCTag(npc).getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if ((attribute.startsWith("npcs_named") || attribute.startsWith("list_npcs_named")) && Depends.citizens != null && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        ListTag npcs = new ListTag();
        String name = attribute.getParam();
        for (NPC npc : CitizensAPI.getNPCRegistry()) {
            if (CoreUtilities.equalsIgnoreCase(npc.getName(), name)) {
                npcs.addObject(new NPCTag(npc));
            }
        }
        event.setReplacedObject(npcs.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("has_file") && attribute.hasParam()) {
        File f = new File(Denizen.getInstance().getDataFolder(), attribute.getParam());
        try {
            if (!Utilities.canReadFile(f)) {
                Debug.echoError("Cannot read from that file path due to security settings in Denizen/config.yml.");
                return;
            }
        } catch (Exception e) {
            Debug.echoError(e);
            return;
        }
        event.setReplacedObject(new ElementTag(f.exists()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("list_files") && attribute.hasParam()) {
        File folder = new File(Denizen.getInstance().getDataFolder(), attribute.getParam());
        try {
            if (!Utilities.canReadFile(folder)) {
                Debug.echoError("Cannot read from that file path due to security settings in Denizen/config.yml.");
                return;
            }
            if (!folder.exists() || !folder.isDirectory()) {
                attribute.echoError("Invalid path specified. No directory exists at that path.");
                return;
            }
        } catch (Exception e) {
            Debug.echoError(e);
            return;
        }
        File[] files = folder.listFiles();
        if (files == null) {
            return;
        }
        ListTag list = new ListTag();
        for (File file : files) {
            list.add(file.getName());
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("has_permissions")) {
        event.setReplacedObject(new ElementTag(Depends.permissions != null && Depends.permissions.isEnabled()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("has_economy")) {
        event.setReplacedObject(new ElementTag(Depends.economy != null && Depends.economy.isEnabled()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("denizen_version")) {
        event.setReplacedObject(new ElementTag(Denizen.getInstance().getDescription().getVersion()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("bukkit_version")) {
        event.setReplacedObject(new ElementTag(Bukkit.getBukkitVersion()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("version")) {
        event.setReplacedObject(new ElementTag(Bukkit.getServer().getVersion()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("java_version")) {
        event.setReplacedObject(new ElementTag(System.getProperty("java.version")).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("max_players")) {
        event.setReplacedObject(new ElementTag(Bukkit.getServer().getMaxPlayers()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("sql_connections") || attribute.startsWith("list_sql_connections")) {
        listDeprecateWarn(attribute);
        ListTag list = new ListTag();
        for (Map.Entry<String, Connection> entry : SQLCommand.connections.entrySet()) {
            try {
                if (!entry.getValue().isClosed()) {
                    list.add(entry.getKey());
                } else {
                    SQLCommand.connections.remove(entry.getKey());
                }
            } catch (SQLException e) {
                Debug.echoError(attribute.getScriptEntry(), e);
            }
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("group_prefix")) {
        if (Depends.permissions == null) {
            attribute.echoError("No permission system loaded! Have you installed Vault and a compatible permissions plugin?");
            return;
        }
        String group = attribute.getParam();
        if (!Arrays.asList(Depends.permissions.getGroups()).contains(group)) {
            attribute.echoError("Invalid group! '" + (group != null ? group : "") + "' could not be found.");
            return;
        }
        // -->
        if (attribute.startsWith("world", 2)) {
            WorldTag world = attribute.contextAsType(2, WorldTag.class);
            if (world != null) {
                event.setReplacedObject(new ElementTag(Depends.chat.getGroupPrefix(world.getWorld(), group)).getObjectAttribute(attribute.fulfill(2)));
            }
            return;
        }
        // Prefix in default world
        event.setReplacedObject(new ElementTag(Depends.chat.getGroupPrefix(Bukkit.getWorlds().get(0), group)).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("group_suffix")) {
        if (Depends.permissions == null) {
            attribute.echoError("No permission system loaded! Have you installed Vault and a compatible permissions plugin?");
            return;
        }
        String group = attribute.getParam();
        if (!Arrays.asList(Depends.permissions.getGroups()).contains(group)) {
            attribute.echoError("Invalid group! '" + (group != null ? group : "") + "' could not be found.");
            return;
        }
        // -->
        if (attribute.startsWith("world", 2)) {
            WorldTag world = attribute.contextAsType(2, WorldTag.class);
            if (world != null) {
                event.setReplacedObject(new ElementTag(Depends.chat.getGroupSuffix(world.getWorld(), group)).getObjectAttribute(attribute.fulfill(2)));
            }
            return;
        }
        // Suffix in default world
        event.setReplacedObject(new ElementTag(Depends.chat.getGroupSuffix(Bukkit.getWorlds().get(0), group)).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("permission_groups") || attribute.startsWith("list_permission_groups")) {
        if (Depends.permissions == null) {
            attribute.echoError("No permission system loaded! Have you installed Vault and a compatible permissions plugin?");
            return;
        }
        listDeprecateWarn(attribute);
        event.setReplacedObject(new ListTag(Arrays.asList(Depends.permissions.getGroups())).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    if (attribute.startsWith("list_plugin_names")) {
        Deprecations.serverPluginNamesTag.warn(attribute.context);
        ListTag plugins = new ListTag();
        for (Plugin plugin : Bukkit.getServer().getPluginManager().getPlugins()) {
            plugins.add(plugin.getName());
        }
        event.setReplacedObject(plugins.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("scripts") || attribute.startsWith("list_scripts")) {
        listDeprecateWarn(attribute);
        ListTag scripts = new ListTag();
        for (ScriptContainer script : ScriptRegistry.scriptContainers.values()) {
            scripts.addObject(new ScriptTag(script));
        }
        event.setReplacedObject(scripts.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("match_player") && attribute.hasParam()) {
        Player matchPlayer = null;
        String matchInput = CoreUtilities.toLowerCase(attribute.getParam());
        if (matchInput.isEmpty()) {
            return;
        }
        for (Player player : Bukkit.getOnlinePlayers()) {
            String nameLow = CoreUtilities.toLowerCase(player.getName());
            if (nameLow.equals(matchInput)) {
                matchPlayer = player;
                break;
            } else if (nameLow.contains(matchInput)) {
                if (matchPlayer == null || nameLow.startsWith(matchInput)) {
                    matchPlayer = player;
                }
            }
        }
        if (matchPlayer != null) {
            event.setReplacedObject(new PlayerTag(matchPlayer).getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if (attribute.startsWith("match_offline_player") && attribute.hasParam()) {
        PlayerTag matchPlayer = null;
        String matchInput = CoreUtilities.toLowerCase(attribute.getParam());
        if (matchInput.isEmpty()) {
            return;
        }
        for (Map.Entry<String, UUID> entry : PlayerTag.getAllPlayers().entrySet()) {
            String nameLow = CoreUtilities.toLowerCase(entry.getKey());
            if (nameLow.equals(matchInput)) {
                matchPlayer = new PlayerTag(entry.getValue());
                break;
            } else if (nameLow.contains(matchInput)) {
                PlayerTag newMatch = new PlayerTag(entry.getValue());
                if (matchPlayer == null) {
                    matchPlayer = newMatch;
                } else if (newMatch.isOnline() && !matchPlayer.isOnline()) {
                    matchPlayer = newMatch;
                } else if (nameLow.startsWith(matchInput) && (newMatch.isOnline() == matchPlayer.isOnline())) {
                    matchPlayer = newMatch;
                }
            }
        }
        if (matchPlayer != null) {
            event.setReplacedObject(matchPlayer.getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if ((attribute.startsWith("npcs_assigned") || attribute.startsWith("list_npcs_assigned")) && Depends.citizens != null && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        ScriptTag script = attribute.paramAsType(ScriptTag.class);
        if (script == null || !(script.getContainer() instanceof AssignmentScriptContainer)) {
            attribute.echoError("Invalid script specified.");
        } else {
            AssignmentScriptContainer container = (AssignmentScriptContainer) script.getContainer();
            ListTag npcs = new ListTag();
            for (NPC npc : CitizensAPI.getNPCRegistry()) {
                if (npc.hasTrait(AssignmentTrait.class) && npc.getOrAddTrait(AssignmentTrait.class).isAssigned(container)) {
                    npcs.addObject(new NPCTag(npc));
                }
            }
            event.setReplacedObject(npcs.getObjectAttribute(attribute.fulfill(1)));
            return;
        }
    }
    // -->
    if ((attribute.startsWith("online_players_flagged") || attribute.startsWith("list_online_players_flagged")) && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        String flag = attribute.getParam();
        ListTag players = new ListTag();
        for (Player player : Bukkit.getOnlinePlayers()) {
            PlayerTag plTag = new PlayerTag(player);
            if (plTag.getFlagTracker().hasFlag(flag)) {
                players.addObject(plTag);
            }
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if ((attribute.startsWith("players_flagged") || attribute.startsWith("list_players_flagged")) && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        String flag = attribute.getParam();
        ListTag players = new ListTag();
        for (Map.Entry<String, UUID> entry : PlayerTag.getAllPlayers().entrySet()) {
            PlayerTag plTag = new PlayerTag(entry.getValue());
            if (plTag.getFlagTracker().hasFlag(flag)) {
                players.addObject(plTag);
            }
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if ((attribute.startsWith("spawned_npcs_flagged") || attribute.startsWith("list_spawned_npcs_flagged")) && Depends.citizens != null && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        String flag = attribute.getParam();
        ListTag npcs = new ListTag();
        for (NPC npc : CitizensAPI.getNPCRegistry()) {
            NPCTag dNpc = new NPCTag(npc);
            if (dNpc.isSpawned() && dNpc.hasFlag(flag)) {
                npcs.addObject(dNpc);
            }
        }
        event.setReplacedObject(npcs.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if ((attribute.startsWith("npcs_flagged") || attribute.startsWith("list_npcs_flagged")) && Depends.citizens != null && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        String flag = attribute.getParam();
        ListTag npcs = new ListTag();
        for (NPC npc : CitizensAPI.getNPCRegistry()) {
            NPCTag dNpc = new NPCTag(npc);
            if (dNpc.hasFlag(flag)) {
                npcs.addObject(dNpc);
            }
        }
        event.setReplacedObject(npcs.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("npc_registries") && Depends.citizens != null) {
        ListTag result = new ListTag();
        for (NPCRegistry registry : CitizensAPI.getNPCRegistries()) {
            result.add(registry.getName());
        }
        event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if ((attribute.startsWith("npcs") || attribute.startsWith("list_npcs")) && Depends.citizens != null) {
        listDeprecateWarn(attribute);
        ListTag npcs = new ListTag();
        NPCRegistry registry = CitizensAPI.getNPCRegistry();
        if (attribute.hasParam()) {
            registry = NPCTag.getRegistryByName(attribute.getParam());
            if (registry == null) {
                attribute.echoError("NPC Registry '" + attribute.getParam() + "' does not exist.");
                return;
            }
        }
        for (NPC npc : registry) {
            npcs.addObject(new NPCTag(npc));
        }
        event.setReplacedObject(npcs.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("worlds") || attribute.startsWith("list_worlds")) {
        listDeprecateWarn(attribute);
        ListTag worlds = new ListTag();
        for (World world : Bukkit.getWorlds()) {
            worlds.addObject(WorldTag.mirrorBukkitWorld(world));
        }
        event.setReplacedObject(worlds.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("plugins") || attribute.startsWith("list_plugins")) {
        listDeprecateWarn(attribute);
        ListTag plugins = new ListTag();
        for (Plugin plugin : Bukkit.getServer().getPluginManager().getPlugins()) {
            plugins.addObject(new PluginTag(plugin));
        }
        event.setReplacedObject(plugins.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("players") || attribute.startsWith("list_players")) {
        listDeprecateWarn(attribute);
        ListTag players = new ListTag();
        for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
            players.addObject(PlayerTag.mirrorBukkitPlayer(player));
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("online_players") || attribute.startsWith("list_online_players")) {
        listDeprecateWarn(attribute);
        ListTag players = new ListTag();
        for (Player player : Bukkit.getOnlinePlayers()) {
            players.addObject(PlayerTag.mirrorBukkitPlayer(player));
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("offline_players") || attribute.startsWith("list_offline_players")) {
        listDeprecateWarn(attribute);
        ListTag players = new ListTag();
        for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
            if (!player.isOnline()) {
                players.addObject(PlayerTag.mirrorBukkitPlayer(player));
            }
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("banned_players") || attribute.startsWith("list_banned_players")) {
        listDeprecateWarn(attribute);
        ListTag banned = new ListTag();
        for (OfflinePlayer player : Bukkit.getBannedPlayers()) {
            banned.addObject(PlayerTag.mirrorBukkitPlayer(player));
        }
        event.setReplacedObject(banned.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("banned_addresses") || attribute.startsWith("list_banned_addresses")) {
        listDeprecateWarn(attribute);
        ListTag list = new ListTag();
        list.addAll(Bukkit.getIPBans());
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("is_banned") && attribute.hasParam()) {
        // BanList contains an isBanned method that doesn't check expiration time
        BanEntry ban = Bukkit.getBanList(BanList.Type.IP).getBanEntry(attribute.getParam());
        if (ban == null) {
            event.setReplacedObject(new ElementTag(false).getObjectAttribute(attribute.fulfill(1)));
        } else if (ban.getExpiration() == null) {
            event.setReplacedObject(new ElementTag(true).getObjectAttribute(attribute.fulfill(1)));
        } else {
            event.setReplacedObject(new ElementTag(ban.getExpiration().after(new Date())).getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    if (attribute.startsWith("ban_info") && attribute.hasParam()) {
        BanEntry ban = Bukkit.getBanList(BanList.Type.IP).getBanEntry(attribute.getParam());
        attribute.fulfill(1);
        if (ban == null || (ban.getExpiration() != null && ban.getExpiration().before(new Date()))) {
            return;
        }
        // -->
        if (attribute.startsWith("expiration_time") && ban.getExpiration() != null) {
            event.setReplacedObject(new TimeTag(ban.getExpiration().getTime()).getObjectAttribute(attribute.fulfill(1)));
        } else if (attribute.startsWith("expiration") && ban.getExpiration() != null) {
            Deprecations.timeTagRewrite.warn(attribute.context);
            event.setReplacedObject(new DurationTag(ban.getExpiration().getTime() / 50).getObjectAttribute(attribute.fulfill(1)));
        } else // -->
        if (attribute.startsWith("reason")) {
            event.setReplacedObject(new ElementTag(ban.getReason()).getObjectAttribute(attribute.fulfill(1)));
        } else // -->
        if (attribute.startsWith("created_time")) {
            event.setReplacedObject(new TimeTag(ban.getCreated().getTime()).getObjectAttribute(attribute.fulfill(1)));
        } else if (attribute.startsWith("created")) {
            Deprecations.timeTagRewrite.warn(attribute.context);
            event.setReplacedObject(new DurationTag(ban.getCreated().getTime() / 50).getObjectAttribute(attribute.fulfill(1)));
        } else // -->
        if (attribute.startsWith("source")) {
            event.setReplacedObject(new ElementTag(ban.getSource()).getObjectAttribute(attribute.fulfill(1)));
        }
        return;
    }
    // -->
    if (attribute.startsWith("ops") || attribute.startsWith("list_ops")) {
        listDeprecateWarn(attribute);
        ListTag players = new ListTag();
        for (OfflinePlayer player : Bukkit.getOperators()) {
            players.addObject(PlayerTag.mirrorBukkitPlayer(player));
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("online_ops") || attribute.startsWith("list_online_ops")) {
        listDeprecateWarn(attribute);
        ListTag players = new ListTag();
        for (OfflinePlayer player : Bukkit.getOperators()) {
            if (player.isOnline()) {
                players.addObject(PlayerTag.mirrorBukkitPlayer(player));
            }
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("offline_ops") || attribute.startsWith("list_offline_ops")) {
        listDeprecateWarn(attribute);
        ListTag players = new ListTag();
        for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
            if (player.isOp() && !player.isOnline()) {
                players.addObject(PlayerTag.mirrorBukkitPlayer(player));
            }
        }
        event.setReplacedObject(players.getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("motd")) {
        event.setReplacedObject(new ElementTag(Bukkit.getServer().getMotd()).getObjectAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("view_distance")) {
        event.setReplacedObject(new ElementTag(Bukkit.getServer().getViewDistance()).getObjectAttribute(attribute.fulfill(1)));
        return;
    } else if (attribute.startsWith("entity_is_spawned") && attribute.hasParam()) {
        Deprecations.isValidTag.warn(attribute.context);
        EntityTag ent = EntityTag.valueOf(attribute.getParam(), new BukkitTagContext(null, null, null, false, null));
        event.setReplacedObject(new ElementTag((ent != null && ent.isUnique() && ent.isSpawnedOrValidForTag()) ? "true" : "false").getObjectAttribute(attribute.fulfill(1)));
    } else if (attribute.startsWith("player_is_valid") && attribute.hasParam()) {
        Deprecations.isValidTag.warn(attribute.context);
        event.setReplacedObject(new ElementTag(PlayerTag.playerNameIsValid(attribute.getParam())).getObjectAttribute(attribute.fulfill(1)));
    } else if (attribute.startsWith("npc_is_valid") && attribute.hasParam()) {
        Deprecations.isValidTag.warn(attribute.context);
        NPCTag npc = NPCTag.valueOf(attribute.getParam(), new BukkitTagContext(null, null, null, false, null));
        event.setReplacedObject(new ElementTag((npc != null && npc.isValid())).getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("current_bossbars")) {
        ListTag dl = new ListTag(BossBarCommand.bossBarMap.keySet());
        event.setReplacedObject(dl.getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("bossbar_viewers") && attribute.hasParam()) {
        BossBar bar = BossBarCommand.bossBarMap.get(CoreUtilities.toLowerCase(attribute.getParam()));
        if (bar != null) {
            ListTag list = new ListTag();
            for (Player player : bar.getPlayers()) {
                list.addObject(new PlayerTag(player));
            }
            event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
        }
    } else // -->
    if (attribute.startsWith("recent_tps")) {
        ListTag list = new ListTag();
        for (double tps : NMSHandler.getInstance().getRecentTps()) {
            list.addObject(new ElementTag(tps));
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("port")) {
        event.setReplacedObject(new ElementTag(NMSHandler.getInstance().getPort()).getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("debug_enabled")) {
        event.setReplacedObject(new ElementTag(com.denizenscript.denizen.utilities.debugging.Debug.showDebug).getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("last_reload")) {
        event.setReplacedObject(new TimeTag(DenizenCore.lastReloadTime).getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("idle_timeout")) {
        event.setReplacedObject(new DurationTag(Bukkit.getIdleTimeout() * 60).getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("vanilla_tags")) {
        event.setReplacedObject(new ListTag(VanillaTagHelper.tagsByKey.keySet()).getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("vanilla_tagged_materials")) {
        if (!attribute.hasParam()) {
            return;
        }
        HashSet<Material> materials = VanillaTagHelper.tagsByKey.get(CoreUtilities.toLowerCase(attribute.getParam()));
        if (materials == null) {
            return;
        }
        ListTag list = new ListTag();
        for (Material material : materials) {
            list.addObject(new MaterialTag(material));
        }
        event.setReplacedObject(list.getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if ((attribute.matches("plugins_handling_event") || attribute.matches("list_plugins_handling_event")) && attribute.hasParam()) {
        listDeprecateWarn(attribute);
        String eventName = attribute.getParam();
        if (CoreUtilities.contains(eventName, '.')) {
            try {
                Class clazz = Class.forName(eventName, false, ServerTagBase.class.getClassLoader());
                ListTag result = getHandlerPluginList(clazz);
                if (result != null) {
                    event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
                }
            } catch (ClassNotFoundException ex) {
                if (!attribute.hasAlternative()) {
                    Debug.echoError(ex);
                }
            }
        } else {
            ScriptEvent scriptEvent = ScriptEvent.eventLookup.get(CoreUtilities.toLowerCase(eventName));
            if (scriptEvent instanceof Listener) {
                Plugin plugin = Denizen.getInstance();
                for (Class eventClass : plugin.getPluginLoader().createRegisteredListeners((Listener) scriptEvent, plugin).keySet()) {
                    ListTag result = getHandlerPluginList(eventClass);
                    // Return results for the first valid match.
                    if (result != null && result.size() > 0) {
                        event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
                        return;
                    }
                }
                event.setReplacedObject(new ListTag().getObjectAttribute(attribute.fulfill(1)));
            }
        }
    } else // -->
    if (attribute.startsWith("generate_loot_table") && attribute.hasParam()) {
        MapTag map = attribute.paramAsType(MapTag.class);
        ObjectTag idObj = map.getObject("id");
        ObjectTag locationObj = map.getObject("location");
        if (idObj == null || locationObj == null) {
            return;
        }
        NamespacedKey key = NamespacedKey.fromString(CoreUtilities.toLowerCase(idObj.toString()));
        if (key == null) {
            return;
        }
        LootTable table = Bukkit.getLootTable(key);
        LootContext.Builder context = new LootContext.Builder(locationObj.asType(LocationTag.class, attribute.context));
        ObjectTag killer = map.getObject("killer");
        ObjectTag luck = map.getObject("luck");
        ObjectTag bonus = map.getObject("loot_bonus");
        ObjectTag entity = map.getObject("entity");
        if (entity != null) {
            context = context.lootedEntity(entity.asType(EntityTag.class, attribute.context).getBukkitEntity());
        }
        if (killer != null) {
            context = context.killer((HumanEntity) killer.asType(EntityTag.class, attribute.context).getLivingEntity());
        }
        if (luck != null) {
            context = context.luck(luck.asElement().asFloat());
        }
        if (bonus != null) {
            context = context.lootingModifier(bonus.asElement().asInt());
        }
        Collection<ItemStack> items;
        try {
            items = table.populateLoot(CoreUtilities.getRandom(), context.build());
        } catch (Throwable ex) {
            attribute.echoError("Loot table failed to generate: " + ex.getMessage());
            if (Debug.verbose) {
                attribute.echoError(ex);
            }
            return;
        }
        ListTag result = new ListTag();
        for (ItemStack item : items) {
            if (item != null && item.getType() != Material.AIR) {
                result.addObject(new ItemTag(item));
            }
        }
        event.setReplacedObject(result.getObjectAttribute(attribute.fulfill(1)));
    } else // -->
    if (attribute.startsWith("stack_trace")) {
        String trace = com.denizenscript.denizen.utilities.debugging.Debug.getFullExceptionMessage(new RuntimeException("TRACE"), false);
        event.setReplacedObject(new ElementTag(trace).getObjectAttribute(attribute.fulfill(1)));
    }
}

Example 5 with Attribute

use of com.denizenscript.denizencore.tags.Attribute in project Denizen-For-Bukkit by DenizenScript.

the class SchematicCommand method schematicTags.

public void schematicTags(ReplaceableTagEvent event) {
    if (!event.matches("schematic")) {
        return;
    }
    Attribute attribute = event.getAttributes();
    String id = attribute.hasParam() ? attribute.getParam().toUpperCase() : null;
    attribute = attribute.fulfill(1);
    // -->
    if (attribute.startsWith("list")) {
        event.setReplaced(new ListTag(schematics.keySet()).getAttribute(attribute.fulfill(1)));
    }
    if (id == null) {
        return;
    }
    if (!schematics.containsKey(id)) {
        // Meta below
        if (attribute.startsWith("exists")) {
            event.setReplaced(new ElementTag(false).getAttribute(attribute.fulfill(1)));
            return;
        }
        Debug.echoError(attribute.getScriptEntry(), "Schematic file " + id + " is not loaded.");
        return;
    }
    CuboidBlockSet set = schematics.get(id);
    // -->
    if (attribute.startsWith("exists")) {
        event.setReplaced(new ElementTag(true).getAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("height")) {
        event.setReplaced(new ElementTag(set.y_length).getAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("length")) {
        event.setReplaced(new ElementTag(set.z_height).getAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("width")) {
        event.setReplaced(new ElementTag(set.x_width).getAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("block")) {
        if (attribute.hasParam() && LocationTag.matches(attribute.getParam())) {
            LocationTag location = attribute.paramAsType(LocationTag.class);
            FullBlockData block = set.blockAt(location.getX(), location.getY(), location.getZ());
            event.setReplaced(new MaterialTag(block.data).getAttribute(attribute.fulfill(1)));
            return;
        }
    }
    // -->
    if (attribute.startsWith("origin")) {
        event.setReplaced(new LocationTag(null, set.center_x, set.center_y, set.center_z).getAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("blocks")) {
        event.setReplaced(new ElementTag(set.blocks.length).getAttribute(attribute.fulfill(1)));
        return;
    }
    // -->
    if (attribute.startsWith("cuboid") && attribute.hasParam()) {
        LocationTag origin = attribute.paramAsType(LocationTag.class);
        event.setReplaced(set.getCuboid(origin).getAttribute(attribute.fulfill(1)));
        return;
    }
}