| Name | AreaObject |
| Prefix | None |
| Identity Format | N/A |
| Description | "AreaObject" is a pseudo-ObjectType that represents any object that indicates a world-space area, such as a CuboidTag. |
| Matchable | AreaObject matchers (applies to CuboidTag, EllipsoidTag, PolygonTag, ...), sometimes identified as "<area>":
"cuboid" plaintext: matches if the area is a CuboidTag. "ellipsoid" plaintext: matches if the area is an EllipsoidTag. "polygon" plaintext: matches if the area is a PolygonTag. "area_flagged:<flag>": a Flag Matchable for AreaObject flags. Area note name: matches if the AreaObject's note name matches the given advanced matcher. |
| Extended By | CuboidTag, EllipsoidTag, PolygonTag |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/AreaContainmentObject.java#L28 |
| Name | FlaggableObject |
| Prefix | None |
| Identity Format | N/A |
| Description | "FlaggableObject" is a pseudo-ObjectType that represents any type of object that can hold flags,
for use with flag or any other flag related tags and mechanisms. Just because an ObjectType implements FlaggableObject, does not mean a specific instance of that object type is flaggable. For example, LocationTag implements FlaggableObject, but a LocationTag-Vector (a location without a world) cannot hold a flag. |
| Extended By | GriefPreventionClaimTag, NationTag, TownTag, DiscordBotTag, DiscordChannelTag, DiscordCommandTag, DiscordGroupTag, DiscordInteractionTag, DiscordMessageTag, DiscordReactionTag, DiscordRoleTag, DiscordUserTag, BiomeTag, ChunkTag, CuboidTag, EllipsoidTag, EnchantmentTag, EntityTag, InventoryTag, ItemTag, LocationTag, MaterialTag, NPCTag, PlayerTag, PluginTag, PolygonTag, WorldTag, QueueTag, ScriptTag, TimeTag |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/flags/FlaggableObject.java#L7 |
| Name | ObjectTag |
| Prefix | None |
| Identity Format | N/A |
| Description | "ObjectTag" is a pseudo-ObjectType that represents the fundamental root of all object types.
If a tag says it returns an "ObjectTag", that means it can return any type of tag (for example MapTag.get[...] returns an object of ... well, whatever type the value happens to be, so it's simply documented as "ObjectTag"). |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/ObjectTag.java#L14 |
| Name | PropertyHolderObject |
| Prefix | None |
| Identity Format | N/A |
| Description | "PropertyHolderObject" is a pseudo-ObjectType that represents any object that holds properties. |
| Extended By | EntityTag, InventoryTag, ItemTag, MaterialTag, TradeTag |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/properties/PropertyParser.java#L449 |
| Name | server |
| Prefix | None |
| Identity Format | N/A |
| Description | "server" is an internal pseudo-ObjectType that is used as a mechanism adjust target for some global mechanisms. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/tags/core/ServerTagBase.java#L82 |
| Name | system |
| Prefix | None |
| Identity Format | N/A |
| Description | "system" is an internal pseudo-ObjectType that is used as a mechanism adjust target for some core mechanisms. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/tags/core/UtilTagBase.java#L32 |
| Name | VectorObject |
| Prefix | None |
| Identity Format | N/A |
| Description | "VectorObject" is a pseudo-ObjectType that represents any object that indicates a 3D vector, such as a LocationTag. |
| Extended By | LocationTag |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/VectorObject.java#L12 |
| Name | bungee |
| Prefix | None |
| Identity Format | N/A |
| Description | "bungee" is an internal pseudo-ObjectType that is used as a mechanism adjust target for some global mechanisms. |
| Requires | Depenizen, DepenizenBungee, BungeeCord |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/bungee/BungeeBridge.java#L237 |
| Name | BinaryTag |
| Prefix | binary@ |
| Base Type | ElementTag |
| Identity Format | The identity format for BinaryTag is a hex encoding of the byte set, in order.
Each byte is encoded as an individual big-endian hexadecimal pair, like "FF" for byte=255, "00" for byte=0, "0F" for 15, "F0" for 240, ... etc. |
| Description | BinaryTags represent raw binary data in Denizen.
This is useful in particular for file or network interop. Generally you should only be interacting with BinaryTag if you have a specific reason to, otherwise there are usually more appropriate types to use. Most content you'll come across will be encoded in a text-based format, not a binary one. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/BinaryTag.java#L31 |
| Name | BiomeTag |
| Prefix | b@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for biomes is a world name, then a comma, then the biome key. For example: 'hub,desert', or 'space,minecraft:desert'. |
| Description | A BiomeTag represents a world biome type. Vanilla biomes are globally available, however some biomes are world-specific when added by datapacks.
A list of all vanilla biomes can be found at https://minecraft.wiki/w/Biome#Biome_IDs. BiomeTags without a specific world will work as though they are in the server's default world. This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__biomes" |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/BiomeTag.java#L33 |
| Name | ChunkTag |
| Prefix | ch@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for chunks is <x>,<z>,<world>
For example, 'ch@5,3,world'. |
| Description | A ChunkTag represents a chunk in the world.
Note that the X/Z pair are chunk coordinates, not block coordinates. To convert from block coordinates to chunk coordinates, divide by 16 and round downward. Note that negative chunks are one unit lower than you might expect. To understand why, simply look at chunks on a number line... x x x x x -2 -1 b 0 a 1 2 The block 'a' at block position '1' is in chunk '0', but the block 'b' at block position '-1' is in chunk '-1'. As otherwise (if 'b' was in chunk '0'), chunk '0' would be double-wide (32 blocks wide instead of the standard 16). For example, block at X,Z 32,67 is in the chunk at X,Z 2,4 And the block at X,Z -32,-67 is in the chunk at X,Z -2,-5 This object type is flaggable. Flags on this object type will be stored in the chunk file inside the world folder. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/ChunkTag.java#L33 |
| Name | ColorTag |
| Prefix | co@ |
| Base Type | ElementTag |
| Identity Format | The identity format for colors is <red>,<green>,<blue> or <red>,<green>,<blue>,<alpha> or the name of a color.
When using the numeric form, the number must be between 0 and 255, where 0 is least bright and 255 is most bright. For example, 'co@50,64,128' or 'co@255,0,0,128' or 'co@red'. |
| Description | A ColorTag represents an RGBA color code.
Note that a ColorTag is NOT a base dye color (used by wool, etc). That is handled by a separate naming system. Constructing a ColorTag also accepts 'random' to pick a random RGB color, or 'transparent' to return 0,0,0,0 or RGB hex code like '#FF00FF', or RGBA hex codes like '#FF00FF80', or valid minecraft chat color codes (hex or historical codes). A list of accepted color names can be found at util.color_names. Red/green/blue/alpha values are each from 0 to 255. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/ColorTag.java#L20 |
| Name | CuboidTag |
| Prefix | cu@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, AreaObject |
| Identity Format | The identity format for cuboids is <world>,<x1>,<y1>,<z1>,<x2>,<y2>,<z2>
Multi-member cuboids can simply continue listing x,y,z pairs. For example, 'cu@space,1,2,3,4,5,6'. |
| Description | A CuboidTag represents a cuboidal region in the world.
The word 'cuboid' means a less strict cube. Basically: a "cuboid" is to a 3D "cube" what a "rectangle" is to a 2D "square". One 'cuboid' consists of two points: the low point and a high point. a CuboidTag can contain as many cuboids within itself as needed (this allows forming more complex shapes from a single CuboidTag). Note that the coordinates used are inclusive, meaning that a CuboidTag always includes the blocks identified as the low and high corner points. This means for example that a cuboid from "5,5,5" to "5,5,5" will contain one full block, and have a size of "1,1,1". This object type can be noted. This object type is flaggable when it is noted. Flags on this object type will be stored in the notables.yml file. |
| Matchable | Refer to areaobject's matchable list. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/CuboidTag.java#L35 |
| Name | CustomObjectTag |
| Prefix | custom@ |
| Base Type | ElementTag |
| Identity Format | The identity format for custom objects is the script name, followed by property syntax listing all fields with their values. |
| Description | Custom objects are custom object types.
They use a script basis to create an object similar to the base object types (ListTag, PlayerTags, etc). Usage of these should generally be avoided, as they can be considered 'over-engineering'... That is, using a very complicated solution to solve a problem that can be solved much more simply. Custom objects exist for experimental reasons. Do not use these in any real scripts. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/CustomObjectTag.java#L19 |
| Name | DurationTag |
| Prefix | d@ |
| Base Type | ElementTag |
| Identity Format | The identity format for DurationTags is the number of seconds, followed by an 's'. |
| Description | Durations are a unified and convenient way to get a 'unit of time' throughout Denizen.
Many commands and features that require a duration can be satisfied by specifying a number and unit of time, especially command arguments that are prefixed 'duration:', etc. The unit of time can be specified by using one of the following: t=ticks (0.05 seconds), s=seconds, m=minutes (60 seconds), h=hours (60 minutes), d=days (24 hours), w=weeks (7 days), y=years (365 days). Not using a unit will imply seconds. Examples: 10s, 50m, 1d, 20. Specifying a range of duration will result in a randomly selected duration that is in between the range specified. The smaller value should be first. Examples: '10s-25s', '1m-2m'. The input of 'instant' or 'infinite' will be interpreted as 0 (for use with commands where instant/infinite logic applies). |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/DurationTag.java#L19 |
| Name | ElementTag |
| Prefix | el@ |
| Identity Format | Just the plain text of the element value, no prefix or formatting. |
| Description | ElementTags are simple objects that contain a simple bit of text.
Their main usage is within the replaceable tag system, often times returned from the use of another tag that isn't returning a specific object type, such as a location or entity. For example, <player.name> or <list[item1|item2|item3].comma_separated> will both return ElementTags. Pluses to the ElementTag system is the ability to utilize its tag attributes, which can provide a range of functionality that should be familiar from any other programming language, such as 'to_uppercase', 'split', 'replace', 'contains', and many more. See 'ElementTag.*' tags for more information. While information fetched from other tags resulting in an ElementTag is often times automatically handled, it may be desirable to utilize element attributes from text/numbers/etc. that aren't already an element object. To accomplish this, the standard 'element' tag base can be used for the creation of a new element. For example: <element[This_is_a_test].to_uppercase> will result in the value 'THIS_IS_A_TEST'. Note that while other objects often return their object identifier (p@, li@, e@, etc.), elements usually do not (except special type-validation circumstances). They will, however, recognize the object notation "el@" if it is used. |
| Matchable | ElementTag matchers, often used as a default when other object types aren't available
"integer": plaintext: matches if the element is an integer number. "decimal": plaintext: matches if the element is a decimal number. "boolean": plaintext: matches if the element is a valid boolean ("true" or "false"). |
| Extended By | AreaShopTag, BigDoorsDoorTag, FactionTag, GriefPreventionClaimTag, JobsJobTag, LibsDisguiseTag, LuckPermsGroupTag, LuckPermsTrackTag, PartyTag, MobArenaArenaTag, MythicMobsMobTag, MythicSpawnerTag, PlotSquaredPlotTag, PVPArenaArenaTag, ResidenceTag, ShopKeeperTag, SkillAPIClassTag, NationTag, TownTag, ViveCraftPlayerTag, WorldGuardRegionTag, DiscordBotTag, DiscordButtonTag, DiscordChannelTag, DiscordCommandTag, DiscordEmbedTag, DiscordGroupTag, DiscordInteractionTag, DiscordMessageTag, DiscordReactionTag, DiscordRoleTag, DiscordSelectionTag, DiscordTextInputTag, DiscordUserTag, BiomeTag, ChunkTag, CuboidTag, EllipsoidTag, EnchantmentTag, EntityTag, InventoryTag, ItemTag, LocationTag, MaterialTag, PluginTag, PolygonTag, TradeTag, WorldTag, BinaryTag, ColorTag, CustomObjectTag, DurationTag, ImageTag, JavaReflectedObjectTag, ListTag, MapTag, QuaternionTag, QueueTag, ScriptTag, SecretTag, TimeTag |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/ElementTag.java#L28 |
| Name | EllipsoidTag |
| Prefix | ellipsoid@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, AreaObject |
| Identity Format | The identity format for ellipsoids is <x>,<y>,<z>,<world>,<x-radius>,<y-radius>,<z-radius>
For example, 'ellipsoid@1,2,3,space,7,7,7'. |
| Description | An EllipsoidTag represents an ellipsoidal region in the world.
The word 'ellipsoid' means a less strict sphere. Basically: an "ellipsoid" is to a 3D "sphere" what an "ellipse" (or "oval") is to a 2D "circle". This object type can be noted. This object type is flaggable when it is noted. Flags on this object type will be stored in the notables.yml file. |
| Matchable | Refer to areaobject's matchable list. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/EllipsoidTag.java#L29 |
| Name | EnchantmentTag |
| Prefix | enchantment@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for enchantments is the vanilla ID, Denizen ID, or full key. Can also be constructed by Denizen script name.
For example, 'enchantment@sharpness', 'enchantment@my_custom_ench', or 'enchantment@otherplugin:customench'. |
| Description | An EnchantmentTag represents an item enchantment abstractly (the enchantment itself, like 'sharpness', which *can be* applied to an item, as opposed to the specific reference to an enchantment on a specific item).
For enchantment names, check https://minecraft.wiki/w/Enchanting#Summary_of_enchantments. Note spaces should swapped to underscores, so for example "Aqua Affinity" becomes "aqua_affinity". This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__enchantments" |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/EnchantmentTag.java#L28 |
| Name | EntityTag |
| Prefix | e@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, PropertyHolderObject |
| Identity Format | The identity format for entities is a spawned entity's UUID, or an entity type.
For example, 'e@abc123' or 'e@zombie'. |
| Description | An EntityTag represents a spawned entity, or a generic entity type.
Note that players and NPCs are valid EntityTags, but are generally represented by the more specific PlayerTag and NPCTag objects. Note that a spawned entity can be a living entity (a player, NPC, or mob) or a nonliving entity (a painting, item frame, etc). This object type is flaggable. Flags on this object type will be stored in the world chunk files as a part of the entity's NBT. |
| Matchable | EntityTag matchers, sometimes identified as "<entity>", "<projectile>", or "<vehicle>":
"entity" plaintext: always matches. "player" plaintext: matches any real player (not NPCs). "npc" plaintext: matches any Citizens NPC. "vehicle" plaintext: matches for any vehicle type (minecarts, boats, horses, etc). "fish" plaintext: matches for any fish type (cod, pufferfish, etc). "projectile" plaintext: matches for any projectile type (arrow, trident, fish hook, snowball, etc). "hanging" plaintext: matches for any hanging type (painting, item_frame, etc). "monster" plaintext: matches for any monster type (creepers, zombies, etc). "animal" plaintext: matches for any animal type (pigs, cows, etc). "mob" plaintext: matches for any mob type (creepers, pigs, etc). "living" plaintext: matches for any living type (players, pigs, creepers, etc). "vanilla_tagged:<tag_name>": matches if the given vanilla tag applies to the entity. Allows advanced matchers, for example: "vanilla_tagged:axolotl_*". "entity_flagged:<flag>": a Flag Matchable for EntityTag flags. "player_flagged:<flag>": a Flag Matchable for PlayerTag flags (will never match non-players). "npc_flagged:<flag>": a Flag Matchable for NPCTag flags (will never match non-NPCs). "npc_<type>": matches if the NPC is the given entity type (like "npc_cow" or "npc_mob" or "npc_player"). Any entity type name: matches if the entity is of the given type, using advanced matchers. |
| Extended By | NPCTag, PlayerTag |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/EntityTag.java#L68 |
| Name | ImageTag |
| Prefix | image@ |
| Base Type | ElementTag |
| Identity Format | The identity format for ImageTag is a hex encoding of the image's raw bytes, in order.
Each byte is encoded as an individual big-endian hexadecimal pair, like "FF" for byte=255, "00" for byte=0, "0F" for 15, "F0" for 240, ... etc. Alternatively, an image's identity format can be an image id (from images loaded in with Image), see description for more information. |
| Description | ImageTags represent an image of any supported format.
They are represented by either a hex encoding of their bytes or their image id, but new images can also be created by providing a MapTag with the following keys: - "width": the new image's width, required. - "height": the new image's height, required. - "background": a ColorTag for the new image's background, optional. For id-based images, the image will directly reference the image loaded in under that id, so for example: See ImageTag.copy for getting normal image objects from id-based ones. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/ImageTag.java#L30 |
| Name | InventoryTag |
| Prefix | in@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, PropertyHolderObject |
| Identity Format | The identity format for inventories is the classification type of inventory to use. All other data is specified through properties. |
| Description | An InventoryTag represents an inventory, generically or attached to some in-the-world object.
Inventories can be generically designed using inventory script containers, and can be modified using the inventory command. Valid inventory type classifications: "npc", "player", "crafting", "enderchest", "workbench", "entity", "location", "generic" This object type can be noted. This object type is flaggable when it is noted. Flags on this object type will be stored in the notables.yml file. |
| Matchable | InventoryTag matchers, sometimes identified as "<inventory>":
"inventory" plaintext: always matches. "note" plaintext: matches if the inventory is noted. Inventory script name: matches if the inventory comes from an inventory script of the given name, using advanced matchers. Inventory note name: matches if the inventory is noted with the given name, using advanced matchers. Inventory type: matches if the inventory is of a given type, using advanced matchers. "inventory_flagged:<flag>": a Flag Matchable for InventoryTag flags. "gui" plaintext: matches if the inventory is a GUI (see inventory script containers). |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/InventoryTag.java#L59 |
| Name | ItemTag |
| Prefix | i@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, PropertyHolderObject |
| Identity Format | The identity format for items is the basic material type name, or an item script name. Other data is specified in properties.
For example, 'i@stick'. |
| Description | An ItemTag represents a holdable item generically.
ItemTags are temporary objects, to actually modify an item in an inventory you must add the item into that inventory. ItemTags do NOT remember where they came from. If you read an item from an inventory, changing it does not change the original item in the original inventory. You must set it back in. Find a list of valid materials at: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html Note that some materials on that list are exclusively for use with blocks, and cannot be held as items. This object type is flaggable. Flags on this object type will be stored in the item NBT. |
| Matchable | ItemTag matchers, sometimes identified as "<item>", often seen as "with:<item>":
"potion": plaintext: matches if the item is any form of potion item. "script": plaintext: matches if the item is any form of script item. "item_flagged:<flag>": A Flag Matcher for item flags. "item_enchanted:<enchantment>": matches if the item is enchanted with the given enchantment name (excluding enchantment books). Allows advanced matchers. "raw_exact:<item>": matches based on exact raw item data comparison (almost always a bad idea to use). Item property format: will validate that the item material matches and all directly specified properties also match. Any properties not specified won't be checked. for example "stick[display=Hi]" will match any 'stick' with a displayname of 'hi', regardless of whether that stick has lore or not, or has enchantments or not, or etc. Item script names: matches if the item is a script item with the given item script name, using advanced matchers. If none of the above are used, uses MaterialTag matchables. Refer to MaterialTag matchable list above. Note that "item" plaintext is always true. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/ItemTag.java#L56 |
| Name | JavaReflectedObjectTag |
| Prefix | reflected@ |
| Base Type | ElementTag |
| Identity Format | The identity format for JavaReflectedObjectTag is a random UUID that is associated with a temporary lookup to reduce reparsing risk. |
| Description | JavaReflectedObjectTag represent raw Java objects for reflection-based interactions in Denizen.
This is only useful in certain interop edge cases, and should usually be avoided. They have no persistent identity, and instead only use a temporary generated UUID for the identity to allow reconstruction by lookup. Two different JavaReflectedObjectTag might simultaneously refer to the same underlying Java object, despite having different IDs. A Java object should not be retained in flags or other long term storage, as they will necessarily become invalid quickly. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/JavaReflectedObjectTag.java#L18 |
| Name | ListTag |
| Prefix | li@ |
| Base Type | ElementTag |
| Identity Format | The identity format for ListTags is each item, one after the other, in order, separated by a pipe '|' symbol.
For example, for a list of 'taco', 'potatoes', and 'cheese', it would be 'li@taco|potatoes|cheese|' A list with zero items in it is simply 'li@', and a list with one item is just the one item and a pipe on the end. If the pipe symbol "|" appears in a list entry, it will be replaced by "&pipe", similarly if an ampersand "&" appears in a list entry, it will be replaced by "&". This is a subset of Denizen standard escaping, see Escaping System. |
| Description | A ListTag is a list of any data. It can hold any number of objects in any order.
The objects can be of any Denizen object type, including another list. List indices start at 1 (so, the tag 'get[1]' gets the very first entry) and extend to however many entries the list has (so, if a list has 15 entries, the tag 'get[15]' gets the very last entry). Inputs that accept list indices will generally accept 'first' to mean '1', 'last' to mean the last entry in the list, or negative numbers to automatically select an index starting at the end - so for example 'get[-1]' gets the last entry, 'get[-2]' gets the second-to-last, etc. |
| Synonyms (Search Aid) | arraytag |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/ListTag.java#L32 |
| Name | LocationTag |
| Prefix | l@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, VectorObject |
| Identity Format | The identity format for locations is <x>,<y>,<z>,<pitch>,<yaw>,<world>
Note that you can leave off the world, and/or pitch and yaw, and/or the z value. You cannot leave off both the z and the pitch+yaw at the same time. For example, 'l@1,2.15,3,45,90,space' or '[email protected],99,3.2' |
| Description | A LocationTag represents a point in the world.
Note that 'l' prefix is a lowercase 'L', the first letter in 'location'. This object type is flaggable. Flags on this object type will be stored in the chunk file inside the world folder. |
| Matchable | LocationTag matchers, sometimes identified as "<location>" or "<block>":
"location" plaintext: always matches. "block_flagged:<flag>": a Flag Matchable for location flags at the given block location. "location_in:<area>": runs AreaObject checks, as defined below. If none of the above are used, and the location is at a real block, a MaterialTag matchable is used. Refer to MaterialTag matchable list. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/LocationTag.java#L65 |
| Name | MapTag |
| Prefix | map@ |
| Base Type | ElementTag |
| Identity Format | The identity format for MapTags is a replica of property syntax - square brackets surrounded a semi-colon separated list of key=value pairs.
For example, a map of "taco" to "food", "chicken" to "animal", and "bob" to "person" would be "map@[taco=food;chicken=animal;bob=person]" A map with zero items in it is simply 'map@[]'. If the semicolon symbol ";" appears in a key or value, it will be replaced by "&sc", an equal sign "=" will become "&eq", a left bracket "[" will become "&lb", a right bracket "]" will become "&rb", and an ampersand "&" will become "&". This is a subset of Denizen standard escaping, see Escaping System. |
| Description | A MapTag represents a mapping of keys to values.
Keys are plain text, case-insensitive. Values can be anything, even lists or maps themselves. Any given key can only appear in a map once (ie, no duplicate keys). Values can be duplicated into multiple keys without issue. Order of keys is preserved. Casing in keys is preserved in the object but ignored for map lookups. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/MapTag.java#L25 |
| Name | MaterialTag |
| Prefix | m@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, PropertyHolderObject |
| Identity Format | The identity format for materials is the material type name.
For example, 'm@stick'. |
| Description | A MaterialTag represents a material (a type of block or item).
Block materials may sometimes also contain property data, for specific values on the block material such as the growth stage of a plant or the orientation of a stair block. Material types: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html. This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__materials" |
| Matchable | MaterialTag matchers, sometimes identified as "<material>", associated with "<block>":
"material" plaintext: always matches. "block" plaintext: matches if the material is a block-type material. "item" plaintext: matches if the material is an item-type material. "material_flagged:<flag>": a Flag Matchable for MaterialTag flags. "vanilla_tagged:<tag_name>": matches if the given vanilla tag applies to the material. Allows advanced matchers, for example: "vanilla_tagged:mineable*". If none of the above are used, uses an advanced matcher for the material name, like "stick". |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/MaterialTag.java#L36 |
| Name | NPCTag |
| Prefix | n@ |
| Base Type | EntityTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for NPCs is the NPC's id number.
For example, 'n@5'. Or, an NPC's id number, followed by a comma, followed by a custom registry name. For example 'n@12,specialnpcs' |
| Description | An NPCTag represents an NPC configured through Citizens.
This object type is flaggable. Flags on this object type will be stored in the Citizens saves.yml file, under the 'denizen_flags' trait. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/NPCTag.java#L51 |
| Name | PlayerTag |
| Prefix | p@ |
| Base Type | EntityTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for players is the UUID of the relevant player. |
| Description | A PlayerTag represents a player in the game.
This object type is flaggable. Flags on this object type will be stored in the file "plugins/Denizen/player_flags/(UUID).dat", with automatic loading only when the player is online and caching for interacting with offline player flags. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/PlayerTag.java#L63 |
| Name | PluginTag |
| Prefix | pl@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for plugins is the plugin's registered name.
For example, 'pl@Denizen'. |
| Description | A PluginTag represents a Bukkit plugin on the server.
This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__plugins" |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/PluginTag.java#L24 |
| Name | PolygonTag |
| Prefix | polygon@ |
| Base Type | ElementTag |
| Implements | FlaggableObject, AreaObject |
| Identity Format | The identity format for polygons is <world>,<y-min>,<y-max>,<x1>,<z1>,... (the x,z pair repeats for as many points as the polygon has). |
| Description | A PolygonTag represents a polygonal region in the world.
The word 'polygon' means an arbitrary 2D shape. PolygonTags, in addition to a 2D polygon, contain a minimum and maximum Y coordinate, to allow them to function in 3D. PolygonTags are NOT polyhedra. A PolygonTag with 4 points at right angles would cover an area also possible to be defined by a CuboidTag, however all other shapes a PolygonTag can form are unique. Compared to CuboidTags, PolygonTags are generally slower to process and more complex to work with, but offer the benefit of supporting more intricate shapes. Note that forming invalid polygons (duplicate corners, impossible shapes, etc) will not necessarily give any error message, and may cause weird results. This object type can be noted. This object type is flaggable when it is noted. Flags on this object type will be stored in the notables.yml file. |
| Matchable | Refer to areaobject's matchable list. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/PolygonTag.java#L29 |
| Name | QuaternionTag |
| Prefix | quaternion@ |
| Base Type | ElementTag |
| Identity Format | The identity format for quaternions is <x>,<y>,<z>,<w>
For example "0,0,0,1" is the Identity quaternion. You can input the word "identity" to get an identity quaternion as well. You can also construct quaternions via tags such as VectorObject.to_axis_angle_quaternion or VectorObject.quaternion_between_vectors. |
| Description | A QuaternionTag represents a 3D rotation in an advanced mathematical format.
These are only useful in certain obscure cases, such as Display entities. They have some useful capabilities, such as preventing 'gimbal lock' (a phenomenon where repeatedly rotating something eventually stops working). See https://en.wikipedia.org/wiki/Quaternion for more info about what a quaternion actually is. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/QuaternionTag.java#L16 |
| Name | QueueTag |
| Prefix | q@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for queues is simply the queue ID. |
| Description | A QueueTag is a single currently running set of script commands.
This is not to be confused with a script path, which is a single set of script commands that can be run. There can be one, multiple, or zero queues running at any time for any given path. This object type is flaggable. Flags on this object type will be reinterpreted as definitions. Flags on queues should just not be used. Use definitions directly. |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/QueueTag.java#L21 |
| Name | ScriptTag |
| Prefix | s@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for scripts is simply the script name. |
| Description | An ObjectTag that represents a script container. ScriptTags contain all information inside the script,
and can be used in a variety of commands that require script arguments. For example, run and inject will 'execute' script entries inside of a script container when given a matching ScriptTag object. ScriptTags also provide a way to access attributes accessed by the replaceable tag system by using the object fetcher or any other entry point to a ScriptTag object. This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__scripts" |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/ScriptTag.java#L84 |
| Name | SecretTag |
| Prefix | secret@ |
| Base Type | ElementTag |
| Identity Format | The identity format for secrets is simply the secret key (as defined by the file 'secrets.secret' in the Denizen folder). |
| Description | A SecretTag represents a value that should never be exposed to logs or tags.
For example: authorization tokens, API keys, etc. A SecretTag is made of a 'key', and a 'value'. The key is a simple name, like 'my_bot_token', that is safe to show in logs/etc. The value is the actual internal data that must be kept secret, often a generated code. The keys and values must be defined in the 'secrets.secret' file inside the Denizen folder. The contents of that file would look something like: !SECRETS_FILE my_bot_token: abc123.123abc my_api_key: 1a2b3c4d5e6f The above example defines SecretTag 'my_bot_token' as 'abc123.123abc', meaning you could then use '<secret[my_bot_token]>' in the input to a command that parses secrets to have it understand the real value to input should be 'abc123.123abc' However if you use the same tag in for example a narrate command, it would just narrate 'secret@my_bot_token', keeping your real value safe. Note that the "!SECRETS_FILE" prefix cannot be removed, but comments can be added/removed/altered freely with a "#" prefix. Commands that accept SecretTag inputs will document that information in the command meta. For example, see webget. There is intentionally no tag that can read the value of a secret. You can reload the secrets file via "/ex reload config" |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/SecretTag.java#L48 |
| Name | TimeTag |
| Prefix | time@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for TimeTags is "yyyy/mm/dd_hh:mm:ss:mill_offset"
So, for example, 'time@2020/05/23_02:20:31:123_-07:00' |
| Description | A TimeTag represents a real world date/time value.
TimeTags can also be constructed from 'yyyy/mm/dd', 'yyyy/mm/dd_hh:mm:ss', or 'yyyy/mm/dd_hh:mm:ss:mill'. (Meaning: the offset is optional, the milliseconds are optional, and the time-of-day is optional, but if you exclude an optional part, you must immediately end the input there, without specifying more). This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__time" |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/core/TimeTag.java#L25 |
| Name | TradeTag |
| Prefix | trade@ |
| Base Type | ElementTag |
| Implements | PropertyHolderObject |
| Identity Format | The identity format for trades is just the text 'trade'. All other data is specified through properties. |
| Description | Merchant trades are the parts of a special merchant inventory that is typically viewed by right clicking
a villager entity. Any number of trades can fit in a single merchant inventory. Trades are represented by TradeTags. The properties that can be used to customize a merchant trade are: result=<item> inputs=<item>(|<item>) uses=<number of uses> max_uses=<maximum number of uses> has_xp=true/false For example, the following command opens a virtual merchant inventory with two merchant trades. The first trade offers a sponge for two emeralds, can be used up to 10 times, and offers XP upon a successful transaction. The second trade has zero maximum uses and displays a barrier. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/TradeTag.java#L17 |
| Name | WorldTag |
| Prefix | w@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for worlds is the name of the world it should be associated with.
For example, to reference the world named 'world1', use simply 'world1'. World names are case insensitive. |
| Description | A WorldTag represents a world on the server.
This object type is flaggable. Flags on this object type will be stored in the world folder in a file named 'denizen_flags.dat', like "server/world/denizen_flags.dat". |
| Matchable | WorldTag matchers, sometimes identified as "<world>":
"world" plaintext: always matches. World name: matches if the world has the given world name, using advanced matchers. "world_flagged:<flag>": a Flag Matchable for WorldTag flags. |
| Source | https://github.com/DenizenScript/Denizen/blob/dev/plugin/src/main/java/com/denizenscript/denizen/objects/WorldTag.java#L42 |
| Name | AreaShopTag |
| Prefix | areashop@ |
| Base Type | ElementTag |
| Identity Format | The identity format for shops is <shop_name>
For example, 'areashop@my_shop'. |
| Description | An AreaShopTag represents an AreaShop shop. |
| Requires | Depenizen, AreaShop |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/areashop/AreaShopTag.java#L19 |
| Name | BigDoorsDoorTag |
| Prefix | bigdoor@ |
| Base Type | ElementTag |
| Identity Format | The identity format for a door is it's Door ID as a number. NOT the name of the door you have set.
For example, 'bigdoor@1'. |
| Description | A BigDoorsDoorTag represents a Big Doors door. |
| Requires | Depenizen, Big Doors |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/bigdoors/BigDoorsDoorTag.java#L20 |
| Name | DiscordBotTag |
| Prefix | discord@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord bots is the bot ID (as chosen in discord).
For example: mybot |
| Description | A DiscordBotTag is an object that represents a Discord bot powered by dDiscordBot.
This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordBotTag.java#L19 |
| Name | DiscordButtonTag |
| Prefix | discordbutton@ |
| Base Type | ElementTag |
| Identity Format | The identity format for Discord button is a map of button data. Do not alter raw button data, use the with.as tag instead. |
| Description | A DiscordButtonTag is an object that represents a Discord button for use with dDiscordBot. |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordButtonTag.java#L22 |
| Name | DiscordChannelTag |
| Prefix | discordchannel@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord channels is the bot ID (optional), followed by the channel ID (required).
For example: 1234 Or: mybot,1234 |
| Description | A DiscordChannelTag is an object that represents a channel (text or voice) on Discord, either as a generic reference,
or as a bot-specific reference (the relevant guild is inherently linked, and does not need to be specified). This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__channels" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordChannelTag.java#L28 |
| Name | DiscordCommandTag |
| Prefix | discordcommand@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord commands is the bot ID (optional), followed by the guild ID (optional), followed by the command ID (required).
For example: 1234 Or: 12,1234 Or: mybot,12,1234 |
| Description | A DiscordCommandTag is an object that represents a created slash command on Discord, as a bot-specific reference.
This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__commands" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordCommandTag.java#L25 |
| Name | DiscordEmbedTag |
| Prefix | discordembed@ |
| Base Type | ElementTag |
| Identity Format | The identity format for Discord embeds is a map of embed data.
The map matches the key set documented at DiscordEmbedTag.with.as, along with a "fields" key as a ListTag of MapTags with keys "title", "value", and "inline". |
| Description | A DiscordEmbedTag is an object that represents a Discord embed for use with dDiscordBot. |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordEmbedTag.java#L21 |
| Name | DiscordGroupTag |
| Prefix | discordgroup@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord groups is the bot ID (optional), followed by the guild ID (required).
For example: 1234 Or: mybot,1234 |
| Description | A DiscordGroupTag is an object that represents a group on Discord, either as a generic reference,
or as a bot-specific reference. Note that the correct name for what we call here a 'group' is inconsistent between different people. The Discord API calls it a "guild" (for historical reasons, not called that by *people* anymore usually), messages in the Discord app call it a "server" (which is a convenient name but is factually inaccurate, as they are not servers), many people will simply say "a Discord" (which is awkward for branding and also would be confusing if used in documentation). So we're going with "group" (which is still confusing because "group" sometimes refers to DM groups, but... it's good enough). This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__guilds" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordGroupTag.java#L27 |
| Name | DiscordInteractionTag |
| Prefix | discordinteraction@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord interactions is the bot ID, followed by the interaction ID.
For example: mybot,5678 |
| Description | A DiscordInteractionTag is an object that represents an interaction on Discord, either as a generic reference, or as a bot-specific reference.
Interactions are temporary - they only exist for 15 minutes. This object type is flaggable. Flags on this object type will be stored in temporary memory. |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordInteractionTag.java#L28 |
| Name | DiscordMessageTag |
| Prefix | discordmessage@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord messages is the bot ID (optional), followed by the channel ID (optional), followed by the message ID (required).
For example: 1234 Or: 12,1234 Or: mybot,12,1234 |
| Description | A DiscordMessageTag is an object that represents a message already sent on Discord, either as a generic reference,
or as a bot-specific reference. Note that this is not used for messages that *are going to be* sent. Note that this often does not contain data for messages that have been deleted (unless that data is cached). This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__messages" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordMessageTag.java#L26 |
| Name | DiscordReactionTag |
| Prefix | discordreaction@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord reactions is the bot ID, followed by the channel ID, followed by the message ID, followed by the reaction ID.
Or: mybot,12,1234,99 The reaction ID for custom reactions is an ID number, and for default emojis is the unicode text format of the emoji. |
| Description | A DiscordReactionTag is an object that represents a reaction to a message already sent on Discord, as a generic reference.
This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__reactions" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordReactionTag.java#L27 |
| Name | DiscordRoleTag |
| Prefix | discordrole@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord roles is the bot ID (optional), followed by the guild ID (optional), followed by the role ID (required).
For example: 4321 Or: 1234,4321 Or: mybot,1234,4321 |
| Description | A DiscordRoleTag is an object that represents a role on Discord, either as a generic reference,
or as a guild-specific reference, or as a bot+guild-specific reference. This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__roles" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordRoleTag.java#L26 |
| Name | DiscordSelectionTag |
| Prefix | discordselection@ |
| Base Type | ElementTag |
| Identity Format | The identity format for Discord selection menu is a map of menu data. Do not alter raw menu data, use the with.as tag instead. |
| Description | A DiscordSelectionTag is an object that represents a Discord selection menu for use with dDiscordBot. |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordSelectionTag.java#L24 |
| Name | DiscordTextInputTag |
| Prefix | discordtextinput@ |
| Base Type | ElementTag |
| Identity Format | The identity format for Discord text input is a map of relevant data. Do not alter raw text input data, use the with.as tag instead. |
| Description | A DiscordTextInputTag is an object that represents a Discord text input for use with dDiscordBot. |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordTextInputTag.java#L21 |
| Name | DiscordUserTag |
| Prefix | discorduser@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for Discord users is the bot ID (optional), followed by the user ID (required).
For example: 1234 Or: mybot,1234 |
| Description | A DiscordUserTag is an object that represents a user (human or bot) on Discord, either as a generic reference,
or as a bot-specific reference. This object type is flaggable. Flags on this object type will be stored in: plugins/dDiscordBot/flags/bot_(botname).dat, under special sub-key "__users" |
| Requires | dDiscordBot |
| Source | https://github.com/DenizenScript/dDiscordBot/blob/master/src/main/java/com/denizenscript/ddiscordbot/objects/DiscordUserTag.java#L28 |
| Name | FactionTag |
| Prefix | faction@ |
| Base Type | ElementTag |
| Identity Format | The identity format for factions is <faction_name>
For example, 'faction@my_faction'. |
| Description | A FactionTag represents a Factions faction. |
| Requires | Depenizen, Factions |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/factions/FactionTag.java#L22 |
| Name | GriefPreventionClaimTag |
| Prefix | gpclaim@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for claims is <claim_id>
For example, 'gpclaim@1234'. |
| Description | A GriefPreventionClaimTag represents a GriefPrevention claim.
This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__depenizen_gp_claims_id" |
| Requires | Depenizen, GriefPrevention |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/griefprevention/GriefPreventionClaimTag.java#L27 |
| Name | JobsJobTag |
| Prefix | job@ |
| Base Type | ElementTag |
| Identity Format | The identity format for jobs is the player UUID (optional), followed by the job name
For example: job@460e96b9-7a0e-416d-b2c3-4508164b8b1b,job_name Or: job@job_name |
| Description | A JobsJobTag represents a Jobs job, with a player's progression if specified. |
| Matchable | JobsJobTag matchers, sometimes identified as "<job>":
"job" plaintext: always matches. Job name: matches if the job name matches the input, using advanced matchers. |
| Requires | Depenizen, Jobs |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/jobs/JobsJobTag.java#L26 |
| Name | LibsDisguiseTag |
| Prefix | libsdisguise@ |
| Base Type | ElementTag |
| Identity Format | The identity format for disguises is <disguise_name>
For example, 'libsdisguise@zombie'. |
| Description | A LibsDisguiseTag represents a LibsDisguises disguise type. |
| Requires | Depenizen, LibsDisguises |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/libsdisguises/LibsDisguiseTag.java#L17 |
| Name | LuckPermsGroupTag |
| Prefix | luckpermsgroup@ |
| Base Type | ElementTag |
| Identity Format | The identity format for group is <group_name>
For example, 'luckpermsgroup@my_group'. |
| Description | A LuckPermsGroupTag represents a LuckPerms group. |
| Requires | Depenizen, LuckPerms |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/luckperms/LuckPermsGroupTag.java#L16 |
| Name | LuckPermsTrackTag |
| Prefix | luckpermstrack@ |
| Base Type | ElementTag |
| Identity Format | The identity format for tracks is <track_name>
For example, 'luckpermstrack@my_track'. |
| Description | A LuckPermsTrackTag represents a LuckPerms track. |
| Requires | Depenizen, LuckPerms |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/luckperms/LuckPermsTrackTag.java#L24 |
| Name | MobArenaArenaTag |
| Prefix | mobarena@ |
| Base Type | ElementTag |
| Identity Format | The identity format for arenas is <arena_name>
For example, 'mobarena@my_arena'. |
| Description | A MobArenaArenaTag represents a mob arena in the world. |
| Requires | Depenizen, MobArena |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/mobarena/MobArenaArenaTag.java#L18 |
| Name | MythicMobsMobTag |
| Prefix | mythicmob@ |
| Base Type | ElementTag |
| Identity Format | The identity format for MythicMobsMobTag is <uuid>
For example, 'mythicmob@1234-1234-1234'. |
| Description | A MythicMobsMobTag represents a Mythic mob entity in the world. |
| Requires | Depenizen, MythicMobs |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/mythicmobs/MythicMobsMobTag.java#L31 |
| Name | MythicSpawnerTag |
| Prefix | mythicspawner@ |
| Base Type | ElementTag |
| Identity Format | The identity format for a MythicSpawner is its name.
For example, 'mythicspawner@AngrySludgeSpawner1'. |
| Description | A MythicSpawnerTag represents a MythicMobs spanwer in the world. |
| Requires | Depenizen, MythicMobs |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/mythicmobs/MythicSpawnerTag.java#L28 |
| Name | NationTag |
| Prefix | nation@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for nations is <nation_uuid>
For example, 'nation@123-abc'. |
| Description | A NationTag represents a Towny nation.
This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__depenizen_towny_nations_uuid" |
| Requires | Depenizen, Towny |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/towny/NationTag.java#L27 |
| Name | PartyTag |
| Prefix | party@ |
| Base Type | ElementTag |
| Identity Format | The identity format for parties is <party_name>
For example, 'party@my_party'. |
| Description | A PartyTag represents an McMMO party. |
| Requires | Depenizen, McMMO |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/mcmmo/PartyTag.java#L20 |
| Name | PlotSquaredPlotTag |
| Prefix | plotsquaredplot@ |
| Base Type | ElementTag |
| Identity Format | The identity format for plots is <x>,<z>,<world>
For example, 'plotsquaredplot@5,10,Hub'. |
| Description | A PlotSquaredPlotTag represents a PlotSquared plot in the world. |
| Requires | Depenizen, PlotSquared |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/plotsquared/PlotSquaredPlotTag.java#L25 |
| Name | PVPArenaArenaTag |
| Prefix | pvparena@ |
| Base Type | ElementTag |
| Identity Format | The identity format for arenas is <arena_name>
For example, 'pvparena@myarena'. |
| Description | A PVPArenaArenaTag represents a PvP Arena in the world. |
| Requires | Depenizen, PvPArena |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/pvparena/PVPArenaArenaTag.java#L17 |
| Name | ResidenceTag |
| Prefix | residence@ |
| Base Type | ElementTag |
| Identity Format | The identity format for residences is just the name.
For example, 'residence@myresidence'. |
| Description | A ResidenceTag represents a Residence in the world. |
| Matchable | ResidenceTag matchers, sometimes identified as "<residence>":
"residence" plaintext: always matches. Residence name: matches if the residence is named matches the input, using advanced matchers. |
| Requires | Depenizen, Residence |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/residence/ResidenceTag.java#L24 |
| Name | ShopKeeperTag |
| Prefix | shopkeeper@ |
| Base Type | ElementTag |
| Identity Format | The identity format for shopkeepers is <uuid>
For example, 'shopkeeper@1234-1234-1234'. |
| Description | A ShopKeeperTag represents a ShopKeeper entity in the world. |
| Requires | Depenizen, Shopkeepers |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/shopkeepers/ShopKeeperTag.java#L26 |
| Name | SkillAPIClassTag |
| Prefix | skillapiclass@ |
| Base Type | ElementTag |
| Identity Format | The identity format for regions is <class_name>
For example, 'skillapiclass@myclass'. |
| Description | A SkillAPIClassTag represents a SkillAPI class. |
| Requires | Depenizen, SkillAPI |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/skillapi/SkillAPIClassTag.java#L16 |
| Name | TownTag |
| Prefix | town@ |
| Base Type | ElementTag |
| Implements | FlaggableObject |
| Identity Format | The identity format for towns is <town_uuid>
For example, 'town@123-abc'. |
| Description | A TownTag represents a Towny town in the world.
This object type is flaggable. Flags on this object type will be stored in the server saves file, under special sub-key "__depenizen_towny_towns_uuid" |
| Requires | Depenizen, Towny |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/towny/TownTag.java#L29 |
| Name | ViveCraftPlayerTag |
| Prefix | vivecraft@ |
| Base Type | ElementTag |
| Identity Format | The identity format for ViveCraftPlayerTag is the UUID of the relevant player. |
| Description | A ViveCraftPlayerTag represents a player which is in VR. |
| Requires | Depenizen, ViveCraft |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/vivecraft/ViveCraftPlayerTag.java#L22 |
| Name | WorldGuardRegionTag |
| Prefix | region@ |
| Base Type | ElementTag |
| Identity Format | The identity format for regions is <region_name>,<world_name>.
For example, 'region@spawnland,Hub'. |
| Description | A WorldGuardRegionTag represents a WorldGuard region in the world. |
| Requires | Depenizen, WorldGuard |
| Source | https://github.com/DenizenScript/Depenizen/blob/master/src/main/java/com/denizenscript/depenizen/bukkit/objects/worldguard/WorldGuardRegionTag.java#L31 |