# Use to set a custom display name on an entity.
- adjust <[some_entity]> custom_name:ANGRY!

# Use to set the skin of every online player.
- adjust <server.online_players> skin:Notch

# Use to modify an item held in a definition.
- adjust def:stick "display_name:Fancy stick"

# Use to call a custom event with path "on custom event id:things_happened:"
- customevent id:things_happened

# Use to call a custom event with path "on custom event id:things_happened:" and supply a context map of basic data.
- customevent id:things_happened context:[a=1;b=2;c=3]

# Use to call a custom event with a path such as "on custom event id:things_happened data:item:stone:" and supply a context map of more interesting data.
- definemap context:
    waffle: hello world
    item: <player.item_in_hand>
- customevent id:things_happened context:<[context]>

# Use to call a custom event and allow cancelling or replacing a value.
- definemap context:
    message: hello world
- customevent id:custom_message context:<[context]> save:event
- if <entry[event].was_cancelled>:
    - stop
- define message <entry[event].determination_list.first.if_null[<[context.message]>]>
- narrate "Final message is: <[message]>"

# Use to show an error.
- debug error "Something went wrong!"

# Use to add some information to help your own ability to read debug output from you script.
- debug debug "Time is currently <[milliseconds].div[1000].round> seconds!"

# Use to record a debug log of a certain script.
# NOTICE: Spamming debug recordings to the official Denizen Paste instance will result in you being blocked from the paste service.
- debug record start
- run myscript
- ~debug record submit save:mylog
- narrate "Recorded log as <entry[mylog].submitted||<red>FAILED>"

# Use to create or set a flag on a player.
- flag <player> playstyle:aggressive

# Use to set a temporary flag for five minutes on a player.
- flag <player> just_did_something expire:5m

# Use to flag an npc with a given tag value.
- flag <npc> location:<npc.location>

# Use to apply mathematical changes to a flag's value on a unique object.
- flag <context.damager> damage_dealt:+:<context.damage>

# Use to add an item to a server flag as a new value without removing existing values.
- flag server cool_people:->:<[player]>

# Use to add multiple items as individual new values to a server flag that is already a list.
- flag server cool_people:|:<[player]>|<[someplayer]>

# Use to remove an entry from a server flag.
- flag server cool_people:<-:<[someplayer]>

# Use to completely remove a flag.
- flag server cool_people:!

# Use to modify a specific index in a list flag.
- flag server myflag[3]:HelloWorld

# Use to connect to a Mongo instance.
- ~mongo id:name connect:<secret[uri]>

# Use to disconnect from a Mongo instance.
- mongo id:name disconnect

# Run a simple command.
- ~mongo id:name command:[dbStats=1]

# Run more complex commands.
- definemap commands:
     count: my_collection
     skip: 4
 - ~mongo id:name command:<[commands]>

# Simple find query.
- ~mongo id:name find:[name=Bob]

# Complex find query with query filters.
- definemap filters:
     $and:
         - number_greater_than:
             $gt: 2
         - number_less_than:
             $lt: 5
- ~mongo id:name find:<[filters]>

# Insert data into a Collection.
- definemap data:
     name: Pluto
     order_from_sun: 9
     has_rings: false
     main_atmosphere:
         - N2
         - CH4
         - CO
- ~mongo id:name insert:<[data]> save:mg

# Update data.
- definemap old_data:
     name: Pluto
- definemap new_data:
     $set:
         name: Pluto (A Dwarf Planet)
- ~mongo id:name update:<[old_data]> new:<[new_data]>

# Change Databases.
- ~mongo id:name use_database:my_new_database

# Change Collections.
- ~mongo id:name use_collection:my_new_collection

# Use to note a cuboid.
- note <[some_cuboid]> as:mycuboid

# Use to remove a noted cuboid.
- note remove as:mycuboid

# Use to note a location.
- note <context.location> as:mylocation

# Use to connect to a Redis server.
- ~redis id:name connect:localhost

# Use to connect to a Redis server with a secret auth key.
- ~redis id:name connect:localhost auth:<secret[my_redis_secret]>

# Use to connect to a Redis server over ssl.
- ~redis id:name connect:localhost port:6380 ssl:true

# Set a key/value pair in the Redis server.
- ~redis id:name "command:set my_key my_value"

# Delete the "foo" key.
- ~redis id:name "command:del my_key"

# Set a key that auto-expires in 60 seconds.
- ~redis id:name "command:setex my_key 60 'value with spaces'"

# Run a command with unpredictable input.
- ~redis id:name command:set args:<list[my_key].include_single[<context.message>]>

# Get a key's value.
- ~redis id:name "command:get my_key" save:result

# Get a key's value in the background via a waitable.
- ~redis id:name "command:get my_key" save:result

