Alter Aeon Online Help

Keywords are:  'escape \ backslash slash'

The '\' or 'escape' character is used to bypass specific command parsers when
a single command can have multiple meanings or do multiple things.  The
order of preference for parsers is currently:

pagebreaking
context handler    (use '\' to bypass)
walking directions (use '\' to bypass)
door parsing       (use '\' to bypass)
special character commands (like /, #, $, ', etc.)
regular commands
socials

The '\' character can be used in front of a command to bypass the context,
walking, and door parsers if needed.  For example:

----------------------------------
You are in a clan board room writing a note. (note write is a context parser)
The available exits are north, left, and right.
The door on the north exit is a grate, opened/closed by the keyword 'lift'.

Now let's say you want to 'look' from there, and see the room.  You type
'look' like you normally would - but since you are writing a note, the word
'look' goes into the buffer and you have to edit it to get the word out.

You could use the escape character to get around this though - so you type
'\look' instead.  The '\' character bypasses the context handler, and passes
'look' to the walking and door parsers.  Since neither of them recognize
'look' as a command, they ignore it.  Eventually, you look and see the room
you are standing in.

But suppose you don't like having to type out the whole word 'look'.  Is
there any way you can look just by using its abbreviation, 'l'?  Yes, if
you use multiple escape characters.

Suppose you type in '\l' this time.  Let's track the flow through:
The context handler (note write) sees an '\' and strips it off.  It then
passes '\l' through to the next handler.
The direction parser sees an '\' and a direction after it ('l' is an
abbreviation for 'left'), so it strips off the '\' and passes 'l' through.
The door parser sees 'l', and matches it with the 'lift' command for the
grate.  It tries to open the grate based on that command.

So we don't quite get all the way through, but we are closer.  What if we
add one more escape?  This time the string looks like '\\l'.  The flow
is now:
Context sees '\' and passes through '\l'.
Direction sees '\' and passes through '\l'.
Door sees '\' and passes through 'l'.
Finally, the 'l' gets trapped by the regular parser and you 'look' in the
room, as intended.

While this seems a little roundabout, it's put in place as a safety valve
to protect you from incorrect builders and broken areas.  If a builder
makes a room with a normal command overloaded by a door or direction, you
can use the escape characters to invoke the command you really wanted to
do.