| 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 | 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 | 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 | EntityTag, ItemTag, LocationTag, MaterialTag, ModTag, 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#L29 |
| Name | EntityTag |
| Prefix | e@ |
| Base Type | ElementTag |
| Implements | PropertyHolderObject |
| Identity Format | The identity format for entities is either a spawned entity's UUID, or an entity type.
For example, 'e@1d7b97ac-e5dc-45f6-8bb2-3eb8a5ef190e' or 'e@zombie'. |
| Description | An EntityTag represents a spawned entity or a generic entity type.
Note that a spawned entity can be a living entity (a player, animal, monster, etc.) or a non-living entity (a painting, item frame, etc). |
| Matchable | EntityTag matchers, sometimes identified as "<entity>":
"entity" plaintext, always matches. "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). Any entity type name: matches if the entity is of the given type, using advanced matchers. |
| Source | https://github.com/DenizenScript/Clientizen/blob/master/src/main/java/com/denizenscript/clientizen/objects/EntityTag.java#L37 |
| 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 | ItemTag |
| Prefix | i@ |
| Base Type | ElementTag |
| Implements | PropertyHolderObject |
| Identity Format | The identity format for items is the basic material type name. Other data is specified in properties.
For example, 'i@stick'. |
| Description | An ItemTag represents a holdable item generically.
ItemTags do NOT remember where they came from. If you read an item from somewhere, changing it does not change the original item. 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. |
| Matchable | ItemTag matchers, sometimes identified as "<item>":
"item" plaintext: always matches. "item_enchanted:<enchantment>": matches if the item is enchanted with the given enchantment (excluding enchantment books), allows advanced matchers. "server_script:<name>": matches if the item is from the given server-side item script, allows advanced matchers. Any item name: matches if the item is of the given type, using advanced matchers. |
| Source | https://github.com/DenizenScript/Clientizen/blob/master/src/main/java/com/denizenscript/clientizen/objects/ItemTag.java#L22 |
| 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 | VectorObject |
| Identity Format | The identity format for locations is <x>,<y>,<z>,<pitch>,<yaw>,<world>
Note that you can omit the world value. You can also omit either the pitch and yaw pair or the z value. For example, 'l@1,2.15,3,45,90,space' or 'l@7.5,99,3.2' |
| Description | A LocationTag represents a point in the world.
The Minecraft client has no concept of worlds other than the one it's currently in, so while including worlds is valid and supported for compatibility with server-side LocationTags, there is no validation that the world actually exists, and worlds are only referenced as simple names. Note that the 'l' prefix is a lowercase 'L', the first letter in 'location'. |
| Source | https://github.com/DenizenScript/Clientizen/blob/master/src/main/java/com/denizenscript/clientizen/objects/LocationTag.java#L27 |
| 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 | PropertyHolderObject |
| Identity Format | The identity format for materials is the material type name.
For example, 'm@stick'. |
| Description | A MaterialTag represents 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. |
| Matchable | MaterialTag matchers, sometimes identified as "<material>":
"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. Any block/item name: matches if the material is of the given type, using advanced matchers. |
| Source | https://github.com/DenizenScript/Clientizen/blob/master/src/main/java/com/denizenscript/clientizen/objects/MaterialTag.java#L21 |
| Name | ModTag |
| Prefix | mod@ |
| Base Type | ElementTag |
| Identity Format | The identity format for mods is the mod id.
For example, 'mod@clientizen' or 'mod@theprinter'. |
| Description | A ModTag represents a currently loaded Fabric mod.
This can be either a mod that's been downloaded and installed, a built-in mod, or a mod within another mod (a library mod, for example) |
| Matchable | ModTag matchers:
"mod" plaintext: always matches. Mod id: matches if the mod id matches the input, using advanced matchers. |
| Source | https://github.com/DenizenScript/Clientizen/blob/master/src/main/java/com/denizenscript/clientizen/objects/ModTag.java#L22 |
| 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 | 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 | 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, ItemTag, MaterialTag |
| Source | https://github.com/DenizenScript/Denizen-Core/blob/master/src/main/java/com/denizenscript/denizencore/objects/properties/PropertyParser.java#L449 |
| 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 |