Commands

command /heal:
    description: Restore your health
    usage: /heal [player]
    permission: demo.heal
    permission message: "&cYou cannot use /heal."
    aliases: h, mend
    trigger:
        execute console command "effect give %player.name% minecraft:instant_health 1 10"
        send "&aHealed."

A number within limits. An argument that is a number can say what it has to lie between: <amount:number 1 to 10000>, <level:integer at least 1>, [percent:number at most 100]. A player who gives another number is told amount must be between 1 and 10000. and the trigger does not run.

command /pay <target:player> <amount:number 1 to 10000>:
    trigger:
        subtract arg.2 from {%player%.coins}
        add arg.2 to {%arg.1%.coins}
        send "&aYou paid %arg.1% %money(arg.2)%."

The command line may describe its arguments after the name, as in command /pay <player> <amount>:. It becomes the usage text unless a usage: line is given, and it decides what pressing Tab offers while the command is typed:

Subcommands. A command with several jobs can give each one its own block instead of a switch on the first argument. Each subcommand has its own permission, description, checked arguments and trigger, and arg.1 inside it is the first word *after* its name:

command /warp <name>:
    tab complete: keys of {warp}
    trigger:
        teleport player to {warp.%arg.1%}
    subcommand set <name>:
        permission: "warps.manage"
        trigger:
            set {warp.%arg.1%} to player's location
            send "&aWarp %arg.1% set."
    subcommand list:
        trigger:
            send "&7Warps: &f" + join keys of {warp} with ", "

• /warp set base runs the set block; /warp base runs the command's own trigger.
• A command may consist of subcommands only. Used without one, it answers with their names.
• Tab offers the subcommands a player is allowed to use, then each one's own arguments.
• tab complete: takes any list and is worked out when Tab is pressed, so it can offer warp names, team names or anything else a script keeps.

What Tab offers, argument by argument. tab complete: can also be a block. Its lines run each time Tab is pressed, and set arg.1 to ... in it says what is offered for the first argument, set arg.2 to ... for the second, and so on. The lines are ordinary code, so what is offered for one argument can depend on what was typed for the ones before it:

command /rank [action] [target] [rank]:
    permission: "ranks.admin"
    tab complete:
        set arg.1 to "set", "remove", "list"
        set {_online} to server.players
        if arg.1 is "set" or arg.1 is "remove":
            set arg.2 to {_online}
        if arg.1 is "set":
            set arg.3 to "owner", "admin", "moderator", "vip"
    trigger:
        send "&7You typed: %args%"

What stands after to may be values written one after the other, a list, or both.

• Typing /rank and pressing Tab offers set, remove and list; after /rank set Steve it offers the ranks; after /rank list nothing, because the block set nothing for that.
• An argument the block says nothing about is offered what the command's header says: the players who are online for <player>, the words of <on|off>.
• Only what begins with what has been typed so far is shown, whatever the capitals.
• The block runs on every press of Tab, so keep it to working out what to offer. It is not the place to send messages or change variables.
• Outside this block an argument cannot be set: in a trigger arg.1 is what was typed.

Checked arguments. Give an argument a type and HyperScript checks it before the trigger runs, answering with what is wrong, and the usage line for a missing argument or a number that is not one:

command /pay <target:player> <amount:number> [note]:
    players only: true
    trigger:
        subtract arg.2 from {%player%.coins}
        add arg.2 to {%arg.1%.coins}

An argument without a type is not checked, as before. The types are not shown in the usage line.

A command declared without any arguments keeps the server's default, which is player names. The arguments are still read with %arg.1%, %arg.2% and so on, and are not checked for you.

A short command can also simply use a switch on the first argument, without subcommand blocks:

command /kit <starter|food>:
    trigger:
        switch arg.1:
            case "starter":
                give 1 stone sword to player
            case "food":
                give 16 bread to player
            default:
                send "&eUsage: /kit <starter|food>"

Commands can be run from the console; there is then no player. players only: true keeps the console out, or test if player is not set: yourself.