# Effect
(boost|launch) %players% using [firework [rocket]] %itemstack%

#Get the fishing hook entity
[the] [event-]fish[ing]( |-)hook

# The fish entity if state was caught
hook[ed] entity

# event value
[the] [event-]fish[ing]( |-)state

[player] fish[ing] [state[s] [of] %-fishingstates%] with event-entity, and fishing state [the] [event-]fish[ing]( |-)state

on player fishing state of reel in or failed:
     if fishing state is failed:
        message "Damn, you failed at a fishing?"

(0¦ticks|1¦milli[( |-)]seconds|2¦seconds|3¦minutes|4¦hours|5¦days|6¦weeks|7¦months|8¦years) (of|from|[with]in) %timespans%

block save[s] of %blocks

%blocks%'[s] block save

command /pos1:
   trigger:
       if target block is set:
           set {pos::%player%::1} to location of target block
       else:
           set {pos::%player%::1} to location of player
       message "pos1 set to %{pos::%player%::1}%"

command /pos2:
   trigger:
       if target block is set:
           set {pos::%player%::2} to location of target block
       else:
           set {pos::%player%::2} to location of player
       message "pos2 set to %{pos::%player%::2}%"

command /save <string>:
   trigger:
       {pos::%player%::2} is set
       {pos::%player%::1} is set
       set {saves::%player%::%argument%::*} to block saves of blocks within {pos::%player%::2} to {pos::%player%::1}
       clear {pos::%player%::1} and {pos::%player%::2}
       message "Saved blocks to save %argument%"

command /load <string>:
   trigger:
       {saves::%player%::%argument%::*} is set
       loop {saves::%player%::%argument%::*}:
           set block at loop-value to loop-value
       message "Loaded blocks from save %argument%"

command /delete [<string>]:
   trigger:
       if argument is set:
           delete {saves::%player%::%argument%::*}
           message "Deleted save %argument%"
           stop
       delete {saves::%player%::*}
       message "Deleted all saves"

command /listSaves:
   trigger:
       message indexes of {saves::%player%::*}

on quit:
   delete {pos::%player%::*}

on script unload:
   delete {pos::*}
 

- Updated to Java 16
- Updated to Skript 2.6
- Updated to Spigot 1.17
- Updated to Gradle 7.1.1
- Updated Citizens to 2.0.27
- 35% smaller jar size
- Changed the collidable state to a condition %livingentities% is|are collidable
- Updated the open book effect to use Spigot method and not reflection now.