# Append values to the front or back of a redis list.
- ~redis id:name "command:rpush my_list a"
- ~redis id:name "command:rpush my_list b"
- ~redis id:name "command:lpush my_list c"

# Retrieve a ListTag of the members stored in a redis list (0 is the start of the list, -1 is the end).
- ~redis id:name "command:lrange my_list 0 -1"

# Subscribe to a redis channel. This will match published messages to channel_1, channel_foo, etc.
- ~redis id:name subscribe:channel_*

# Subscribe to multiple redis channels. Supports wildcards for any list entry.
- ~redis id:name subscribe:a|b*|c|d

# Publish a message to a redis channel. This will trigger the <@link event redis pubsub message> event for any subscribed connections for any server.
- ~redis id:name publish:channel_1 "message:hey look something happened"

# Unsubscribe from a redis channel. Leaves the connection intact.
- redis id:name unsubscribe

# Disconnect from redis.
- redis id:name disconnect

# Use to change Bukkit's reference to a world's environment to the_end.
- narrate <world[world].environment>
- define obj <world[world].reflected_internal_object>
- narrate <[obj].reflect_field[environment].interpret>
- reflectionset object:<[obj]> field:environment value:the_end
- narrate <world[world].environment>
- narrate <[obj].reflect_field[environment].interpret>

# Use to reload scripts automatically
- reload

# Use to connect to an SQL server.
- ~sql id:name connect:localhost:3306/test username:space password:<secret[sql_pw]>

# Use to connect to an SQL server over an SSL connection.
- ~sql id:name connect:localhost:3306/test username:space password:<secret[sql_pw]> ssl:true

# Use to connect to an SQL server with a UTF8 text encoding.
- ~sql id:name connect:localhost:3306/test?characterEncoding=utf8 username:space password:<secret[sql_pw]>

# Use to update an SQL server.
- ~sql id:name "update:CREATE table things(id int,column_name1 varchar(255),column_name2 varchar(255));"

# Use to update an SQL server.
- ~sql id:name "update:INSERT INTO things VALUES (3, 'hello', 'space');"

# Use to query an SQL server.
- ~sql id:name "query:SELECT id,column_name1,column_name2 FROM things;" save:saveName
- narrate <entry[saveName].result_list>

# Use to query an SQL server.
- ~sql id:name "query:SELECT id,column_name1,column_name2 FROM things WHERE id=3;" save:saveName2
- narrate <entry[saveName2].result_list>

# Use to disconnect from an SQL server.
- sql disconnect id:name

# Use to download the google home page.
- ~webget https://google.com save:google
- narrate <entry[google].result>

# Use to save a webpage to your server's base directory
- ~webget https://google.com savefile:google.html

# Use to post data to a server.
- ~webget https://api.mojang.com/orders/statistics 'data:{"metricKeys":["item_sold_minecraft"]}' headers:<map.with[Content-Type].as[application/json]> save:request
- narrate <entry[request].result>

# Use to retrieve and load an API response into yaml.
- ~webget https://api.mojang.com/users/profiles/minecraft/<player.name> save:request
- yaml loadtext:<entry[request].result> id:player_data

# Use to start a webserver on port 8081.
- webserver start port:8081

# Use to stop the webserver on port 8081.
- webserver stop port:8081

# Use to copy a custom YAML data file to a backup folder, overwriting any old backup of it that exists.
- ~filecopy o:data/custom.yml d:data/backup.yml overwrite save:copy
- narrate "Copy success<&co> <entry[copy].success>"

# Use to read 'myfile' and narrate the text content.
- ~fileread path:data/myfile.dat save:read
- narrate "Read data: <entry[read].data.utf8_decode>"

# Use to write some simple text to 'myfile'
- ~filewrite path:data/myfile.dat data:<element[Hello].utf8_encode>

# Use to log some information to a file.
- ~log "Security breach on level 3!" type:severe file:securitylog.txt

# Use to log a player's name and location when they did something dangerous.
- ~log "<player.name> used the '/EXPLODE' command at <player.location.simple>!" type:warning file:security.log

# Use to write information directly to a file.
- ~log "This won't have a date or type" type:none file:example.log

# Use to clear a log file and write some text at the start.
- ~log "// Log File Generated by my Denizen script, do not edit!" type:clear file:myfile.log

# Use to clear a log file entirely.
- ~log "" type:clear file:myfile.log

# Use to create a new YAML file.
- yaml create id:myfile

# Use to load a YAML file from disk.
- ~yaml load:myfile.yml id:myfile

# Use to modify a YAML file similarly to a flag.
- yaml id:myfile set my.key:HelloWorld

# Use to save a YAML file to disk.
- ~yaml savefile:myfile.yml id:myfile

# Use to unload a YAML file from memory.
- yaml unload id:myfile

# Use to modify a YAML file similarly to a flag.
- yaml id:myfile set my.key:+:2

