on player clicks in inventory:
- take iteminhand
on entity damaged:
- remove <context.entity>

after player clicks in inventory:
- take iteminhand
after entity damaged:
- if <context.entity.is_spawned||false>:
  - remove <context.entity>

on player clicks in inventory:
- determine passively cancelled
- wait 1t
- take iteminhand
on entity damaged:
- determine passively cancelled
- wait 1t
- if <context.entity.is_spawned||false>:
  - remove <context.entity>

- opentrades trade[max_uses=10;inputs=emerald[quantity=2];result=sponge]|trade[result=barrier]

open random inventory:
  type: task
  script:
  - inventory open "d:generic[size=18;title=<red>My <green>Awesome <blue>Inventory;contents=air|snow_ball]"

Assignment_Script_Name:
  type: assignment
  # | All assignment scripts MUST have this key!
  actions:
    on <action>:
    - ...
  # | Most assignment scripts should exclude this key, but it's available.
  default constants:
    <constant_name>: <value>
    <constant_list>:
    - ...
  # | MOST assignment scripts should have this key!
  interact scripts:
  - <interact_script_name>

Book_Script_Name:
  type: book
  # The 'custom name' can be anything you wish.
  # | All book scripts MUST have this key!
  title: custom name
  # The 'custom name' can be anything you wish.
  # | All book scripts MUST have this key!
  author: custom name
  # Defaults to true. Set to false to spawn a 'book and quill' instead of a 'written book'.
  # | Some book scripts might have this key!
  signed: true/false
  # Each -line in the text section represents an entire page.
  # To create a newline, use the tag <n>. To create a paragraph, use <p>.
  # | All book scripts MUST have this key!
  text:
  - page
  - ...

# The name of the script doesn't matter, and will not affect the command in any way.
Command_Script_Name:
  type: command
  # The name of the command. This will be the default method for running the command, and will show in '/help'.
  # | All command scripts MUST have this key!
  name: mycmd
  # The description of the command. This will be shown in the '/help' command.
  # Multiple lines are acceptable, via <&nl> (the tag for a new line), but you should
  # make the first line a brief summary of what your command does.
  # | All command scripts MUST have this key!
  description: My command.
  # Correct usage for the command. This will show in the '/help' command.
  # This is NOT the name of the command, and it is NOT used to control input parsing. It is EXCLUSIVELY for '/help'.
  # | All command scripts MUST have this key!
  usage: /mycmd <&lt>myArg1<&gt>
  # A list of aliases for the command. These will be used as alternative ways to trigger the command, and will show in the '/help' command.
  # | Some command scripts might have this key, but it's optional.
  aliases:
  - myalias
  - mycommand
  # The permission node to check for permissions plugins. This will automatically
  # block players without the permission from accessing the command and help for
  # the command.
  # Note that you can include multiple permission nodes (a player only needs to have any one permission from the list)
  # by separating them with a semicolon, like: perm.one;perm.two;third.perm
  # | Most command scripts should have this key!
  permission: my.permission.node
  # The message to send to the player when they try to use the command without
  # permission. If this is not specified, the default Bukkit message will be sent.
  # | Most command scripts should NOT have this key, but it's available.
  permission message: Sorry, <player.name>, you can't use my command because you don't have the permission '<permission>'!
  # The procedure-based script that will be checked when a player or the console
  # is trying to view help for this command. This must always be determined true
  # or false. If there is no script, it's assumed that all players and the console
  # should be allowed to view the help for this command.
  # Available context: <context.server> returns whether the server is viewing the help (a player if false).
  # | Most command scripts should NOT have this key, but it's available.
  allowed help:
  - determine <player.has_flag[special_allowed_help_flag]||<context.server>>
  # You can optionally specify tab completions on a per-argument basis.
  # Available context:
  # <context.args> returns a list of input arguments.
  # <context.raw_args> returns all the arguments as raw text.
  # <context.server> returns whether the server is using tab completion (a player if false).
  # <context.alias> returns the command alias being used.
  # | This key is great to have when used well, but is not required.
  tab completions:
    # This will complete "alpha" and "beta" for the first argument
    1: alpha|beta
    # This will complete any online player name for the second argument
    2: <server.online_players.parse[name]>
    # This will allow flags "-a", "-b", or "-c" to be entered in the third, fourth, or fifth argument.
    3 4 5: -a|-b|-c
    # Any argument other than the ones explicitly listed will be handled here with a tab complete that just says 'StopTyping'.
    default: StopTyping
  # You can also optionally use the 'tab complete' key to build custom procedure-style tab complete logic
  # if the simply numeric argument basis isn't sufficient.
  # Has the same context available as 'tab completions'.
  # | Most scripts should leave this key off, though it can be useful to some.
  tab complete:
  - determine some|dynamic|logic|here
  # The script that will run when the command is executed.
  # No, you do not need '- determine fulfilled' or anything of the sort, since the command is fully registered.
  # Available context:
  # <context.args> returns a list of input arguments.
  # <context.raw_args> returns all the arguments as raw text.
  # <context.source_type> returns the source of the command. Can be: PLAYER, SERVER, COMMAND_BLOCK, or COMMAND_MINECART.
  # <context.alias> returns the command alias being used.
  # <context.command_block_location> returns the command block's location (if the command was run from one).
  # <context.command_minecart> returns the EntityTag of the command minecart (if the command was run from one).
  # | All command scripts MUST have this key!
  script:
  - if !<player.is_op||<context.server>>:
    - narrate "<red>You do not have permission for that command."
    - stop
  - narrate Yay!
  - narrate "My command worked!"
  - narrate "And I typed '/<context.alias> <context.raw_args>'!"

