Conditions

Allay May Beget a Twin

🔗

Condition

Patterns:
Since: 2.11
Doth verify whether an allay is able to duplicate itself by nature's own course.

Examples:

if last spawned allay can duplicate:
    disallow last spawned to duplicate

Be Amongst the Living

🔗

Condition

Patterns:
  • %entities% (is|are) (amongst the living|fallen)
  • %entities% (isn't|is not|aren't|are not) (amongst the living|fallen)
Since: 2.0, 2.4-alpha4 (non-living entity support)
Examineth whether an entity yet liveth. Functioneth for non-living entities as well.

Examples:

if {villager-buddy::%player's uuid%} is not fallen:

on shoot:
    while the projectile is amongst the living:

Be Astride

🔗

Condition

Patterns:
Since: 2.0, 2.11 (entities)
Doth examine whether an entity rideth upon any creature, a particular manner of entity, or a specific entity.

Examples:

if player is riding:

if player is riding an entity:

if player is riding a saddled pig:

if player is riding last spawned horse:

Be Banished

🔗

Condition

Patterns:
Since: 1.4
Ascertaineth whether a player or IP hath been banished from the realm.

Examples:

player is banished

victim is not IP-banished

"127.0.0.1" is banished

Be Block Redstone Empowered

🔗

Condition

Patterns:
  • %blocks% (is|are) redstone empowered
  • %blocks% (is|are) indirectly redstone empowered
  • %blocks% (is|are)(n't| not) redstone empowered
  • %blocks% (is|are)(n't| not) indirectly redstone empowered
Since: 2.5
Examineth whether a block be indirectly or directly empowered by redstone.

Examples:

if clicked block is redstone empowered:
    send "This block is well-empowered by redstone!"

if clicked block is indirectly redstone empowered:
    send "This block is indirectly redstone empowered."

Be Born of a Mob Spawner

🔗

Condition

Patterns:
  • %entities% (is|are) born of a [mob] spawner
  • %entities% (isn't|aren't|is not|are not) born of a [mob] spawner
  • %entities% (was|were) brought forth (from|by) a [mob] spawner
  • %entities% (wasn't|weren't|was not|were not) brought forth (from|by) a [mob] spawner
Since: 2.10
Ascertaineth whether an entity was brought forth from a mob spawner.

Examples:

send whether target is born of a mob spawner

Be Feigning Death

🔗

Condition

Patterns:
Since: 2.11
Doth verify whether an axolotl be feigning death, playing lifeless as a ruse most cunning.

Examples:

if last spawned axolotl is playing dead:
    make last spawned axolotl stop playing dead

Be Incendiary

🔗

Condition

Patterns:
  • %entities% ((is|are) incendiary|bringeth[s] a[n] (incendiary|fiery) explosion)
  • %entities% ((is not|are not|isn't|aren't) incendiary|(does not|do not|doesn't|don't) bringeth[s] a[n] (incendiary|fiery) explosion)
  • the [event(-| )]explosion (is|(is not|isn't)) (incendiary|fiery)
Since: 2.5
Discerneth whether an entity shall kindle fire when it doth explode. This condition may also be employed within an explosion prime event.

Examples:

on explosion prime:
    if the explosion is fiery:
        broadcast "A fiery explosive hath been set alight!"

Be Infinite

🔗

Condition

Patterns:
Since: 2.7
Doth ascertain whether potion effects or timespans be without end, stretching unto eternity.

Examples:

all of the active potion effects of the player are infinite

if timespan argument is infinite:

Be Interactable

🔗

Condition

Patterns:
Since: 2.5.2
Doth examine whether or not a block may be engaged with by mortal hand.

Examples:

on block break:
    if event-block is interactable:
        cancel event
        send "You cannot break interactable blocks!"

Be Invisible

🔗

Condition

Patterns:
Since: 2.7
Doth verify whether a living entity be hidden from mortal sight, unseen as a ghost upon the wind.

Examples:

target entity is invisible

Be Invulnerable

🔗

Condition

Patterns:
Since: 2.5, 2.10 (gamemode)
Doth ascertain whether an entity or a gamemode be beyond the reach of harm, as if blessed by divine providence.

Examples:

target entity is invulnerable

loop all gamemodes:
    if loop-value is not invulnerable:
        broadcast "the gamemode %loop-value% is vulnerable!"

Be It Fit for Plunder

🔗

Condition

Patterns:
Since: 2.10
Doth ascertain whether an entity or block be fit for plunder.Plunderable things art entities or blocks that may bear a loot table.

Examples:

spawn a pig at event-location
set {_pig} to last spawned entity
if {_pig} is fit for plunder:
    set loot table of {_pig} to "minecraft:entities/cow"
    # the pig shall now yield the spoils of a cow when slain, for it is indeed a plunderable entity.

set block at event-location to chest
if block at event-location is fit for plunder:
    set loot table of block at event-location to "minecraft:chests/simple_dungeon"
    # the chest shall now beget the spoils of a simple dungeon when opened, for it is indeed a plunderable block.

set block at event-location to white wool
if block at event-location is fit for plunder:
    # alas, naught shall come to pass, for a wool is not a plunderable block.

Be It Normalized

🔗

Condition

Patterns:
  • %vectors% (is|are) normalized
  • %vectors% (isn't|is not|aren't|are not) normalized
Since: 2.5.1
Ascertaineth whether a vector be normalized, that is to say, of a length equal to one.

Examples:

vector of player's location is normalized

Be It Tethered

🔗

Condition

Patterns:
Since: 2.5
Ascertaineth whether an entity be presently tethered by a leash.

Examples:

target entity is tethered by leash

Be It Transparent

🔗

Condition

Patterns:
  • %item types% (is|are) of transparent nature
  • %item types% (isn't|is not|aren't|are not) of transparent nature
Since: 2.2-dev36
Ascertaineth whether an item doth possess transparency. Mark well that this condition may not avail for all blocks, for the transparency ledger employed by Spigot is not entirely faithful.

Examples:

player's tool is of transparent nature.

Be It Unbreakable

🔗

Condition

Patterns:
Since: 2.5.1, 2.9.0 (breakable)
Ascertaineth whether an item be unbreakable in its constitution.

Examples:

if event-item is unbreakable:
    send "This item is unbreakable!" to player

if tool of {_p} is breakable:
    send "Your tool is breakable!" to {_p}

Be It Upon the Whitelist

🔗

Condition

Patterns:
  • [the] server (is|(isn't|is not)) (upon the white[ ]list|white[ ]listed)
  • %offline players% (is|are|(isn't|is not|aren't|are not)) white[ ]listed
  • [the] server white[ ]list (is|(isn't|is not)) enforced
Since: 2.5.2, 2.9.0 (enforce, offline players)
Requirements: MC 1.17+ (enforce)
Whether the server or a player doth stand upon the whitelist, or whether the server's whitelist be enforced.

Examples:

if the player is whitelisted:

if the server is upon the whitelist:

if the server whitelist is enforced:

Be It Valid

🔗

Condition

Patterns:
Since: 2.7, 2.10 (Scripts & Configs)
Ascertaineth whether a thing (an entity, a script, a config, and the like) doth hold validity.
An invalid entity may have perished or vanished from this mortal plane by some other cause.
An invalid script reference may have been reloaded, displaced, or rendered dormant since.

Examples:

if event-entity is of sound validity

Be Jumping

🔗

Condition

Patterns:
Since: 2.8.0
Doth verify whether a living entity be leaping skyward. This condition worketh not upon players.

Examples:

on spawn of zombie:
    while event-entity is not jumping:
        wait 5 ticks
    push event-entity upwards

Be Laden Upon Memory

🔗

Condition

Patterns:
  • chunk[s] %directions% [%locations%] (is|are)[((n't| not))] laden upon memory
  • chunk [at] %number%, %number% (in|of) [world] %world% is[((n't| not))] laden upon memory
  • %scripts/worlds% (is|are)[(n't| not)] laden upon memory
  • script[s] %scripts% (is|are)[(n't| not)] laden upon memory
  • world[s] %worlds% (is|are)[(n't| not)] laden upon memory
Since: 2.3, 2.5 (revamp with chunk at location/coords), 2.10 (Scripts)
Doth verify whether a world, chunk, or script hath been laden into memory and standeth ready.
'chunk at 1, 1' employeth chunk coordinates, which art location coords divided by 16.

Examples:

if chunk at {home::%player's uuid%} is laden upon memory:

if chunk 1, 10 in world "world" is laden upon memory:

if world("lobby") is laden upon memory:

if script named "MyScript.sk" is laden upon memory:

Be Occluding

🔗

Condition

Patterns:
Since: 2.5.1
Doth ascertain whether an item be a block that doth wholly obstruct one's vision, as a wall before thine eyes.

Examples:

player's tool is occluding

Be Passable

🔗

Condition

Patterns:
  • %blocks% (is|are) passable
  • %blocks% (isn't|is not|aren't|are not) passable
Since: 2.5.1
Doth examine whether a block may be traversed without hindrance.
A block is passable if it possesseth no colliding parts that would bar players from passing through.
Blocks such as tall grass, flowers, signs, and the like art passable, yet open doors, fence gates, trap doors, and their ilk art not, for they still bear parts with which one may collide.

Examples:

if player's targeted block is passable

Be Pathfinding

🔗

Condition

Patterns:
Since: 2.9.0
Doth ascertain whether living entities art seeking a path upon their journey.
The entity in question must needs be a living creature that is a Mob.

Examples:

make {_entity} pathfind to {_location} at speed 2
while {_entity} is pathfinding
    wait a second
launch flickering trailing burst firework colored red at location of {_entity}
subtract 10 from {defence::tower::health}
clear entity within {_entity}

Be Persistent

🔗

Condition

Patterns:
Since: 2.11
Whether entities, players, or leaves do endure with persistence.
Persistence of entities speaketh to whether they be retained through server restarts.
Persistence of leaves is whether they ought to decay when unconnected to a log block within six metres.
Persistence of players determineth if the player's data shall be preserved when they depart the server. Players' persistence is restored unto 'true' when they rejoin the server.
Passengers do inherit the persistence of their vehicle, meaning a persistent zombie set upon a non-persistent chicken shall itself become non-persistent. This applieth not unto players.
By default, all entities art persistent.

Examples:

on spawn:
    if event-entity is persistent:
        make event-entity not persistent

Be Plugin Enabled

🔗

Condition

Patterns:
  • plugin[s] %texts% (is|are) enabled
  • plugin[s] %texts% (is|are)(n't| not) enabled
  • plugin[s] %texts% (is|are) disabled
Since: 2.6
Doth examine whether a plugin be enabled or disabled upon the server.
Plugin names may be found within the plugin's 'plugin.yml' scroll or by invoking the '/plugins' command; they art NOT the name of the plugin's jar vessel.
When checking if a plugin be not enabled, this shall yield true if the plugin be either disabled or absent from the server.
When checking if a plugin be disabled, this shall yield true if the plugin resideth upon the server yet standeth disabled.

Examples:

if plugin "Vault" is enabled:

if plugin "WorldGuard" is not enabled:

if plugins "Essentials" and "Vault" are enabled:

if plugin "MyBrokenPlugin" is disabled:

Be Present in the Realm

🔗

Condition

Patterns:
Since: 1.4
Doth ascertain whether a player be present within the realm. The 'connected' pattern shall yield false once said player departeth the server, even shouldst they return anon. Be warned that employing the 'connected' pattern with a variable shall not possess this special comportment. Employ the direct event-player or other non-variable expression for truest results.

Examples:

player is online

player-argument is offline

while player is connected:
    wait 60 seconds
    send "hello!" to player

# The following will act like `{_player} is online`.
# Using variables with `is connected` will not behave the same as with non-variables.
while {_player} is connected:
    broadcast "online!"
    wait 1 tick

Be Spawnable

🔗

Condition

Patterns:
Since: 2.13
Whether a creature type may be summoned forth into a world. Any general types such as 'monster, mob, entity, living entity' and the like shall never be spawnable.

Examples:

if a pig is spawnable in world "world": # true
if a monster can be spawned in {_world}: # false

Be Stackable

🔗

Condition

Patterns:
Since: 2.7
Ascertaineth whether an item may be stacked together in a pile.

Examples:

diamond axe is stackable

birch wood is stackable

torch is stackable

Be Tameable

🔗

Condition

Patterns:
Since: 2.5
Ascertaineth whether an entity may be tamed and brought under one's dominion.

Examples:

on damage:
    if victim is tameable:
        cancel event

Be Tamed

🔗

Condition

Patterns:
  • %entities% (is|are) (tamed|domesticated)
  • %entities% (isn't|is not|aren't|are not) (tamed|domesticated)
Since: 2.10
Ascertaineth whether a tameable creature hath been tamed and brought to heel (horse, parrot, cat, and such).

Examples:

send true if {_horse} is tamed

tame {_horse} if {_horse} is untamed

Be They Adorned

🔗

Condition

Patterns:
Since: 1.0
Ascertaineth whether an entity be adorned with certain items (most oft armour).

Examples:

player is adorned with an iron chestplate and iron leggings

target is adorned with wolf armor

Be Upon the Ground

🔗

Condition

Patterns:
  • %entities% (is|are) upon [the] ground
  • %entities% (isn't|is not|aren't|are not) upon [the] ground
Since: 2.2-dev26
Doth verify whether an entity standeth firm upon the earth.

Examples:

player is not upon the ground

Be Warding

🔗

Condition

Patterns:
  • %players% (is|are) (warding|defending) [with [a] shield]
  • %players% (isn't|is not|aren't|are not) (warding|defending) [with [a] shield]
Since: unknown (before 2.1)
Discerneth whether a player doth ward themselves with their shield.

Examples:

on damage of player:
    victim is warding
    damage attacker by 0.5 hearts

Be a Block

🔗

Condition

Patterns:
  • %item types% (is|are) ([a] block|blocks)
  • %item types% (isn't|is not|aren't|are not) ([a] block|blocks)
Since: 2.4
Discerneth whether an item be a block.

Examples:

player's held item is a block

{list::*} are blocks

Be a Skript Command

🔗

Condition

Patterns:
  • %text% (is|are) [a] s(k|c)ript (command|cmd)
  • %text% (isn't|is not|aren't|are not) [a] s(k|c)ript (command|cmd)
Since: 2.6
Ascertaineth whether a command or string be a custom Skript command.

Examples:

on command:
    command is a skript command

Be a Slime Chunk

🔗

Condition

Patterns:
  • %chunk% (is|are) ([a] slime chunk|slime chunks|slimey)
  • %chunk% (isn't|is not|aren't|are not) ([a] slime chunk|slime chunks|slimey)
Since: 2.3
Determineth whether a chunk be a so-called slime chunk.
Slimes may generally spawn within the swamp biome and within slime chunks.
For further knowledge, consult the Minecraft wiki.

Examples:

command /slimey:
    trigger:
        if chunk at player is a slime chunk:
            send "Aye, verily it is!"
        else:
            send "Nay, it is not"

Be an Operator of the Realm

🔗

Condition

Patterns:
Since: 2.7
Doth verify whether a player holdeth the mantle of server operator, wielding authority most supreme.

Examples:

player is an operator

Be of Solid Substance

🔗

Condition

Patterns:
Since: 2.2-dev36
Ascertaineth whether an item possesseth solid substance.

Examples:

grass block is solid

player's tool isn't solid

Be of a Certain Kind

🔗

Condition

Patterns:
Since: 1.4
Doth verify whether an item or an entity be of the given kind. This serveth most usefully for variables, for thou mayest employ the general 'is' condition otherwise (e.g. 'victim is a creeper').

Examples:

tool is of kind {selected type}

victim is of kind {villager type}

Beehive Be Sedated

🔗

Condition

Patterns:
  • %blocks% (is|are) sedated
  • %blocks% (isn't|is not|aren't|are not) sedated
Since: 2.11
Ascertaineth whether a beehive hath been lulled to calm by a nearby campfire.

Examples:

if {_beehive} is sedated:

Bell Doth Resonate

🔗

Condition

Patterns:
  • %blocks% (is|are) resonating
  • %blocks% (isn't|is not|aren't|are not) resonating
Since: 2.9.0
Doth verify whether a bell presently resonateth with its sonorous voice.
A bell shall commence its resonance five game ticks after being struck, and shall continue to resound for forty game ticks.

Examples:

target block is resonating

Bell Doth Ring

🔗

Condition

Patterns:
  • %blocks% (is|are) ringing
  • %blocks% (isn't|is not|aren't|are not) ringing
Since: 2.9.0
Ascertaineth whether a bell doth presently ring. A bell doth commonly toll for fifty game ticks.

Examples:

target block is ringing

Brewing Stand Shall Consume Fuel

🔗

Condition

Patterns:
  • [the] brewing stand shall consume [the] fuel
  • [the] brewing stand (shall not|shan't) consume [the] fuel
Since: 2.13
Ascertaineth whether the 'brewing fuel' occasion shall consume fuel. Preventing the fuel from being consumed shall preserve the fuel item and still augment the fuel level of the brewing stand.

Examples:

on brewing fuel:
    if the brewing stand shall consume the fuel:
        forbid the brewing stand from consuming the fuel

Camel Is Dashing

🔗

Condition

Patterns:
Since: 2.11
Discerneth whether a camel doth presently employ its galloping dash.

Examples:

if last spawned camel is dashing:
    kill last spawned camel

Can Age

🔗

Condition

Patterns:
Since: 2.10
Discerneth whether an entity shall be able to age and grow unto maturity.

Examples:

on breeding:
    entity can't age
    broadcast "An immortal hath been born!" to player

Can Breed

🔗

Condition

Patterns:
Since: 2.10
Discerneth whether a living entity may be bred.

Examples:

on right click on living entity:
    event-entity can't breed
    send "It doth appear %event-entity% cannot be bred. Surely a Skript user!" to player

Can Vanish

🔗

Condition

Patterns:
Since: 2.11
Inspecteth whether an entity may vanish when the chunk wherein it dwelleth is unloaded.
Further wisdom on what creatures vanish and when may be found at reference.

Examples:

if last spawned entity can vanish on chunk unload:
    make last spawned entity not vanish on chunk unload

Commenceth or Concludeth With

🔗

Condition

Patterns:
  • %texts% (commence|conclude)[s] with %texts%
  • %texts% (doesn't|does not|do not|don't) (commence|conclude) with %texts%
Since: 2.2-dev36, 2.5.1 (multiple strings support)
Doth examine whether a text commenceth or concludeth with another.

Examples:

if the argument commences with "test" or "debug":
    send "Cease!"

Comparison of Worth

🔗

Condition

Patterns:
  • [(neither)] %objects% ((is|are)[(n't| not| neither)] ((greater|more|higher|bigger|larger) than|above)|>) %objects%
  • [(neither)] %objects% ((is|are)[(n't| not| neither)] (greater|more|higher|bigger|larger|above) [than] or (equal to|the same as)|>=) %objects%
  • [(neither)] %objects% ((is|are)[(n't| not| neither)] ((less|smaller|lower) than|below)|<) %objects%
  • [(neither)] %objects% ((is|are)[(n't| not| neither)] (less|smaller|lower|below) [than] or (equal to|the same as)|<=) %objects%
  • [(neither)] %objects% ((is|are) (not|neither)|isn't|aren't|!=) [equal to] %objects%
  • [(neither)] %objects% (is|are|=) [(equal to|the same as)] %objects%
  • [(neither)] %objects% (is|are) between %objects% and %objects%
  • [(neither)] %objects% (is not|are not|isn't|aren't) between %objects% and %objects%
  • [(neither)] %objects% (was|were)[(n't| not| neither)] ((greater|more|higher|bigger|larger) than|above) %objects%
  • [(neither)] %objects% (was|were)[(n't| not| neither)] (greater|more|higher|bigger|larger|above) [than] or (equal to|the same as) %objects%
  • [(neither)] %objects% (was|were)[(n't| not| neither)] ((less|smaller|lower) than|below) %objects%
  • [(neither)] %objects% (was|were)[(n't| not| neither)] (less|smaller|lower|below) [than] or (equal to|the same as) %objects%
  • [(neither)] %objects% ((was|were) (not|neither)|wasn't|weren't) [equal to] %objects%
  • [(neither)] %objects% (was|were) [(equal to|the same as)] %objects%
  • [(neither)] %objects% (was|were) between %objects% and %objects%
  • [(neither)] %objects% (was not|were not|wasn't|weren't) between %objects% and %objects%
  • [(neither)] %objects% (will be|(will (not|neither) be|won't be)) ((greater|more|higher|bigger|larger) than|above) %objects%
  • [(neither)] %objects% (will be|(will (not|neither) be|won't be)) (greater|more|higher|bigger|larger|above) [than] or (equal to|the same as) %objects%
  • [(neither)] %objects% (will be|(will (not|neither) be|won't be)) ((less|smaller|lower) than|below) %objects%
  • [(neither)] %objects% (will be|(will (not|neither) be|won't be)) (less|smaller|lower|below) [than] or (equal to|the same as) %objects%
  • [(neither)] %objects% ((will (not|neither) be|won't be)|(isn't|aren't|is not|are not) (turning|changing) [in]to) [equal to] %objects%
  • [(neither)] %objects% (will be [(equal to|the same as)]|(is|are) (turning|changing) [in]to) %objects%
  • [(neither)] %objects% will be between %objects% and %objects%
  • [(neither)] %objects% (will not be|won't be) between %objects% and %objects%
Since: 1.0
A most general condition, which doth simply compare two values. Ordinarily thou canst only compare for equality (e.g. block is/isn't of <type>), yet some values may also be compared using greater than or less than. In such a case thou mayest also test whether an object doth lie betwixt two others.
Note: This is the sole element wherein not all patterns are shown. It hath in truth another two sets of similar patterns, but with (was|were) or will be in place of (is|are) respectively, which do examine different time states of the first expression.

Examples:

the clicked block is a stone slab or a double stone slab

time in the player's world is greater than 8:00

the creature is not an enderman or an ender dragon

Contains (Property)

🔗

Condition

Patterns:
Since: Unknown
Checks whether a type or list contains certain elements. When checking if a list contains a specific element, use '{list::*} contains {x}'. When checking if a single type contains something, use `player's inventory contains {x}`. When checking if many types contain something, use '{inventories::*} contain {x}` or `contents of {inventories::*} contain {x}`.

Examples:

block contains 20 cobblestone

player has 4 flint and 2 iron ingots

{list::*} contains 5

names of {list::*} contain "prefix"

contents of the inventories of all players contain 1 stick

Creature Storage Be Full

🔗

Condition

Patterns:
  • [the] creature storage of %blocks% (is|are) full
  • %blocks%'[s] creature storage (is|are) full
  • [the] creature storage of %blocks% (isn't|is not|aren't|are not) full
  • %blocks%'[s] creature storage (isn't|is not|aren't|are not) full
Since: 2.11
Examineth whether a block's creature storage (such as a beehive) be filled to the brim.

Examples:

if the creature storage of {_beehive} is full:
    release the creature storage of {_beehive}

Do Respawn Anchors Function

🔗

Condition

Patterns:
  • respawn anchors [do[(n't| not)]] function in %worlds%
Since: 2.7
Requirements: Minecraft 1.16+
Doth ascertain whether respawn anchors shall function within a given world.

Examples:

respawn anchors function in world "world_nether"

Dominion Doth Contain

🔗

Condition

Patterns:
Since: 2.1
Requirements: Supported regions plugin
Doth verify whether a location be contained within a particular dominion.
This condition doth require a supported regions plugin to be installed.

Examples:

player is within the dominion {regions::3}

on region enter:
    region contains {flags.%world%.red}
    message "The crimson banner doth lie near!"

Doth Bear a Saddle

🔗

Condition

Patterns:
Since: 2.10
Ascertaineth whether a given entity (horse or steerable beast) doth bear a saddle.
If 'properly' be employed, this shall only yield true if the entity doth wear specifically a saddle item.

Examples:

send whether {_horse} is saddled

Doth Creep About

🔗

Condition

Patterns:
  • %players% (is|are) sneaking
  • %players% (isn't|is not|aren't|are not) sneaking
Since: 1.4.4
Ascertaineth whether a player doth creep about in stealth.

Examples:

# prevent mobs from espying sneaking players if they stand at least 4 metres apart
on target:
    target is sneaking
    distance of target and the entity is bigger than 4
    cancel the event

Doth Employ Experimental Feature

🔗

Condition

Patterns:
Since: 2.9.0
Ascertaineth whether a script doth employ an experimental feature by its given name.

Examples:

the script doth employ "example feature"

on load:
    if the script doth employ "example feature":
        broadcast "You're using an experimental feature!"

Doth Exist / Be Established

🔗

Condition

Patterns:
  • %~objects% (exist[s]|(is|are) set)
  • %~objects% (do[es](n't| not) exist|(is|are)(n't| not) set)
Since: 1.2
Ascertaineth whether a given expression or variable hath been established.

Examples:

{teams::%player's uuid%::preferred-team} is not set

on damage:
    projectile exists
    broadcast "%attacker% used a %projectile% to attack %victim%!"

Doth Hold Silence

🔗

Condition

Patterns:
Since: 2.5
Ascertaineth whether an entity remaineth silent, that is to say, its utterances be suppressed.

Examples:

target entity is silent

Doth Lie Within

🔗

Condition

Patterns:
Since: 2.7, 2.11 (world borders)
Requirements: MC 1.17+ (within block)
Whether a location doth lie within some other thing. The "something" may be a block, an entity, a chunk, a world, or a cuboid formed betwixt two other locations.
Mark well that employing the is between condition shall refer to a straight line betwixt locations, whilst this condition shall refer to the cuboid betwixt them.

Examples:

if player's location is contained betwixt {_loc1} and {_loc2}:
    send "You are in a PvP zone!" to player

if player is in world("world"):
    send "You are in the overworld!" to player

if attacker's location is inside of victim:
    cancel event
    send "Back up!" to attacker and victim

if player is in world "world1" or world "world2":
    kill player

if player is in world "world" and chunk at location(0, 0, 0):
    give player 1 diamond

Doth Match

🔗

Condition

Patterns:
  • %texts% (doth match|do[es](n't| not) match) %texts%
  • %texts% (doth partially match|do[es](n't| not) partially match) %texts%
Since: 2.5.2
Ascertaineth whether the given strings doth match the supplied regexes (Regular expressions).

Examples:

on chat:
    if message doth partially match "\d":
        send "Message contains a digit!"
    if message doesn't match "[A-Za-z]+":
        send "Message doesn't only contain letters!"

Doth Possess Permission

🔗

Condition

Patterns:
Since: 1.0
Doth examine whether a player possesseth a certain permission.

Examples:

player has permission "skript.tree"

victim has the permission "admin":
    send "Thou dost assail an administrator!" to attacker

Doth Riptide

🔗

Condition

Patterns:
Since: 2.5
Ascertaineth whether an entity doth presently employ the Riptide enchantment.

Examples:

target entity is riptiding

Doth Scream

🔗

Condition

Patterns:
Since: 2.11
Ascertaineth whether a goat or enderman doth cry out in terrible screaming.

Examples:

    if last spawned goat is not screaming:
        make last spawned goat scream

    if {_enderman} is screaming:
        force {_enderman} to stop screaming

Doth Slumber

🔗

Condition

Patterns:
Since: 1.4.4, 2.11 (living entities)
Ascertaineth whether an entity doth presently slumber.

Examples:

if player is sleeping:
    make player wake up without spawn location update

if last spawned fox is sleeping:
    make last spawned fox stop sleeping

Doth Sprint

🔗

Condition

Patterns:
  • %players% (is|are) sprinting
  • %players% (isn't|is not|aren't|are not) sprinting
Since: 1.4.4
Ascertaineth whether a player doth sprint with great haste.

Examples:

player is not sprinting

Doth Swim

🔗

Condition

Patterns:
Since: 2.3
Ascertaineth whether a living entity doth presently swim through the waters.

Examples:

player is swimming

Doth Tick

🔗

Condition

Patterns:
Since: 2.10
Ascertaineth whether an entity doth presently tick within the world's course.

Examples:

send true if target is ticking

Doth Wield

🔗

Condition

Patterns:
Since: 1.0
Ascertaineth whether a player doth wield a particular item. Cannot be employed with endermen; use 'entity is [not] an enderman holding <item type>' in its stead.

Examples:

player doth wield a stick

victim doth not wield a diamond sword of sharpness

Egg Shall Hatch

🔗

Condition

Patterns:
  • [the] egg (shall|shall not|shan't) hatch
Since: 2.7
Whether the egg shall hatch in a Player Egg Throw event.

Examples:

on player egg throw:
    if an entity shan't hatch:
        send "Better fortune next time!" to the player

Enderman Hath Been Gazed Upon

🔗

Condition

Patterns:
Since: 2.11
Doth ascertain whether an enderman hath been gazed upon.
This shall return true so long as the entity that did gaze upon the enderman yet liveth.

Examples:

if last spawned enderman has been gazed upon:

Entity Be Drenched

🔗

Condition

Patterns:
  • %entities% (is|are) drenched
  • %entities% (isn't|is not|aren't|are not) drenched
Since: 2.6.1
Ascertaineth whether an entity be drenched or nay (submerged in water, beset by rain, or within a bubble column).

Examples:

if player is drenched:

Entity Be Shorn

🔗

Condition

Patterns:
Since: 2.8.0
Ascertaineth whether entities have been shorn of their fleece.

Examples:

if targeted entity of player is sheared:
    send "This entity hath nothing left to shear!" to player

Entity Dwelleth in Liquid

🔗

Condition

Patterns:
  • %entities% (is|are) in (water|lava|[a] bubble[ ]column|rain)
  • %entities% (isn't|is not|aren't|are not) in (water|lava|[a] bubble[ ]column|rain)
Since: 2.6.1
Doth examine whether an entity dwelleth in rain, lava, water, or a bubble column.

Examples:

if player is in rain:

if player is in water:

player is in lava:

player is in bubble column

Equippable Component - May Be Dispensed Forth

🔗

Condition

Patterns:
Since: 2.13
Requirements: Minecraft 1.21.2+
Whether an item may be dispensed forth by a dispenser. NOTE: Equippable component elements art experimental. Thus, they art subject to change and may not function as intended.

Examples:

if {_item} can be dispensed forth:
    add "Dispensable" to lore of {_item}

set {_component} to the equippable component of {_item}
if {_component} is not able to be dispensed forth:
    grant {_component} to be dispensed forth

Equippable Component - May Be Donned Upon Entities

🔗

Condition

Patterns:
Since: 2.13
Requirements: Minecraft 1.21.5+
Whether an entity ought to don the item whence one doth right-click upon the entity with said item. NOTE: Equippable component elements art experimental. Thus, they art subject to change and may not function as intended.

Examples:

if {_item} can be donned upon entities:

Equippable Component - May Be Shorn

🔗

Condition

Patterns:
Since: 2.13
Requirements: Minecraft 1.21.6+
Whether an item may be shorn from an entity. NOTE: Equippable component elements art experimental. Thus, they art subject to change and may not function as intended.

Examples:

if {_item} can be shorn from:
    add "Shearable" to lore of {_item}

set {_component} to the equippable component of {_item}
if {_component} can not be shorn from:
    grant {_component} to be shorn from

Equippable Component - May Exchange Armament

🔗

Condition

Patterns:
Since: 2.13
Requirements: Minecraft 1.21.2+
Whether an item may exchange armament by right clicking with it in thine hand. The item shall swap places of the appointed 'equipment slot' of the item. If no equipment slot be set, it defaults to the helmet. NOTE: Equippable component elements art experimental. Thus, they art subject to change and may not function as intended.

Examples:

if {_item} can exchange armament:
    add "Swappable" to lore of {_item}

set {_component} to the equippable component of {_item}
if {_component} can not exchange armament when right clicked:
    make {_component} exchange armament

Equippable Component - Shall Forfeit Durability

🔗

Condition

Patterns:
  • %equippable components% shall (forfeit durability|suffer damage) (upon [wearer['s]] wounding|when [[the] wearer [is]] (hurt|wounded|harmed))
  • %equippable components% (shall not|shan't) (forfeit durability|suffer damage) (upon [wearer['s]] wounding|when [[the] wearer [is]] (hurt|wounded|harmed))
Since: 2.13
Requirements: Minecraft 1.21.2+
Whether an item shall suffer damage whence its wearer receiveth injury. NOTE: Equippable component elements art experimental. Thus, they art subject to change and may not function as intended.

Examples:

if {_item} shall forfeit durability when hurt:
    add "Damageable on injury" to lore of {_item}

set {_component} to the equippable component of {_item}
if {_component} shan't forfeit durability upon wounding:
    make {_component} forfeit durability when wounded

Fishing Lure Bestowed

🔗

Condition

Patterns:
  • lure enchantment boon is (bestowed|active)
  • lure enchantment boon is(n't| not) (bestowed|active)
Since: 2.10
Ascertaineth whether the lure enchantment is bestowed upon the present fishing occasion.

Examples:

on fishing line cast:
    if lure enchantment boon is bestowed:
        cancel event

Fortune's Favour

🔗

Condition

Patterns:
  • fortune of %number%[(\%)] [(fails|failed)]
Since: 1.0, 2.14 (chance fails)
A condition that doth randomly succeed or fail, as Fortune wills it. Valid values art between 0% and 100%, or if the percent sign be omitted, between 0 and 1.

Examples:

fortune of 50%:
    drop a diamond at location(100, 100, 100, "world')

fortune of {chance}% # {chance} between 0 and 100

fortune of {chance} # {chance} between 0 and 1

if fortune of 99% fails:
    broadcast "Haha loser! *points and laughs*"

Goat Hath Horns

🔗

Condition

Patterns:
  • %living entities% (has|have) ((any|a) horn|[a] sinister horn[s]|[a] dexter horn[s]|both horns)
  • %living entities% (doesn't|does not|do not|don't) have ((any|a) horn|[a] sinister horn[s]|[a] dexter horn[s]|both horns)
Since: 2.11
Examineth whether a goat doth possess or doth lack a sinister, dexter, or both horns.

Examples:

    if last spawned goat does not have both horns:
        make last spawned goat have both horns

if {_goat} has a dexter horn:
    force {_goat} to not have a dexter horn

Hath Artificial Intelligence

🔗

Condition

Patterns:
  • %living entities% (has|have) (ai|artificial intelligence|a cunning mind)
  • %living entities% (doesn't|does not|do not|don't) have (ai|artificial intelligence|a cunning mind)
Since: 2.5
Doth ascertain whether an entity possesseth artificial intelligence.

Examples:

target entity has ai

Hath Bespoke Weather

🔗

Condition

Patterns:
  • %players% (has|have) [a] (bespoke|custom) weather [set]
  • %players% (doesn't|does not|do not|don't) have [a] (bespoke|custom) weather [set]
Since: 2.3
Ascertaineth whether the given players possess a bespoke client weather bestowed upon them.

Examples:

if the player has bespoke weather:
    message "Thy bespoke weather is %player's weather%"

Hath Chat Purification

🔗

Condition

Patterns:
  • %players% (has|have) (chat|text) purification (on|enabled)
  • %players% (doesn't|does not|do not|don't) have (chat|text) purification (on|enabled)
Since: 2.10
Doth ascertain whether a player hath chat purification enabled upon their person.

Examples:

if player doesn't have chat purification enabled:
    send "<gray>This server may contain mature chat messages. You have been warned!" to player

Hath Custom Model Data

🔗

Condition

Patterns:
  • %item types% (has|have) [custom] model data [floats|flags|strings|colo[u]rs]
  • %item types% (doesn't|does not|do not|don't) have [custom] model data [floats|flags|strings|colo[u]rs]
Since: 2.5, 2.12 (expanded data types)
Requirements: Minecraft 1.21.4+ (floats/flags/strings/colours)
Examineth whether an item doth bear a custom model data tag.

Examples:

player's tool has custom model data

if player's tool has custom model data flags:
    loop custom model data flags of player's tool:
        send "Flag %loop-index%: %loop-value%"

set {_coloured} to whether player's tool has model data colours

Hath Graced This Server Before

🔗

Condition

Patterns:
  • %offline players% [(has|have|did)] [already] graced [the halls of] (this|the) server (before|already)
  • %offline players% (has not|hasn't|have not|haven't|did not|didn't) [(already|yet)] graced [the halls of] (this|the) server (before|already|yet)
Since: 1.4, 2.7 (multiple players)
Doth determine whether a player hath previously graced this server with their presence. Thou mayest also employ on first join shouldst thou wish to fashion triggers for newcomers.

Examples:

player has graced this server before

player hasn't graced the server before

Hath Item Cooldown

🔗

Condition

Patterns:
Since: 2.8.0
2.12 (cooldown group)
Requirements: MC 1.21.2 (cooldown group)
Checketh whether a cooldown be active upon the specified item for a particular player. Should the provided item bear a cooldown group component, the cooldown group shall take precedence. Otherwise, the cooldown of the item's material shall be employed.

Examples:

if player has player's tool upon cooldown:
    send "Thou canst not wield this item presently. Tarry %item cooldown of player's tool for player%"

Hath Item Tooltips

🔗

Condition

Patterns:
  • [the] [entire|additional] tool[ ]tip[s] of %item types% (is|are) (revealed|concealed)
  • [the] [entire|additional] tool[ ]tip[s] of %item types% (isn't|is not|aren't|are not) (revealed|concealed)
  • %item types%'[s] [entire|additional] tool[ ]tip[s] (is|are) (revealed|concealed)
  • %item types%'[s] [entire|additional] tool[ ]tip[s] (isn't|is not|aren't|are not) (revealed|concealed)
Since: 2.9.0
Requirements: Spigot 1.20.5+
Whether the entire or additional tooltip of an item is revealed or concealed.
The 'entire tooltip' is that which doth appear before the player when they hover upon an item (i.e. name, lore, and such).
The 'additional tooltip' doth conceal certain particulars from certain items (potions, maps, books, fireworks, and banners).

Examples:

send true if entire tooltip of player's tool is revealed

if additional tooltip of {_item} is concealed:

Hath Line of Sight

🔗

Condition

Patterns:
Since: 2.8.0
Ascertaineth whether living entities possess an unobstructed line of sight unto other entities or locations.

Examples:

player has clear line of sight to location 5 blocks to the right of player

victim has line of sight to attacker

player has no line of sight to location 100 blocks in front of player

Hath Luminous Text

🔗

Condition

Patterns:
Since: 2.8.0
Discerneth whether a sign (be it a block or an item) doth bear luminous text.

Examples:

if target block has luminous text

Hath Metadata

🔗

Condition

Patterns:
Since: 2.2-dev36
Examineth whether a metadata holder doth bear a metadata tag.

Examples:

if player has metadata mark "healer":

Hath Resource Pack

🔗

Condition

Patterns:
  • %players% (has|have) [a] resource pack [(laden|installed)]
  • %players% (doesn't|does not|do not|don't) have [a] resource pack [(laden|installed)]
Since: 2.4
Discerneth whether the given players have a server resource pack laden upon them. Pray note that this cannot detect a player's own resource pack, only the resource pack dispatched by the server.

Examples:

if the player has a resource pack laden:

Hath Scoreboard Mark

🔗

Condition

Patterns:
  • %entities% (has|have) [the] score[ ]board mark[s] %texts%
  • %entities% (doesn't|does not|do not|don't) have [the] score[ ]board mark[s] %texts%
Since: 2.3
Ascertaineth whether the given entities doth bear the given scoreboard marks.

Examples:

if the targeted armor stand has the scoreboard mark "test tag":

Ignition Process

🔗

Condition

Patterns:
  • [creeper[s]] %living entities% ((is|are)|(isn't|is not|aren't|are not)) about to burst asunder
  • [creeper[s]] %living entities% ((is|are)|(isn't|is not|aren't|are not)) in the (ignition|detonation) process
  • creeper[s] %living entities% ((is|are)|(isn't|is not|aren't|are not)) set alight
Since: 2.5
Discerneth whether a creeper be readying itself to burst asunder.

Examples:

if the last spawned creeper is about to burst asunder:
    loop all players in radius 3 of the last spawned creeper
        send "FLEE!!!" to the loop-player

In Days of Yore or Yet to Come

🔗

Condition

Patterns:
  • %dates% (is|are)[(n't| not)] in the (past|future)
  • %dates% ha(s|ve)[(n't| not)] passed hence
Since: 2.10
Doth ascertain whether a date lieth in the past or in the future.
Mark well that employing the 'now' expression shall not be reckoned in the past nor the future when used directly within the condition.

Examples:

set {_date} to now
wait 5 seconds
if {_date} is in the past:
    # this will be true

if now is in the future:
    # this will be false

set {_dates::*} to 1 day from now, 12 days from now, and 1 year from now
if {_dates::*} are in the future:
    # this will be true
if {_dates::*} have passed hence:
    # this will be false

Is Ablaze

🔗

Condition

Patterns:
  • %entities% (is|are) (burning|ablaze|engulf'd in flame)
  • %entities% (isn't|is not|aren't|are not) (burning|ablaze|engulf'd in flame)
Since: 1.4.4
Discerneth whether an entity doth burn, e.g. a zombie set alight by the sun's cruel gaze, or any creature fallen into molten rock.

Examples:

# increased attack against burning targets
victim is burning:
    increase damage by 2

Is Aloft

🔗

Condition

Patterns:
  • %players% (is|are) flying
  • %players% (isn't|is not|aren't|are not) flying
Since: 1.4.4
Discerneth whether a player doth soar through the heavens.

Examples:

player is not flying

Is Ascending

🔗

Condition

Patterns:
Since: 2.8.0
Requirements: Minecraft 1.17+
Whether a living entity doth climb, such as a spider scaling a wall or a player upon a ladder.

Examples:

spawn a spider at location of spawn
wait a second
if the last spawned spider is ascending:
    message "The spider doth now ascend!"

Is Bed or Anchor of Respawning

🔗

Condition

Patterns:
  • [the] respawn location (was|is)[(n'| no)t] [a] (bed|respawn anchor)
Since: 2.7
Requirements: Minecraft 1.16+
Doth ascertain the nature of a player's respawn location in the respawn event.

Examples:

on respawn:
    the respawn location is a bed
    broadcast "%player% doth respawn in their bed! How most comfortable!"

Is Bespelled

🔗

Condition

Patterns:
Since: 1.4.6, 2.12 ('or better')
Discerneth whether an item doth bear enchantments. Enchantments must match the precise level by default, unless 'or better' or 'or worse' be declared.

Examples:

tool of the player is enchanted with efficiency 2

if player's helmet or player's boots are enchanted with protection 3 or better:

if player's chestplate is enchanted with protection

Is Charged with Power

🔗

Condition

Patterns:
  • %entities% (is|are) (charged|empowered)
  • %entities% (isn't|is not|aren't|are not) (charged|empowered)
Since: 2.5, 2.10 (withers, wither skulls)
Discerneth whether a creeper, wither, or wither skull doth bear a mighty charge (empowered).

Examples:

if the last spawned creeper is charged:
    broadcast "A charged creeper doth lurk at %location of last spawned creeper%"

Is Conditional

🔗

Condition

Patterns:
  • %blocks% (is|are) [un]conditional
  • %blocks% (isn't|is not|aren't|are not) [un]conditional
Since: 2.10
Discerneth whether a command block be conditional or nay.

Examples:

if {_block} is conditional:
    make {_block} unconditional

Is Dancing

🔗

Condition

Patterns:
Since: 2.11
Discerneth whether an entity doth dance a merry jig, such as allays, parrots, or piglins.

Examples:

if last spawned allay is dancing:
    broadcast "A Grand Ball commenceth!"

Is Denizen/Lord of Dominion

🔗

Condition

Patterns:
Since: 2.1
Requirements: Supported regions plugin
Doth ascertain whether a player be a denizen or lord of a particular dominion.
This condition doth require a supported regions plugin to be installed.

Examples:

on region enter:
    player is the lord of the dominion
    message "Welcome back to %region%!"
    send "%player% hath just entered %region%!" to all denizens of the dominion

Is Empty

🔗

Condition

Patterns:
  • %objects% (is|are) empty
  • %objects% (isn't|is not|aren't|are not) empty
Since: unknown (before 2.1)
Checks whether something is empty.

Examples:

player's inventory is empty

Is Enamoured

🔗

Condition

Patterns:
Since: 2.10
Discerneth whether a living entity doth find itself in a state of amorous affection.

Examples:

on spawn of living entity:
    if entity is in love:
        broadcast "That was most swift!"

Is Envenomed

🔗

Condition

Patterns:
Since: 1.4.4
Ascertaineth whether an entity hath been envenomed.

Examples:

if the player is envenomed:
    purge the player of venom
    message "Thou hast been cured of thy affliction!" to the player

Is Evenly Divisible By

🔗

Condition

Patterns:
Since: 2.10, 2.12 (tolerance)
Discerneth whether a number may be evenly divided by another.

Examples:

if 5 is evenly divisible by 5:

if 11 cannot be evenly divided by 10:

if 0.3 can be evenly divided by 0.1 with a tolerance of 0.0000001:

Is Favoured Implement

🔗

Condition

Patterns:
Since: 2.7
Requirements: 1.16.5+, Paper 1.19.2+ (blockdata)
Checks whether an item is the favoured implement for a block. A favoured implement is one that shall cause the block to yield its item when employed. For example, a wooden pickaxe is a favoured implement for grass and stone blocks, but not for iron ore.

Examples:

on left click:
    event-block is set
    if player's tool is the favoured implement for event-block:
        break event-block naturally using player's tool
    else:
        cancel event

Is Feasting

🔗

Condition

Patterns:
Since: 2.11
Whether a panda or horse-kind creature (horse, camel, donkey, llama, mule) doth presently feast.

Examples:

if last spawned panda is feasting:
    force last spawned panda to stop feasting

Is Fish Hook in Open Waters

🔗

Condition

Patterns:
  • %entities% (is|are) in open water[s]
  • %entities% (isn't|is not|aren't|are not) in open water[s]
Since: 2.10
Ascertaineth whether the fish hook doth rest in open waters.
Open water is defined by a 5x4x5 expanse of water, air, and lily pads.If in open waters, treasures of great worth may be caught.

Examples:

on fish catch:
    if fish hook is in open waters:
        send "Thou shalt soon catch a shark!"

Is Fit for Consumption

🔗

Condition

Patterns:
Since: 2.2-dev36
Discerneth whether an item be fit for eating.

Examples:

cooked beef is edible

player's tool is edible

Is Frost-Bitten

🔗

Condition

Patterns:
Since: 2.7
Discerneth whether an entity be frozen in bitter cold.

Examples:

if player is frozen:
    kill player

Is Furnace Fuel

🔗

Condition

Patterns:
Since: 2.5.1
Discerneth whether an item may serve as fuel within a furnace.

Examples:

on right click on furnace:
    if player's tool is not fuel:
        send "Prithee, hold a proper fuel in thine hand"
        cancel event

Is Given Name Visible

🔗

Condition

Patterns:
  • %entities%'[s] custom name[s] (is|are) visible
  • %entities%'[s] custom name[s] (isn't|is not|are not|aren't) visible
  • custom name of %entities% (is|are) visible
  • custom name of %entities% (isn't|is not|are not|aren't) visible
Since: 2.10
Discerneth whether an entity's given name be visible unto all.

Examples:

send true if target's custom name is visible

Is Gliding Upon the Wind

🔗

Condition

Patterns:
Since: 2.7
Discerneth whether a living entity doth glide upon the wind.

Examples:

if player is gliding

Is Hand Raised Aloft

🔗

Condition

Patterns:
Since: 2.8.0
Discerneth whether an entity hath one or both hands raised aloft.
Hands are raised when an entity doth employ an item (e.g.: blocking, drawing a bow, partaking of sustenance).

Examples:

on damage of player:
    if victim's main hand is raised:
        drop player's tool at player
        set player's tool to air

Is Marked by Tag

🔗

Condition

Patterns:
Since: 2.10
Ascertaineth whether an item, block, entity, or entitydata is marked with the given tag.

Examples:

if player's tool is marked with minecraft tag "enchantable/sharp_weapon":
    enchant player's tool with sharpness 1

if all logs are marked with tag "minecraft:logs"

Is Pressing Key

🔗

Condition

Patterns:
Since: 2.10
Requirements: Minecraft 1.21.2+
Ascertaineth whether a player doth press a certain input key.

Examples:

on player input:
    if player is pressing forward movement key:
        send "Thou art advancing forward!"

Is Proof Against Flame

🔗

Condition

Patterns:
  • %item types% (is|are) (fire resistant|resistant to fire)
  • %item types% (isn't|is not|aren't|are not) (fire resistant|resistant to fire)
Since: 2.9.0
Requirements: Spigot 1.20.5+
Discerneth whether an item doth withstand the ravages of fire.

Examples:

if player's tool is fire resistant:

if {_items::*} aren't resistant to fire:

Is Script Laden

🔗

Condition

Patterns:
  • script[s] [%texts%] (is|are) laden
  • script[s] [%texts%] (isn't|is not|aren't|are not) laden
Since: 2.2-dev31
Doth verify whether the present script, or another script, is currently laden and active.

Examples:

script is laden

script "example.sk" is laden

Is Summoning a Fireball

🔗

Condition

Patterns:
Since: 2.11
Discerneth whether a ghast doth summon forth a fireball.

Examples:

if last spawned ghast is summoning fireball:
    kill last spawned ghast

Is Susceptible to Flame

🔗

Condition

Patterns:
Since: 2.2-dev36
Discerneth whether an item may catch fire and burn.

Examples:

send whether the tag contents of minecraft tag "planks" are flammable

player's tool is flammable

Is Within Radius Hence

🔗

Condition

Patterns:
Since: 2.7
Doth ascertain whether a location resideth within a certain radius of another location.

Examples:

on damage:
    if attacker's location is within 10 blocks around {_spawn}:
        cancel event
        send "Thou canst not engage in mortal combat at the spawn."

Is Yielding

🔗

Condition

Patterns:
  • %entities% (is|are) (yielding|unyielding)
  • %entities% (isn't|is not|aren't|are not) (yielding|unyielding)
Since: 2.14
Doth ascertain whether an interaction be yielding or nay. Yieldingness determineth whether clicking upon the entity shall cause the clicker's arm to swing.

Examples:

if last spawned interaction is yielding:

if last spawned interaction is unyielding:

Is a Babe

🔗

Condition

Patterns:
Since: 2.10
Discerneth whether a living entity is yet but a babe.

Examples:

on drink:
    event-entity is a baby
    kill event-entity

Is of Full Age

🔗

Condition

Patterns:
Since: 2.10
Discerneth whether a living entity hath reached full maturity.

Examples:

on drink:
    event-entity is not an adult
    kill event-entity

Item Beareth Enchantment Glint Override

🔗

Condition

Patterns:
  • %item types% (has|have) enchantment glint overrid(den|e)
  • %item types% (doesn't|does not|do not|don't) have enchantment glint overrid(den|e)
Since: 2.10
Requirements: Spigot 1.20.5+
Ascertaineth whether an item doth bear the enchantment glint overridden, or be compelled to glint or not.

Examples:

if the player's tool has the enchantment glint override
    send "Your tool has the enchantment glint override." to player

if {_item} is forced to glint:
    send "This item is forced to glint." to player
else if {_item} is forced to not glint:
    send "This item is forced to not glint." to player
else:
    send "This item does not have any glint override." to player

Item Beareth Enchantment Glint Override

🔗

Condition

Patterns:
  • %item types% (is|are) forced to [not] glint
  • %item types% (isn't|is not|aren't|are not) forced to [not] glint
Since: 2.10
Requirements: Spigot 1.20.5+
Ascertaineth whether an item doth bear the enchantment glint overridden, or be compelled to glint or not.

Examples:

if the player's tool has the enchantment glint override
    send "Your tool has the enchantment glint override." to player

if {_item} is forced to glint:
    send "This item is forced to glint." to player
else if {_item} is forced to not glint:
    send "This item is forced to not glint." to player
else:
    send "This item does not have any glint override." to player

Leash Shall Fall

🔗

Condition

Patterns:
  • [the] (lead|leash) [item] (shall|(shan't|shall not)) (fall|be dropped)
Since: 2.10
Ascertaineth whether the leash item shall fall to the ground during the detaching of the leash in an unleash event.

Examples:

on unleash:
    if the leash shall fall:
        prevent the leash from dropping
    else:
        allow the leash to drop

Lid Be Open or Shut

🔗

Condition

Patterns:
  • [the] lid[s] of %blocks% (is|are) (open[ed]|close[d])
  • [the] lid[s] of %blocks% (isn't|is not|aren't|are not) (open[ed]|close[d])
  • %blocks%'[s] lid[s] (is|are) (open[ed]|close[d])
  • %blocks%'[s] lid[s] (isn't|is not|aren't|are not) (open[ed]|close[d])
Since: 2.10
Ascertaineth whether lidded blocks (chests, shulker boxes, and the like) stand open or shut.

Examples:

if the lid of {_chest} is closed:
    open the lid of {_block}

May Behold Chat Colours

🔗

Condition

Patterns:
  • %players% can behold chat colo[u]r[s|ing]
  • %players% (can't|cannot|can not) behold chat colo[u]r[s|ing]
Since: 2.10
Doth examine whether a player can behold the colours of chat.

Examples:

if player can behold chat colours:
    send "Find the red word in <red>this<reset> message."
else:
    send "You cannot partake in finding the colored word."

May Build

🔗

Condition

Patterns:
Since: 2.0
Requirements: Supported regions plugin
Doth test whether a player be permitted to build upon a certain location.
This condition doth require a supported regions plugin to be installed.

Examples:

command /setblock <material>:
    description: set the block at your crosshair to a different type
    trigger:
        player cannot build at the targeted block:
            message "Thou hast not permission to alter blocks there!"
            stop
        set the targeted block to argument

May Contain Within

🔗

Condition

Patterns:
Since: 1.0
Doth test whether a player or a chest may harbour the given wares within.

Examples:

block can hold 200 cobblestone

player has sufficient room for 64 feathers

May Gather Up Wares

🔗

Condition

Patterns:
Since: 2.8.0
Whether living entities art able to gather up wares from the ground or nay.

Examples:

if player can gather up wares:
    send "You can pick up items!" to player

on drop:
    if player can't gather up wares:
        send "Be careful, you won't be able to pick that up!" to player

May Perceive

🔗

Condition

Patterns:
Since: 2.3, 2.10 (entities)
Requirements: Minecraft 1.19+ (entities)
Doth verify whether the given players can perceive the provided entities.

Examples:

if sender can't perceive the player-argument:
    message "who dat?"

if the player can perceive the last spawned entity:
    message "hello there!"

May Perceive Missives

🔗

Condition

Patterns:
  • %player% can perceive all missives [in chat]
  • %player% can only perceive (commands|system missives) [in chat]
  • %player% can('t|[ ]not) perceive any (command[s]|missive[s]) [in chat]
  • %player% can('t|[ ]not) perceive all missives [in chat]
  • %player% can('t|[ ]not) only perceive (commands|system missives) [in chat]
Since: 2.10
Doth verify whether a player can perceive specific varieties of missives in chat.

Examples:

if player can perceive all missives:
    send "You can see all messages."

if player can only perceive commands:
    send "This game doesn't work with commands-only chat."

if player can't perceive any missives:
    send action bar "Server shutting down in 5 minutes!"

May Take to the Skies

🔗

Condition

Patterns:
  • %players% can take to the skies
  • %players% (can't|cannot|can not) take to the skies
Since: 2.3
Whether a player is permitted to soar through the heavens.

Examples:

player can take to the skies

Mortal Combat

🔗

Condition

Patterns:
  • (is mortal combat|mortal combat is) permitted [in %worlds%]
  • (is mortal combat|mortal combat is) forbidden [in %worlds%]
Since: 1.3.4
Doth inspect the state of player-versus-player combat within a world.

Examples:

mortal combat is permitted

mortal combat is forbidden in "world"

Occasion Annull'd

🔗

Condition

Patterns:
  • [the] occasion is annull'd
  • [the] occasion (is not|isn't) annull'd
Since: 2.2-dev36
Doth examine whether the occasion hath been annull'd or nay.

Examples:

on click:
    if occasion is annull'd:
        broadcast "no clicks allowed!"

Of Letters and Numerals

🔗

Condition

Patterns:
  • %texts% (is|are) of letters and numerals
  • %texts% (isn't|is not|aren't|are not) of letters and numerals
Since: 2.4
Doth examine whether the given string be composed solely of letters and numerals.

Examples:

if the argument is not of letters and numerals:
    send "Invalid name!"

Panda Be Affrighted

🔗

Condition

Patterns:
Since: 2.11
Whether a panda be affrighted and trembling with fear.

Examples:

if last spawned panda is affrighted:

Panda Doth Sneeze

🔗

Condition

Patterns:
Since: 2.11
Whether a panda be given to sneezing most vigorously.

Examples:

if last spawned panda is given to sneezing:
    make last spawned panda stop sneezing

Panda Doth Tumble

🔗

Condition

Patterns:
Since: 2.11
Whether a panda doth tumble about in merriment.

Examples:

if last spawned panda is tumbling about:
    make last spawned panda stop rolling

Panda Lieth Upon Its Back

🔗

Condition

Patterns:
Since: 2.11
Whether a panda doth lie upon its back.

Examples:

if last spawned panda is upon its back:
    make last spawned panda get off its back

Passage of Time

🔗

Condition

Patterns:
  • %date% (was|were)( more|(n't| not) less) than %time span% [hence]
  • %date% (was|were)((n't| not) more| less) than %time span% [hence]
Since: 2.0
Doth test whether a given real moment was more or less than some span of time hence.

Examples:

command /command-with-cooldown:
    trigger:
        {command::%player's uuid%::last-usage} was less than a minute hence:
            message "Please wait a minute between uses of this command."
            stop
        set {command::%player's uuid%::last-usage} to now
        # ... actual command trigger here ...

Possesseth Potion Effect

🔗

Condition

Patterns:
  • %living entities% (has|have) ([any|a[n]] [active] potion effect[s]|[any|a] potion effect[s] active)
  • %living entities% (doesn't|does not|do not|don't) have ([any|a[n]] [active] potion effect[s]|[any|a] potion effect[s] active)
  • %living entities% (has|have) %skriptpotioneffects% [active]
  • %living entities% (doesn't|does not|do not|don't) have %skriptpotioneffects% [active]
Since: 2.6.1
2.14 (support for potion effects)
Ascertaineth whether an entity doth possess a potion effect with certain properties.
An entity is considered to possess a potion effect if it beareth a potion effect with at least the specified properties.
For example, if an entity hath an 'ambient speed 5' effect, it would be deemed as possessing 'speed 5'.
For exact comparisons, consider employing the Potion Effect of Entity/Item expression within an 'is' comparison.

Examples:

if the player has a potion effect of speed:
    message "Thou art swift as Mercury!"

if all players have speed and haste active:
    broadcast "This server standeth ready to mine!"

Possesseth a Plunder Table

🔗

Condition

Patterns:
Since: 2.10
Discerneth whether an entity or block doth possess a plunder table.The plunder tables of chests shall be struck from existence when the chest is opened or broken asunder.

Examples:

set event-block to chest
if event-block has a plunder table:
    # this shall never come to pass, for it possesseth no plunder table.

set plunder table of event-block to "minecraft:chests/simple_dungeon"
if event-block has a plunder table:
    # this shall come to pass, for it now possesseth a plunder table.

Potion Effect Type — Is Instantaneous

🔗

Condition

Patterns:
Since: 2.14
Ascertaineth whether a potion effect type is instantaneous.
That is to say, whether the effect doth transpire once and forthwith.

Examples:

if any of the potion effects of the player's tool are instant:
    message "Employ thy tool for immediate benefit!"

Potion Effect — Is Ambient

🔗

Condition

Patterns:
  • %skriptpotioneffects% (is|are) ambient
  • %skriptpotioneffects% (isn't|is not|aren't|are not) ambient
Since: 2.14
Ascertaineth whether a potion effect is ambient.
That is to say, whether the potion effect doth produce more, translucent particles.

Examples:

on entity potion effect modification:
    if the potion effect is ambient:
        message "'Tis the hour of particles!"

Potion Effect — Possesseth Particles

🔗

Condition

Patterns:
  • %skriptpotioneffects% (has|have) particles
  • %skriptpotioneffects% (doesn't|does not|do not|don't) have particles
Since: 2.14
Ascertaineth whether a potion effect doth possess particles.

Examples:

on entity potion effect modification:
    if the potion effect has particles:
        hide the particles of event-potioneffecttype for event-entity

Potion Effect — Possesseth an Emblem

🔗

Condition

Patterns:
  • %skriptpotioneffects% (has|have) ([an] emblem|emblems)
  • %skriptpotioneffects% (doesn't|does not|do not|don't) have ([an] emblem|emblems)
Since: 2.14
Ascertaineth whether a potion effect doth bear an emblem (icon).

Examples:

on entity potion effect modification:
    if the potion effect has an emblem:
        hide the emblem of event-potioneffecttype for event-entity

Resource Pack Decree

🔗

Condition

Patterns:
Since: 2.4
Doth examine the state of the resource pack in a resource pack request response event.

Examples:

on resource pack response:
    if the resource pack wasn't accepted:
        kick the player due to "Thou must install the resource pack to partake in this server!"

Runneth Upon Minecraft

🔗

Condition

Patterns:
  • running [beneath] minecraft %text%
Since: 2.5
Ascertaineth whether the present Minecraft version be the given version or of newer vintage.

Examples:

running minecraft "1.14"

Shall It Perish

🔗

Condition

Patterns:
  • %itementities% can (despawn naturally|naturally despawn)
  • %itementities% (can't|cannot|can not) (despawn naturally|naturally despawn)
Since: 2.11
Ascertaineth whether the dropped item shall perish of its own accord through Minecraft's appointed timer.

Examples:

if all dropped items will naturally perish:
    prevent all dropped items from naturally perishing

Shall It Perish

🔗

Condition

Patterns:
  • %itementities% will (perish naturally|naturally perish)
  • %itementities% (will (not|neither)|won't) (perish naturally|naturally perish)
Since: 2.11
Ascertaineth whether the dropped item shall perish of its own accord through Minecraft's appointed timer.

Examples:

if all dropped items will naturally perish:
    prevent all dropped items from naturally perishing

Shall the Boosting Firework Be Consumed

🔗

Condition

Patterns:
  • [the] (boosting|employed) firework shall be consumed
  • [the] (boosting|employed) firework (shall not|shan't) be consumed
Since: 2.10
Doth examine whether the firework employed in an 'elytra boost' occasion shall be consumed.

Examples:

on elytra boost:
    if the employed firework shall be consumed:
        prevent the employed firework from being consumed

Sinistral or Dextral

🔗

Condition

Patterns:
Since: 2.8.0
Doth examine whether living entities or players be sinister-handed or right-handed. Armour stands art neither right nor left-handed.

Examples:

on damage of player:
    if victim is left handed:
        cancel event

Strider Doth Tremble

🔗

Condition

Patterns:
Since: 2.12
Whether a strider doth tremble with cold.

Examples:

if last spawned strider is trembling:
    make last spawned strider stop trembling

Text Display Beareth Drop Shadow

🔗

Condition

Patterns:
  • [[the] text of] %displays% (hath|have) [a] (drop|text) shadow
  • %displays%'[s] text (hath|have) [a] (drop|text) shadow
  • [[the] text of] %displays% (hath not|doth not have|do not|don't) have [a] (drop|text) shadow
  • %displays%'[s] text (hath not|doth not have|do not|don't) have [a] (drop|text) shadow
Since: 2.10
Returns whether the text of a display hath drop shadow applied unto it.

Examples:

if {_display} hath drop shadow:
    remove drop shadow from the text of {_display}

Text Display Visible Through Ramparts

🔗

Condition

Patterns:
  • %displays% (is|are) visible through (blocks|walls)
  • %displays% (isn't|is not|aren't|are not) visible through (blocks|walls)
Since: 2.10
Returns whether text displays may be perceived through blocks or not.

Examples:

if last spawned text display is visible through walls:
    prevent last spawned text display from being visible through walls

Wound's Origin

🔗

Condition

Patterns:
  • [the] wound (was|is|hath)[( not)] [been] (wrought|caused|dealt) by %damage cause%
Since: 2.0
Doth test what manner of harm caused a damage occasion. Pray refer to the Damage Cause type for a catalogue of all possible causes.

Examples:

# make players use their potions of fire resistance whenever they take any kind of fire damage
on damage:
    wound was wrought by lava, fire or burning
    victim is a player
    victim has a potion of fire resistance
    cancel event
    apply fire resistance to the victim for 30 seconds
    remove 1 potion of fire resistance from the victim

# prevent mobs from dropping items under certain circumstances
on death:
    entity is not a player
    wound was not wrought by a block explosion, an attack, a projectile, a potion, fire, burning, thorns or poison
    clear drops

Wound's Source — Doth Scale With Difficulty

🔗

Condition

Patterns:
  • %damage sources% ((doth|do) scale|scales) harm with difficulty
  • %damage sources% (do not|don't|doth not|doesn't) scale harm with difficulty
  • %damage sources%'[s] harm ((doth|do) scale|scales) with difficulty
  • %damage sources%'[s] harm (do not|don't|doth not|doesn't) scale with difficulty
Since: 2.12
Whether the harm wrought by a damage source doth wax or wane with the difficulty of the realm.

Examples:

on death:
    if event-damage source scales harm with difficulty:

Wound's Source — Was Indirectly Wrought

🔗

Condition

Patterns:
  • %damage sources% (was|were) ([in]directly wrought|wrought [in]directly)
  • %damage sources% (was not|wasn't|were not|weren't) ([in]directly wrought|wrought [in]directly)
Since: 2.12
Whether the harm from a damage source was indirectly wrought.
Vanilla damage sources art deemed indirect if the 'causing entity' and the 'direct entity' be not one and the same.For example, suffering harm from an arrow loosed by another creature.

Examples:

on damage:
    if event-damage source was indirectly wrought: