Conditions

Alphanumeric 🔗
Patterns:
  • %texts% (is|are) alphanumeric
  • %texts% (isn't|is not|aren't|are not) alphanumeric
Since: 2.4
Checks if the given string is alphanumeric.
Examples:
if the argument is not alphanumeric:
    send "Invalid name!"
Can Fly 🔗
Patterns:
Since: 2.3
Whether a player is allowed to fly.
Examples:
player can fly
Can Hold 🔗
Patterns:
Since: 1.0
Tests whether a player or a chest can hold the given item.
Examples:
block can hold 200 cobblestone
player has enough space for 64 feathers
Can See 🔗
Patterns:
Since: 2.3
Checks whether the given players can see another players.
Examples:
if the player can't see the player-argument:
    message "The player %player-argument% is not online!"
Chance 🔗
Patterns:
Since: 1.0
A condition that randomly succeeds or fails. Valid values are between 0% and 100%, or if the percent sign is omitted between 0 and 1.
Examples:
chance of 50%:
    drop a diamond
chance of {chance}% # {chance} between 0 and 100
chance of {chance} # {chance} between 0 and 1
Comparison 🔗
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) than|below)|\<) %objects%
  • [neither] %objects% ((is|are)[((n't| not| neither)]) (less|smaller|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) than|below) %objects%
  • [neither] %objects% (was|were)[((n't| not| neither)]) (less|smaller|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) than|below) %objects%
  • [neither] %objects% (will be|(will (not|neither) be|won't be)) (less|smaller|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 very general condition, it simply compares two values. Usually you can only compare for equality (e.g. block is/isn't of <type>), but some values can also be compared using greater than/less than. In that case you can also test for whether an object is between two others. Note: This is the only element where not all patterns are shown. It has actually another two sets of similar patters, but with (was|were) or will be instead of (is|are) respectively, which check 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 🔗
Patterns:
Since: 1.0
Checks whether an inventory contains an item, a text contains another piece of text, or a list (e.g. {list variable::*} or 'drops') contains another object.
Examples:
block contains 20 cobblestone
player has 4 flint and 2 iron ingots
{list::*} contains 5
Damage Cause 🔗
Patterns:
  • [the] damage (was|is|has)[(n('|o)]t) [been] (caused|done|made) by %damage cause%
Since: 2.0
Tests what kind of damage caused a damage event. Refer to the Damage Cause type for a list of all possible causes.
Examples:
# make players use their potions of fire resistance whenever they take any kind of fire damage
on damage:
    damage was caused 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
    damage wasn't caused by a block explosion, an attack, a projectile, a potion, fire, burning, thorns or poison
    clear drops
Event Cancelled 🔗
Patterns:
  • [the] event is cancel[l]ed
  • [the] event (is not|isn't) cancel[l]ed
Since: 2.2-dev36
Checks whether or not the event is cancelled.
Examples:
on click:
    if event is cancelled:
        broadcast "no clicks allowed!"
Exists/Is Set 🔗
Patterns:
  • %~objects% (exist[s]|(is|are) set)
  • %~objects% (do[es](n't| not) exist|(is|are)(n't| not) set)
Since: 1.2
Checks whether a given expression or variable is set.
Examples:
{teams::%player's uuid%::preferred-team} is not set
on damage:
    projectile exists
    broadcast "%attacker% used a %projectile% to attack %victim%!"
Has AI 🔗
Patterns:
Since: 2.5
Checks whether an entity has AI.
Examples:
target entity has ai
Has Client Weather 🔗
Patterns:
  • %players% (has|have) [a] (client|custom) weather [set]
  • %players% (doesn't|does not|do not|don't) have [a] (client|custom) weather [set]
Since: 2.3
Checks whether the given players have a custom client weather
Examples:
if the player has custom weather:
    message "Your custom weather is %player's weather%"
Has Custom Model Data 🔗
Patterns:
  • %item types% (has|have) [custom] model data
  • %item types% (doesn't|does not|do not|don't) have [custom] model data
Since: 2.5
Requirements: 1.14+
Check if an item has a custom model data tag
Examples:
player's tool has custom model data
Has Metadata 🔗
Patterns:
Since: 2.2-dev36
Checks whether a metadata holder has a metadata tag.
Examples:
if player has metadata value "healer":
Has Permission 🔗
Patterns:
Since: 1.0
Test whether a player has a certain permission.
Examples:
player has permission "skript.tree"
victim has the permission "admin":
    send "You're attacking an admin!" to attacker
Has Played Before 🔗
Patterns:
  • %offline player% [(has|did)] [already] play[ed] [on (this|the) server] (before|already)
  • %offline player% (has not|hasn't|did not|didn't) [(already|yet)] play[ed] [on (this|the) server] (before|already|yet)
Since: 1.4
Checks whether a player has played on this server before. You can also use on first join if you want to make triggers for new players.
Examples:
player has played on this server before
player hasn't played before
Has Resource Pack 🔗
Patterns:
  • %players% (has|have) [a] resource pack [(loaded|installed)]
  • %players% (doesn't|does not|do not|don't) have [a] resource pack [(loaded|installed)]
Since: 2.4
Requirements: Paper 1.9 or newer
Checks whether the given players have a server resource pack loaded. Please note that this can't detect player's own resource pack, only the resource pack that sent by the server.
Examples:
if the player has a resource pack loaded:
Has Scoreboard Tag 🔗
Patterns:
  • %entities% (has|have) [the] score[ ]board tag[s] %texts%
  • %entities% (doesn't|does not|do not|don't) have [the] score[ ]board tag[s] %texts%
Since: 2.3
Checks whether the given entities has the given scoreboard tags.
Examples:
if the targeted armor stand has the scoreboard tag "test tag":
Ignition Process 🔗
Patterns:
  • [creeper[s]] %living entities% ((is|are)|(isn't|is not|aren't|are not)) going to explode
  • [creeper[s]] %living entities% ((is|are)|(isn't|is not|aren't|are not)) in the (ignition|explosion) process
  • creeper[s] %living entities% ((is|are)|(isn't|is not|aren't|are not)) ignited
Since: 2.5
Requirements: Paper 1.13 or newer
Checks if a creeper is going to explode.
Examples:
if the last spawned creeper is going to explode:
    loop all players in radius 3 of the last spawned creeper
        send "RUN!!!" to the loop-player
Is Alive 🔗
Patterns:
  • %entities% (is|are) (alive|dead)
  • %entities% (isn't|is not|aren't|are not) (alive|dead)
Since: 2.0, 2.4-alpha4 (non-living entity support)
Checks whether an entity is alive. Works for non-living entities too.
Examples:
if {villager-buddy::%player's uuid%} is not dead:

on shoot:
    while the projectile is alive:
Is Banned 🔗
Patterns:
Since: 1.4
Checks whether a player or IP is banned.
Examples:
player is banned
victim is not IP-banned
"127.0.0.1" is banned
Is Block 🔗
Patterns:
  • %item types% (is|are) ([a] block|blocks)
  • %item types% (isn't|is not|aren't|are not) ([a] block|blocks)
Since: 2.4
Checks whether an item is a block.
Examples:
player's held item is a block
{list::*} are blocks
Is Block Redstone Powered 🔗
Patterns:
  • %blocks% (is|are) redstone powered
  • %blocks% (is|are) indirectly redstone powered
  • %blocks% (is|are)(n't| not) redstone powered
  • %blocks% (is|are)(n't| not) indirectly redstone powered
Since: 2.5
Checks if a block is indirectly or directly powered by redstone
Examples:
if clicked block is redstone powered:
    send "This block is well-powered by redstone!"
if clicked block is indirectly redstone powered:
    send "This block is indirectly redstone powered."
Is Blocking 🔗
Patterns:
  • %players% (is|are) (blocking|defending) [with [a] shield]
  • %players% (isn't|is not|aren't|are not) (blocking|defending) [with [a] shield]
Since: unknown (before 2.1)
Checks whether a player is blocking with their shield.
Examples:
on damage of player:
    victim is blocking
    damage attacker by 0.5 hearts
Is Burning 🔗
Patterns:
  • %entities% (is|are) (burning|ignited|on fire)
  • %entities% (isn't|is not|aren't|are not) (burning|ignited|on fire)
Since: 1.4.4
Checks whether an entity is on fire, e.g. a zombie due to being in sunlight, or any entity after falling into lava.
Examples:
# increased attack against burning targets
victim is burning:
    increase damage by 2
Is Charged 🔗
Patterns:
Since: 2.5
Checks if a creeper is charged (powered).
Examples:
if the last spawned creeper is charged:
    broadcast "A charged creeper is at %location of last spawned creeper%"
Is Edible 🔗
Patterns:
Since: 2.2-dev36
Checks whether an item is edible.
Examples:
steak is edible
player's tool is edible
Is Empty 🔗
Patterns:
Since: unknown (before 2.1)
Checks whether an inventory, an inventory slot, or a text is empty.
Examples:
player's inventory is empty
Is Enchanted 🔗
Patterns:
Since: 1.4.6
Checks whether an item is enchanted.
Examples:
tool of the player is enchanted with efficiency 2
helm, chestplate, leggings or boots are enchanted
Is Flammable 🔗
Patterns:
Since: 2.2-dev36
Checks whether an item is flammable.
Examples:
wood is flammable
player's tool is flammable
Is Flying 🔗
Patterns:
  • %players% (is|are) flying
  • %players% (isn't|is not|aren't|are not) flying
Since: 1.4.4
Checks whether a player is flying.
Examples:
player is not flying
Is Fuel 🔗
Patterns:
Since: 2.5.1
Requirements: Minecraft 1.11.2+
Checks whether an item can be used as fuel in a furnace.
Examples:
on right click on furnace:
    if player's tool is not fuel:
        send "Please hold a valid fuel item in your hand"
        cancel event
Is Holding 🔗
Patterns:
Since: 1.0
Checks whether a player is holding a specific item. Cannot be used with endermen, use 'entity is [not] an enderman holding <item type>' instead.
Examples:
player is holding a stick
victim isn't holding a sword of sharpness
Is Incendiary 🔗
Patterns:
  • %entities% ((is|are) incendiary|cause[s] a[n] (incendiary|fiery) explosion)
  • %entities% ((is not|are not|isn't|aren't) incendiary|(does not|do not|doesn't|don't) cause[s] a[n] (incendiary|fiery) explosion)
  • the [event(-| )]explosion (is|(is not|isn't)) (incendiary|fiery)
Since: 2.5
Checks if an entity will create fire when it explodes. This condition is also usable in an explosion prime event.
Examples:
on explosion prime:
    if the explosion is fiery:
        broadcast "A fiery explosive has been ignited!"
Is Interactable 🔗
Patterns:
Since: 2.5.2
Requirements: Minecraft 1.13+
Checks wether or not a block is interactable.
Examples:
on block break:
    if event-block is interactable:
        cancel event
        send "You cannot break interactable blocks!"
Is Invulnerable 🔗
Patterns:
  • %entities% (is|are) invulnerable
  • %entities% (isn't|is not|aren't|are not) invulnerable
Since: 2.5
Checks whether an entity is invulnerable.
Examples:
target entity is invulnerable
Is Leashed 🔗
Patterns:
Since: 2.5
Checks to see if an entity is currently leashed.
Examples:
target entity is leashed
Is Loaded 🔗
Patterns:
Since: 2.3, 2.5 (revamp with chunk at location/coords)
Checks whether or not a chunk/world is loaded. 'chunk at 1, 1' uses chunk coords, which are location coords divided by 16.
Examples:
if chunk at {home::%player's uuid%} is loaded:
if chunk 1, 10 in world "world" is loaded:
if world("lobby") is loaded:
Is Normalized 🔗
Patterns:
  • %vectors% (is|are) normalized
  • %vectors% (isn't|is not|aren't|are not) normalized
Since: 2.5.1
Requirements: Minecraft 1.13.2+
Checks whether a vector is normalized i.e. length of 1
Examples:
vector of player's location is normalized
Is Occluding 🔗
Patterns:
Since: 2.5.1
Checks whether an item is a block and completely blocks vision.
Examples:
player's tool is occluding
Is Online 🔗
Patterns:
Since: 1.4
Checks whether a player is online.
Examples:
player is online
player-argument is offline
Is Passable 🔗
Patterns:
  • %blocks% (is|are) passable
  • %blocks% (isn't|is not|aren't|are not) passable
Since: 2.5.1
Requirements: Minecraft 1.13.2+
Checks whether a block is passable. A block is passable if it has no colliding parts that would prevent players from moving through it. Blocks like tall grass, flowers, signs, etc. are passable, but open doors, fence gates, trap doors, etc. are not because they still have parts that can be collided with.
Examples:
if player's targeted block is passable
Is Poisoned 🔗
Patterns:
Since: 1.4.4
Checks whether an entity is poisoned.
Examples:
player is poisoned:
    cure the player from poison
    message "You have been cured!"
Is Riding 🔗
Patterns:
Since: 2.0
Tests whether an entity is riding another or is in a vehicle.
Examples:
player is riding a saddled pig
Is Riptiding 🔗
Patterns:
Since: 2.5
Checks to see if an entity is currently using the Riptide enchantment.
Examples:
target entity is riptiding
Is Script Loaded 🔗
Patterns:
  • script[s] [%texts%] (is|are) loaded
  • script[s] [%texts%] (isn't|is not|aren't|are not) loaded
Since: 2.2-dev31
Check if the current script, or another script, is currently loaded.
Examples:
script is loaded
script "example.sk" is loaded
Is Silent 🔗
Patterns:
Since: 2.5
Checks whether an entity is silent i.e. its sounds are disabled.
Examples:
target entity is silent
Is Sleeping 🔗
Patterns:
  • %players% (is|are) sleeping
  • %players% (isn't|is not|aren't|are not) sleeping
Since: 1.4.4
Checks whether a player is sleeping.
Examples:
# cut your enemies' throats in their sleep >=)
on attack:
    attacker is holding a sword
    victim is sleeping
    increase the damage by 1000
Is Slime Chunk 🔗
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
Tests whether a chunk is a so-called slime chunk. Slimes can generally spawn in the swamp biome and in slime chunks. For more info, see the Minecraft wiki.
Examples:
command /slimey:
    trigger:
        if chunk at player is a slime chunk:
            send "Yeah, it is!"
        else:
            send "Nope, it isn't"
Is Sneaking 🔗
Patterns:
  • %players% (is|are) sneaking
  • %players% (isn't|is not|aren't|are not) sneaking
Since: 1.4.4
Checks whether a player is sneaking.
Examples:
# prevent mobs from seeing sneaking players if they are at least 4 meters apart
on target:
    target is sneaking
    distance of target and the entity is bigger than 4
    cancel the event
Is Solid 🔗
Patterns:
Since: 2.2-dev36
Checks whether an item is solid.
Examples:
grass block is solid
player's tool isn't solid
Is Sprinting 🔗
Patterns:
  • %players% (is|are) sprinting
  • %players% (isn't|is not|aren't|are not) sprinting
Since: 1.4.4
Checks whether a player is sprinting.
Examples:
player is not sprinting
Is Swimming 🔗
Patterns:
Since: 2.3
Requirements: 1.13 or newer
Checks whether a living entity is swimming.
Examples:
player is swimming
Is Tameable 🔗
Patterns:
Since: 2.5
Check if an entity is tameable.
Examples:
on damage:
    if victim is tameable:
        cancel event
Is Transparent 🔗
Patterns:
Since: 2.2-dev36
Checks whether an item is transparent. Note that this condition may not work for all blocks, due to the transparency list used by Spigot not being completely accurate.
Examples:
player's tool is transparent.
Is Unbreakable 🔗
Patterns:
Since: 2.5.1
Requirements: Minecraft 1.11+
Checks whether an item is unbreakable.
Examples:
if event-item is unbreakable
Is Wearing 🔗
Patterns:
Since: 1.0
Checks whether a player is wearing some armour.
Examples:
player is wearing an iron chestplate and iron leggings
player is wearing all diamond armour
Is Whitelisted 🔗
Patterns:
  • [the] server (is|is(n't| not)) white[ ]listed
  • %players% (is|are)[((n't| not)]) white[ ]listed
Since: 2.5.2
Whether or not the server or a player is whitelisted.
Examples:
if server is whitelisted:
if player is whitelisted
Is in World 🔗
Patterns:
Since: 1.4
Checks whether an entity is in a specific world.
Examples:
player is in "world"
argument isn't in world "world_nether"
the player is in the world of the victim
Is of Type 🔗
Patterns:
Since: 1.4
Checks whether an item of an entity is of the given type. This is mostly useful for variables, as you can use the general 'is' condition otherwise (e.g. 'victim is a creeper').
Examples:
tool is of type {selected type}
victim is of type {villager type}
Is on Ground 🔗
Patterns:
  • %entities% (is|are) on [the] ground
  • %entities% (isn't|is not|aren't|are not) on [the] ground
Since: 2.2-dev26
Checks whether an entity is on ground.
Examples:
player is not on ground
Matches 🔗
Patterns:
  • %texts% (match[es]|do[es](n't| not) match) %texts%
  • %texts% (partially match[es]|do[es](n't| not) partially match) %texts%
Since: 2.5.2
Checks whether the defined strings match the input regexes (Regular expressions).
Examples:
on chat:
    if message partially matches "\d":
        send "Message contains a digit!"
    if message doesn't match "[A-Za-z]+":
        send "Message doesn't only contain letters!"
Projectile Can Bounce 🔗
Patterns:
Since: 2.5.1
Whether or not a projectile can bounce.
Examples:
on shoot:
    send "Boing!" to all players if projectile can bounce
PvP 🔗
Patterns:
  • (is PvP|PvP is) enabled [in %worlds%]
  • (is PvP|PvP is) disabled [in %worlds%]
Since: 1.3.4
Checks the PvP state of a world.
Examples:
PvP is enabled
PvP is disabled in "world"
Resource Pack 🔗
Patterns:
Since: 2.4
Usable in events: resource pack request response
Checks 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 "You have to install the resource pack to play in this server!"
Starts/Ends With 🔗
Patterns:
  • %texts% (start|end)[s] with %texts%
  • %texts% (doesn't|does not|do not|don't) (start|end) with %texts%
Since: 2.2-dev36, 2.5.1 (multiple strings support)
Checks if a text starts or ends with another.
Examples:
if the argument starts with "test" or "debug":
    send "Stop!"
Time 🔗
Patterns:
Since: 2.0
Tests whether a given real time was more or less than some time span ago.
Examples:
command /command-with-cooldown:
    trigger:
        {command::%player's uuid%::last-usage} was less than a minute ago:
            message "Please wait a minute between uses of this command."
            stop
        set {command::%player's uuid%::last-usage} to now
        # ... actual command trigger here ...
Weather 🔗
Patterns:
Since: 1.0
Checks whether the weather in a world is of a specific type. I welcome any ideas how to write this condition differently.
Examples:
is thundering
is raining in "world" or "world2"