# Use to modify a YAML file similarly to a flag.
- yaml id:myfile set my.key[2]:hello

# Use to modify a copy the contents of one YAML key to a new owning key.
- yaml id:myfile copykey:my.first.key my.new.key

# Use to modify a copy the contents of one YAML key to a new owning key on a different YAML file.
- yaml id:myfile copykey:my.first.key my.new.key to_id:myotherfile

# Opens a GUI script named "my_gui".
- gui open my_gui

# Closes the currently open GUI.
- gui close

# Use to draw a single red pixel in the top left corner of an image.
- draw id:image pixel x:0 y:0 color:red

# Use to draw a purple 100x100 filled circle in the top left of an image.
- draw id:image oval x:0 y:0 width:100 height:100 color:purple filled

# Use to draw the image with the id 'star' into the image with id 'sky'.
- draw id:sky image:star x:50 y:50

# Use to load an image from a file into memory under the id "image".
- ~image id:image load path:data/image.png

# Use to load an image object from a definition, draw on it, then store it back into the definition.
- define image <image[width=50;height=50;background=blue]>
- image id:to_edit load image:<[image]>
- draw id:to_edit oval x:0 y:0 width:50 height:50 color:green
# Copy the image to avoid it auto-updating with the image loaded in under that id, can skip '.copy' if this doesn't matter for your use case.
- define image <image[to_edit].copy>

# Use to save an image into file and unload it.
- ~image id:image save path:data/image.png
- image id:image unload

# Use to narrate text.
- narrate "Hello World!"

# Use to narrate some text in the center of the chat area.
- narrate "This is in the center!" center

# Use to narrate 2 centered lines.
- narrate "Hello!<n>This is centered!" center

# Use to send the server an event with the id "something_happened"
- serverevent id:something_happened

# Use to send the server an event with the id "user" and supply a context map of basic data.
- serverevent id:user data:[name=Aya;message=Hello]

# Use to send the server an event with the id "something_happened" and supply a context map of more interesting data.
- definemap context:
    Denizen: scripting
    food: waffle
    loaded_entities: <client.loaded_entities.size>
- serverevent id:something_happened context:<[context]>

# Use to choose the only case.
- choose 1:
  - case 1:
    - debug LOG "Success!"

# Use to choose the default case.
- choose 2:
  - case 1:
    - debug log "Failure!"
  - default:
    - debug log "Success!"

# Use for dynamically choosing a case.
- choose <[entity_type]>:
  - case zombie:
    - narrate "You slayed an undead zombie!"
  - case skeleton:
    - narrate "You knocked the bones out of a skeleton!"
  - case creeper:
    - narrate "You didn't give that creeper a chance to explode!"
  - case pig cow chicken:
    - narrate "You killed an innocent farm animal!"
  - default:
    - narrate "You killed a <[entity_type].to_titlecase>!"

# Use to make complex tags look less complex, and scripts more readable.
- narrate "You invoke your power of notice..."
- define range <player.flag[range_level].mul[3]>
- define blocks <player.flag[noticeable_blocks]>
- define count <player.location.find_blocks[<[blocks]>].within[<[range]>].size>
- narrate "<&[base]>[NOTICE] You have noticed <[count].custom_color[emphasis]> blocks in the area that may be of interest."

# Use to validate a player input to a command script, and then output the found player's name.
- define target <server.match_player[<context.args.get[1]>]||null>
- if <[target]> == null:
  - narrate "<red>Unknown player target."
  - stop
- narrate "You targeted <[target].name>!"

# Use to keep the value of a tag that you might use many times within a single script.
- define arg1 <context.args.get[1]>
- if <[arg1]> == hello:
    - narrate Hello!
- else if <[arg1]> == goodbye:
    - narrate Goodbye!

# Use to remove a definition.
- define myDef:!

# Use to make a MapTag definition and set the value of a key inside.
- define myroot.mykey MyValue
- define myroot.myotherkey MyOtherValue
- narrate "The main value is <[myroot.mykey]>, and the map's available key set is <[myroot].keys>"

# Use to make a MapTag definition with three inputs.
- definemap my_map count:5 type:Taco smell:Tasty

# Use to make a MapTag definition with complex input.
- definemap my_map:
    count: 5
    some_list:
    - a
    - b
    some_submap:
        some_subkey: taco

# Use to modify the result of an event.
- determine message:<context.message.to_lowercase>

# Use to cancel an event, but continue running script commands.
- determine passively cancelled

# See IF command documentation.

# Use to run commands 'for each entry' in a manually created list of objects/elements.
- foreach <[some_entity]>|<[some_npc]>|<[player]> as:entity:
    - announce "There's something at <[entity].location>!"