# The script name will be shown to the economy provider as the name of the economy system.
Economy_Script_Name:
  type: economy
  # The Bukkit service priority. Priorities are Lowest, Low, Normal, High, Highest.
  priority: normal
  # The name of the currency in the singular (such as "dollar" or "euro").
  name single: scripto
  # The name of the currency in the plural (such as "dollars" or "euros").
  name plural: scriptos
  # How many digits after the decimal to include. For example, '2' means '1.05' is a valid amount, but '1.005' will be rounded.
  digits: 2
  # Format the standard output for the money in human-readable format. Use "<amount>" for the actual amount to display.
  # Fully supports tags.
  format: $<amount>
  # A tag that returns the balance of a linked player. Use a 'proc[]' tag if you need more complex logic.
  # Must return a decimal number.
  balance: <player.flag[money]>
  # A tag that returns a boolean indicating whether the linked player has the amount specified by auto-tag "<amount>".
  # Use a 'proc[]' tag if you need more complex logic.
  # Must return 'true' or 'false'.
  has: <player.flag[money].is[or_more].than[<amount>]>
  # A script that removes the amount of money needed from a player.
  # Note that it's generally up to the systems calling this script to verify that the amount can be safely withdrawn, not this script itself.
  # However you may wish to verify that the player has the amount required within this script.
  # The script may determine a failure message if the withdraw was refused. Determine nothing for no error.
  # Use def 'amount' for the amount to withdraw.
  withdraw:
  - flag <player> money:-:<[amount]>
  # A script that adds the amount of money needed to a player.
  # The script may determine a failure message if the deposit was refused. Determine nothing for no error.
  # Use def 'amount' for the amount to deposit.
  deposit:
  - flag <player> money:+:<[amount]>

# The name of the entity script is the same name that you can use to construct a new
# EntityTag based on this entity script. For example, an entity script named 'space_zombie'
# can be referred to as 'space_zombie'.
Entity_Script_Name:
  type: entity
  # Must be a valid EntityTag (EG 'zombie' or 'pig[age=baby]') See 'EntityTag' for more information.
  # | All entity scripts MUST have this key!
  entity_type: BASE_ENTITY_TYPE_HERE
  # Samples of mechanisms to use (any valid EntityTag mechanisms may be listed like this):
  # Whether the entity has the default AI
  # | Do not copy this line, it is only an example.
  has_ai: true/false
  # What age the entity is
  # | Do not copy this line, it is only an example.
  age: baby/adult/<#>

Format_Script_Name:
  type: format
  # The only key is the format. The format can use '<text>' as a special tag to contain the message being sent.
  # '<name>' is available as a special tag as well for use with the 'on player chats' event to fill the player's name properly.
  # | All format scripts MUST have this key!
  format: <name> says <text>

Interact_Script_Name:
  type: interact
  # | All interact scripts MUST have this key!
  steps:
    # The first step
    1:
      # Any trigger type here
      click trigger:
        script:
        # Handle what happens when the NPC is clicked during step 1
        - some commands
      # Other triggers here
    # other steps here