because they're in Skript 2.6+ now (I added majority of these to Skript myself):
- Removed event cancel event.
- Removed condition to check if redstone is powered.
- Removed condition to check if item is unbreakable.
- Removed condition to check if player is whitelisted.
- Removed the effect to teleport a player to a world spawn (You can get the spawn of a world now)
- Removed active potion effects expression (This is just a string and not properly implemented and Skript will soon)
- Removed expression for getting drops of a block.
- Removed powered block value (Redstone).
- Removed block hardness expression.
- Removed block xp expression.
- Removed clicked action expression it's now inventory action in Skript.
- Removed clicked inventory expression.
- Removed clicked slot expression use index of clicked slot.
- Removed clicked type expression.
- Removed clicked hotbar type expression.
- Removed client side weather syntaxes.
- Removed custom syntaxes shit.
- Removed custom name of entities expression.
- Removed enchantment level expression.
- Removed custom name visible expression.
- Removed player exhaustion expression.
- Removed fall distance expression.
- Removed fishing syntaxes (Use RandomSk until it's added in Skript, Skellett had poor implementation)
- Removed hotbar switch expressions.
- Removed inventory type expression.
- Removed invulnerable state expression.
- Removed projectile bounce expression and condition.
- Removed silent state of entities expression.
- Removed spectate target expression.
- Removed whitelist syntaxes.
- Removed world change event value expression. Use former|future event-location in Skript.
- Removed stuck arrows expression.
- Removed title expression.
- Removed fireworks.
- Removed item despawn event.
- Removed entity teleport event (but kept the event values as Skript doesn't for some reason)
- Removed resurrect event.
- Removed particles (Bad implementation)
- Removed sound syntaxes.

Removed because un-used or un-needed:
- REMOVED ALL DISGUISE SYNTAXES (Unreleased addon for Disguises coming soon)
- Removed the effects relating to files (Use Skent or SkQuery)
- Removed condition to check if a player is viewing the credits. (It used reflection and isn't really a good addition)
- Removed file existence condition (It's in Skent or SkQuery or SkUtils)
- Removed the effect that opens a chest to players (It's in Khoryl now)
- Removed the reload whitelist effect (This isn't required anymore)
- Removed the effect that saved the player list (This isn't required anymore)
- Removed the serialize effect (Skript serializing should not be accessible for Skript users)
- Removed the expression getting size of variables (Inefficient, not needed and shouldn't be accessible for Skript users)
- Removed hitbox syntaxes (This used reflection and was bad, It's now called BoundingBox in Spigot and will be added sometime to Skellett maybe)
- Removed java version expression. (Skript users don't need this)
- Removed long date expression (Skript users don't need this)
- Removed item type to material string expression (Skript users don't need this)
- Removed NBT syntaxes (These are just item flags and should be implemented properly)
- Removed world folder expression (Skript users don't need this and it's not needed for other parts of Skellett)
- Removed Yaml (There are lots of other alternatives now). I'm over the yaml hype train. Don't use YAML as a database, it's for configurations, but Skript has variables and options at the top of a script so.

- Fixed adding text components to books (Used to use reflection and it broke in newer Spigot)
- Updated the %players% is in water condition to 1.17 methods.

[(the|all)] [of] [the] [loaded] functions

function broadcastExample(message: string):
    broadcast {_message}
on script load:
    set {_functions::*} to all functions where [string input contains "broadcastExample"]
    evaluate "%{_functions::1}%(""Hello world!"")"

   #effects:
      (place|paste) schematic %string% at %locations% [[(with|at)] angle %-number%] [with limit %-number%] [[and] (without|exclud(e|ing)) air %-boolean%]

paste schematic "test" at player with angle 90 and without air true

[skellett] [client] relative time of %player% [is] [%-boolean%] [relative] [to] [server]
#to
[client] relative time of %player% (1¦is|2¦is(n't| not)) relative [to server]

[server] whitelist[ed] [state]
#to
[server] (1¦is|2¦is(n't| not)) whitelisted

[file] exist(s|ance) [(at|of)] %string% [is %-boolean%]

Conditions:
 
    juke[ ]box %block% (1¦is|2¦is(n't| not)) playing [a] (record|track|song)
 
#Effects:

    #Removes all potion effects from a player
    remove all [potion] effects from %players%
 
#Expressions:

    #Returns a blank inventory
    [a] new inv[entory] [with type] %string% [with %-number% row[s]] [named %-string%]
 
    [the] tick[s] (of|from) [time[span]] %timespan%", "[time[span]] %timespan%'s tick[s]
 
    #Returns the offline player of a skull block
    [the] [skellett] skull[ ]owner of [skull] %block%
    [skellett] [skull] %block%'s skull[ ]owner
 
    #Returns the block face of a skull block in direction, blockface or string
    [the] [skellett] skull[ ]rotation of [skull] %block% [in (1¦direction|2¦blockface)]
    [skellett] [skull] %block%'s skull[ ]rotation [in (1¦direction|2¦blockface)]
 
    #Grabs the spigot BlockFace compared from a direction and block
    [the] [block[ ]]face of [block] %block% from %direction%
    [block] %block%'s [block[ ]]face from %direction%
 
    #Grabs the last bossbar that was created
    [the] last created [boss[ ]]bar
 
#Regenerators:
 
    #Effects
    #Create a regenerator with specific blocks. Good for minigames like Paintball.
    (create|make) [a] [new] [skellett] regenerator with ID %string% (from|with) %blocks%
 
    #Expressions
    #Get all blocks of a regenerator
    block[s] of [skellett] regenerator [[with] id] %string%
 
#Citizens:

    #Effect
    (make|force) [the] (npc|citizen) %citizen% (talk|say|speak) %string% [to %-players%]
 
    #Event:
    [on] (npc|citizen) (speech|speak|talk):
     
        #Get message in event
        event-string
     
        #Get citizen in event
        event-citizen
 

%entity% [can] (see|visibly see|line of sight) [can see] %entity%
#to
%entity% (1¦can|2¦can([ ]no|')t) [visibly] see %entity%

#Expressions:
   
    #Grab a new written book (Because Skript's is different)
    [a] new [written] book

#TextComponent stuff

    #Create a new text component
    [a] [new] text component [with [text]] %strings%
   
    #Add hover event stuff to the text component (When a player hovers their mouse over it)
    add hover event with action %hovereventaction% (and|with) [(value|text)] %string% to [text component] %textcomponent%
   
    #Add clickable event stuff to the text component (When a player clicks the text)
    add click event with action %clickeventaction% (and|with|to) [(execute|text|link)]  %string% to [text component] %textcomponent%

    #Add a page with the text component to a book
    add text component %textcomponent% to [book] %itemstack%
   
    #Message the json text component (tellraw) to the player
    message text component %textcomponent% to %players%
   
    #Works from 1.8-1.12 as tested

command /book <integer>:
    trigger:
        set {_book} to a new book
        #SUGGEST_COMMAND and OPEN_FILE doesn't work in books. It is a chat only feature. Which is coming soon!
        if arg 1 is 1:
            set {_component} to a new text component with "Hello world!%nl%%nl%&5&lExample %arg 1%!"
            add hover event with action SHOW_TEXT with text "&5This message is a hover!" to text component {_component}
            add text component {_component} to book {_book}
        else if arg 1 is 2:
            set {_component} to a new text component with "&l&nExample 2!%nl%%nl%%nl%%nl%%nl%&4Working!"
            #If the slash isn't inserted in the execute string. It will make them chat.
            #WARNING: Entering color symbols in the execute string, causes the player to crash.
            add click event with action RUN_COMMAND with execute "/example" to text component {_component}
            add hover event with action SHOW_TEXT with text "&3&oClick me to execute chat or command" to text component {_component}
            add text component {_component} to book {_book}
        else if arg 1 is 3:
            add page "Testing 1" to {_book}
            add page "&1Testing 2" to {_book}
            set {_component} to a new text component with "&3&l&n&nExample 3!%nl%%nl%&4Working! %all players%"
            add click event with action CHANGE_PAGE to "2" to text component {_component}
            add hover event with action SHOW_TEXT with text "&4&kgewhbewgjbjehbf%nl%&r&5Click me%nl%to go back a page" to text component {_component}
            add text component {_component} to book {_book}
            add page "&6Testing 3" to {_book}
        else if arg 1 is 4:
            set {_component} to a new text component with "%nl%%nl%%nl%%nl%%nl%     &5&l&nClick me link!%nl%&rLeave a 5 star review!"
            add click event with action OPEN_URL with link "https://forums.skunity.com/threads/skellett.39/" to text component {_component}
            add hover event with action SHOW_TEXT with text "&5&lClick me to open Skellett.%nl%&5The beast addon!" to text component {_component}
            add text component {_component} to book {_book}
            #message text component {_component} to player
        open book {_book} to player

#Events:

    [on] (skellett[ ][(cord|proxy)]|bungee[ ][cord]) [player] switch server[s]
    [on] (skellett[ ][(cord|proxy)]|bungee[ ][cord]) [player] server[s] switch

#Effects:
 
    #Create or load a world Async and/or with a generator.
    #Info You can't have a generator option if you're loading the world Async, Because FAWE is your generator.
    #Also the node Async has to be enabled in the Skellett config.yml and FAWE installed for the async to work.
    [skellett] (load|create) world %string% [with generator %-string%] [[and] [with] [fawe] async[hronous]]

#Expresions:
 
    #Get the world folder file path
    world folder of %world%

         #Get any data possible from an entity
        data watcher value %number% from %entity%

         data watcher type (of|from) %*object%

command /dw <integer>:
    trigger:
        broadcast "%data watcher value arg 1 from target entity%"

command /sizedChest:
    trigger:
        loop 6 times:
            if size of all players is within row loop-number:
                set {_size} to loop-number
                exit loop
        open "CHEST" with {_size} rows named "&6This" to player

on bungeecord player disconnect:
    broadcast "%event-string%"
    broadcast "%event-uuid%"
    broadcast "%event-offlineplayer%"
on bungeecord player switch server:
    broadcast "%event-string%"
    broadcast "%event-uuid%"
    broadcast "%event-offlineplayer%"

[on] (skellett[ ][(cord|proxy)]|bungee[ ][cord]) [player] switch server[s]
[on] (skellett[ ][(cord|proxy)]|bungee[ ][cord]) [player] server[s] switch

#Expressions:
 
    #Changers: set (OfflinePlayer)
    #Info: Gets the offline player linked to the skull.
    #Info: This can only be set at the moment for some reason.
    [the] skull[ ]owner of [skull] %block%
    [skull] %block%'s skull[ ]owner
 
    #Info: Returns a spigot material name of a aliases https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html
    [the] [spigot] material [name] (from|of) %itemtype%
    %itemtype%'s [spigot] material [name]
 
    #Info: Calculates the row that was clicked in the inventory clicking event.
    [the] click[ed] row
 
    #Info: create a pastebin. This returns the link of the pastebin.
    #You can get and find your pastebin API key at https://pastebin.com/api
    [(get|make|create)] [a] paste[ ]bin [link] with (data|lines) %strings%[(,| and|with)] (title|header) %string%[(,| and|with|for)] [api] key %string%
 
#Conditions:

    #Info: Checks if a slot is within a row of a defined inventory.
    #If the inventory isn't set, it assumes it's a chest.
    #Supported inventories: Player, Chest, ShulkerBox, Enderchest, Dropper, Dispenser, Workbench and Hopper.
    #Any other inventory will be calculated and guessed apon it's inventory size.
    [slot] %number% (1¦is|2¦is(n't| not)) (within|of|in) row %number% [(of|in|from) [inventory] %-inventory%]

on inventory click:
   cancel event
   broadcast "&6%clicked row%"
   if clicked slot is within row 2 of clicked inventory:
       broadcast "&a&lYes"
   if clicked row is 2:
       broadcast "&a&lDoes same thing :P"

on rightclick on anything:
    set {_material} to material from player's tool
    if player hasn't got a cooldown for {_material}:
        set the cooldown of {_material} for player to 100
    wait 2 ticks
    if player has a cooldown for {_material}:
        broadcast "yes"
command /skull:
    trigger:
        broadcast "%skull owner of target block%"

[event] method %string% [is [a] loop[able] %-boolean%] [(from|of) [(expression|type|class)] %-object%] [with parameter[s] %-objects%]

#Effects:

    #Info: This acts the same as the custom effect executer. Except you don't need to return an object. This just invokes it raw.
    (invoke|execute|run) method %string% [(from|of) [(expression|type|class)] %-object%] [with parameter[s] %-objects%]
    #Example:
        invoke method "setFlying" from player with parameter true
   
#Expressions:

    #Info: Get all the loaded chunks of a world.
    [(the|all)] [of] [the] loaded chunks (in|of|from) [world] %world%
   
    #Info: Get the server's java version
    [the] server[[']s] java version
    [the] java version of [the] server
   
    #Info: Returns a date string from the given milliseconds
    date (from|of) [(long|millseconds)] %number%
   
    #Changers: set and reset (Number)
    #Info: Set or return a cooldown of an item. This shows the cooldown animation on an items slot when used.
    #Keep in mind this is only an animation. You will have to test if the cooldown is set using the cooldown condition.
    #This is similar to the 1.11+ cooldown enderpearls have when used.
    [the] cool[ ]down of [(item|material)] %string% (for|of) %player%
    [(item|material)] %string%'s cool[ ]down (for|of) %player%

#Conditons:
   
    #Info: Check if a player has a cooldown active for a specific material
    %player% (1¦does|2¦does(n't| not)) have [a] cool[ ]down for [(item|material)] %string%
   
#RedisBungee:

    #Info: Returns a list of all redisbungee servers.
    [(the|all)] [of] [the] redis[[ ]bungee] [connected] servers
   
    #Info: Returns a list of all redisbungee players.
    [(the|all)] [of] [the] redis[[ ]bungee] players
   
    #Does the same thing as above, but with usernames rather than uuids.
    [(the|all)] [of] [the] [online] redis[[ ]bungee] player [user]names
   
    #Info: Returns a long (number) in milliseconds of the date the player last logged in.
    #Info: You can use the date from long expression to get the date string.
    [the] last login of redis[[ ]bungee] [(player|uuid)] %string%
    redis[[ ]bungee] [(player|uuid)] %string%'s last login
   
    #Info: Get players on a proxy.
    [(the|all)] [of] [the] redis[[ ]bungee] players on proxy %string%
    redis[[ ]bungee] proxy %string%'s players
   
    #Info: Get players on a server from redis bungee.
    [(the|all)] [of] [the] redis[[ ]bungee] players on server %string%
    redis[[ ]bungee] server %string%'s players
   
    #Info: Returns the redis bungee id of a player.
    redis[[ ]bungee] player id (for|of) [(player|uuid)] %string%
   
    #Info: Get a server of a player within the redis bungee system.
    [the] redis[[ ]bungee] [connected] server (for|of) [(player|uuid)] %string%
   
    #Info: Returns the redis bungee id of the bungeecord this syntax is attached too.
    [the] redis[[ ]bungee] server id [(for|of) this bungee[[ ]cord]]
   
    #Info: Get the username of an uuid though redis bungee.
    #The lookup addon allows you to tell redis bungee to do a more indepth uuid name lookup.
    #It will always be true if that part of the syntax is added.
    [the] redis[[ ]bungee] [player] [user[ ]]name of uuid %string% [[with] expensive lookup %-boolean%]

    #Info: Check if a player/uuid is online the redis bungee network.
    redis[[ ]bungee] [(player|uuid)] %string% (1¦is|2¦is(n't| not)) online [the] [bungee[ ][cord]]
   
    #Info: Executes a command on all proxy servers connected to the redis.
    #If the ID is set. The command will only be ran on that proxy with that id.
    (run|execute) redis[[ ]bungee] [proxy] command %string% on [all [of the]] proxy server[s] [[with] id %-sting%]

[the] (npc|citizen) %npc% (1¦is|2¦is(n't| not)) (navigating|moving)

[the] [skellett[ ][(cord|proxy)]] (global|network) [var[iable]] [(from|of)] %object%

set network variable {test} to "&6Hello world!"
set {_this} to network variable {test}

set global variable {test} to "&6Hello world"
 

broadcast "%{test}%"

Expressions:

    #Info: This gets the server tick not tps. Tick is basically the interval of Minecraft.
    #It's like the System time, but for Minecraft.
    #You can use this to get how long the server has been up in ticks etc.
    [the] server tick[s]
    [the] server's tick[s]
    [the] tick[s] of [the] server

#Effects:

    #Make a citizens attack another entity
    #Info: The aggressive state means the Npc will attack and damage it. If this is false the npc will just target an entity but not damage
    (make|force) (npc|citizen) %npc% (target|attack|damage|follow) %entity% [[aggressive] [state] %-boolean%]

Events:

    [on] (unhang|[entity] unhung)
       
        #The entity being unhung
        event-entity
       
        #Gets the entity removing the hung entity
        [the] (hung|hang)[(ed|ing)] remover [entity]
       
        #Returns the cause of this event
        [the] (hung|hang)[(ed|ing)] cause
   
    [on] (hang|[entity] hung)
       
        #The player hanging the entity
        event-player
        #The hanged entity
        event-entity
        #The block an entity was hung on
        event-block
       
    [on] ([un]hang[ing]|[un]hung) [entity] (remove|break|destroy)
       
        #Gets the entity removing the hung entity
        [the] (hung|hang)[(ed|ing)] remover [entity]
       
        #The entity being destroyed
        event-entity
       
        #Returns the cause of this event
        [the] (hung|hang)[(ed|ing)] cause

Conditions:

    #Checks if the player is protocol hidden to another player using the reveal and hide effects
    [player] %player% (1¦can|2¦can([ ]no|')t) see [player] %player%
       
Expressions:

    #Get the statistic of anything from a player
    #Info if the Statistic requires a Material or Entity. Insert that data into the appropriate string provided.
    [the] stat[istic][s] %string% (of|from) %player% [[(with|from|for|of)] entity[[ ]type] %-string%] [[(with|from|for|of)] material %-string%]
   
    #Get the locations outlining a chunk
    [(the|all)] [of] [the] blocks [in [a[n]]] (around|outlin(e|ing)) [of] chunk %chunk% [[at] [y(-| )coordinate] %-number%]

command /stats <text> <text> [<integer>]:
    usage: /stats (get|set|add|subtract|reset) (statistic) [(value)]
    trigger:
        loop enum values of statistic:
            if "%loop-value%" is arg 2:
                set {_found} to true
        if {_found} is true:
            if arg 1 is "set":
                if arg 3 is set:
                    set statistic "%arg 2%" from player to arg 3
            else if arg 1 is "add":
                if arg 3 is set:
                    add arg 3 to statistic "%arg 2%" from player
            else if arg 1 is "subtract":
                if arg 3 is set:
                    subtract arg 3 from statistic "%arg 2%" from player
            else if arg 1 is "reset":
                reset statistic "%arg 2%" from player
            set {_stat} to statistic "%arg 2%" from player
            broadcast "%{_stat}%"
        else:
            message "&c%arg 2% is not a statistic"
command /statMaterial:
    trigger:
        set {_stat} to statistic "DROP" from player from material "ROTTEN_FLESH"
        broadcast "%{_stat}%"
command /statEntity:
    trigger:
        set {_stat} to statistic "KILL_ENTITY" from player from entity "ZOMBIE"
        broadcast "%{_stat}%"
command /blocks <boolean>:
    trigger:
        set {_chunk} to chunk at player's location
        if arg 1 is false:
            loop all blocks outlining chunk {_chunk}:
                set loop-block to diamond block
        else:
            loop all blocks outlining chunk {_chunk} at y-coordinate of player:
                set loop-block to diamond block
                wait a tick
on unhang:
    if unhang cause is not "ENTITY":
        cancel event

%disguise%'s [custom] name
#to
disguise %disguise%'s [custom] name

Effects:

    #Make a block appear open like a chest or shulker box
    [skellett] make [the] %block% (appear|look) (1¦open|2¦closed) for %players%
    [skellett] play chest (1¦open|2¦close) animation at %block% for %players%
    [skellett] (1¦open|2¦close) [the] %block% for %players%
   
    #If generating is true, it will generate the chunk if it's never been loaded before
    [skellett] load chunk %chunk% [[with] generat(e|ing) %-boolean%]
   
    #Saving will save the chunk to memory
    [skellett] unload chunk %chunk% [[with] sav(e|ing) %-boolean%]
   
Expressions:

    #Changers: set (ItemStack)
    [skellett] item (in|inside|within|of|from) item[ ]frame %entity%
    [skellett] %entity%'s item[ ]frame item
    [skellett] item[ ]frame %entity%'s item
   
    #Changers: set (Rotation)
    [skellett] rotation (of|from) item[ ]frame %entity%
    [skellett] %entity%'s item[ ]frame rotation
    [skellett] item[ ]frame %entity%'s rotation
   
    #Doesn't work. PlaceholderAPI is stupid.
    [parse[d]] place[ ]holder [(from|with)] %string% [[(from|for)] %-player%]

Types:
   
    rotation

#/itemframe stone COUNTER_CLOCKWISE_45
command /itemframe [<item>] [<rotation>]:
    trigger:
        if target entity is set:
            if arg 1 is set:
                set item in itemframe target entity to arg 1
                broadcast "%item in itemframe target entity%"
            if arg 2 is set:
                set rotation of itemframe target entity to arg 2
                broadcast "%rotation of itemframe target entity%"
command /openChest:
    trigger:
        make target block appear open for player

on packet:
    if event-string is "PacketPlayInSettings":
        broadcast "%event-player%"
        set {_this} to packet field "a"
        broadcast "Language: %{_this}%"
        set {_this} to packet field "b"
        broadcast "View distance: %{_this}%"
        set {_this} to packet field "c"
        broadcast "Chat setting: %{_this}%"
        set {_this} to packet field "f"
        broadcast "Lefty or Righty: %{_this}%"

#Event:
    [on] packet [(send|sent|recieve)]
#Expression:
    #Changers: set (Object)
    [the] [skellett] packet (data|value|field) %string% [[is] [a] loop[able] %-boolean%]

on packet:
    if event-string is "PacketPlayInSettings":
        set {_this} to packet field "a"
        broadcast "Language: %{_this}%"
        set {_this} to packet field "b"
        broadcast "View distance: %{_this}%"
        set {_this} to packet field "c"
        broadcast "Chat setting: %{_this}%"
        set {_this} to packet field "f"
        broadcast "Lefty or Righty: %{_this}%"

#Changers: set, add and remove (Number)
#Info: This was a test to see how minecraft handles block hardness/durability.
#This expression applys to all blocks of it's type. Not just one.
#When setting this, say you set the value to like 5.5 or something.
#The block won't break until the durability of the block has reached 5.5. This will stay contant.
#So if you break a block it won't break until X ticks after, this isn't the value 5.5 that's in ticks.
#It's just a strange mechanic I was playing around with. I thought the outcome would be different, but my hypothesis was wrong.
#Anyways you can get the hardness of any block which can be helpful.
[the] block (break delay|durability|hardness) of [all] %block%
[all] %block%'s block (break delay|durability|hardness)

command /hardness [<number>]:
    trigger:
        broadcast "%block hardness of target block%"
        if arg 1 is set:
            set block hardness of target block to arg 1
            broadcast "&cNew: %block hardness of target block%"
command /test:
    trigger:
        set {_this} to bungeecord uuid of player
        broadcast "%{_this}%"
        set {_this} to bungeecord uuid of "%player%"
        broadcast "%{_this}%"
        set {_this} to bungeecord uuid of "%uuid of player%"
        broadcast "%{_this}%"

   #Changers: set (Number)
   #This is the size of rows
   [skellett] (gui|menu|inventory|chest|window) row[s] (of|from) %inventory%
   %inventory%'s (gui|menu|inventory|chest|window) row[s]

Expressions:
     
    #Returns a new blank map created for a world
    [skellett] [a] new map[[ ]view] (for|from|with) [world] %world%

function animate(p: player):
    add "&a", "&b", "&c", "&d", "&e", "&1", "&2", "&3", "&4", "&5", "&6", "&7", "&8", "&9" and "&f" to {_d::*}
    set {_t} to "This is some text made for testing yeeeeeeeeeeeeeee!"
    set {_num} to a random integer out of {list::*}
    remove {_num} from {list::*}
    #set {_time} to "%random integer between 1 and 3% ticks" parsed as timespan
    loop (the length of {_t}) times:
        wait a tick
        set {_s} to subtext of {_t} from characters loop-number to (loop-number + 32)
        set the text of id "%{_p}%Slot%{_num}%" to "%{_d::%{_num}%}%&6%{_s}%"
command /testing:
    trigger:      
        add "&a", "&b", "&c", "&d", "&e", "&1", "&2", "&3", "&4", "&5", "&6", "&7", "&8", "&9" and "&f" to {_d::*}
        if stylish scoreboard "T-%player%" does not exist:
            create new stylish scoreboard named "T-%player%"
            loop 15 times:
                if loop-number is not 15:
                    add loop-number to {list::*}
                create a new id based score "%player%Slot%loop-number%" with text "%{_d::%loop-number%}%" slot loop-number for stylish scoreboard "T-%player%"
        set title of stylish scoreboard "T-%player%" to "&a&lSkellett"
        set stylish scoreboard of player to "T-%player%"
        set the text of id "%player%Slot15" to "&a&lSkellett stylish scoreboards ftw"
        loop 50 times:
            animate(player)
            wait "%random integer between 1 and 10% ticks" parsed as timespan
        delete {list::*}
        wait a second
        message "done"
        loop 15 times:
            delete the id based score "%player%Slot%loop-number%" in stylish scoreboard "T-%player%"
        delete stylish scoreboard "T-%player%"
        loop 15 times:
            delete the id based score "%player%Slot%loop-number%" in stylish scoreboard "TEST-%player%"
        delete stylish scoreboard "TEST-%player%"

Client borders:

    Expressions:
       
        #Changers: set (Location)
        #Info: The location ignores the y coordinate
        [client [side]] [world] border center [location] (for|of) %player%
        %player%'s [client [side]] [world] border center [location]
       
        #Changers: set, add, remove and reset (Number)
        #Info: Resetting it returns it to like how a new border would be made
        [client [side]] [world] border size (for|of) %player%
        %player%'s [client [side]] [world] border size
       
        #Changers: set, add, remove and reset (Number)
        #Info: Resetting it returns it to like how a new border would be made
        [client [side]] [world] border [damage] buffer (for|of) %player%
        %player%'s [client [side]] [world] border [damage] buffer
       
        #Changers: set, add, remove and reset (Number)
        #Info: Resetting it returns it to like how a new border would be made
        [client [side]] [world] border damage [amount] (for|of) %player%
        %player%'s [client [side]] [world] border damage [amount]
       
        #Changers: set, add, remove and reset (Integer)
        #Info: Resetting it returns it to like how a new border would be made
        [client [side]] [world] border warning [time] (for|of) %player%
        %player%'s [client [side]] [world] border warning [time]
       
        #Changers: set, add, remove and reset (Integer)
        #Info: Resetting it returns it to like how a new border would be made
        [client [side]] [world] border warning distance (for|of) %player%
        %player%'s [client [side]] [world] border warning distance

command /b:
    trigger:
        set client border warning distance of player to 100
        set client border center location of player to player's location
        broadcast "&6%client border center location of player%"
        broadcast "%client border size of player%"
        loop 20 times:
            set client border size of player to loop-number
            broadcast "%client border size of player%"
            wait a second
        reset client border warning distance of player

Effects:

   update [the] (inventory|menu|gui) %inventory%

   open book %itemstack% to %player%

Expressions:

   [the] hitbox length of %entity%
   %entity%'s hitbox length
   [the] length of %entity%'s hitbox

   [the] hitbox width of %entity%
   %entity%'s hitbox width
   [the] width of %entity%'s hitbox

Conditions:

   [player] %player% (1¦is|2¦is(n't| not)) viewing [the] credits

   [entity] %entity% (1¦is|2¦is(n't| not)) in water

Spawners:

   Expressions:

       #Changers: set, add and remove (Integer)
       delay (of|from) spawner [at] %block%
       %block%'s spawn[er] delay
       spawn[er] delay (of|from) %block%
 
       #Changers: set (String)
       (entity|mob|creature) [type] (of|from) spawner [at] %block%
       %block%'s spawn[er] (entity|mob|creature) [type]
 
   Effects:

       (make|force) spawner [at] %block% to spawn [[a[n]] entity]
 
   Events:

       [on] spawner spawn:
     
           #Get the spawner used to spawn the entity
           event-block
     
           #Get entity spawned
           event-entity

#command /egg:
#    trigger:
#        set {_p} to the eggwars player player
#        broadcast "%{_p}%"
command /hello:
    trigger:
        if enchantments of player's tool are set:
            loop all enchantments on player's tool:
                add "%loop-enchantment% %enchantment level of loop-enchantment in player's tool%" to {_enchantments::*}
            broadcast "%{_enchantments::*}%"
command /i <itemtype>:
    trigger:
        give player arg 1
#on npc rightclick:
#    if id of npc event-npc is 6:
#        make event-player execute command "say hi"
command /hi:
    trigger:
        open "HOPPER" to player
        wait 2 seconds
        open "BEACON" to player
#on join:
#    while player is online:
#        wait a second
#        if player is viewing the credits:
#            broadcast "&aYes"
#        else:
#            broadcast "no"
command /test:
    trigger:
        skellett nms of target entity
command /example:
    trigger:
        if target entity is in water:
            broadcast "&bYes"
        else:
            broadcast "no"
command /spawnTest:
    trigger:
        set mob type of spawner target block to "Zombie"
        message "%mob of spawner target block%"
on spawner spawn:
    broadcast "%event-block%"
    broadcast "%event-entity%"
command /size:
    trigger:
        message "%target entity%: %hitbox length of target entity% x %hitbox width of target entity%"
command /search <text>:
    trigger:
        message " "
        loop all packettypes:
            if "%loop-value%" contains "%arg 1%":
                message "&6%loop-value%"
        message " "
command /openBook:
    trigger:
        set {_item} to slot player's current hotbar slot of player
        set slot player's current hotbar slot of player to a written book
        add page "&4&l&m-&a&l*&4&l&m__ &2&l&nSkellett&4&l&m __&a&l*&4&l&m-&r%nl%%nl%%nl%%nl%%nl%%nl%%nl%%nl%%nl%%nl%           &dHot" to player's tool
        open book player's tool to player
        set slot player's current hotbar slot of player to {_item}

[a] [new] (npc|citizen) [with] (name[d]|id|string) %string% [and] [with] [entity [type]] %string%
[a] [new] npc [with] [entity [type]] %string% [and] [with] (name[d]|id|string) %string%

Expressions:
 
    #Changers: set (Boolean)
    [skellett] custom name visib(le|ility) of %entity%
    [skellett] visib(le|ility) of %entity%'s custom name
     
    #Changers: set, reset, remove, remove all and delete (ItemStack)
    [items (from|of|in)] slots %numbers% (from|of|in) %inventory%

Npc:
   
    Expressions:
       
        [the] (npc|citizen) (of|from) entity %entity%
       
        [the] (npc|citizen) (of|from) [id] %number%

PlayerPoints:
   
    Expressions:
   
        #Changers: set, add, remove/subtract, remove all and delete
        [the] [player[ ]]points of [(player|uuid)] %string%
        [(player|uuid)] %string%'s [player[ ]]points
       
    Effects:
   
        pay %string% %number% [player[ ]]points from %string%['s account]
        [(force|make)] %string% [to] pay %number% [player[ ]]points to %string%
       
SkellettProxy:

    Expressions:
   
        [the] [(skellett[ ][(cord|proxy)]|bungee[ ][cord])] online [status] of (skellett[ ][(cord|proxy)]|bungee[ ][cord]) server %string%

[on] (skellett[ ][(cord|proxy)]|bungee[ ][cord]) player (disconnect|leave)

eval[uate] [skript] [code] %string% (on|from) [the] [bungee[ ][cord]] [server] %string%

on script load:
    evaluate "set {testing} to ""&6&lYES""" on bungeecord server "Tests2"
    evaluate "broadcast ""&6&lWhat the actual ****!!!!!""" on bungeecord server "Tests2"
    broadcast "sent"
on bungee player leave:
    broadcast "%event-player%"

[the] max[imum] [amount] [of] players for (skellett[ ][(cord|proxy)]|bungee[ ][cord]) server %string%

[skellett] entity (from [the]|of) (uuid|[universal] unique id) %string%

[skellett] [get] item[s] (of|in|inside|within) entity %entity%
[skellett] (size|number|amount) of item[[ ]stack] %itemstack%

[skellett] (size|number|amount) of item[[ ]stack] %itemstack%

%player% (1¦is|2¦is(n't| not)) (running|using) [the] [client] SquidHQ [client]

command /spawnmob:
    trigger:
        spawn 1 of zombie
        set {_entity} to last spawned zombie
        if {_entity} is an adult:
            broadcast "yes"
        else:
            broadcast "no"
        make {_entity} a baby

#Effects:

    [skellett] hide [player] %player% from %players%
 
    [skellett] show [player] %player% to %players%

#Expressions:

    #Loopable
    [(the|all)] [of] [the] hidden players (of|from) %player%
    [all] [of] %player%'s hidden players

[the] (skellett[ ][(cord|proxy)]|bungee[ ][cord]) [player] (uuid|unique[ ]id) of [player] %player%
(skellett[ ][(cord|proxy)]|bungee[ ][cord]) %player%['s] (uuid|unique[ ]id)

#Effects:

   [skellett] apply [potion[s]] [of] %potioneffecttype% [potion] [[[of] tier] %-number%] to %livingentities% [for %-timespan%] [[and] ambient %-boolean% [hide [particle [effects] %-boolean% [colo[u]r %-color%]]]

#Expressions:
 
   [skellett] [dye[d]] [colo[u]r] [of] %itemstack% [to] (colo[u]r[ed]|dyed) %color%
 
   [skellett] ping of [player] %player%
   [skellett] %player%'s ping
 
   #Changers: set (Boolean)
   [skellett] piston[s] (power|toggle) [state] of %block%
   %block%'s piston (power|toggle) [state]
 
   #Changers: set (Integer)
   #Info: This is the repeater tick delay
   [skellett] [redstone] repeater[s] [(redstone|power)] delay of %block%
   [redstone] repeater %block%'s [(redstone|power)] delay
 
#Conditons:
 
   [piston] %block% (1¦is|2¦is(n't| not)) [a] sticky [piston]
 
#Regenerators:

   #Expressions:
   
     #Changers: set (Location)
     #Info: Once changed the regenerator will rebuild itself then reconfigure itself
     pos[ition][ ]1 of [skellett] regenerator [[with] id] %string%
   
     #Changers: set (Location)
     #Info: Once changed the regenerator will rebuild itself then reconfigure itself
     pos[ition][ ]2 of [skellett] regenerator [[with] id] %string%
   
     #Loopable
     [(the|all)] [of] [the] [skellett] regenerator [ids]
   
   #Effects:
   
     create a regenerator with ID "test" from player's location to location of target block
     (create|make) [a] [new] [skellett] regenerator with ID %string% (from|within) [location[s]] %location% (to|and) %location%
   
     #Info if te rebuild is not defined it will default to true
     (delete|remove) [the] [skellett] regenerator with ID %string% [re[ ]build %-boolean]
   
     re[ ]configure [the] [skellett] regenerator with ID %string%
   
     re(generate|[ ]build) [the] [skellett] regenerator with ID %string%
   
   #Conditions:
 
     [skellett] regenerator with id %string% (1¦does|2¦does(n't| not)) exist

#Citizen stuff:

   #Events:
   
     [on] (npc|citizen) damage (by|from) [a[n]] entity
     
       #Get the attacker
       event-entity
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get damage cause in String
       event-string
     
       #Get or set the damage (Number)
       [the] (citizen|npc) damage
     
     [on] (npc|citizen) damage (by|from) [a] block
     
       #Get the block
       event-block
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get or set the damage (Number)
       [the] (citizen|npc) damage
   
     #This is called when a citizen attacks
     [on] (npc|citizen) entity damage
   
       #Get the victim
       event-entity
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get or set the damage (Number)
       [the] (citizen|npc) damage
   
     [on] entity target (npc|citizen)
   
       #Get the entity that targeted this npc
       event-entity
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get the target reason
       [the] target reason
     
     [on] (npc|citizen) [(right|left)] click
   
       #Get the player that clicked the NPC
       [the] (citizen|npc) [event[(-| )]](player|clicker)
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) [entity] colli(sion|de)
     
       #Get the entity that was collided with
       event-entity
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) (combust[ion]|ignition) (by|from) [a] block
     
       #Get the block
       event-block
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get or set the combustion time (Number)
       [the] (citizen|npc) [event[(-| )]](combust[ion]|ignition) time
     
     [on] (npc|citizen) (combust[ion]|ignition) (by|from) [a[n]] entity
     
       #Get the entity
       event-entity
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get or set the combustion time (Number)
       [the] (citizen|npc) [event[(-| )]](combust[ion]|ignition) time
     
     [on] (npc|citizen) create
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) despawn
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
       #Get despawn reason
       [the] [(npc|citizen)] despawn reason
     
     [on] (npc|citizen) ender[[ ]pearl] [teleport]
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) (push|(vector|velocity) change)
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) remove
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) sel[ect[ed]]
     
       [the] (citizen|npc) [player] selector
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] (npc|citizen) spawn
     
       #Get the location
       event-location
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)
   
     [on] (npc|citizen) teleport
     
       #Get the future location.
       event-location
           
       #Get the NPC
       [the] [event(-| )](citizen|npc)
     
     [on] player create (npc|citizen)
     
       #Get the creator
       event-player
     
       #Get the NPC
       [the] [event(-| )](citizen|npc)

   #Condtions:
 
     [entity] %entity% (1¦is|2¦is(n't| not)) [a[n]] (npc|citizen)
 
   #Effects:
 
     (delete|unregister) (npc|citizen) %npc%
   
     (delete|unregister|remove) [(the|all)] [of] [the] (npcs|citizens)

#CorpseReborn stuff:

   #Effects:
 
     (spawn|create) [a] corpse [with] [player [data]] %player% at %location% [with] id %string% [[with] inventory %-itemstacks%] [[with] helmet %-itemstack%[(,| and)] chestplate %-itemstack%[(,| and)] leg[ging][s] %-itemstack%[(,| and)] boot[s] %-itemstack%] [holding [item] %-itemstack%] [[and] offhand [item] %-itemstack%]]
   
     (delete|unregister|remove) (the|all) [of] [the] corpse[s]
   
     (delete|remove|unregister) corpse %corpse%
   
   #Expressions:
 
     #Loopable
     [(the|all)] [of] [the] corpse[s]
   
     [the] corpse with ID %string%
   
     #Changers: set (Player)
     [the] player of corpse %corpse%
     corpse %corpse%'s player
   
#LibsDisguises stuff:

   #Expressions:
 
     [a] [new] disguise [with] type %disguisetype% [with block [id] %-integer%] [(and|with) data [id] %-integer%] [with [user[ ]]name %-string%] [(and|with) baby [state] %-boolean%]
   
     disguise type of %entities%[[']s]
     %entities%'s disguise type
   
     #Changers: set (Disguise)
     #Info: if the player option is set this will make the entities disguise client side to that player
     disguise [of] %entities%[[']s] [(to|from) player %player%]
     %entities%'s disguise [(to|from) player %player%]
   
     #Info: This gets all possible disguises that different players can see of this entity
     [(the|all)] [of] [the] client [viewed] disguise[[']s] [of] %entity%
   
     #Changers: set (Boolean)
     self view[ing] disguise [state] of %entities%[[']s]
     %entities%'s self view[ing] disguise [state]
   
     #Changers: set (Entity)
     [the] entity of disguise %disguise%
     %disguise%'s disgusie entity
   
     [(the|all)] [of] [the] armo[u]r of disguise %disguise%
     %disguise%'s armo[u]r
   
     #Changers: set (ItemStack)
     [held] item of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s [held] item
   
     #Changers: set (ItemStack)
     [held] offhand item of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s [held] offhand item
   
     #Changers: set (ItemStack)
     [the] (item|equipment) [in] slot %equipmentslot% (of|in) disguise %disguise%
     [skellett] [[Libs]Disguises] slot %equipmentslot% (of|in) disguise %disguise%
   
     #Changers: set (Boolean)
     [skellett] [[Libs]Disguises] (burning|ignited|lit) [state] of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s (burning|ignited|lit) [state]
   
     #Changers: set (Boolean)
     [skellett] [[Libs]Disguises] (vanish[ed]|invisible) [state] of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s (vanish[ed]|invisible) [state]
   
     #Changers: set (Boolean)
     [skellett] [[Libs]Disguises] (sprint[ing]|run[ning]) [state] of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s (sprint[ing]|run[ning]) [state]
   
     #Changers: set (Boolean)
     [skellett] [[Libs]Disguises] (sneak[ing]|crouch[ing]) [state] of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s (sneak[ing]|crouch[ing]) [state]
   
     #Changers: set (Boolean)
     [skellett] [[Libs]Disguises] (block[ing]|right[(-| )]click[ing]) [state] of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s (block[ing]|right[(-| )]click[ing]) [state]
   
     #Changers: set (Boolean)
     [skellett] [[Libs]Disguises] name visib(le|ility) [state] of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s name visib(le|ility) [state]
   
     #Changers: set (String)
     [skellett] [[Libs]Disguises] [custom] name of disguise %disguise%
     [skellett] [[Libs]Disguises] %disguise%'s [custom] name
   
   #Effects:
   
     un[( |-)]disguise %entity%
   
   #Condition:
   
     [(entity|player)] %entity% (1¦(is|[does] (ha(s|ve)))|2¦(do[es](n't| not) have|is(n't| not))) [a] disguise[d]
     [(entity|player)] %entity% is disguised
     [(entity|player)] %entity% is(n't| not) disguised
     [(entity|player)] %entity% [does] (ha(s|ve)) [a] disguise
     [(entity|player)] %entity% do[es](n't| not) have [a] disguise
   
     disguise %disguise% (1¦(is|[does] (ha(s|ve)))|2¦(do[es](n't| not) have|is(n't| not))) [a] [custom] name

command /example:
    trigger:
        spawn a corpse with player data player at location of player with id "Test" with inventory air with helmet diamond helmet, chestplate diamond chestplate, legs diamond leggings, boots diamond boots holding diamond sword
command /exampledel:
    trigger:
        set {_corpse} to corpse with ID "Test"
        unregister corpse {_corpse}
command /test1:
    trigger:
        if target block is a piston:
            broadcast "%piston power of target block%"
            set piston power of target block to true
            broadcast "%piston power of target block%"
            if target block is not a sticky piston:
                broadcast "test"
            else:
                broadcast "test1"
        else if target block is a repeater:
            broadcast "%redstone repeater delay of target block%"
            set redstone repeater delay of target block to 2
            broadcast "%redstone repeater delay of target block%"
command /ping:
    trigger:
        broadcast "Your ping: %ping of player%"
command /regen:
    trigger:
        if regenerator with id "test" does exist:
            regenerate regenerator with ID "test"
            message "done"
        else:
            message "hello?"
command /testd:
    trigger:
        if player is not disguised:
            set {_d} to a new disguise with type PLAYER with username "%player%"
            set disguise of player to {_d}
            set self viewing disguise state of player to true
            broadcast "%self viewing disguise state of player%"
            set {_e} to the entity of disguise {_d}
            broadcast "&e%{_e}%"
            broadcast "&b%armour of disguise {_d}%"
            set item slot HEAD of disguise {_d} to diamond helmet
            set item slot CHEST of disguise {_d} to diamond chestplate
            set item slot LEGS of disguise {_d} to diamond leggings
            set item slot FEET of disguise {_d} to diamond boots
            broadcast "&b%armour of disguise {_d}%"
            set held item of disguise {_d} to stone sword
            set held offhand item of disguise {_d} to stone pickaxe
            broadcast "%item in slot HAND of disguise {_d}%"
            set burning state of disguise {_d} to true
            broadcast "%vanished state of disguise {_d}%"
            set sprinting state of disguise {_d} to true
            set sneaking state of disguise {_d} to true
            set blocking state of disguise {_d} to true
            set name visibility of disguise {_d} to true
            set custom name of disguise {_d} to "&6&l%player%"
        broadcast "%disguise type of player%"

#Expressions:

   #Gets the piston reaction state of what is going to happen if a piston was to extend this block
   [the] piston [move] reaction (of|from) %block%
   %block%'s piston [move] reaction
   
   [skellett] [the] image (of|from) [the] file [(location|path)] %string%
   
   [the] [skellett] holo[gram] with ID %string%
   
   [(the|all)] [of] [the] [skellett] holo[gram][s] ids
   
   #made this settable (So you can update holograms cleaner)
   [the] [skellett] (text|string) of holo[gram] line %hologramline%
   
   #Changers: set (ItemStack)
   [the] [skellett] item[[ ](type|stack)] of holo[gram] line %hologramline%
   
   [skellett] [(the|all)] [of] [the] map cursors (in|on|for) [skellett] [map] %map%
   
   #Changers: set (Integer)
   [skellett] map cursor direction (of|for) [map[ ]cursor] %mapcursor%
   
   #Changers: set (String)
   #Info: This is a MapCursor.Type
   [skellett] map cursor type (of|for) [map[ ]cursor] %mapcursor%
   
   #Changers: set (Integer)
   [skellett] map cursor (1¦x|2¦y)(-| )(coord[inate]|pos[ition]|loc[ation])[s] of [map[ ]cursor] %mapcursor%
   
   #Changers: set (Boolean)
   [skellett] map cursor visibl(e|ity) [state] (of|for) [map[ ]cursor] %mapcursor%
   
   #Changers: set (Number)
   #Info: The number is a byte being a colour on Spigot's MapColour scale
   [skellett] map pixle [colo[u]r] at [coordinate[s]] [x] %number%(,| and) [y] %number% (on|in) [skellett] map %map%
   
#Conditons:

   [block] %block% (1¦(is|has)|2¦(is|has)(n't| not)) [got] [redstone] powered
   
   [map] %map% (1¦is|2¦is(n't| not)) being handled [by skellett]
   
#Effects:

   (manage|override|overwrite|create) [skellett] map %map% [[and] [with] override %-boolean%]
   
   (show|send|display) [skellett] [custom] map %map% to %players%
   
   draw [buffered] image %image% [at [coordinate[s]] [x] %number%(,| and) [y] %number%] on [skellett] map %map%
   
   draw [map] cursor %string% pointing %number% at [coordinate[s]] [x] %number%(,| and) [y] %number% on [skellett] map %map%
   
   (erase|clear|remove|delete|unregister) [skellett] map %map%

on map:
   set {_map} to event-map
   set scale of map {_map} to FARTHEST
   broadcast "%scale of map {_map}%"
   manage skellett map {_map}
   if map {_map} is being handled by skellett:
     set {_image} to image from the file path "plugins\Skellett\test.png"
     draw image {_image} on skellett map {_map}
     draw text "&aSexy" at 44, 30 on skellett map {_map}
     draw cursor "BLUE_POINTER" pointing 1 at 50, 50 on skellett map {_map}
     loop all players:
       send map {_map} to loop-player
     stop
     loop all of the map cursors in skellett map {_map}:
       broadcast "&a%map cursor direction of cursor loop-value%"
       set map cursor direction of cursor loop-value to 5
       broadcast "&2%map cursor direction of cursor loop-value%"
       broadcast "&c%map cursor type of cursor loop-value%"
       set map cursor type of cursor loop-value to "RED_POINTER"
       broadcast "&4%map cursor type of cursor loop-value%"
       broadcast "&b%map cursor x-coord of cursor loop-value%"
       set map cursor x-coord of cursor loop-value to 30
       broadcast "&1%map cursor x-coord of cursor loop-value%"
       broadcast "&3%map cursor y-coord of cursor loop-value%"
       set map cursor y-coord of cursor loop-value to 30
       broadcast "&9%map cursor y-coord of cursor loop-value%"
       broadcast "&7%map cursor visible state of cursor loop-value%"
       set map cursor visible state of cursor loop-value to false
       broadcast "&8%map cursor visible state of cursor loop-value%"
       wait a second
       set map cursor visible state of cursor loop-value to true
       add "WHITE_POINTER", "GREEN_POINTER", "RED_POINTER", "WHITE_CROSS" and "BLUE_POINTER" to {_s::*}
       loop {_s::*}:
         set map cursor type of cursor loop-value-1 to loop-value-2
         wait 10 ticks
     broadcast "&f%map pixle at 50, 50 in skellett map {_map}%"
command /test:
   trigger:
     if target block is not redstone powered:
       broadcast "no"
     else:
       broadcast "yes"

#Effects:

   [(make|set)] [entity] %entity% [to] [a[n]] (1¦baby|2¦adult)

#Expressions:

   [get] [the] (digit|num[ber])[s] (of|from|in) %string%
   
   #Changers: set (Integer)
   [skellett] age of [entity] %entity%
   [entity] %entity%'s age
   
   #Changers: set (Boolean)
   #Info: This locks the age of an entity
   [skellett] age lock of [entity] %entity%
   [entity] %entity%'s age lock
   
   #Changers: set (Boolean)
   #Info: This toggles the ability for an entity to breed
   [skellett] breeding state of [entity] %entity%
   [entity] %entity%'s breeding state
   
   #Changers: set (World)
   [skellett] world (of|from) [location] %location%
   
   [skellett] (uuid|[universal] unique id) of [entity] %entity%
   [entity] %entity%'s (uuid|[universal] unique id)

#Conditions:

   [entity] %entity% (1¦is|2¦is(n't| not)) [a[n] adult

   [entity] %entity% (1¦can|2¦(can([ ]no|')t) breed

   (stylish|style|simple) [score][ ]board %string% (1¦(is set|[does] exist[s])|2¦(is(n't| not) set|does(n't| not) exist[s]))

[skellett] save [the] holo[gram] %hologram%

[skellett] remove %hologramline% from holo[gram] %hologram%

[skellett] [a] [new] [holo[gram]] line (for|in|of) holo[gram] %hologram% [and] (1¦with [(text|string)] %-string%|2¦with [item[(stack|type)]] %-itemstack%)

[the] [skellett] holo[gram] location of %hologram%
[skellett] holo[gram] %hologram%'s location

[skellett] (delete|remove) [the] holo[gram] %hologram%

[the] [skellett] height of holo[gram] line %hologramline%

[skellett] [create] [a] [new] holo[gram] at %location% [with] id %string%

[the] [skellett] holo[gram] line %number% (in|from|of) %hologram%

[skellett] add %hologramline% to holo[gram] %hologram% [(on|to) line %-number%]

[the] [skellett] location of holo[gram] line %hologramline%

[the] [skellett] visib(le|ility) [state] of holo[gram] line %hologramline%

[skellett] (despawn|clear) holo[gram] %hologram%

[(the|all)] [of] [the] [skellett] holo[gram] lines (in|from|of) %hologram%

[skellett] [re[-]]spawn holo[gram] %hologram%

[the] [skellett] holo[gram] ID of %hologram%
[skellett] holo[gram] %hologram%'s ID
[skellett] id of holo[gram] %hologram%

[skellett] (delete|remove|clear) [(the|all)] [of] [the] holograms

[the] [skellett] (text|string) of holo[gram] line %hologramline%

command /testing:
   trigger:
     set {_holo} to a new hologram at player's location with id "Example"
     set {_newLine} to a new line in hologram {_holo} with text "&6&lTesting"
     set {_newLineItem} to a new line in hologram {_holo} with itemstack diamond sword of sharpness
     add {_newLine} to hologram {_holo}
     add {_newLineItem} to hologram {_holo}
     loop all hologram lines of {_holo}:
       broadcast "%text of hologram line loop-value%"
     broadcast "ID: %hologram id of {_holo}%"
     wait 5 seconds
     delete hologram {_holo}