# Use to iterate through entries in any tag that returns a list.
- foreach <player.location.find_entities[zombie].within[50]> as:zombie:
    - narrate "There's a zombie <[zombie].location.distance[<player.location>].round> blocks away"

# Use to iterate through a list of players and run commands automatically linked to each player in that list.
- foreach <server.online_players> as:__player:
    - narrate "Thanks for coming to our server, <player.name>! Here's a bonus $50.00!"
    - money give quantity:50

- goto potato
- narrate "This will never show"
- mark potato

# Use to jump forward to a location.
- goto potato

# Use to narrate a message only if a player has a flag.
- if <player.has_flag[secrets]>:
    - narrate "The secret number is 3!"

# Use to narrate a different message depending on a player's money level.
- if <player.money> > 1000:
    - narrate "You're rich!"
- else:
    - narrate "You're poor!"

# Use to stop a script if a player doesn't have all the prerequisites.
- if !<player.has_flag[quest_complete]> || !<player.has_permission[new_quests]> || <player.money> < 50:
    - narrate "You're not ready!"
    - stop
- narrate "Okay so your quest is to find the needle item in the haystack build next to town."

# Use to perform a complicated requirements test before before changing some event.
- if ( poison|magic|melting contains <context.cause> and <context.damage> > 5 ) or <player.has_flag[weak]>:
    - determine <context.damage.mul[2]>

# Injects the InjectedTask task into the current queue
- inject InjectedTask

# Use to mark a location.
- mark potato

# Use to force-stop a given queue.
- queue <server.flag[OtherQueue]> clear

# Use to delay the current queue (use <@link command wait> instead!)
- queue delay:5t

# Use to pause the given queue.
- queue <server.flag[OtherQueue]> pause

# Use to resume the given queue.
- queue <server.flag[OtherQueue]> resume

# Use to choose randomly from a braced set of commands
- random:
  - narrate "hi"
  - narrate "hello"
  - narrate "hey"

# Use to perform multiple commands randomly
- random:
  - repeat 1:
    - narrate "Hello"
    - narrate "How are you?"
  - repeat 1:
    - narrate "Hey"
    - narrate "It is a nice day."

# Use to show a message to a player no faster than once every ten seconds.
- ratelimit <player> 10s
- narrate "Wow!"

# Use to loop through a command five times.
- repeat 5:
    - announce "Announce Number <[value]>"

# Use to announce the numbers: 1, 2, 3, 4, 5.
- repeat 5 as:number:
    - announce "I can count! <[number]>"

# Use to announce the numbers: 21, 22, 23, 24, 25.
- repeat 5 from:21:
    - announce "Announce Number <[value]>"

# Use to run a task script named 'MyTask'.
- run MyTask

# Use to run a task script named 'MyTask' that isn't normally instant, instantly.
- run MyTask instantly

# Use to run a local subscript named 'alt_path'.
- run <script> path:alt_path

# Use to run 'MyTask' and pass 3 definitions to it.
- run MyTask def:A|Second_Def|Taco

# Use to run 'MyTask' and pass 3 named definitions to it.
- run MyTask def.count:5 def.type:Taco def.smell:Tasty

# Use to run 'MyTask' and pass a list as a single definition.
- run MyTask def:<list_single[<list[a|big|list|here]>]>
# MyTask can then get the list back by doing:
- define mylist <[1]>

# Use to run a task script named 'example' 3 days later.
- runlater example delay:3d

# Use to run a task script named 'my_task' 5 hours later with definition 'targets' set to a list of all the players that were near the player before the delay.
- runlater my_task delay:5h def.targets:<player.location.find_players_within[50]>

# Use to plan to go for a jog tomorrow then change your mind after 5 seconds.
- runlater go_for_jog id:healthy_plan delay:1d
- wait 5s
- adjust system cancel_runlater:healthy_plan

# Use to stop the current queue.
- stop

# Use to delay the current queue for 1 minute.
- wait 1m

# Use to delay the current queue until 1 hour of system time passes.
- wait 1h system

# Use to delay the current queue until the player respawns (useful in a death event, for example).
- waituntil <player.is_spawned>

# Use to delay the current queue until the player is healed, only checking once per second.
- waituntil rate:1s <player.health> > 15

# Use to loop until a player sneaks, or the player goes offline. (Note: generally use 'waituntil' for this instead)
- while !<player.is_sneaking> && <player.is_online>:
    - narrate "Waiting for you to sneak..."
    - wait 1s

# Use to spawn a large flame particle above the player.
- particle type:flame at:<client.self_entity.location.above[2.5]> scale_multiplier:4

# Use to spawn a dust color transition particle that changes color from red to blue.
- particle type:dust_color_transition at:<[location]> data:[from=red;to=blue;scale=2]

# Use to spawn a block marker particle of a stone block that slowly moves upwards.
- particle type:block_marker at:<[location]> data:[material=stone] velocity:0,0.1,0