# The name of the script is the same name that you can use to construct a new
# InventoryTag based on this inventory script. For example, an inventory script named 'Super_Cool_Inventory'
# can be referred to as 'Super_Cool_Inventory'.
Inventory_Script_Name:
  type: inventory
  # Must be a valid inventory type.
  # Valid inventory types: BREWING, CHEST, DISPENSER, ENCHANTING, ENDER_CHEST, HOPPER, PLAYER, WORKBENCH
  # | All inventory scripts MUST have this key!
  inventory: inventory type
  # The title can be anything you wish. Use color tags to make colored titles.
  # Note that titles only work for some inventory types, including CHEST, DISPENSER, FURNACE, ENCHANTING, and HOPPER.
  # | MOST inventory scripts should have this key!
  title: custom title
  # The size must be a multiple of 9. It is recommended to not go above 54, as it will not show correctly when a player looks into it.
  # | Some inventory scripts should have this key! Most can exclude it if 'slots' is used.
  size: 27
  # Set 'gui' to 'true' to indicate that the inventory is a GUI, meaning it's a set of buttons to be clicked, not a container of items.
  # This will prevent players from taking items out of or putting items into the inventory.
  # | SOME inventory scripts should have this key!
  gui: true
  # You can use definitions to define items to use in the slots. These are not like normal script definitions, and do not need to be in a definition tag.
  # | Some inventory scripts MAY have this key, but it is optional. Most scripts will just specify items directly.
  definitions:
    my item: ItemTag
    other item: ItemTag
  # Procedural items can be used to specify a list of ItemTags for the empty slots to be filled with.
  # Each item in the list represents the next available empty slot.
  # When the inventory has no more empty slots, it will discard any remaining items in the list.
  # A slot is considered empty when it has no value specified in the slots section.
  # If the slot is filled with air, it will no longer count as being empty.
  # | Most inventory scripts should exclude this key, but it may be useful in some cases.
  procedural items:
    - define list <list>
    - foreach <server.online_players>:
      - define item player_head[skull_skin=<[value].name>]
      - define list <[list].include[<[item]>]>
    - determine <[list]>
  # You can specify the items in the slots of the inventory. For empty spaces, simply put an empty "slot" value, like "[]".
  # Note the quotes around the entire lines.
  # | Most inventory scripts SHOULD have this key!
  slots:
    - [] [] [] [my item] [ItemTag] [] [other item] [] []
    - [my item] [] [] [] [] [ItemTag] [ItemTag] [] []
    - [] [] [] [] [] [] [] [] [other item]

