spw / speedwalk               Interprets a speedwalk string

   Format:
      ;spw <string>           Interprets the string

   Notes:
      Speedwalking is a method of moving from one location in the world to
         another with a minimum of typing.
      Speedwalk commands can be typed in the 'main' window's command entry box.
         These commands start with the speedwalk sigil, a full stop/period
         character:

         .3nw2s

      ...which is the equivalent of typing 'north;north;north;west;south;south'.

      Speedwalk sigils are turned off by default (use ';togglesigil -w' to turn
         them on again). However, this client command is always available, and
         you don't need to type the sigil:

         ;speedwalk 3nw2s

      The simplest speedwalk <string> is made up one or more speedwalk
         characters, always a lower-case letter. Each speedwalk character
         represents a single movement command:

         n                    > north
         ns                   > north;south
         nssse                > north;south;south;south;east

      The current dictionary usually specifies abbreviations for these primary
         directions, in which case the actual output will be more like this:

         nssse                > n;s;s;s;e

      If the current dictionary specifies different primary directions (for
         example, if you're using a French-language dictionary), the movement
         commands are automatically converted.
      Many worlds use directions like 'northwest'. If you use 'nw' in a
         speedwalk string, it will be interpreted as two movement commands:

         nw                   > north;west

      However, Axmud dictionaries provide a larger set of speedwalk characters
         by default:

         u > up, d > down, l > look,
         t > northwest, y > northeast, g > southwest, h > southeast

      If that's not convenient, you have two options. The first is to use
         customised speedwalk characters (see the help for ';addspeedwalk').
      The second is to enclose the movement command in brackets:

         n(sw)e               > north;southwest;east

      The '(sw)' component is treated exactly the same as a speedwalk character,
         which means you can put a number in front of it:

         n2(sw)e              > north;southwest;southwest;east

      By the way, any number between 1-999 is acceptable. If you specify a
         larger number like 12345, only the last three digits (345) are used. If
         you specify the number 0, the command immediately after it is not
         processed:

         n2we                 > north;west;west;east
         n0we                 > north;east

      If you type a very large number of characters, you can use a comment to
         help keep your place. Comments are enclosed within square brackets
         {...}, and are ignored. For example:

         3nw2n5ws{the city gates are here}5sw{the guild is here}nwn
                              > n;n;n;w;n;n;w;w;w;w;w;s;s;s;s;s;s;s;w;n;w;n

      If you want to retrace your steps, add a full stop (period) character to
         the beginning of the speedwalk <string>. This reverses the list of
         commands:

         3nw2e                > north;north;north;west;east;east
         .3nw2e               > west;west;east;south;south;south

      However, that won't work if you use longer movement commands inside
         brackets:

         n(sw)e               > north;southwest;east
         .n(sw)e              > west;southwest;south

      Commands inside brackets are not reversed; you have to specify your own
         reverse command like this:

         (sw/ne)              > southwest
         .(sw/ne)             > northeast

      Of course, if you were typing in the 'main' window's command entry box,
         a speedwalk command already begins with a full stop character, so to
         reverse the path you'd have to type two of them.

      A speedwalk character like 'n' or a longer movement command in brackets
         like '(sw)' can be preceded by a modifier. A modifier converts a
         simple direction like 'north' into a command like 'open north door',
         'sail north' and so on.
      A modifier can be a single character which is always an upper-case letter.
         Axmud dictionaries provide the following speedwalk modifier characters:

         G   > go <dir>     S   > sail <dir>      O   > open <dir> door
         N   > run <dir>    I   > ride <dir>      C   > close <dir> door
         A   > walk <dir>   D   > drive <dir>     K   > unlock <dir> door
         F   > fly <dir>    R   > creep <dir>     L   > lock <dir> door
         W   > swim <dir>   E   > sneak <dir>     P   > pick <dir> door
         V   > dive <dir>   Q   > squeeze <dir>   B   > break <dir> door

      The modifier character is used immediately before the movement command:

         n                    > north
         On                   > open north door

         (sw)                 > southwest
         S(sw)                > sail southwest

      If you use a number, it goes before the modifier:

         3S(sw)               > sail southwest;sail southwest;sail southwest

      If that's not convenient, you again have two options. The first is to use
         customised speedwalk modifier characters (see the help for
         ';addmodifierchar').
      The second is to specify the full modifier command yourself, inside a pair
         of square brackets [...]. The following two strings are equivalent:

         Sn                   > sail north
         [sail]n              > sail north

      If the command is different when you retrace your steps, you can use a
         modifier containing two commands:

         [sail/fly]n          > sail north
         .[sail/fly]n         > fly south

      In some situations, you might need to provide two modifiers and two
         movement commands together:

         [sail/fly](sw/ne)    > sail southwest
         .[sail/fly](sw/ne)   > fly northeast

      If you go through a door, and then reverse the path, you might find that
         the 'open door' command is now in the wrong place:

         Oww                  > open west door;west
         .Oww                 > east;open east door

      One solution is to put the 'open' command both and after the movement
         command, so that the speedwalk string works in both directions:

         OwwOw                > open west door;west;open west door
         .OwwOw               > open east door;east;open east door

      Of course, you might see a message like 'there is no door here', but at
         least your character will be where you intended them to be.

      The modifier characters use Axmud command cages to get a world command in
         the correct format for each world. (For example, at some worlds the
         correct command will be 'open west door', but at others it might be
         'open west' or even 'open door', with no direction possible.)
      If you modify the current world's command cages, the equivalent world
         commands for each modifier will change.
      If you modify them so that the replacement command doesn't include a
         direction (e.g. replace 'open direction door' with 'open door'), the
         direction you specify isn't used:

         Oww                  > open door;west
         Onw                  > open door;west

      Speedwalk <string>s can include any number of spaces, so both of the
         following are acceptable:

         3nw2s                > north;north;north;west;south;south
         3 nw 2 s             > north;north;north;west;south;south

      Enclosing the speedwalk string in diamond brackets <...> will not make any
         difference to the outcome.

   User commands:
      spw / speed / speedwalk
