{
  // Adds the innate `attack` command to your rotation, useful if you don't know many 
  // attacks yet.
  "addAttack": false,
  // The list of commands you want to run, in the order they'll run
  // Note: all scripts loop unless you add a command: `"/stop"`
  "commandList": [
    {
      // The text that will be sent to the game when this command runs.
      // Note: the use of `<target>` here is not the in-game target - but the one you set
      // when starting your script using the extension. It will be replaced and is often
      // used if you want to add it in the middle of a command instead of at the end 
      // (where it's added automatically).
      "command": "pslash <target> high",
      // One or more set of outcomes that the script will look for in the game's output
      // in order to decide when to move to the next command.
      // Note: some `parse`s have square brackets (denoting a list) like this one. This
      // is to tell the script to check more than one possible outcome to check for
      // the command.
      "parse": [
        {
          // If the `outcome` below this has happened already, this is the text that
          // actually causes the script to move to the next command.
          "moveNextWhen": "You are no longer busy",
          // The text the script is looking for from the game output to flag that it's
          // now time to begin moving to the next command.
          "outcome": "Sliding your front leg back"
        },
        {
          "moveNextWhen": "You are no longer busy",
          "outcome": "You start to fumble"
        }
      ]
    },
    {
      // This is an example of a command that doesn't need to aim high, and without 
      // including `<target>`, the script will add the target after the command 
      // automatically when it sends it to the game.
      "command": "upslash",
      // This is an example of a single parse outcome to check.
      "parse": {
        "moveNextWhen": "You are no longer busy",
        "outcome": "You twist your wrists"
      }
    },
    {
      "command": "strike <target> high",
      "parse": [
        {
            "moveNextNow": true,
            "outcome": "is not wielding anything"
        },
        {
            "moveNextWhen": "You are no longer busy",
            "outcome": "With a quick snapping motion, you"
        }
      ]
      }
  ],
  // If this is true, the script will run the current command when an enemy walks into
  // the area, arrives, or appears in some other fashion. Without this, the script 
  // will essentially stop until it finds the current 'outcome' it's looking for. 
  "continueOnWalkIn": true,
  // This appears as the longer name in the UI describing the purpose of your script.
  "scriptFriendlyName": "Spear Hunting - Aim High",
  // Short name for the script used in slash commands and internally to identify the 
  // script. This must be unique among all scripts.
  "scriptName": "spearHuntHigh",
  // Denotes this as a combat script
  "scriptType": "combat",
  // If true, the script sends the `kill` command when your target falls unconscious.
  "shouldKill": true,
  // This is the `outcome` the script looks for to identify when you've successfully
  // killed a target with the `kill` command, and will continue the next command.
  "shouldKillParse": "You thrust your",
  // If you don't have stance mastered so it auto-assumes, this command will be used
  // to enter your stance when the game tells you `You are not in the correct stance`.
  "stanceCommand": "scorpion",
  // If this command is used in a script, it will replace the usage of the `free` 
  // command when your weapon is entangled.
  // The commands work in the following ways:
  //  - Note: `fling` is an example, you would replace this with your freeing ability.
  //  - "fling <weapon>": You need to literally use <weapon> here, and it'll be replaced
  //    dynamically with what is entered as your weapon name when starting the script.
  //  - "fling gladius": You can 'hard-code' the name of your weapon here and it'll use it.
  //  - "fling": This will work as expected if the ability doesn't need to also target
  //    your weapon by name.
  "entangledCommand": "fling <weapon>"
},

{
  "commandList": [
    {
      "command": "bait pole with worm",
      // This causes a 5 second delay (in milliseconds) before running the next command after
      // the `outcome` conditions of this command are met.
      "delayBeforeNext": 5000, 
      "parse": [
        {
          "moveNextWhen": "You are no longer busy",
          "outcome": "You bait a"
        },
        {
          // This causes the script to immediately send the next command after it detects
          // the `outcome` below, as opposed to waiting for `moveNextWhen`.
          // Note: this replaces the use of `moveNextWhen`, and they shouldn't be used
          // together inside any one `parse`.
          "moveNextNow": true,
          "outcome": "is already baited"
        }
      ]
    },
    {
      "command": "cast pole",
      "parse": {
        "moveNextWhen": "You are no longer busy",
        "outcome": "no longer has any bait on it"
      }
    }
  ],
  "scriptFriendlyName": "Fish With Worms",
  "scriptName": "fishworms",
  // Denotes this as a Non-Combat script
  "scriptType": "nonCom"
},

{
  "commandList": [
    {
      "command": "echo <target>",
      "parse": {
        "moveNextWhen": "Now you repeat it",
        // If you leave outcome empty like this, the script will not try to check for an outcome, 
        // and will just immediately move to the next command when it detects `moveNextWhen`.
        // This is useful if your intent is to immediately repeat a command or move to the next
        // one without needing to wait for a second condition like "You are no longer busy".
        "outcome": ""
      }
    }
  ],
  "scriptFriendlyName": "Language Echo",
  "scriptName": "languageEcho",
  "scriptType": "nonCom"
},

{
  "commandList": [
    {
      "command": "palm",
      "parse": [
        {
          "moveNextWhen": "You are no longer busy",
          // Players will be aware you can use the | character in game to collect multiple
          // things to look for into one command, this works similarly. Adding | between
          // outcomes is a replacement for having multiple parses in some cases. In this
          // specific case I'm using a mix of `moveNextWhen` and `moveNextNow`, so I still
          // need multiple parses, but otherwise I could use this feature to shorten my 
          // script to one parse!
          "outcome": "You very nimbly palm|You barely manage to palm|You nearly drop a|You manage to palm"
        },
        {
          "moveNextNow": true,
          "outcome": "You are already palming that"
        }
      ]
    },
    {
        "command": "unpalm",
        "parse": {
            "moveNextNow": true,
            "outcome": "You flip your wrist"
        }
    }
  ],
  "scriptFriendlyName": "Palming",
  "scriptName": "palming",
  "scriptType": "nonCom"
},

{
  "commandList": [
    {
      "command": "wait for ferry",
      "parse": [
        {
          "moveNextNow": true,
          // `<target>` can also be used in `outcome`, again this is the script target not
          // the in-game target.
          "outcome": "Next destination is <target>"
        },
        {
          "moveNextNow": true,
          "outcome": "You arrive at an a small river ferry"
        }
      ],
      // This tells the script not to add your current script-set `target` to the end of the
      // command. This is useful for commands that do not need a target at the end or 
      // anywhere in the middle using `<target>`.
      // Note: this works with combat scripts as well, and can be seen by example in the
      // default archery scripts for loading a bow.
      "targetRequired": false
    },
    {
      "command": "wait for dock",
      "parse": [
        {
          "moveNextNow": true,
          "outcome": "You arrive at"
        }
      ],
      "targetRequired": false
    },
    {
      // This is a good example of some extra flexibility that the extension's slash commands
      // offer. In this case we're stopping the script (it won't loop) after we get to this 
      // command, but you can imagine instead using `/start` to chain into a second script!
      "command": "/stop",
      "parse": {
        "moveNextWhen": "Never",
        // When stopping a script like this, I've opted to put text I don't expect to be 
        // read from the game in here so things don't break, this isn't strictly necessary
        // however.
        "outcome": "Nothing"
      },
      "targetRequired": false
    }
  ],
  "scriptFriendlyName": "Ferry To <target>",
  "scriptName": "ferry",
  "scriptType": "nonCom"
},