# The name of the item script is the same name that you can use to construct a new
# ItemTag based on this item script. For example, an item script named 'sword_of_swiftness'
# can be referred to as simply 'sword_of_swiftness'.
Item_Script_Name:
  type: item
  # Must be a valid ItemTag. See 'ItemTag' for more information.
  # | All item scripts MUST have this key!
  material: base_material
  # List any mechanisms you want to apply to the item within
  # | Some item scripts should have this key!
  mechanisms:
    # An example of a mechanism to apply
    unbreakable: true
    # Other common example
    custom_model_data: 5
    # This mess demonstrates how to add a custom attribute modifier.
    attribute_modifiers:
        generic_armor:
            - <map.with[operation].as[add_number].with[amount].as[5].with[slot].as[head]>
  # The 'custom name' can be anything you wish. Use color tags to make colored custom names.
  # | Some item scripts should have this key!
  display name: custom name
  # Lore lines can make items extra unique. This is a list, so multiple entries will result in multiple lores.
  # If using a replaceable tag, they are filled in when the item script is given/created/dropped/etc.
  # | Some item scripts should have this key!
  lore:
  - item
  - ...
  # If you want an item to be damaged on creation, you can change its durability.
  # | Most item scripts should exclude this key!
  durability: 12
  # Each line must specify a valid Minecranft enchantment name.
  # | Some item scripts should have this key!
  enchantments:
  - enchantment_name:level
  - ...
  # Set this to 'true' to allow the item script item to be used in material-based recipe (eg most vanilla recipes).
  # Defaults to false if unspecified.
  # | Most item scripts should exclude this key!
  allow in material recipes: false
  # You can specify flags to be added to the item.
  flags:
    # Each line within the flags section should be a flag name as a key, and the flag value as the value.
    # You can use lists or maps here the way you would expect them to work.
    my_flag: my_value
  # You can optionally add crafting recipes for your item script.
  # Note that recipes won't show in the recipe book when you add a new item script, until you either reconnect or use the "resend_recipes" mechanism.
  # | Most item scripts should exclude this key, unless you're specifically building craftable items.
  recipes:
      1:
          # The type can be: shaped, shapeless, stonecutting, furnace, blast, smoker, or campfire.
          # | All recipes must include this key!
          type: shaped
          # The recipe can optionally have a custom internal recipe ID (for recipe books).
          # If not specified, will be of the form "<type>_<script.name>_<id>" where ID is the recipe list index (starting at 1, counting up).
          # IDs will always have the namespace "denizen". So, for the below, the full ID is "denizen:my_custom_item_id"
          # Note that most users should not set a custom ID. If you choose to set a custom one, be careful to avoid duplicates or invalid text.
          # Note that the internal rules for Recipe IDs are very strict (limited to "a-z", "0-9", "/", ".", "_", or "-").
          # | Most recipes should exclude this key.
          recipe_id: my_custom_item_id
          # You can optional add a group as well. If unspecified, the item will have no group.
          # Groups are used to merge together similar recipes in the recipe book (in particular, multiple recipes for one item).
          # | Most recipes should exclude this key.
          group: my_custom_group
          # You can optionally specify the quantity to output. The default is 1 (or whatever the item script's quantity is).
          # | Only some recipes should have this key.
          output_quantity: 4
          # You must specify the input for the recipe. The below is a sample of a 3x3 shaped recipe. Other recipe types have a different format.
          # You are allowed to have non-3x3 shapes (can be any value 1-3 x 1-3, so for example 1x3, 2x1, and 2x2 are fine).
          # For an empty slot, use "air".
          # By default, items require an exact match. For a material-based match, use the format "material:MaterialNameHere" like "material:stick".
          # To make multiple different items match for any slot, just separate them with slashes, like "stick/stone".
          # To match multiple materials, use "material:a/b/c".
          # You can also make a dynamic matcher using '*', like "material:*_log" to match any log block,
          # or 'test_*' to match any item script that has name starting with 'test_'.
          # Note that to require multiple of an item as an input, the only option is to use multiple slots.
          # A single slot cannot require a quantity of items, as that is not part of the minecraft recipe system.
          # | All recipes must include this key!
          input:
          - ItemTag|ItemTag|ItemTag
          - ItemTag|ItemTag|ItemTag
          - ItemTag|ItemTag|ItemTag
     # You can add as many as you want.
     2:
          # Sample of the format for a 2x2 recipe
          type: shaped
          input:
          - ItemTag|ItemTag
          - ItemTag|ItemTag
     3:
         # Shapeless recipes take a list of input items.
         type: shapeless
         input: ItemTag|...
     4:
         # Stonecutting recipes take exactly one input item.
         type: stonecutting
         input: ItemTag
     5:
         # Furnace, blast, smoker, and campfire recipes take one input and have additional options.
         type: furnace
         # Optionally specify the cook time as a duration (default 2s).
          # | Only some recipes should have this key.
         cook_time: 1s
         # Optionally specify experience reward amount (default 0).
          # | Only some recipes should have this key.
         experience: 5
         input: ItemTag
  # Set to true to not store the scriptID on the item, treating it as an item dropped by any other plugin.
  # NOTE: THIS IS NOT RECOMMENDED UNLESS YOU HAVE A SPECIFIC REASON TO USE IT.
  # | Most item scripts should exclude this key!
  no_id: true/false
  # If your material is a 'written_book', you can specify a book script to automatically scribe your item
  # upon creation. See 'book script containers' for more information.
  # | Most item scripts should exclude this key, though there are certain rare cases it may be useful to.
  book: book_script_name

# The name of the map script is used by the map command.
Map_Script_Name:
  type: map
  # Whether to display the original map below the custom values. Defaults to true.
  # | Some map scripts should have this key!
  original: true/false
  # The 'custom name' can be anything you wish. Use color tags to make colored custom names.
  # | Some map scripts should have this key!
  display name: custom name
  # Whether to constantly update things.
  # | Some map scripts should have this key!
  auto update: true
  # Lists all contained objects.
  # | Most map scripts should have this key!
  objects:
    # The first object...
    1:
      # Specify the object type
      type: image
      # Specify an HTTP url or file path within Denizen/images/ for the image. Supports animated .gif!
      image: my_image.png
      # Optionally add width/height numbers.
    2:
      type: text
      # Specify any text, with tags.
      text: Hello <player.name>
      # Specify a tag to show or hide custom content! Valid for all objects.
      visible: <player.name.contains[bob].not>
    3:
      type: cursor
      # Specify a cursor type
      cursor: red_marker
      # Supported on all objects: x/y positions, and whether to use worldly or map coordinates.
      x: 5
      y: 5
      world_coordinates: false

script name:
  key: value
  list key:
    - list value
    - ...
  parent key:
    child key: value

a haiku script:
  type: task
  script:
  - narrate "A simple script,"
  - narrate "with a key value relationship."
  - narrate "Oh look, a list!"

script name:         <--- script name
  type: script_type
  script:            <--- base script
    - script entries
    - ...
  local script:      <--- local script path
    - script entries
    - ...

script name:
  type: script_type  <--- script type
  script:
    - script entries
    - ...

Custom_Script_Name:
  type: custom
  # Use 'inherit' to make this custom script container inherit from another custom object.
  inherit: some_object
  # This adds default field 'some_field' with initial value of 'some_value'.
  some_field: some_value
  # List additional fields here...
  # Use 'tags' to define scripted tags on the object.
  # Tags are subject to the same rules as procedure scripts:
  # NEVER change any external state. Just determine a value. Nothing else should change from the script.
  tags:
    # This would be read like <[my_object].my_tag>
    my_tag:
    # Perform any logic here, and 'determine' the result.
    - determine 3
    # list additional tags here...
  # Use 'mechanisms' to define scripted mechanisms on the object.
  # Note that these should only ever determine a new object,
  # with NO CHANGES AT ALL outside the replacement determined object.
  # (Same rules as tags and procedure scripts).
  mechanisms:
    # This would be used like custom@Custom_Script_Name[my_mech=3]
    my_mech:
    - adjust <context.this> true_value:<context.value.mul[2]> save:new_val
    - determine <entry[new_val].result>
    # list additional mechanisms here...

Data_Script_Name:
  type: data
  # Your data here
  some key: some value
  some list key:
  - some list value
  some map key:
    some subkey: some value

Proc_Script_Name:
  type: procedure
  # Optionally specify definition names to use with the 'context' input of the proc tag.
  definitions: def|names|here
  script:
  # Put any logic, then determine the result.
  - determine 5

Task_Script_Name:
  type: task
  # When intending to run a task script via the run command with the "def:" argument to pass data through,
  # use this "definitions" key to specify the names of the definitions (in the same order as the "def:" argument will use).
  definitions: name1|name2|...
  script:
  - your commands here

World_Script_Name:
  type: world
  events:
    # Any event label can be placed here
    # This includes generic labels like 'on entity death:',
    # Specified labels  like 'on player death:',
    # And detailed labels like 'on player death ignorecancelled:true priority:5:'
    some event label:
    # Write any logic that should fire when the event runs.
    # Optionally 'determine' any results to the event.
    - some commands
    # List additional events here

# Some identifier for the trigger, this only serves to make the sub-triggers unique, and sort them (alphabetically).
1:
  # The trigger message written by a player. The text between // must be typed by a player, the other text is filled automatically.
  trigger: /keyword/ othertext
  script:
  # Your code here
  - wait 1
  # use "<context.message>" for the exact text written by the player.
  - chat "<context.message> eh?"
# You can list as many as you want
2:
  # You can have multi-option triggers, separated by pipes (the "|" symbol). This example matches if player types 'hi', 'hello', OR 'hey'.
  trigger: /hi|hello|hey/
  script:
  - wait 1
  # use "<context.keyword>" for the specific word that was said.
  # this example will respond to players that said 'hi' with "hi there buddy!", 'hello' with "hello there buddy!", etc.
  - chat "<context.keyword> there buddy!"
3:
  # You can have regex triggers. This example matches when the player types any numbers.
  trigger: /regex:\d+/
  script:
  - wait 1
  # use "<context.keyword>" for the text matched by the regex matcher.
  - chat "<context.keyword> eh?"
4:
  # Use '*' as the trigger to match anything at all.
  trigger: /*/
  # Add this line to hide the "[Player -> NPC]: hi" initial trigger message.
  hide trigger message: true
  # Add this line to show the player chat message in the normal chat.
  show as normal chat: true
  script:
  # If you hide the trigger message but not show as normal chat, you might want to fill that spot with something else.
  - narrate "[Player -> NPC]: I don't know how to type the right thing"
  - wait 1
  - chat "Well type 'keyword' or any number!"

- animatechest [<location>] ({open}/close) (sound:{true}/false)

- repeat 3:
  - narrate "<[value]>"
  - narrate "everything spaced out as a sub-block (these two narrates) following a ":" ended command (that repeat) is for the <commands> input!"

- if <player||null> == null: