&help
+===========================================================================+
|                    B A B C O M   O n l i n e   H e l p                    |
+---------------------------------------------------------------------------+
|                  HELP LAST UPDATED: Monday, May 10, 1999                  |
|     Available help topics are organized by date.  Type 'help <topic>'     |
|                                                                           |
| DATE            TOPIC            DESCRIPTION                              |
| 05-10-99        helpinf          Instruction on help files.  READ ME!     |
| 05-10-99        topics           Available hardcode and softcode topics   |
| 05-10-99        comsys           Help on our channel system               |
| 05-10-99        commands         Help on MUX commands                     |
+===========================================================================+
              Use the @mail alias *HelpBugs to report problems.
     
&revisions
This topic will detail all revisions to the help.txt file.  The individual
who did the alterations, the date of the alterations, and what was done is
included.  Use this topic to keep track of changes to the server code and
other systems.
    
05-12-97 - Airam added the chargen sections, including skill hierarchies,
 guide to purchasing skills and attribs, deciding on a race, explanations for
 each skill, and skills lists for each empire.
12-30-97 - JohnD added help for the +view and +ic/+ooc commands.
02-05-98 - JohnD added help for the +finger and +ictime commands.
02-20-98 - JohnD added help for Myrddin's BBS 4.04, MudNet, and +selfboot.
05-29-98 - JohnD added help for PICK command, knock and +wear.
07-09-98 - JohnD added help for +wsearch, +smell, +taste, and +touch.
08-11-98 - JohnD added help for @whine.
08-17-98 - JohnD added help for speak and +staff.
01-17-99 - JohnD added help for +info and +nom and edited many other entries.
03-25-99 - JohnD added help for a number of softcode commands/bboard 4.0.5
05-10-99 - JohnD added help for +features.
        
&helpinf
 
     Notes on help descriptions:
        [text] - Text enclosed in []'s is optional.  The []'s are never typed
                 in as part of the command.
        <parameter> - Information parameter for a command.  The <>'s are
                      never typed in as part of the command.
 
  -  Syntax of help command:        -  To get a list of MUX topics:
       help [<command>]                  help topics 
     
  -  List of channel commands:      -  To get a list of MUX Commands:
       help comsys                       help commands (or @list commands)
     
  Some of the configuration shown in the help.txt might not be the same as
  the configuration of this MUX.  If you notice any errors, contact a wiz.
    
&commands
 
  Help available for MUX Commands:
  Note: Some commands are @-related.
 
  drop         enter        examine      get          give         goto
  help         inventory    kill         leave        LOGOUT       look
  move         news         OUTPUTPREFIX OUTPUTSUFFIX page         pose
  QUIT         read         say          score        SESSION      take
  think        throw        use          version      whisper      WHO
  "            :            ;            &            #            \\
  @@           @cemit       @chown       @chzone      @clone       @cpattr
  @create      @decompile   @destroy     @dig         @doing       @dolist
  @drain       @edit        @emit        @entrances   @femit       @find
  @force       @fpose       @fsay        @halt        @last        @link
  @list        @listmotd    @lock        @mail        @mvattr      @name
  @notify      @npemit      @oemit       @open        @parent      @password
  @pemit       @power       @program     @ps          @quitprogram @quota
  @remit       @robot       @search      @set         @stats       @sweep
  @switch      @teleport    @trigger     @unlink      @unlock      @verb
  @wait        @wipe        +erefresh    +elist       +call security
<Continued in HELP COMMANDS2>
     
&commands2
 
  Help available for MUX Commands (continued):
 
  @aahear      @aclone      @aconnect    @adescribe   @adfail      @adisconnect
  @adrop       @aefail      @aenter      @afail       @agfail      @ahear
  @akill       @aleave      @alfail      @alias       @amail       @amhear
  @amove       @apay        @arfail      @asuccess    @atfail      @atofail
  @atport      @aufail      @ause        @away        @charges     @cost
  @daily       @describe    @dfail       @drop        @ealias      @efail
  @enter       @fail        @filter      @forwardlist @gfail       @idesc
  @idle        @infilter    @inprefix    @kill        @lalias      @leave
  @lfail       @listen      @mailsucc    @move        @odescribe   @odfail
  @odrop       @oefail      @oenter      @ofail       @ogfail      @okill
  @oleave      @olfail      @omove       @opay        @orfail      @osuccess
  @otfail      @otofail     @otport      @oufail      @ouse        @oxenter
  @oxleave     @oxtport     @pay         @prefix      @reject      @rfail
  @runout      @sex         @signature   @startup     @success     @tfail
  @tofail      @tport       @ufail       @use         +ic          +ooc
<Continued in HELP COMMANDS3>
         
&commands3
     
  Help available for MUX Commands (continued):
     
  +view        +finger      +ictime      +selfboot    bboard       mudnet
  pick         +wear        knock        +taste       +touch       +smell
  +wsearch     @whine       speak        +quotame     +train       +staff
  +info        +nom         +dyell       +who         +what        +where
  mutter       places       +3where      +bcast       +featurs
    
&ZONE OBJECTS
ZONE OBJECTS
 
Zones are areas of the MUX which may be controlled by many people.
Essentially, they allow group ownership of objects.  The default zone is
NOTHING.  Any building done by a player defaults to belonging to the same
zone that the player belongs to.  Every zone is defined by a Zone Master
Object (ZMO).  The ZMO is an ordinary MUX object owned by some player.  A
wizard may change the zone of an object or player to a ZMO.
  
If the ZMO is a room, it is called a "parent room."  Most of the statements
about ZMOs also apply to parent rooms.  For details, see the help topic
PARENT ROOMS.
<Continued in HELP ZONES2>
     
&ZONES2
  
Anyone who can pass the enter lock of the ZMO has control over all objects in
that zone.  This, in essence, gives that player wizard powers within that
zone.  For this reason, one must be extremely careful with the enter locks of
ZMOs!
  
Also, $commands on a ZMO are treated as global within that zone.  The game
attempts to match $commands for the ZMO of the player's location, as well as
$commands for the player's own zone.  For some suggestions on how to use
zones, see "help ZONES3".
<Continued in HELP ZONES3>
          
&ZONES3
     
Some suggested uses of zones:
  
1. If you are working on a building project with several people, it may be
     useful to create a zone object and @elock it to all of you, and ask a
     wizard to @chzone the players involved to the zone object.  That way,
     all of the players working on the project will be able to modify the
     building.
      
2. On a similar thread, if several players are working on a project involving
     only a few objects, it may be simpler to create a zone object and
     @chzone those few objects to the ZMO instead of resetting the zones of
     the players. Note that a player does not have to belong to a zone in
     order to change objects in that zone; all is merely required to pass the
     ZMO's enter lock.
    
See ZONES4.
     
&ZONES4
 
More possible uses for zones:
  
3. If local wizards are desired, a zone object may be created and enter
     locked to the local wizard. Players building within that zone should be
     @chzone'd to that ZMO. The local wizard will then be able to control
     anything within that domain.
      
4. If you want restricted global commands defined over only a small area, you
     can define that area to be part of a zone, and place the desired
     $commands upon the ZMO.
      
&parent rooms
     
Parent rooms are a subset of zones.  If a room is used as as zone object, it
is a parent room (PR).  PRs are like local "master" rooms.  Exits in the PR
are global to that zone, and $commands on objects in the PR are global to
that zone.  Parent rooms are only defined if globals are used.  Parent rooms
should only be used for very large zones which have a lot of global exits.
Otherwise, a ZMO thing should be used, because command evaluation on a parent
room is slower than command evaluation on a ZMO.  Large numbers of parent
rooms may slow down the game significantly.
  
See ZONE OBJECTS and COMMAND EVALUATION for more information.
  
&comsys
 
This is the help for the MUX comsystem.  Note that the channel names and
aliases are case-sensitive.  Upon creation, new players automatically join
the "Public" channel, while guest characters join channel "Guests" when they
connect.
 
Note: <alias> is the alias you choose for the channel.  The "Public" channel
for new players is aliased to "pub".  The "Guests" channel for guests is
aliases to "g".
     
Aliases are the most common way to manipulate channels, and may be used in
two different ways: <alias> <who|on|off> and <alias> <message>
<Continued in HELP COMSYS2>
        
&comsys2
    
For example:
> pub off
[Public] Foobar has left this channel.
     
> pub on
You have joined channel Public.
[Public] Foobar has joined this channel.
     
> pub who
-- Players --
Foobar(#23PWc)
Wizard(#1PWc)
-- Objects --
-- Public --
   
> pub Hello world!  
[Public] Foobar says, "Hello world!"
<Continued in HELP COMSYS COMMANDS>
       
&comsys commands
   
These are the topics for the MUX comsystem:
  
  addcom       allcom       alias        comlist      comtitle     clearcom
  delcom
 
  @ccreate     @cboot       @ccharge     @cchown      @cdestroy    @clist
  @coflags     @cpflags     @cset        @cwho
  
&@cboot
   
Command: @cboot <channel>=<object>
   
Only wizards, or the owner of the channel can use this command.  It
forcefully removes an object from that channel.
   
Note: You may specify a player name as <object> if you prefix it with an '*'.
Otherwise, <object> should be a dbref, or a name of an object if you are
nearby it.
     
&addcom
     
Command: addcom <alias>=<channel>
            
This command joins you to an existing channel with <alias>.  You should avoid
having multiple aliases for a channel, although it is allowed.
      
See also: delcom, comlist, alias, comtitle.
     
&alias
     
Command: <channel alias> <on|off|who|message|:pose|;pose>
     
'on' allows you to turn an alias on.
'off' lets you temporarily leave that channel.
'who' shows you who is on that channel.
     
You may send a message over the channel with <alias> <text>, where <text> is
the message to be sent, or you can pose on a channel with <alias> :<text> or
<alias> ;<text>
    
See also: allcom, comlist, addcom, delcom.
   
&allcom
   
Command: allcom <on|off|who>
           
This works like using a single alias, except it does an action for every
alias you have.  You can turn every alias on, or off, or see who is on every
channel you subscribe to.
    
See also: alias, comtitle, delcom, addcom.
   
&comlist
   
Command: comlist
     
Displays a list of all the aliases you are using, whether you are 'on' or
'off' the channel, and some information about them, such as your channel
title and status.
    
See also: comtitle, addcom, alias, delcom.
 
&comtitle
 
Command: comtitle <alias>=<title>
 
This command allows you to prefix your name on a channel with a title.
 
For example:
> comtitle pub=The Great and Powerful
Title set to 'The Great and Powerful' on channel Public.
> pub :waves to everyone.
[Public] The Great and Powerful Foobar waves to everyone.
 
See also: comlist, addcom, alias, delcom.
 
&clearcom
 
Command: clearcom
 
Removes all your aliases for channels.You should be extremely careful about
this command, as it will wipe out all of your channel information.
  
See also: addcom, delcom.
 
&delcom
 
Command: delcom <alias>
 
Deletes <alias> from your list of channel aliases.If <alias> was the only
alias you had for a certain channel, you may no longer use that channel until
you add a new alias for it.
  
See also: addcom, comlist, clearcom.
 
&@ccreate
 
Command: @ccreate <channel name>
 
Creates a channel with default settings.  Only wizards can create a channel.
 
See also: @cdestroy, @clist, @cchown.
 
&@cdestroy
 
Command: @cdestroy <channel>
 
Deletes <channel> permanently from the comsystem database.It does not destroy
all aliases that exist for <channel>, which is left to the owners of those
aliases.Players are notified at login when they own aliases for which a
channel no longer exists.
 
See also: @clist, @ccreate, @cchown.
 
&@clist
 
Command: @clist[/full]
 
Without any switches, it will display the list of public channels with their
owner, and description.It will also display all channels you own.  With the
/full switch, it will display the various channel statistics.

See also: @ccreate, @cdestroy, @cchown.
 
&@cwho
 
Command: @cwho <channel>[/all]
 
For channels that you own, identifies all connected players on the channel
and their stats for the channel.  If switch is /all, then it also displays
unconnected players.

See also: @clist.
 
&@cchown
 
Command: @cchown <channel>=<player>
 
Changes ownership of <channel> to <player>.

See also: @clist, @cwho.
 
&@ccharge
 
Command: @ccharge <channel>=<amount>
 
This command imposes a charge of <amount> coins on transmitting over a
channel.  The default fee when a channel is created is 0.  All proceeds
benefit the channel owner.
 
&@cpflags
 
Command: @cpflags <channel>=[!]flag
 
Sets player flags for that channel.  The flag can be one of: join, transmit,
or receive.

Transmit: Whether a player can broadcast things over the channel.
Join: Whether a player can join the channel.
Receive: Whether a player can receive messages over the channel.

If it is !flag, then that flag is reset.  Note that channel flags ALWAYS
override locks on channel objects.

See also: @coflags, @clist, CHANNEL OBJECTS.

&@coflags
 
Command: @coflags <channel>=[!]flag
 
Sets object flags for that channel.  The flag can be one of: join, transmit,
or receive.

Transmit: Whether an object can broadcast things over the channel.
Join: Whether an object can join the channel.
Receive: Whether a object can receive messages over the channel.

If it is !flag, then that flag is reset.  Note that channel flags ALWAYS
override locks on channel objects.

See also: @coflags, @clist, CHANNEL OBJECTS.
 
&@cset
 
Command: @cset/<option> <channel>
Changes the way a channel behaves.<option> can be one of the following:
public, private, loud, mute, quiet, object.  Public makes it show up on
everyone's @clist, private hides it.  Loud makes it announce
connects/disconnects.  Mute/quiet, shuts them off.
 
The object switch sets the channel object to whatever you specify.
It will allow you to set a description for the @clist, by @descing the
object.Also, the lock will be used to check to see if people should be
able to join the channel or not.See help channel object for more.
 
&channel object
 
In the comsystem, you may specify a channel object for each channel. 
(@cset/object channel=<object>).
 
Channel objects allow you to specify a description for a channel, and
place certain restrictions on joining, transmitting, and receiving.
 
NOTE: If a channel flag is set by @cpflags/@coflags, it will ALWAYS
override the equivalent lock. The flags are set by default, so you will
have to clear them before your locks work.
 
The join lock for a channel is a normal @lock on the channel object.
The transmit lock for a channel is a use @lock on the channel object.
The receive lock for a channel is an enter @lock on the channel object.
The description of a channel is the @desc of the channel object.
 
&cwho()
Function: cwho(<channel>)
 
Returns a list of dbrefs who are connected, and on that channel. 
This is limited to wizards and channel owners.
       
&macros
 
  This is the help for the MUX macro system. Note that all macros must be
  proceeded with '.'. If the macro is not found, it will be passed on like
  a normal command. The purpose of macros is to make repeated sequences of
  commands easier. This system should NOT be used if your telnet client
  supports macros of it's own, like TinyFugue.
  
  These are the topics for the MUX macro system:
 
  .add         .chmod       .chslot      .clear     .create      .del   
  .ex          .gex         .list        .name      .glist       .undef 
   
  For general macro usage see 'help macro general'.
  
&.ex
 
  Command: .ex [slot]
 
  Lists the macros in your current slot. The optional parameter allows
  for the examination of other slots.
 
&.gex
 
  Command: .gex <slot>
 
  Examines a set in the global macro list.
 
&.glist
 
  Command: .glist
 
  This command lists all macro sets from the global macro list.
 
&.list
 
  Command: .list
 
  This command lists all macro sets that you have in your private slots.
 
&.chmod
 
  Command: .chmod
 
  This command changes the permissions on the current slot. Legal
  modes are L, R, and W. Use !mode to clear a permission. 
  
  L corresponds to Locked. A locked set cannot be modified in any way.
  R corresponds to Read. A set marked read can be used by anyone.
  W corresponds to Write. A set marked write can be modified by
  anyone.
  
&.name
 
  Command: .name <name>
 
  Renames the current macro slot.
 
&.create
 
  Command: .create <name>
 
  Creates a macro set and adds it to first available slot.  You only
  have 5 slots, however, and all macros you own use your slots.
 
&.add
 
  Command: .add <number>
 
  Adds an existing macro set from the global list to your first available
  slot. To remove it, .del <slot>.
 
&.del 
 
  Command: .del <slot>
 
  Removes a macro set from slot <slot>.  You cannot remove macros
  that you own, without erasing them. If you delete a slot that you added
  with .add, it merely removes that entry from your private list.
 
&.clear
 
  Command: .clear
 
  Removes/deletes all macros in your slots.  It deletes them if you
  own them. This command should be used with extreme caution. 
 
&.chslot
 
  Command: .chslot <slot>
 
  This command changes your current slot to <slot>. Note that this is with
  your private list of slots, and commands like .ex and .del, when they take
  no arguments, use your current slot. When you define a macro with .def, it
  defines that macro in your current slot.  
 
&.def
 
  Command: .def <name>=<macro>
 
  Defines a macro in your current macro slot. You always invoke this macro
  with .<name>.
 
&.undef
 
  Command: .undef <name>
 
  Deletes a macro in the current slot.
 
&macro general
 
  The macro system serves the function of most macro systems, it allows
  aliases for commands, or for a series of commands.  All MUX macros and
  commands begin with '.'. In a macro, '*' is replaced by all the arguments
  you send to it.  If you typed:
    .create Test
    .def t = say Howdy *!
    .t Neighbor 
 
   You would see:
 
    Macro set created with description Test.
    macro defined t:say Howdy *!
    You say, "Howdy Neighbor!"
 
&@malias
 
  Command: @malias
  
  This allows you to generate and maintain mailing lists with the mail
  system. All mail aliases start with '*', and are case-sensitive. (*dir is
  different than *Dir).  There are two kinds of mail aliases, Personnal
  and Global. Global mailing lists are owned and maintained by the god (#1)
  char and are available for anyone to use.  Generally there will be
  *Wizards, *Admin, *Roleplay, and things of that nature.  Personal mailing
  aliases are mailing lists that you have defined with the @malias commad.
  Currently there is no limit to the number of people you can have on a
  mailing alias.
 
  To begin sending mail to a mailing list, use @mail *<alias>=subject.
  
  Usage:
  
  @malias                   Displays a list of all mail aliases.
  @malias *<alias>          Displays a list of people on that alias.
  @malias *<alias>=<list>   Creates that mailing list, using <list>.
  
  For more help, see the following help topics.  All errors can be
  sent to *Bugs, or Lauren.
<Continued in HELP @MALIAS2>
 
&@malias2
 
  You can add, remove, rename, chown, redescribe, and delete mailing lists
  with a switch.
  
  @malias/remove *<alias>=<player>     Removes <player> from *<alias>.
  @malias/desc *<alias>=<description>  Changes the description for *<alias>. 
  @malias/add *<alias>=<player>        Adds <player> to *<alias>.
  @malias/rename *<alias>=<name>       Renames that alias. Names must always
                                       begin with '*'.
  @malias/delete <alias>               Deletes <alias>. This is the only
                                       alias command that does not require
                                       the '*' in front of the alias' name.
  @malias/chown *<alias>=<player>      Changes the owner of <alias> to
                                       <player>.
 
  Wizards can use all of the malias commands on any mail alias. Instead of
  trying to figure out different mailing lists with the same name, wizards
  may use #<MALIAS NUMBER> instead of *alias in regards to the command.
  Remember that the alias commands will only recognize aliases owned by #1,
  owned by you, or by number.
  
  @malias/list                         When invoked by a wizard, it will
                                       list all mailing aliases currently
                                       defined by their number.
 
&drop 
  
  Command: drop[/<switch>] <object>
           drop[/<switch>] <exit>
 
  The first form removes <object> from your inventory and puts it in your
  location, except for the following special cases: Dropping a STICKY thing
  sends it home, and dropping a thing in a room with a drop-to sends the thing
  to the drop-to location.
 
  The second form removes <exit> from your list of exits and adds it to the
  list of exits for the current location.  Anyone in the same location as
  you may then use the exit to travel to the exit's destination.  You can
  only drop exits when you own the location where you are dropping them.
 
  The following switch is recognized:
     /quiet   - Don't perform the @odrop/@adrop attributes on the dropped
                 object.  This switch only works if you control the object.
 
  'throw' is the same as 'drop'.
  See also: get, @adrop, @drop, @odrop, DROP-TO, STICKY.  
 
&enter
 
  Command: enter[/<switch>] <object>
  The enter command is used to enter an object. Insides of objects are best
  used for vehicles, or storage spaces when you don't have a home (or even
  as a floating home).  In order to enter an object you must either own it or
  it must have its ENTER_OK flag set, and you must also pass the object's
  EnterLock (if it has one).
 
  The following switch is recognized:
 
     /quiet   - Don't perform the @oenter/@aenter or @oefail/@aefail
                attributes on the entered object, and don't perform the
                @oxleave attribute on your current location.  This switch
                only works if you control the object being entered.
 
  See also: leave, @aefail, @aenter, @efail, @enter, @idesc, @lock, @oefail,
            @oenter, @oxleave, ENTER_OK.
 
&examine
 
  Command: examine[/<switches>] <object>[/<wild-attrib>]
  Displays all available information about <object>.  <object> may be an
  object, 'me' or 'here'. You must control the object to examine it, or it
  must be set VISUAL.  If you do not own the object, you will just see the
  name of the object's owner, and optionally any public attributes and 
  attributes owned by you set on the object.
 
  If an attribute is owned by a player other than the owner of the object,
  the number of the attribute owner is shown in parentheses immediately
  following the attribute name.  Flag letters may appear in parentheses also,
  to indicate the status of the attribute:
    + - The attribute is locked, it does not change ownership when the
        object is @chowned and may not be modified.
    $ - The attribute is not checked when looking for $-commands.  Note
        that the predefined attributes DESC, IDESC, ODESC, FAIL, OFAIL,
        SUCC, OSUCC, DROP, ODROP, SEX, and CHARGES are never checked.
    I - This attribute is not inherited by children of the object.
    V - The attribute is visible to anyone who examines you.  Note that
        the predefined attributes DESC, SEX, and LAST are always VISUAL.
<Continued in HELP EXAMINE2>
     
&examine2
 
  If you specify a wildcarded attribute name, then only those attributes
  that match are shown.  So, 'exam me/v?' will show all your attributes that
  start with v and are two characters long.
 
  The following switches are available:
     /brief  - Shows everything except attributes. 
     /full   - When examining an object you don't control, show any public
               attributes set on the object in addition to the owner's name.
     /parent - Includes attributes that are not present on the object itself
               but which are inherited from the object's parent.
  See also: look, @decompile, VISUAL, ATTRIBUTE OWNERSHIP.
 
&get
 
  Command: get[/<switch>] <object>
           get[/<switch>] <exit>
           get[/<switch>] <object>'s <sub-object>
 
  The first form picks up <object> from your location and adds it to your
  inventory.  It will fail if the object is locked against you, or if you
  are inside a player or object that you don't control and which isn't
  set ENTER_OK.
 
  The second form takes an exit from your location and adds it to you.
  Anyone inside you may then use the exit to travel to the exit's destination.
  You may take exits that you own, and exits owned by others in locations that
  you own.
 
  The third form takes <sub-object> from <object> and adds it to your
  inventory.  <object> must be ENTER_OK and <sub-object> must not be locked
  against you for this to work.  The lock on <object> is not checked.
<Continued in HELP GET2>
      
&get2
 
  The following switch is recognized:
     /quiet   - Don't perform the @osucc/@asucc or @ofail/@afail attributes
                on the target object.  This switch only works if you control
                the object.
 
  <object> and <sub-object> may be either players or things.
  'take' is the same as 'get'.
  See also: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ, ENTER_OK,
            FAILURE, SUCCESS.
 
&give
 
  Command: give <player>=<amount/object>
  Gives player the specified amount of money or <object>. You can't give
  someone money if their new total would be greater than 10000 (No reason to
  get greedy).  You may also give players objects, but the other player must
  be set ENTER_OK to receive something you give. 
  See also: @apay, @cost, @opay, @pay, ENTER_OK.
 
&goto
 
  Command: goto[/<switch>] <direction>
           goto[/<switch>] home
           <direction>
           home
 
  Moves you in the specified direction, assuming that the direction is not
  locked against you.  'move home' is a special command that returns you to
  your home. The word 'move' may be omitted.
 
  The following switch is recognized:
     /quiet   - Don't perform the @osucc/@asucc/@odrop/@adrop or @ofail/@afail
                attributes on the exit being used.  This switch only works if
                you control the exit.
 
  'move' is the same as 'goto'.
  See also: enter, home, leave, 
 
&inventory
 
  Command: inventory
  Lists what you are carrying and how much money you have.
 
&kill
 
  Command: kill <player> [=<cost>]
  Attempts to kill the specified player. Killing costs <cost> coins, which
  gives you a <cost>% chance of killing the player. Thus, spending 100 
  coins always works (except against wizards and immortals, who can never be
  killed). Players cannot be killed in rooms which have been set HAVEN or
  which they control.  If you don't specify a cost, the default is 10 (for a
  10% chance of success).  The player, if killed, receives <cost>/2 coins in
  insurance.
  See also: @akill, @kill, @okill, BEING KILLED, IMMORTAL, WIZARD.
 
&leave
 
  Command: leave[/<switch>]
  This command leave allows you to exit an object you have entered, arriving
  in the same location as the object. You may not leave an object if you fail
  that object's LeaveLock (but you may still @teleport out, use an exit inside
  the object, or go home).
 
  The following switch is recognized:
     /quiet   - Don't perform the @oleave/@aleave or @olfail/@alfail
                attributes on the entered object, and don't perform the
                @oxenter attribute on your new location.  This switch
                only works if you control your current location.
 
  See also: enter, @lock, ENTER_OK, @aleave, @alfail, @leave, @lfail, @oleave,
            @olfail, @oxenter.
 
&LOGOUT
 
  Command: LOGOUT
  Disconnects you from your character without breaking the network connection
  to the game.  You may then log in to another character.  The LOGOUT command
  must be entered in all capitals.
  See also: QUIT.
 
&look
 
  Command: look[/<switches>] [<object>]
  Displays the description of <object>, or the room you're in if you don't
  specify an object.  Specifying object as <name> or #<dbref> or 'me' or
  'here' is legal.  You can also use look to look at objects held by other
  people, just use 'look <person>'s <object>'.
 
  You may use the /outside switch to look at the location of your current
  location (useful if you are inside a vehicle or other object).  You may
  also look at other objects in the 'outer' location, but you may not
  use the possessive form with the /outside switch (ie: "look/outside
  <person>'s <object>" won't work).
  
  'read' is the same as 'look'.
 
  See also: @adesc, @describe, @odesc.
 
&move
 
  Command: move[/<switch>] <direction>
           move[/<switch>] home
           <direction>
           home
 
  Moves you in the specified direction, assuming that the direction is not
  locked against you.  'move home' is a special command that returns you to
  your home. The word 'move' may be omitted.
 
  The following switch is recognized:
     /quiet   - Don't perform the @osucc/@asucc/@odrop/@adrop or @ofail/@afail
                attributes on the exit being used.  This switch only works if
                you control the exit.
 
  'goto' is the same as 'move'.
  See also: enter, home, leave.
 
&news
 
  Command: news [<topic>]
  Shows you the current news for the MUX. It is highly recommended that
  you check the news daily for new information.  Otherwise, the wizards will
  have no pity on you for messing up with the new commands.
 
&OUTPUTPREFIX
 
  Command: OUTPUTPREFIX <string>
  Causes <string> to be output on a line by itself before printing the
  results of each command.  This command is intended for use by external
  robot programs, and may be restricted to players whose ROBOT flag is set.
  The OUTPUTPREFIX command must be entered in all capitals.
  See also; @robot, OUTPUTSUFFIX, ROBOT.
 
&OUTPUTSUFFIX
 
  Command: OUTPUTSUFFIX <string>
  Causes <string> to be output on a line by itself after printing the results
  of each command.  This command is intended for use by external robot
  programs, and may be restricted to players whose ROBOT flag is set.
  The OUTPUTSUFFIX command must be entered in all capitals.
  See also; @robot, OUTPUTPREFIX, ROBOT.
 
&page 
 
  Command: page <player-list> [=[<control>]<message>]
 
  This command sends <message> to <player-list>.  If you do not specify a
  name, it defaults to the players you last paged.  You may use either the
  player's name or alias, a list of names and/or aliases, and you may also
  give a string that uniquely matches the start of a player's name on the
  WHO list.
 
  You can format the message one of several ways by specifying ':', ';', or
  '"' as the first character of the message.  ':' and ';' format the message
  as 'From afar, <player> <message>', with ';' omitting the space between
  <player> and <message>.  '"' formats the message in normal page format
  (this is the default).
 
  If your Idle attribute is set to something, then it is sent to anyone
  who successfully pages you.  This is useful for when you are away from
  your terminal for a short while.
<Continued in HELP PAGE2>
     
&page2  
 
  You can selectively disable pages from certain players with the '@lock/page'
  command (players must pass the lock in order to page you).  If someone
  cannot page you, they will be sent a message including of your Reject
  attribute if they try.  If someone pages you while you are not connected,
  they are sent a message including your Away attribute.
<Continued in HELP PAGE3>
     
&page3
 
  You can also page many players at one time, where all the players you page
  will see the message. 
  Ex:
  > p darkenelf lauren = Hi
  You paged (Darkenelf Lauren) with 'Hi'.
  
  To (Darkenelf Lauren), Dreamline pages: Hi
 
  You only need to type the player-list once, then the next time you page that
  player or set of players, you can abbreviate it with:
  "p :waves."  or,
  "p I'm back."
 
  This will work until you page another player or list of players.  
 
  See also: pose, say, whisper, :, ;, ", @pemit, @away, @idle, @reject.
 
&pose
 
  Command: pose[/<switches>] <message>
  Displays <message> to everyone in your current room, preceded by your name
  and optionally a space.  Example: the command 'pose jumps for joy' produces
  '<yourname> jumps for joy'.
 
  The following switches are available:
     /default - (default) Put a space between your name and the message
                (ie, display '<name> <message>').
     /nospace - Don't put a space between your name and the message
                (ie, display '<name><message>').
 
  See also: page, say, whisper, :, ;, ".
 
&QUIT    
 
  Command: QUIT
  Logs you out and disconnects you from the game. Must be in all capitals.  
  See also: LOGOUT.
 
&read 
 
  Command: read [<object>]
  Displays the description of <object>, or the room you're in if you don't
  specify an object.  Specifying object as <name> or #<dbref> or 'me' or
  'here' is legal.  You can also use look to look at objects held by other
  people, just use 'read <person>'s <object>'.
 
  You may use the /outside switch to look at the location of your current
  location (useful if you are inside a vehicle or other object).  You may
  also look at other objects in the 'outer' location, but you may not
  use the possessive form with the /outside switch (ie: "read/outside
  <person>'s <object>" won't work).
  
  'look' is the same as 'read'.
 
&;
 
  Command: ;<message>
  This command is much like the ':' command, except that no space is inserted
  between your name and the action.  Example: the command ';'s watch beeps.'
  produces '<yourname>'s watch beeps.'.
 
  Warning: This command does not work in command lists run from an attribute
  because the ';' is treated as the command separator.  Use pose/nospace
  instead.
 
  See also: page, pose, say, whisper, :, ".
 
&:
 
  Command: :<message>
  Displays <message> to everyone in your current room, preceded by your name
  and a space.  Example: the command ':jumps for joy' produces
  '<yourname> jumps for joy'.
  See also: page, pose, say, whisper, ;, ".
 
&"
 
  Command: "<message>
  Says <message> out loud to everyone in your current room.  Example:
  the command '"Where is the movie theater?' produces
  '<yourname> says "Where is the movie theater>"'.  Note that the closing
  double quote is automatically added.
  See also: page, pose, say, :, ".
 
&#
 
  Command: #<number> <command>
  Forces the object whose database number is <number> to perform <command>.
  Example: '#1033 move north' forces object #1033 to go north (assuming that
  you control it).  The same restrictions that apply to @force also apply to
  this command.
  See also: @force.
 
&\\
 
  Command: \\<message>
  Outputs <message> to everyone in your current room without embellishment.
  Example: the command '\\A chill falls over the room.' produces
  'A chill falls over the room.'
  See also: @emit, @oemit, NOSPOOF.
 
&say
 
  Command: say <message>
  Says <message> out loud to everyone in your current room. You can also
  use '"<message>'.
  See also: page, pose, whisper, :, ;, ".
 
&score
 
  Command: score
  Displays how much money you have.  Helpful to see if any machines are
  looping.
  See also: @ps, LOOPING.
 
&SESSION
 
  Command: SESSION
  Displays information on how many characters you have sent and received
  during this session, and which (Internal) port you are connected to on the
  MUX.  It must be typed in all uppercase.
 
  Example:
    > SESSION
                                   Characters Input----  Characters Output---
  Player Name     On For Idle Port Pend  Lost     Total  Pend  Lost     Total
  Mortal           00:06   0s   16    0     0        44   156     0      2679
  2 Players logged in.
 
  Pending characters are those waiting to be acted on as commands (for input)
  or waiting to be sent out over the network (output).  Lost characters are
  due to overflowing either the MUX's input or output buffers, either as the
  result of running a single command that produces too much output (such as
  @find and @search commands that match a large number of objects), or from
  typing too much on one line.
 
  Note: your Pending count for output will always be nonzero, as the output
  of the SESSION command hasn't been sent out over the network yet.
 
&take
 
  Command: take[/<switch>] <object>
           take[/<switch>] <exit>
           take[/<switch>] <object>'s <sub-object>
 
  The first form picks up <object> from your location and adds it to your
  inventory.  It will fail if the object is locked against you, or if you
  are inside a player or object that you don't control and which isn't
  set ENTER_OK.
 
  The second form takes an exit from your location and adds it to you.
  Anyone inside you may then use the exit to travel to the exit's destination.
  You may take exits that you own, and exits owned by others in locations that
  you own.
 
  The third form takes <sub-object> from <object> and adds it to your
  inventory.  <object> must be ENTER_OK and <sub-object> must not be locked
  against you for this to work.  The lock on <object> is not checked.
<Continued in HELP TAKE2>
     
&take2
 
  The following switch is recognized:
     /quiet   - Don't perform the @osucc/@asucc or @ofail/@afail attributes
                on the target object.  This switch only works if you control
                the object.
 
  <object> and <sub-object> may be either players or things.
  'get' is the same as 'take'.
  See also: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ, ENTER_OK,
            FAILURE, SUCCESS.
 
&think
 
  Command: think <message>
 
  You can use this command to send a private message to yourself. Pronoun
  substitution is performed. This is essentially equivalent to "@pemit
  me=<message>", but with "think", there is no prepended text. One possible
  use: "@adesc me=think --> %n(%#[flags(%#)]) just looked at you."
 
&throw
 
  Command: throw[/<switch>] <object>
           throw[/<switch>] <exit>
 
  The first form removes <object> from your inventory and puts it in your
  location, except for the following special cases: Dropping a STICKY thing
  sends it home, and dropping a thing in a room with a drop-to sends the
  thing to the drop-to location.
 
  The second form removes <exit> from your list of exits and adds it to the
  list of exits for the current location.  Anyone in the same location as
  you may then use the exit to travel to the exit's destination.  You can
  only drop exits when you own the location where you are dropping them.
 
  The following switch is recognized:
     /quiet   - Don't perform the @odrop/@adrop attributes on the dropped
                 object.  This switch only works if you control the object.
 
  'drop' is the same as 'throw'.
  See also: get, @adrop, @drop, @odrop, DROP-TO, STICKY.  
 
&use
 
  Command: use <object>
  Uses <object>.  Some objects will do interesting, useful, or dangerous
  things when used, for instance, using a camera should result in a 
  picture being taken.
  See also: @ause, @ouse, @use.
 
&version
 
  Command: version
  Displays the version of MUX that is running and the date it was last
  rebuilt.
 
&whisper
 
  Command: whisper <player>=<message>
  Whispers the message to the named person, if they are in the same room as
  you. No one else can see the message that you whisper.
 
  You can format the message one of several ways by specifying ':', ';', or
  '"' as the first character of the message.  ':' and ';' format the message
  as 'You sense <player> <message>', with ';' omitting the space between
  <player> and <message>.  '"' formats the message in normal whisper format
  (this is the default).
  See also: page, pose, say, :, ;, ".
 
&WHO
 
  Command: WHO <prefix>
  Displays a list of players currently connected to the MUX.
  The WHO report tells you how long a player has been on, how long they
  have been inactive, and what they are doing (if they have used the @doing
  command).  If <prefix> is specified, only players whose names start with
  <prefix> are listed.  The WHO command must be entered in all capitals.
  See also: @doing.
 
&&
 
  Command: &<attribute> <object>[=<value>]
  Synonym: @set <object> = <attribute>:[<value>]
 
  Sets the attribute named <attribute> on <object> to <value>.  If
  <attribute> is not a predefined attribute (like ofail or va), then it is
  created.  Attributes so created are called user-named attributes.
  Attribute names may only contain letters, numbers, and the characters
  < -_.@#$^&*~?=+| >, and must start with a letter.  The names of user-named
  attributes may not be abbreviated (an attempt to get the value of the
  attribute will fail, and an attempt to set will create a new attribute).
  The & command may be used to set predefined attributes (in this instance,
  '&<attr> <object>=<value>' is equivalent to '@<attr> <object>=<value>').
 
  See also: @set.
 
&@@
 
  Command: @@ <args>
 
  This command does nothing, therefore it is useful for putting comments into
  a MUX program.  Be careful that ()'s and {}'s in the (otherwise ignored)
  arguments are nested correctly, lest your command-ending ; be trapped
  inside.
 
  Example:
     @va me=$foobar *:@fo #1234=%0;@@ This controls my foobar puppet.
 
&@chown
 
  Command: @chown <object>[=<player>]
           @chown <object>/<attr>[=<player>]
  The first form changes the ownership of <object> to <player> (default is
  to yourself).  Objects may be things, rooms or exits. To chown things, you
  have to be carrying the thing. For rooms or exits, you have to be in the
  room. Objects must have the CHOWN_OK flag set before they may be @chowned.
  In a room, the command used must be @chown here = <name>, and for an object,
  you must be very specific.
 
  The second form changes the ownership of the indicated attribute on <object>
  to <player> (default is the owner of the object).  You may only @chown
  unlocked attributes.  You may @chown unlocked attributes on objects that
  you own to yourself, and you may also @chown attributes that you own on
  objects owned by others to the owner of the object.
 
  When an object is @chowned, all unlocked attributes on the object are
  automatically @chowned as well, locked attributes remain owned by their
  original owners.
 
  The HALTED flag is automatically set on the new copy of the object.
  Players can't be @chowned; they always own themselves. 
  See also: @lock, @Unlock, CHOWN_OK, ATTRIBUTE OWNERSHIP.
 
&@chzone
 
  Command: @chzone <object>=<zone object>. 
  
  Changes the zone of <object> to <zone object>. If <zone object> is "none",
  the zone is reset to NOTHING.
  
  @chzone'ing a player does not automatically change the zone of their
  objects. Anyone may reset the zone of an object they own; <zone object>
  must either be "none", or must be owned by them. Only wizards may @chzone
  an object to an arbitrary zone object. Players may @chzone themselves to
  an object they own; otherwise, only wizards may @chzone players.
  @chzone'ing resets the WIZARD, ROYALTY, and INHERIT flags on non-player
  objects.
  
  See also: ZONE OBJECTS
 
&@clone
 
  Command: @clone[/<switches>] <object>[=<newname/cost>]
 
  Creates an exact duplicate of <object> that is owned by you and (for things
  and exits) puts it in your current location.  You may have the object put
  in your inventory (or your exitlist in the case of cloning exits) by using
  the /inventory switch.
 
  You may clone your own objects, plus VISUAL objects owned by others.
  The INHERIT and WIZARD bits of the (new) object are cleared when the object
  is cloned.  If <newname> is specified, it is used as the name instead of
  the original name.
 
  If you clone a linked exit, an attempt is made to link the clone to the
  same location.  Except when using the /inventory switch, you can only clone
  exits when you own your current location.
 
  If you clone a room with a drop-to, an attempt is made to link the drop-to
  to the same location.
 
  If the original object was owned by you, then the ACLONE attribute is run
  in the new attribute, otherwise the new object is set HALTED.  Exits and
  contents of cloned objects aren't cloned and LOCKED attributes aren't copied.
<Continued in HELP @CLONE2>
     
&@clone2
 
  The following switches are available:
     /cost       - Treat the argument after the = as the cost of the new
                   object, not the name.
     /inherit    - Don't reset the INHERIT bit on the new object.
     /inventory  - Create the new object in your inventory (or your exitlist,
                   in the case of cloning exits).
     /location   - Create the new object in your location (default).
     /parent     - Set the new object's parent to be the template object and
                   don't copy the attributes.
  See also: @create, @decompile, @destroy, VISUAL.
 
&@cpattr
 
  @cpattr <obj>/<attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]
  @cpattr <obj>/<attr> = <obj1> [,<obj2>,<obj3>,...]
  @cpattr <attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]
  @cpattr <attr> = <obj1> [,<obj2>,<obj3>,...]
 
  The first form of this command is used to copy <attr> on <obj> to the
  object-attribute pairs in a comma-separated list. For example:
 
  @cpattr test/va = test/vb, cube/va, tribble/foo
 
  would copy the VA attribute from object "test" to VB on "test",
  VA on "cube", and FOO on "tribble".  <objN> is matched as if
  you were performing a @set on it.
 
  The second form copies <attr> to the list of objects, with the name
  <attr>. The third form copies <attr> from the object that executes the
  @cpattr, to the object-attribute pairs in the list. Finally, the third
  form copies <attr> from the object that executes the @cpattr to the
  objects in the list, with the name <attr>.
 
&@create
 
  Command: @create <name> [=<cost>] 
  Creates a thing with the specified name.  Creation costs either <cost> 
  or 10 coins, whichever is greater. The value of a thing is proportional 
  to its cost, specifically, value=(cost/5)-1.  The value may not be greater 
  than 100, values that would be greater than 100 are rounded down to 100. 
  See also: @destroy, TYPES OF OBJECTS. 
 
&@decompile 
 
  Command: @decompile <thing>[/attr] [=<newname>] 
  Dumps the sequence of commands you would have to type to clone <thing>. 
  This is handy for saving your objects in a text file in case the MUX dies 
  a horrible death, or for moving your pride-and-joy creation from one MUX 
  to another.  @decompile works on all object types. 
  If you specify <newname>, then the commands emitted will set attributes, 
  locks, and flags on an object named <newname> and will omit the command 
  to create the object. 
  If you specify <thing>/<attr>, <attr> accepts wildcards. 
  See also: examine, look. 
 
&@destroy 
 
  Command: @destroy[/<switches>] <object> 
  This command destroys <object> and refunds its cost of creation to its 
  owner.  You must own <object> in order to @destroy it, unless its 
  DESTROY_OK flag is set, in which case anyone holding it may @destroy it. 
  Rooms, exits, and objects may be destroyed, although the the actual 
  destruction of rooms is delayed for up to ten minutes and the GOING flag 
  is set on the victim room.  Clearing the GOING flag on the room spares it 
  from destruction. 
  
  If a thing OR it's owner is set DESTROY_OK, the thing will be destroyed 
  with no delay. 
  
  The @destroy command will not destroy objects with the SAFE flag set unless 
  the /override switch is specified.  The DESTROY_OK flag overrides the 
  protection given by the SAFE flag. 
  
  The following switches are available: 
    /override  - Negate protection offered by the SAFE flag. 
  See also: DESTROY_OK, SAFE. 
 
&@dig 
 
  Command: @dig[/<switches>] <name> [= <exitlist> [, <exitlist>] ] 
  Creates a new room with the specified name and displays its number. This  
  command costs 10 coins. If the [= <exitlist>] option is used, an exit will 
  be opened from the current room to the new room automatically.  If the 
  second <exitlist> option (after the comma) is specified, an exit from the 
  new room back to the current room with the specified [Exits] name is 
  opened.  Either exit creation may fail if you do not have sufficient 
  rights to the current room to open or link the new exit. 
  Example: The command 
  
     @dig Kitchen = Kitchen;k;north;n,south;s 
  
  will dig a room called Kitchen, and open an exit called 'Kitchen' in your 
  current room.  The ; symbol means that you may enter the exit by typing 
  'k', 'north' or 'n' also.  This command also opens the exit 'south;s' from 
  'Kitchen' back to where you are.  Only the first Exit name is displayed in 
  the Obvious exits list. 
  
  If you specify the /teleport switch, then you are @teleported to the 
  room after it is created and any exits are opened. 
  
  See also: @destroy, @link, @open, LINKING, TYPES OF OBJECTS. 
 
&@doing 
 
  Command: @doing[/<switches>] [<message>] 
  Sets your doing message, which appears after your name in the WHO report. 
  The following switches are available: 
     /message - Sets your Doing string in the WHO report. (default) 
     /poll    - Displays the current Doing poll from the WHO report. 
  See also: WHO, @poll. 
 
&@dolist 
 
  Command: @dolist[/<switch>] [<delimiter>] <list>=<action> 
  <list> is a list of strings, which can be object numbers, attributes, or 
  arbitrary words.  <action> is a command to perform once for each item in 
  <list>, replacing the special symbol ## with the corresponding item from 
  <list>. By default, @dolist considers each item in <list> to be separated 
  with spaces. If you specify the /delimit switch, then each item is 
  considered to be separated by <delimiter>. <delimiter> must be a single 
  character. 
  
  If present, <switch> can be any of: 
    /space   - (Default) List elements are separated by spaces. 
    /delimit - List elements are separated by <delimiter>. 
  
  This command is particularly handy with lcon() and lexits(). A few examples: 
  
    @dolist [lcon(here)] = "[name(##)](##) 
    @dolist [lcon(here)] = @switch [get(##/last)]=*1990*,"[name(##)] 
    @va me = va vb vc 
    @dolist [get(me/va)] = @emit [get(me/##)] 
    @dolist Frodo Bilbo Gandalf = page ## = HELP!!!!  I've fallen into a pit. 
    @dolist/delimit , {Frodo, Bilbo Baggins, Gandalf} = page ## = HELP!!!! 
  See also: iter(), parse(). 
 
&@drain 
 
  Command: @drain <object> 
  Discards all commands waiting on the semaphore <object> and resets the 
  semaphore to its initial state. 
  See also: @notify, @ps, SEMAPHORES 
 
&@edit 
 
  Command: @edit <object>/<wild-attr> = <search>,<replace> 
           @edit <object>/<wild-attr> = ^,<text> 
           @edit <object>/<wild-attr> = $,<text> 
  This command edits the contents of one or more attributes of an object, 
  eliminating the need to retype a long attribute in order to make a simple 
  change.  In the first form, all occurrences of <search> in the specified 
  attribute of the named object are replaced with <replace>.  Use curly 
  braces ({ and }) around <search> or <replace> if they contain commas. 
  The second and third form prepend and append <text> to the selected 
  attributes, respectively. 
  
  If <wild-attr> contains wildcard characters, then all attributes that 
  match are edited. 
 
&@cemit 
 
  Command: @cemit[/<switches>] <channel>=<message> 
  Sends <message> over <channel> prefixed by the channel's name. You must 
  own or control the channel to do this. 
  
  The following switches are available: 
     /noheader - Sends the message to everyone on <channel>, without the 
                 channel's name prefixed. 
  
&@emit 
 
  Command: @emit[/<switches>] <message> 
  Sends <message> to everyone in your current location without prefixing it by 
  your character name.  You can also send the message to everyone in the room 
  that contains the object you are inside with the /room switch. 
  
  The following switches are available: 
     /here  - Sends the message to everyone in the same location as you. 
     /room  - Sends the message to everyone in the room that contains the 
             object you are in.  Starting from your location, this switch 
             'leaves' objects until it reaches a room, and @emits the message 
             there. 
  If both switches are specified, the message is sent to both places.  If 
  neither is specified, /here is assumed. 
  
  Some MUXes may restrict the use of this command. 
  See also: @femit, @oemit, @pemit, @npemit, @remit, SPOOFING. 
 
&@remit 
 
  Command: @remit <room dbref#> = <message> 
  Sends <message> to the contents of <room>. 
  
  See also: @femit, @oemit, @pemit, @npemit, @emit, SPOOFING. 
  
&@entrances 
 
  Command: @entrances [[<object>][,<low>[,<high>]]] 
  
  Lists links from elsewhere to the specified object (default: your current 
  room).  For rooms, exits and drop-to's, leading to the room and players 
  and objects whose home is in the room are listed.  For players and objects, 
  lists exits leading to them.  Because this command is computationally 
  expensive, it costs 100 coins.  <low> and <high> can be used to indicate 
  where to start and stop the search, respectively. 
  
  Examples: 
    > @entrances             <- all links to here 
    > @entrances object      <- all links to object 
    > @entrances ,100,200    <- all links to here from #100 to #200 
    > @entrances me,1000     <- all links to me from #1000 and above. 
  See also: @link, @unlink. 
 
&@femit 
 
  Command: @femit[/<switches>] <object>=<message> 
  Forces <object> to emit <message>.  This command is similar to the command 
  '@force <object> = @emit <message>', except that it will work so long as 
  you own the object, whereas @force may fail if the object has its INHERIT 
  flag set and the object performing the @force does not. 
  
  The following switches are available: 
     /here  - Sends the message to everyone in the same location as <object>. 
     /room  - Sends the message to everyone in the room that contains the 
              object that <object> is in.  Starting from your location, this 
              switch 'leaves' objects until it reaches a room, and @emits the 
              message there. 
 
  If both switches are specified, the message is sent to both places.  If 
  neither is specified, /here is assumed. 
  
  Some MUXes may restrict the use of this command. 
  See also: @remit, @emit, @fpose, @fsay, INHERIT, SPOOFING. 
 
&@find 
 
  Command: @find <name>[,<low>[,<high>]] 
  
  Displays the name and number of every room, thing, or player that you 
  control whose name matches <name>. Because the command is computationally 
  expensive, it costs 100 coins. 
  
  <low> and <high> may be used to restrict the range of objects that are 
  searched, if they are given then the search starts at object #<low> and ends 
  at object #<high>. 
  
  Examples: 
    > @find Lost Room 
    > @find Secret Device,12000,14000 
  See also: @search. 
 
&@force 
 
  Command: @force <player/object>=<command> 
  Forces the game to act as though <player/object> had entered <command>. 
  You may only force objects that you control.  Objects may not force players 
  unless either the object or the player has their INHERIT flag set, and 
  objects that do not have their INHERIT flag set may not force objects that 
  do.  If the victim is specified by number, you may use an alternate form 
  of the command, '#<number> <command>'. 
  See also: puppets. 
 
&@fpose 
 
  Command: @fpose[/<switches>] <object>=<message> 
  Forces <object> to pose <message>.  This command is similar to the command 
  '@force <object> = :<message>', except that it will work so long as you 
  own the object, whereas @force may fail if the object has its INHERIT flag 
  set and the object performing the @force does not. 
  
  The following switches are available: 
     /default - (default) Put a space between the name of the object and 
                the message (ie, send '<name> <message>'). 
     /nospace - Don't put a space between the name of the object and the 
                message (ie, send '<name><message>'). 
  See also: @femit, @fsay, pose, :, ;, INHERIT. 
 
&@halt 
 
  Command: @halt [<object>] 
  Halts all commands being run by <object>, or by the object running the 
  command if no <object> is given.  If the object to be halted is a player, 
  then all commands being run by objects owned by that player are halted. 
  Use this command to stop runaway objects and infinite loops. 
  The process of halting an object involves removing all commands waiting 
  to be run by the object from the queue and refunding the queue deposit. 
  Halting an object does not affect commands waiting on it as a semaphore. 
  See also: @drain, @notify, kill, HALTED, SEMAPHORES. 
 
&@last 
 
  Command: @last <player> 
  This command displays a short 'connection history' for <player>, showing 
  recent successful and failed connection attempts, as well as the total 
  number of successful and failed connections. 
  You can only display information about yourself. 
 
&@link 
 
  Command: @link <object>=#<number>/here/home 
  When used on a player or a thing, this command sets the object's home 
  to the indicated location.  The destination must be owned by you or be an 
  ABODE room, and you must pass the destination's LinkLock. 
  
  When used on a room, this command sets the room's drop-to, where objects 
  dropped in the room go.  The destination must be a room that is either owned 
  by you or is LINK_OK, and you must pass the destination's LinkLock. 
  
  For exits, this command sets the destination if the exit is currently 
  unlinked, you control the destination or it is set LINK_OK, and you pass the 
  destination's LinkLock.  You can @link an unlinked exit regardless of who 
  owns it or the lock set on it, you are made the owner if you successfully 
  link to the destination.  Linking an exit costs 1 coin, and if the exit was 
  owned by someone else, you also reimburse the the former owner 1 coin 
  (making the total cost to you 2 coins). 
{ 'help @link2' for more } 
 
&@link2 
 
  Note that in all the above cases that it is the player performing the @link 
  command that must pass the LinkLock, not the object being linked. 
  Therefore, you should use the '$' lock qualifier if you want to prevent 
  specific players from linking to your LINK_OK locations, as simply locking 
  against '*<playername>' does not lock out their puppets. 
  
  See also: @dig, @open, @unlink, DROP-TOS, HOMES, LINKING. 
 
&@list 
 
  Command: @list [<option>] 
  Lists information from internal databases.  Information is available 
  about the following options: 
    attributes      - Valid object attributes. 
    commands        - Commands that you may use (excluding the  
                      attribute-setting commands as well as any exits, and 
                      $-commands available). 
    costs           - Lists the costs associated with many commands and 
                      actions. 
    default_flags   - Lists the flags that new objects receive by default 
                      when created. 
    flags           - Lists the name and letter of all the flags. 
    functions       - Lists all the available functions. 
    options         - Lists several global options and limits. 
    powers          - Lists all powers. 
    switches        - Lists what commands support switches and the switches 
                      that they do support. 
  The information provided by the @list command is definitive, as it reads 
  the internal tables to produce the information it displays.  Specifying 
  @list with no argument lists the options you may use. 
 
&@listmotd 
 
  Command: @listmotd 
  Displays the current message-of-the-day.  Note that it is displayed when 
  you connect to your character. This will also display the "motd.txt" file.  
 
&@lock 
 
  Command: @lock[/<whichlock>] <object>=<key> 
           @lock <object>/<attrib> 
  
  The first form locks <object> to a specific key(s).  Type 'help @lock keys' 
  for a list of the keys you may use. 
  
  <whichlock> indicates which lock you want to set on the object.  If you 
  don't specify one, you set the Default lock. Type 'help @lock locks' for 
  a list of the locks you may set and what they are used for. 
  
  The second form locks the indicated attribute of the named object, so that 
  when the object is @chowned, the attribute will remain owned by you. 
  It may also be used when you own an attribute on an object that you do not 
  own, in this case it prevents the object's owner from @chowning the 
  attribute to himself, and prevents anyone from modifying or removing the 
  attribute. 
  
  See also: @chown, @unlock. 
 
&@lock locks 
 
  You can set the following locks: 
  
  DefaultLock:  Exits:          controls who may traverse the exit to 
                                its destination. 
                Rooms:          controls whether the player sees the SUCC 
                                or FAIL message for the room following the 
                                room description when looking at the room. 
                Players/Things: controls who may GET the object. 
  EnterLock:    Players/Things: controls who may ENTER the object if the 
                                object is ENTER_OK. Also, the enter lock 
                                of an object being used as a Zone Master 
                                Object determines control of that zone. 
  GiveLock:     Players/Things: controls who may give the object. 
  LeaveLock:    Players/Things: controls who may LEAVE the object. 
  LinkLock:     All but Exits:  controls who may link to the location if the 
                                location is LINK_OK (for linking exits or 
                                setting drop-tos) or ABODE (for setting 
                                homes) 
  PageLock:     Players:        controls who may page the player. 
  ParentLock:   All:            controls who may make @parent links to the 
                                object. 
  ReceiveLock:  Players/Things: controls who may give things to the object. 
<Continued in HELP @LOCK LOCKS2>
     
&@lock locks2 
 
  SpeechLock:   All but Exits:  controls who may speak in that location 
                                (only checked if AUDITORIUM flag is set 
                                on that location) 
  TeloutLock:   All but Exits:  controls who may teleport out of the 
                                location. 
  TportLock:    Rooms/Things:   controls who may teleport there if the 
                                location is JUMP_OK. 
  UseLock:      All but Exits:  controls who may USE the object, GIVE the 
                                object money and have the PAY attributes 
                                run, have their messages heard and possibly 
                                acted on by LISTEN and AxHEAR, and invoke 
                                $-commands stored on the object. 
  DropLock:     All but rooms:  controls who may drop that object. 
  UserLock:     All:            Not used by MUX, is intended to be used 
                                in MUX programming where a user-defined 
                                lock is needed. 
  
 Note: If a player fails the UseLock on a parent of an object being searched 
 for $-commands, then the search for attributes stops and the parent chain is 
 not searched further for matches. 
 
&@Lock keys 
  
  You may use the following keys when setting locks.  For information about 
  a particular type of key, type 'help @lock <keytype>'. 
  
  Key Type    Form in @Lock Command 
  ----------  ------------------------------ 
  Normal      <object> 
  Is          =<object> 
  Carry       +<object> 
  Ownership   $<object> 
  Indirect    @<object> 
  Attribute   <attribute>:<wildcard-pattern> 
              +<attribute>:<wildcard-pattern> 
              =<attribute>:<wildcard-pattern> 
  Evaluation  <attribute>/<value> 
  Compound    <key> & <key> 
              <key> | <key> 
              !<key> 
              ( <key> ) 
 
&@lock attribute 
 
  ATTRIBUTE LOCKS: 
  
  Key: <attribute>:<pattern> 
       +<attribute>:<wildcard-pattern> 
       =<attribute>:<wildcard-pattern> 
  
  You may lock on whether a specific attribute on the player attempting to 
  pass the lock matches a pattern.  Example: '@lock thing=sex:m*' will lock 
  thing to anyone whose sex starts with an M. Wild cards, greater than and 
  less than may be used, for example: '@lock a-f=name:<g' will lock the exit 
  a-f against any one whose name is higher than f. 
  
  Both the player testing the lock and every object in his inventory is 
  checked, the player passes the lock if any of those objects passes the lock. 
  If the attribute name is prefixed by a = then only the player is checked. 
  Similarly, if the attribute name is prefixed by a + then only objects in 
  the player's inventory are tested. 
<Continued in HELP @LOCK ATTRIBUTE2>
     
&@lock attribute2 
 
  Note: you may lock against any attribute, but the locked object must be 
  able to read the attribute from the player attempting to pass the lock or 
  the lock will fail. 
  
  Examples: 
    > @lock men's room=sex:m* 
    > @lock a-f=name:<g 
    > @lock post office=email:*@* 
  See also: ATTRIBUTE OWNERSHIP, @lock evaluation. 
 
&@lock evaluation 
 
  EVALUATION LOCKS: 
  
  Key: <attribute>/<value> 
  
  Evaluation locks let you evaluate one of your attributes and compare the  
  result against a value stored in the lock.  The result must be an exact 
  match (no wildcarding allowed, but uppercase and lowercase are considered 
  to be the same).  When evaluating the attribute the enactor substitutions 
  (%#/%n/etc) are replaced with information about the player trying to pass 
  the lock, and 'me' and %! refer to the locked object or exit. 
  
  If you call an indirect lock and the indirect lock is an evaluation lock 
  (or is a compound lock that includes an evaluation lock), then the original 
  lock object is checked for the attribute first, followed by the object that 
  has the actual evaluation lock.  If there are multiple levels of indirection 
  the intermediate locks are not checked. 
<Continued in HELP @LOCK EVALUATION2>
     
&@lock evaluation2 
 
  Examples: 
    > @lock bank=checkmoney/1 
    > &checkmoney bank=[gt(money(%#),5000)] 
    Only people and objects with more than 5000 pennies may pass. 
    Note: this lock requires wizard privileges to read the worth of other 
    players. 
  
    > @lock divisible_by_five_club = checkdiv/0 
    > &checkdiv divisible_by_five_club = [mod(mid(%#,2,20),5)] 
    Only objects whose db-number is divisible by 5 may pass. 
  See also: @lock attributes. 
 
&@lock indirect 
 
  INDIRECT LOCKS: 
  
  Key: @<object> 
  
  You may reference the lock on another object and use the result of 
  evaluating that other object's lock.    You pass an indirect lock if you 
  pass the default lock on <object>.  This is especially useful if you 
  have a large number of objects or exits that want to have the same lock, 
  and you want to be able to update one object and have all the other 
  locks change at the same time. 
  
  <object> is searched for when you enter the @lock command and its 
  database number is stored in the lock, so something like 
  '@Lock north=@master.lock' is safe even if you are going to move master.lock 
  to another location. 
  
  Examples: 
    > @lock master.lock = me 
    > @lock north = @master.lock 
    > @lock south = @master.lock 
    North and south all reference the lock on master.lock, so you may change 
    the lock on all three exits by changing master.lock. 
  See also: @lock normal. 
 
&@lock normal 
 
  NORMAL LOCKS: 
  
  Key: <object> 
  
  You pass a normal lock if you either are the named object or if you carry 
  the named object.  <object> may be the name or #number of a thing,  a 
  playername prefixed by an asterisk (*<playername>), 'me', or 'here'. 
  
  Examples: 
    > @lock treasure room = secret key 
    > @lock private area = me 
  See also: @lock is, @lock carry. 
 
&@lock is 
 
  IS LOCKS: 
  
  Key: =<object> 
  
  You pass an is lock only if you are the named object. 
  
  Example: 
    > @lock mystical highway = =magic bus 
    Only the magic bus may travel down the mystical highway.  You cannot 
    travel the highway if you are carrying the bus. 
  See also: @lock carry, @lock normal. 
 
&@lock carry 
 
  CARRY LOCKS: 
  
  Key: +<object> 
  
  You pass a carry lock if you are carrying the named object. 
  
  Example: 
    > @lock secret passage = +magic bus 
    You can only traverse the secret passage if you are carrying the 
    magic bus.  The bus cannot enter the passage on its own (perhaps 
    when you are driving it). 
  See also: @lock is, @lock normal. 
 
&@lock ownership 
 
  OWNERSHIP LOCKS: 
  
  Key: $<object> 
  
  You pass an ownership lock if you have the same owner as <object>. 
  
  Examples: 
    > @lock mystuff=$me 
    Only objects you own may use the mystuff exit. 
  
    > @lock/page me = !$*TinyJerk 
    Neither TinyJerk nor any of his objects may page you. 
  See also: @lock normal. 
 
&@lock compound 
 
  COMPOUND LOCKS: 
  
  Key: <key> & <key> 
       <key> | <key> 
       !<key> 
       ( <key> ) 
  
  You can make complex locks by combining keys with the logical AND and OR 
  operators (& and ! respectively), or by using the NOT operator.  You 
  may also group complex locks with parentheses. 
  
  Examples: 
    > @lock exit = me & !me 
    An impossible lock, nothing can be both you and not you. 
  
    > @lock message = me | *recipient 
    Both you and the player recipient may get the msssage. 
 
&@mail 
 
  @mail[/<switches>] <player-list> = <subject> 
  @mail[/<switches>] [<msg-list> [= <target>]] 
  
  @mail invokes the built-in MUX mailer, which allows players to send 
  and receive mail. Pronoun/function substitution is performed on 
  any messages you may try to send. 
  
  A <player-list> is a space-separated list of recipients, which may be: 
        Player names (names with spaces in them should be put in double 
                      quotes, ex: "Foo Bar") 
        Player dbref #'s 
    Message numbers to be replied to. 
    A mix of the above, and mail aliases (see @malias) 
  
  A <msg-list> is one of the following: 
        A single msg # (ex: 3) 
        A message range (ex: 2-5, -7, 3-) 
        A sender (ex: *lauren) 
        An age of mail in days (ex: ~3 (exactly 3), <2, >1) 
           "days" here means 24-hour periods from the current time. 
        One of the following: "read", "unread", "cleared", "tagged", "urgent" 
        For certain commands, "all". 
  
  See the following topics: 
    mail-sending    mail-reading     mail-folders      mail-other 
    mail-admin      @malias          mail-reviewing    mail-examples 
  
&mail-reviewing 
    
  @mail/review <player> 
    Reviews the messages you have sent to <player>. 
  
  @mail/review <player>=<msglist> 
    Reads the messages you have sent to <player>. 
  
  @mail/retract <player>=<msglist> 
    Retracts (deletes) unread messages you have sent to <player>. 
  
&mail-reading 
  
  @mail <msg #> 
  @mail/read <msg-list> 
        This displays messages which match the msg# or msg-list from 
        your current folder. 
  
  @mail 
  @mail <msg-list, but not a single msg #> 
        This gives a brief list of all mail in the current folder, 
        with sender name, a list of receiving players, subject, and 
        message status. 
  @mail/list [<msg-list>] 
        This gives the same list, but with time sent instead of subject. 
        The status field is a set of characters (ex: NC-UF+) which mean: 
                N = New (unread) message 
                C = Cleared message 
                U = Urgent message 
                F = Forwarded message 
                + = Tagged message 
        The opposites of these (read messages, etc.) are indicated with a 
        '-' in the status field in that position. 
  
&mail-sending 
 
  @mail[/switch] <player-list> = <subject> 
    This begins a message to all players in <player-list>. 
    -<text> adds text to the message in progress, for example 
        -This is a test 
    would add the text 'This is a test' to the end of your @mail 
    message, likewise, ~<text> prepends the text. 
     
  @mail/send 
    This sends the message that is currently in progress. 
    -- is the equivalent of @mail/send. @mail/urgent sends 
    the message as urgent, and should not be used often. 
  
  @mail/cc <player-list> 
        This replaces the currect player list with a new one for carbon 
        copying. It does _not_ add onto the existing list. 
<Continued in HELP @MAIL-SENDING2>
      
&mail-sending2 
  
  @mail/proof 
    This shows you the message that is currently in progress, as 
    it would be read by whomever received it. 
   
  @mail/edit <old text> = <new text> 
    Like @edit, but edits the message in process. 
  
  @mail/abort 
    This aborts the message currently in progress, allowing you 
    to start a new one. 
  
  @mail/fwd <msg> = <player-list> 
        This sends a copy of <msg> to all the players in <player-list>. 
        The copy will appear to have been sent by you (not the original 
        sender), and its status will be "Forwarded". Note that this places 
        the message to be forwarded into your mail buffer, where you can 
        edit it with @mail/edit, add text with '-', or prepend text with 
        '~'. You have to use '--' or @mail/send to send the message. 
  
  @mail/quick <player-list>/<subject> = <message> 
    Sends <message> to the list of players. 
   
&mail-other 
 
  @mail/clear [<msg-list | all>] 
  @mail/unclear [<msg-list> | all>] 
        These commands mark mail in the current folder as cleared or uncleared. 
        Mail marked for clearing is deleted when you disconnect, or 
        if you use @mail/purge. If no msg-list is specified, all 
        mail in your current folder is cleared. If "all" is given instead 
        of a msg-list, all mail in *all* folders is cleared/uncleared. 
  
  @mail/purge 
        Actually deletes all messages marked for clearing with @mail/clear. 
        This is done automatically when you log out. 
  
  @mail/tag [<msg-list | all>] 
  @mail/untag [<msg-list> | all>] 
        These commands tag or untag mail in the current folder. 
        Tagged mail can be later acted on en masse by using "tagged" as 
        the msg-list for other commands (which does *not* untag them 
        afterward). If no msg-list is specified, all messages in the 
        current folder are tagged/untagged. If "all" is given as the 
        msg-list, all mail in *all* folders is tagged/untagged. 
        (Ex: To clear all mail from Lauren and Crusade, @mail/tag *lauren, 
        @mail/tag *crusade, @mail/clear tagged, @mail/untag all). 
 
&mail-folders 
 
  The MUX mail system allows each player 16 folders, numbered from 
  0 to 15. Mail can only be in 1 folder at a time. Folder 0 is 
  the "inbox" where new mail is received. Most @mail commands 
  operate on only the current folder. 
  
  @mail/folder 
        This commands lists all folders which contain mail, telling 
        how many messages are in each, and what the current folder is. 
  
  @mail/folder <folder#|foldername> 
        This command sets your current folder to <folder#>. 
  
  @mail/folder <folder#> = <foldername> 
        This command gives <folder#> a name. 
  
  @mail/file <msg-list>=<folder#> 
        This command moves all messages in msg-list from the current 
        folder to a new folder, <folder#>. 
 
&mail-admin 
  
  The @mail command can also take the following switches: 
  
    @mail/stats [<player>]    --  Basic mail statistics. 
    @mail/dstats [<player>]   --  Also provides read/unread count. 
    @mail/fstats [<player>]   --  Does all that, plus gives space usage. 
  
    @mail/debug <action>[=<player>] 
    @mail/nuke 
  
  Only wizards may stats players other than themselves. The mail statistics 
  commands are computationally expensive, and thus are subject to "daytime" 
  restrictions. They also cost the same as a @find (100 credits). 
  
  The /debug switch does sanity checking on the mail database, and may only 
  be used by a wizard. "@mail/debug sanity" just does the check; the command 
  "@mail/debug clear=<player name or dbref number>" wipes mail for an object. 
  "@mail/debug fix" attempts to repair problems noted in the sanity check. 
  
  The /nuke switch destroys the post office, erasing all @mail everywhere. 
  It may only be used by a wizard. 
  
  Also, admin may set the @amail attrib on their char.  When somebody sends 
  you mail, it will trigger that attrib if it exists. 
 
&mail-examples 
  
  Here is an example of mailing a player, where is the player will be "bob", 
  and sending the mail. 
  
  > @mail bob = The MUX              - This is the Subject line.  
  
  Sending mail to player 'Bob' 
  > -Hi bob.                         - This is where you will enter the body 
                                       of the message. 
  Text Added. 
  > @send                            - Basically, sends the @mail. 
  
  MAIL: You sent your message to 'Bob'.    
  
&@mvattr 
 
  Command: @mvattr <object>=<old>,<new>[,<copy1>]... 
  This command moves attributes around on an object.  The attribute <old> is 
  renamed <new> (and is copied to <copy1>, <copy2> and so on if specified). 
  If you cannot modify the <old> attribute (for instance if you are trying to 
  move the Last attribute, or if it were owned by another player), then a new 
  copy is made and the original is not removed. 
  See also: @set. 
 
&@name 
 
  Command: @name <object> = <new name> 
 
  Changes the name of <object>.  <object> can be a thing, player, exit, or 
  room, specified as <name> or #<dbref> or 'me' or 'here'. 
  
  See '@list options' as to whether or not a player name may contain  
  spaces. 
 
&@notify 
 
  Command: @notify[/<switches>] <object>[=<count>] 
  Notifies the semaphore <object>, running the first command that waited on 
  <object> using the '@wait <object>=<command>' or ' 
  @wait <object>/<time>=<command>' forms of the @wait command.  If <count> is 
  specified, it indicates the number of times the semaphore is notified. 
  If there are no commands (or less than <count> commands) pending for 
  <object>, then subsequent @waits will not block until the semaphore count 
  reaches zero again. 
  
  The following switches are available: 
     /first - (default) Notify the first command waiting on the indicated 
              semaphore (or the first <count> commands). 
     /all   - Notify all commands waiting on the semaphore and reset the 
              semaphore count to zero.  <count> is ignored. 
  
  See also: @drain, @ps, @wait, SEMAPHORES 
 
&@oemit 
 
  Command: @oemit <player>=<message> 
  
  Emits <message> to everyone in the current location of <player> except 
  <player>. 
  
  See also:  @remit, @emit, @pemit, @npemit, SPOOFING. 
 
&@open 
 
  Command: @open[/<switches>] <direction list> [=<number>[,<direction list>]] 
  Creates an exit in the specified direction(s). If <number> is specified, 
  it is linked to that room. Otherwise, it is created unlinked. You or anyone 
  else may use the '@link' command to specify where the unlinked exit leads. 
  Opening an exit costs 1 coin. If you specify <number>, linking costs 1 more 
  coin.  You can specify a second direction list (after the comma), which is  
  automatically opened in the room that the new exit goes TO and which is 
  linked back to where you are.  I.e.  @open north;n=#1234,south;s 
  would open exit 'north;n' from here to #1234, and an exit 'south;s' 
  from #1234 to here, assuming you have rights to open exits and link to 
  the rooms in question. 
  
  The following switches are available: 
     /location  - Create the exit in your location (default). 
     /inventory - Create the exit on yourself. 
  
  See also: @dig, @link, LINKING. 
 
&@parent 
 
  Command: @parent <object> [=<parent>] 
  This command sets the parent of <object> to <parent> (or clears the parent 
  if <parent> is omitted.  You must control <object>, and must own <parent>. 
  See also: PARENT OBJECTS. 
 
&PARENT OBJECTS 
 
  Topic: PARENT OBJECTS 
  
  Parent objects provide a way for several objects to inherit common 
  attributes, exits, and $-commands from a single object, so that changing 
  the parent object affects all of its children.  When searching for 
  attributes or exits, first the object itself is checked, then the parent 
  is checked only if the object does not have what was searched for. 
  
  Any attribute the parent object has will be passed down to its children, 
  if they don't already have one. For instance, if the child object has no 
  description, it will inherit the description of its parent. 
  
  Any exits the parent object has will show up in the exit list of the 
  child, and may be used as normal exits. 
  
  The parent is searched for $-commands as well as the child, and only 
  attributes that are unique to the parent are checked, so that conflicting 
  attribute names are skipped.  If both have an attribute named "cmd1", 
  only the child's "cmd1" attributes is checked for a $-command. 
<Continued in HELP PARENT2>
     
&PARENT2  
 
  Topic: PARENT OBJECTS (continued) 
  
  A parent object may itself have a parent, up to a configurable limit 
  (usually 10 levels).  The parent need not be the same type as its children, 
  and flags and locks are not inherited from parent objects.  You may not 
  create parent loops. 
  
  See also: @parent, parent(). 
 
&@password 
 
  Command: @password <old password> = <new password> 
  
  This command changes your password. 
 
&@pemit 
 
  Command: @pemit[/switches] <what>=<message> 
  Emits <message> only to <what>, or to <what>'s contents of the /contents 
  switch is given.  <what> must be either in the same location as you or 
  be something you own.  You can also @pemit to distant players if 
  pagelocks allow you to page them, and this costs as much as a page 
  <This feature is not present in all MUXes>.  You cannot @pemit to the 
  contents of something you don't own. 
  
  The following switches are available: 
    /contents - Send the message to the contents of the named object. 
    /object   - Send the message to the named object. 
    /list     - Send the message to a list of objects. 
 
  See also: page, @remit, @emit, @oemit, SPOOFING. 
 
&@npemit 
 
  Command: @npemit[/switches] <what>=<message> 
  No parse @pemit. Exactly like @pemit, takes the same switches, except it 
  does not evaluate <message>.  
  
  See also: page, @pemit, @remit, @emit, @oemit, SPOOFING. 
  
&@power 
 
  Command: @power <object>=[!]<power> 
  
  This is a command that allows the granting of special powers to objects of 
  any type. 
  
  See also: powers list 
   
&powers list 
MUX POWERS LIST: 
 
  announce      Can use the @wall command. 
  boot          Can use the @boot command. 
  builder       Can build, if the builder power is enabled. 
  chown_anything    Can @chown anything to anyone. 
  comm_all      Like a wizard with respect to channels. 
  control_all       Can modify any object in the database. 
  expanded_who      Sees the wizard WHO, and SESSION commands. 
  find_unfindable   Can locate unfindable people. 
  free_money        Unlimited money. 
  free_quota        Unlimited quota. 
  guest         Is this a guest character? 
  halt          Can @halt anything, and @halt/all. 
  hide          Can set themselves DARK. 
  idle          No idle timeout. 
  long_fingers      Can get, look, whisper, etc from a distance. 
<Continued in HELP POWERS LIST2>
      
&powers list2 
  monitor       Can set or reset monitor flag. 
  poll          Can set the @poll. 
  prog          Can use @program on players other than themself. 
  search        Can @search anyone. 
  see_all       Can examine and see attributes like a wizard. 
  see_queue     Can @ps/all or @ps any player. 
  stat_any      Can @stat any player. 
  steal_money       Can give negative money. 
  tel_anywhere      Can teleport anywhere. 
  tel_anything      Can teleport anything (includes tel_anywhere) 
  unkillable        Cannot be killed with the 'kill' command. 
  
  See also: @power 
  
&@program 
  Command: @program <player>=<obj/attr>[:<prefix>] 
   
  This command allows for small 'programs' within MUX. To understand this 
  command, you must first understand the fact that it completely bypasses any 
  commands, built-in or otherwise, and allows you to send user-input directly 
  into your code. 
  
  A simple example: 
  
  @vb me=$start:@prog %#=me/vb:Please enter a word: 
  @vb me=@emit You entered %0!;@prog %#=me/vc:Please enter another word: 
  @vc me=@emit This time, you entered %0. You're done! 
  
  > start 
  Please enter a word: 
  > foobar          (Note that @program literally gives you a '>' 
                                 prompt.) 
  You entered foobar! 
  Please enter another word: 
  > hoopla 
  This time you entered hoopla. You're done! 
<Continued in HELP @PROGRAM2>
      
&@program2 
  
  As you can see, this command basically takes what a user types at the 
  prompt, stuffs it into %0 in the code in <obj/attr>, and then triggers 
  that attribute. Note that when @program triggers an attribute, the enactor 
  of that triggered attribute is <player>, and is inserted into %#. 
  r-registers are preserved when @program triggers an attribute. 
  
  An optional message, <prefix>, may be specified and will be output before 
  the @program prompt. This is useful for telling the user what information 
  they need to supply. 
  
  A player caught in @program may send a command through to the normal 
  command processor at the @program prompt by prefixing it with the '|' 
  character, for example, '|WHO'. 
  
  See also: @quitprogram. 
 
&@ps 
  Command: @ps[/<switches>] [<object>] 
  Lists information about the commands you have on each of the queues. 
  Unless the /summary switch is used, this command lists all the commands you 
  have on the queues, optionally along with their enactor and arguments. 
  Commands scheduled to be executed at a later time (by the @wait command) 
  also show the number of seconds until they will be executed and/or the 
  semaphore on which they are waiting.  If <object> is specified, only 
  commands run by <object> are listed, otherwise all commands run by any of 
  your objects is listed.  A summary of the number of commands listed and the 
  total number of commands in the queues is also displayed.  This command is 
  useful for identifying infinite loops in programs. 
  
  The following switches are available: 
     /brief   - (default) Display a brief summary that shows the semaphore 
                number, time-to-wait, object running the command, and the 
                command to be run. 
     /long    - In addition to the information in the /brief report, display 
                the name and number of the object that caused the command 
                to be run (the enactor) and the arguments to the command. 
     /summary - Display just the queue counts. 
  
  See also: @notify, @wait. 
 
&@quitprogram 
  
  Command: @quitprogram <player> 
  Terminates the @program for player. If <player> is not specified, then it 
  works upon the enactor (a player may quit a program while they are in it 
  by piping out @quitprogram, see 'help @program'). 
  
  See also: @program. 
  
&@quota 
 
  Command: @quota 
  Lists your total building quota and the amount you have remaining. 
  Creating objects, digging rooms, and opening exits all consume quota. 
  See also: @create, @dig, @open. 
 
&@robot 
 
  Command: @robot <name>=<password> 
  Creates a robot player owned by you.  The robot has its ROBOT flag set, so 
  it may use the OUTPUTPREFIX and OUTPUTSUFFIX commands that most publicly 
  available robot programs require.  This command costs 1000 coins. 
  Note that some sites do not restrict OUTPUTSUFFIX and OUTPUTPREFIX to 
  robots. 
  See also: OUTPUTPREFIX, OUTPUTSUFFIX, ROBOT, TYPES OF OBJECTS. 
 
&@search 
 
  Command: @search [<player>] [<class>=<restriction>[,<low>[,<high>]]] 
  
  Displays information about objects that meet the search criteria. 
  Because this command is computationally expensive, it costs 100 coins. 
  <player> restricts the search to the named player, while <class> 
  and <restriction> control the objects listed.  Type 'help search classes' 
  for a list of the classes you may use. 
 
  Except when getting lists of players ('@search type=player' or 
  '@search flags=P'), you may only search for objects that you own. 
  You may limit the range of the search with <low> and <high>, which specify 
  the objects to start and stop the search at, respectively.  The default for 
  <low> is #0 and the default for <high> is the last object in the database. 
  
  Examples: 
    @search flags=PWc              <-- search for connected wizards. 
    @search type=room              <-- list all rooms owned by me. 
    @search eval=gt(money(##),10)  <-- search for things worth more than 10. 
    @search type=room,100,300      <-- Rooms between #100 and #300, inclusive 
    @search object=Test,5000       <-- Things starting with Test from object 
                                       #5000 to the end of the database. 
  See also: @find, search(). 
 
&@set 
 
  Command: @set[/<switch>] <object>=[!]<flag> 
           @set[/<switch>] <object>=<attribute>:<value> 
           @set[/<switch>] <object>=<attribute>:_<fromobj>/<fromattr> 
           @set[/<switch>] <object>/<attr>=[!]<attrflag> 
  
  The first form sets (or clears) the indicated flag on <object>, the 
  second form sets the <attribute> attribute on <object> to <value>, 
  creating a new user-named attribute if there is no attribute named 
  <attribute>.  The third form copies an attribute from another object, and 
  the fourth form sets (or clears) an attribute flag on the <attr> attribute 
  of <object>. 
  
  When setting attributes on an object, you may also use the command 
  '@<attribute> <object> = <value>' if the attribute is a predefined 
  attribute.  You may also use the command '&<attribute> <object> = <value>' 
  to set either predefined attributes or user-named attributes.  Either of 
  these is equivalent to the second form of the @set command. 
<Continued in HELP @SET2>
     
&@set2 
 
  The following flags may be set using the fourth form of the @set command: 
     no_command - Prevent $-commands and ^-patterns defined in the attribute 
                  from being performed. 
     no_inherit - Prevents children of the object from obtaining the  
                  attribute.  From their perspective the attribute does not 
                  exist. 
     visual     - Anyone may see the attribute when they examine you, and 
                  may get the attribute with get(). 
     hidden     - The attribute is only visable to wizards. 
     wizard     - The attribute may only be changed by wizards. 
  
  The @set command takes the following switch: 
     quiet      - Inhibit 'Set.' acknowledgement messages. 
  
  See also: @lock, @lock, examine, FLAGS, &. 
 
&@stats 
 
  Command: @stats[/all] [<player>] 
  Display the number of objects in the game.  @stats/all gives a 
  breakdown by object types.  If <player> is specified, the breakdown 
  for the named player is given.  You may only list individual counts 
  for yourself.  If invoked with no arguments or switches this command is 
  free, but if you specify either /all or <player>, then this  command costs 
  100 coins to run, because it is computationally expensive. 
  See also: stats(). 
 
&@sweep 
 
  Command: @sweep[/<switches>] 
  This command tells you all of the objects, players, and exits that are 
  listening in the room you are currently in, as well as the objects you are 
  carrying.  Most objects only listen for a particular string or phrase, so 
  they normally do not pose a problem if you need privacy.  You will have to  
  be careful of players, puppets, and audible exits since they will hear 
  everything you say and do.  There are several switches that may be used to 
  limit the type of listeners that are checked for.  They are: 
     /here      - Check the room I am in. 
     /inventory - Check my inventory. 
     /exits     - Check exits in the room. 
  
     /commands  - Check for objects that have $-commands set on them. 
     /connected - Check for connected players and their puppets. 
     /listeners - Check for objects with @listen set to something. 
     /players   - Check for players and their puppets, whether or not they 
                  are connected. 
  
  The default is to search for everything.  If you specify one or more 
  switches from either category (either location or listener type then only 
  that location or listener type is checked. 
  See also: @listen, AUDIBLE, PUPPETS. 
 
&@switch 
 
  Command: @switch[/<switches>] <string>=<t1>,<c1> [,<tN>,<cN>]... [,<cD>] 
  Compares <string> against the targets <t1>, <t2>, etc, until a match is 
  found, at which time the corresponding list of commands is performed. 
  Wildcards, and the < and > operators are allowed in the targets.  By 
  default, any list whose target matches the string is executed (the targets 
  are not mutually exclusive). If no target matches, the default list 
  <cD> is executed. 
  
  The following switches are available: 
     /all   - (default) Perform the actionlists associated with all targets 
              that match <string>. 
     /first - Perform only the actionlist associated with the first target 
              that matches <string>. 
 
&@teleport 
 
  Command: @teleport [<object>=] <room/thing> 
           @teleport [<object>=] <exit> 
           @teleport [<object>=] home 
  
  The first form of the @teleport command moves <object> (or you) to the named 
  room or thing.  The second form sends <object> (or you) to the destination 
  of the named exit, while the third form sends <object> (or you) home. 
  If the destination room has a drop-to, the object will go to the drop-to 
  instead of the named location. 
 
  For the first form of the @teleport command, the object being teleported  
  must pass its location's TeloutLock; and you must control the destination, 
  or it must be JUMP_OK and you must pass the destination's TportLock. 
  
  The second and third forms let you remove any object from locations you 
  control by sending them through an exit or to their home. 
 
  The following switch is available: 
     /quiet - Teleports without setting off success or failure messages. 
  
  See also: JUMP_OK, @lock (tport and telout), @tfail, @otfail, @atfail, 
    @tofail, @otofail, @atofail. 
 
&@trigger  
 
  Command: @trigger[/<switch>] <object>/<attr> [=<param> [, <param>]... ] 
  Invokes an action list stored in an attribute on an object.  The triggering 
  object becomes the enactor and the positional parameters %0 through %9 
  are set to the supplied parameters. 
  
  The @trigger command supports the following switch: 
     quiet      - Inhibit 'Triggered.' acknowledgement messages. 
  
  See also: LOOPING. 
 
&@unlink 
 
  Command: @unlink <room/exit> 
  This command removes drop-tos on rooms and clears the destination on exits. 
  Once unlinked, an exit may be taken over by anyone with the @link command. 
  See also: @link, LINKING. 
 
&@unlock 
 
  Command: @unlock <object> 
           @unlock <object>/<attrib> 
  The first form removes the lock on <object>, so that anyone may pass 
  through (if an exit) or pick it up (if a player or an object). 
  
  The second form clears the locked flag on the indicated attribute of the 
  named object.  This allows the attribute to change ownership to the new 
  owner automatically when the object is @chowned, and allows the owner 
  of the object to @chown the attribute to themself or to overwrite it. 
  You must own the attribute to be unlocked, but you do not need to own the 
  object. 
  See also: @chown, @lock, ATTRIBUTE OWNERSHIP. 
 
&@verb 
 
  Command: @verb <victim>=<actor>,<what>,<def>,<owhat>,<odef>,<awhat>,<args> 
  
  This command provides a way to do user-defined verbs with associated 
  @attr/@oattr/@aattr groups. Invoking it does the following: 
   
  <actor> sees the contents of <victim>'s <what> attribute, or 
    the <def> string if you can't read <victim>'s <what> attribute. 
  Everyone in the same room as <actor> sees the contents of 
    <victim>'s <owhat> attribute, with <actor>'s name prepended, 
    or <odef>, also with <actor>'s name prepended, if you can't read 
    <victim>'s <owhat> attribute. 
  If you control <victim>, then he executes the contents of his <awhat> 
    attribute. 
   
  By supplying up to nine <args>, you may pass those values on 
  the stack (i.e. %0, %1, %2, etc. up through %9). 
  
  You must control the actor, but need not control the victim.  Note that 
  if you don't have the ability to read the appropriate attributes (whether 
  because you control the victim, he is VISUAL, or the attributes are set 
  VISUAL), the default messages will be used. 
<Continued in HELP @VERB2>
     
&@verb2 
 
  Here is a description of the arguments to @verb: 
    victim - The object that is searched for attributes, and which runs the 
             <awhat> attribute if it is found. 
    actor  - The object that 'did' the verb, this is the value for %#/%n/etc 
             in substitutions, and this object's name is included in the 
             message to others in the same location. 
    what   - The name of the attribute containing the message to be delivered 
             to the actor. 
    whatd  - The message to deliver to the actor if the victim does not have a 
             <what> attribute, or if it cannot be read. 
    owhat  - The name of the attribute containing the message (prefixed by the 
             actor's name) that is sent to everyone in the room with the actor. 
    owhatd - The message (prefixed by the actor's name) to deliver to others 
             in the room with the actor if the victim does not have an <owhat> 
             attribute, or it cannot be read. 
    awhat  - The name of the attribute that is to be executed by the victim. 
    args   - The comma-separated arguments to be passed for substitution 
             (%0-%9).  If there is more than one argument, enclose all the 
             arguments within curly braces.  Any argument that contains an 
             embedded comma needs to be enclosed in curly braces as well. 
<Continued in HELP @VERB3>
     
&@verb3 
 
  Examples: 
    > &xtest test1=You just xtested test1. 
    > &oxtest test1=just xtested test1. 
    > &axtest test1="I was xtested.  Yikes.  Arg1=%0, Arg2=%1, Arg3=%2. 
    > @verb test1=me,xtest,XTEST DFLT,oxtest,OXTEST DFLT,axtest,{a,b c,de} 
    You just xtested test1. 
    test1 says "I was xtested. Yikes. Arg1=a, Arg2=b c, Arg3=de." 
    > &xtest test1 
    > @verb test1=me,xtest,XTEST DFLT,oxtest,OXTEST DFLT,axtest,{a,b c,de} 
    XTEST DFLT 
    test1 says "I was xtested. Yikes. Arg1=a, Arg2=b c, Arg3=de." 
    > @fo test1={@verb test1=me,xtest,XTEST D,oxtest,OXTEST D,axtest,{a,b,de}}  
    test1 just xtested test1. 
    test1 says "I was xtested. Yikes. Arg1=a, Arg2=b, Arg3=de." 
  See also: locate(). 
 
&@wait 
 
  Command: @wait <seconds>=<command> 
           @wait <object>[/<seconds>]=<command> 
  The first form of @wait executes <command> after <seconds> seconds.  The 
  second form increments the semaphore count for <object> and executes 
  <command> after <object> is notified with the @notify command.  If the 
  semaphore count for <object> is negative (because it has been notified more 
  times than it has been waited on), then <command> is run immediately. 
  If <seconds> is specified in the second form, the command is automatically 
  run after <seconds> seconds even if the semaphore isn't notified.  This 
  command charges a deposit of 10 coins, which is refunded when <command> 
  is executed. 
  See also: @drain, @notify, @ps, SEMAPHORES. 
 
&@wipe 
 
  Command: @wipe <object>[/<wild-attr>] 
  
  This command erases attributes from an object.  All attributes that match 
  <wild-attr> (or all attributes, if <wild-attr> is not specified) are removed 
  from <object>.  Attributes that you do not have permission to modify (such 
  as read-only or locked attributes) are not removed. 
 
&@aahear 
 
  Command: @aahear <object> = <command-list> 
  Attribute: Aahear 
  
  An Aahear on an object is activated whenever the listen pattern 
  matches anything done/said by anything else in the room, including 
  itself.  (The Ahear ignores itself, helpful for keeping machines from  
  triggering itself) 
  
  Example: @aahear listener = "I heard someone (maybe me?) say the word! 
  See also: @ahear, @amhear, @listen. 
 
&@aclone 
 
  Command: @aclone <object> = <command-list> 
  Attribute: Aclone 
  
  Sets the actions to be taken by a new object that has just been created 
  as the result of a @clone command.  The contents of the Aclone attribute 
  are run by the new object and not by the old object. 
  
  This attribute is only meaningful for things, and will never be 
  automatically triggered on other object types. 
  It is also possible to check the zone object/objects in the zone parent 
  room for an @adisconnect. If one is found, it will be executed when a  
  player disconnects in that zone. 
   
  Example: @aclone Time bomb = @wait 600=@trig me/va;@wait 10=@trig me/vb 
           @va time bomb = :EXPLODES with a thundering roar;@destroy me 
           @vb time bomb = :ticks.; @wait 10=@trig me/vb 
  See also: @clone. 
 
&@aconnect 
 
  Command: @aconnect <object> = <command-list> 
  Attribute: Aconnect 
  
  Sets the actions to be taken by a player right after connecting to the 
  game.  This attribute is only meaningful for players, and will never be 
  automatically triggered on other object types. 
  It is also possible to check the zone object/objects in the zone parent 
  room for an @aconnect. If one is found, it will be executed when a player 
  connects in that zone. 
   
  Example: @aconnect me = check.my.mailbox 
  See also: @adisconnect. 
 
&@adescribe 
 
  Command: @adescribe <object> = <command-list> 
  Attribute: Adescribe 
  
  Sets the actions to be taken when <object> is looked at. 
  
  Example: @adesc kitten = :rubs against %n's legs affectionately. 
  See also: look, @desc, @idesc, @odesc. 
 
  See also "help think" 
 
&@adfail 
 
  Command: @adfail <object> = <command-list> 
  Attribute: Adfail 
  
  Sets the action to be taken by an object when someone tries to drop it 
  but fails because they didn't pass the object's drop lock. 
  
  Example: @adfail sword = @name me=Cursed Sword;:laughs maniacally. 
  See also: drop, @dfail, @odfail, @lock. 
 
&@adisconnect 
 
  Command: @adisconnect <object> = <command-list> 
  Attribute: Adisconnect 
  Sets the actions to be taken by a player right after disconnecting from 
  the game. 
  
  This attribute is only meaningful for players, and will never be 
  automatically triggered on other object types. 
  
  Example: @adisconnect me = home 
  See also: @aconnect. 
 
&@adrop 
 
  Command: @adrop <object> = <command-list> 
  Attribute: Adrop 
  
  Sets the action to be taken by an object when it is dropped, or by an exit 
  when it is successfully used. 
  
  Example: @adrop plastique = kill %n=100; @destroy me 
  See also: drop, @drop, @odrop, DROP-TO, EXITS. 
 
&@aefail 
 
  Command: @aefail <object> = <command-list> 
  Attribute: Aefail 
  
  Sets the action to be taken by an object when someone tries to enter it 
  but fails because the object is not ENTER_OK or the player fails the 
  object's enter lock. 
  
  The enter lock only affects the 'enter' command and its aliases (set via 
  the @ealias command), it does not affect exits that lead to the object or 
  teleporting in. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically triggered on rooms or exits. 
  
  Example: @aefail car = @emit ;'s alarm starts wailing when %n tries 
                         to break in. 
  See also: @aenter, @efail, @ealias, @enter, @oefail, @oenter, enter, 
            ENTER_OK. 
 
&@aenter 
 
  Command: @aenter <object> = <command-list> 
  Attribute: Aenter 
  
  Sets the action to be taken by an object or room when someone enters it, 
  whether by using an exit, the enter or leave commands, or by teleporting. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @aenter car = :starts its engine, eagerly awaiting a road trip.; 
                         "Beep Beep! 
  See also: enter, @enter, @oenter, ENTER_OK. 
 
&@afail 
 
  Command: @afail <object> = <command-list> 
  Attribute: Afail 
  
  Sets the commands to be performed by <object> when one of these events 
  occurs: 
  
    - For exits: Someone tries to traverse the exit but cannot because they 
      fail the exit's default lock or the exit is not linked. 
    - For players and things: Someone tries to pick up the object but cannot 
      because they fail the object's default lock. 
    - For rooms, players, and things: Someone looks around inside the room, 
      player, or thing and fails the object's default lock. 
  
  Example: 
    > @afail vase = :falls to the floor and smashes to pieces.;@destroy me 
  See also: @fail, @ofail, FAILURE. 
 
&@agfail 
 
  Command: @agfail <object> = <command-list> 
  Attribute: Agfail 
  
  Sets the action to be taken by an object when someone tries to give it 
  away but fails because they didn't pass the object's give lock. 
  
  Example: @agfail sword = @name me=Cursed Sword;:laughs maniacally. 
  See also: give, @gfail, @ogfail, @lock. 
 
&@ahear 
 
  Command: @ahear <object> = <command-list> 
  Attribute: Ahear 
  
  Sets the actions to be taken after the object hears a string that matches 
  the pattern in the Listen attribute which was not produced by the object 
  itself.  Messages that are produced by the object itself are ignored. 
  
  Example: @ahear clock = "The time is now [time()].  >> BONNNNGGGGG << 
  See also: @aahear, @amhear, @listen. 
 
&@akill 
 
  Command: @akill <object> = <command-list> 
  Attribute: Akill 
  
  Sets the actions to be taken by an object after it is killed and has 
  returned to its home. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @akill lion = south; :leaps onto %n, roaring loudly.;kill %n=100 
  See also: kill, @kill and @okill, BEING KILLED, IMMORTAL, WIZARD. 
 
&@aleave 
 
  Command: @aleave <object> = <command-list> 
  Attribute: Aleave 
  
  Sets the action to be taken by an object or room when someone leaves it, 
  whether by using an exit, the enter or leave commands, or by teleporting. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @aleave car = :stops to let %n out.;:revs its engine, hoping 
                         another brave soul would like a ride. 
  See also: leave, @leave, @oleave. 
 
&@alfail 
 
  Command: @alfail <object> = <command-list> 
  Attribute: Alfail 
  
  Sets the action to be taken by an object when someone tries to leave it 
  but fails because the player fails the object's leave lock. 
  
  The leave lock only affects the 'leave' command and its aliases (set via 
  the @ealias command), it does not affect going home, using an exit in the 
  location, or teleporting out. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically triggered on rooms or exits. 
  
  Example: @alfail box = :rattles around as %n tries to escape. 
  See also: @aleave, @lalias, @leave, @lfail, @oleave, @olfail, leave. 
 
&@alias 
 
  Command: @alias <player> = <name> 
  Attribute: Alias 
  
  Provides an alternate name by which the player is known.  The alternate 
  name is only used for players when referenced as '*<name>' or by commands 
  that only take playernames (such as page or @stats).  You may not set 
  an alias on any other object type. 
  
  When setting an alias, the alias is checked to see that it is both a legal 
  player name and not already in use.  Only if both checks succeed is the 
  alias set. 
  
&@amail 
 
  Command: @amail <player> = <command-list> 
  Attribute: Amail 
  
  Sets the actions to be taken after a player receives @mail. This should 
  *never* @mail another player, as this could cause an infinite loop. 
  
  Example: @amail me=@mail/file [mail()]=2 
           This would place all incoming messages in folder #2. 
  See also: @mailsucc, @signature, @mail. 
  
&@mailsucc 
 
  Command: @mailsucc <player> = <message> 
  Attribute: Mailsucc 
  
  Sets a message to be displayed to the sender whenever <player> receives 
  mail. 
  
  Example: @mailsucc me=Thanks for the mail. 
  See also: @amail, @signature, @mail. 
  
&@signature 
 
  Command: @signature <player> = <message> 
  Attribute: Signature 
  
  Sets a message to be appended to ever @mail message you send. It is 
  appended directly at the end of the message, so if you wish to start the 
  signature on a new line you should begin it with a %r. 
  
  Example: @signature me=%rThis is a mail signature. (Note: You might want  
  to include the %r at the front of the signature, other wise it will be  
  combined with the @mail message.) 
 
  See also: @mailsucc, @amail, @mail. 
  
&@amhear 
 
  Command: @amhear <object> = <command-list> 
  Attribute: Amhear 
  
  Sets the actions to be taken after the object hears a string that matches 
  the pattern in the Listen attribute which was produced by the object 
  itself. 
  Messages that are produced by anything other than the object itself are 
  ignored. 
  
  Example: @amhear listener = "Wait a minute.  I said the trigger word! 
  See also: @aahear, @ahear, @listen. 
 
&@amove 
 
  Command: @amove <object> = <command-list> 
  Attribute: Amove 
  
  Sets the action to be taken by an object whenever it moves from one  
  location to another, whether by using an exit, entering or leaving an 
  object, teleporting, or going home. 
  
  This attribute is meaningful for players, and things and will never be 
  automatically triggered on other object types. 
  
  Example: @amove car = @vz me=[extract(%vz,1,19)] [loc(me)] 
  See also: @move, @omove. 
 
&@apay 
 
  Command: @apay <object> = <command-list> 
  Attribute: Apay 
  
  Sets the actions to be taken after the object is given the number of coins 
  specified in its Cost attribute.  If the giver tries to give more than that 
  number of coins, the excess is refunded, and if less than the necessary 
  amount is given then it is all given back and a snide message is sent to 
  the giver. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @apay Coke machine = @clone Can of Coke; :drops a can on the 
                                floor. 
  See also: give, @cost, @opay, @pay. 
 
&@arfail 
 
  Command: @arfail <object> = <command-list> 
  Attribute: Arfail 
  
  Sets the action to be taken by an object when someone tries to give it 
  something that fails its give lock. 
  
  Example: @arfail merchant = "I don't buy such junk.  Begone!; 
                              @tel %#=cheater_exit 
  See also: give, @agfail, @gfail, @ogfail, @orfail, @rfail, @lock. 
 
&@asuccess 
 
  Command: @asuccess <object> = <command-list> 
  Attribute: Asucc 
  
  Sets the actions to be taken by an object when someone successfully picks 
  it up (because they passed the lock), by an exit when someone passes 
  through it, or when someone looks at a room and passes the room's lock. 
  
  Example: @asucc kitten = :climbs up your sleeve and nuzzles your face. 
  See also: @osucc, @success, SUCCESS. 
 
&@atfail 
 
  Command: @atfail <object> = <command-list> 
  Attribute: Atfail 
  
  Sets the action to be taken by an object when someone tries to teleport 
  there but fails. 
  
  Example: @atfail here = @page [owner(me)]=%N tried to teleport here. 
  See also: @teleport, @tfail, @otfail, @lock. 
 
&@atofail 
 
  Command: @atofail <object> = <command-list> 
  Attribute: Atofail 
  
  Sets the action to be taken by an object when someone tries to teleport 
  out but fails. 
  
  Example: @atofail here = @page [owner(me)]=%N tried to teleport out. 
  See also: @teleport, @tofail, @otofail, @lock. 
 
&@atport 
 
  Command: @atport <object> = <command-list> 
  Attribute: Atport 
  
  Sets the actions to be performed by object whenever it teleports. 
  The actions are performed after the object moves to its new location. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
   
  Example: @atport me = &TEL.COUNT me=add(v(TEL.COUNT),1) 
  
  See also: @otport, @oxtport, @tport, @teleport. 
 
&@aufail 
 
  Command: @aufail <object> = <command-list> 
  Attribute: Aufail 
  
  Sets the list of commands to be run when someone 'use's the object but 
  fails the object's use lock.  Note that the other functions controlled 
  by the use lock (paying, listening, and $-commands) do not trigger 
  Aufail. 
  
  Example: @aufail robot = "I _told_ you to leave me alone; kill %n=100 
  
  See also: @oufail, @ufail, @use. 
 
&@ause 
 
  Command: @ause <object> = <command-list> 
  Attribute: Ause 
  
  Sets the actions to be taken when someone uses the object with the use 
  command. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @ause grenade = :EXPLODES with a thundering roar; kill %n=100; 
                           @destroy me 
  See also: use, @ouse, @use. 
 
&@away 
 
  Command: @away <object> = <message> 
  Attribute: Away 
  
  This attribute is sent as a message to anyone who tries to page you when  
  you are not connected. 
  
  This attribute is only meaningful for players, and will never be 
  automatically referenced on other object types. 
  
  Example: @away me = Hey, I'm not even connected.  So why are you paging me? 
  See also: @idle, @reject, page. 
 
&@charges 
 
  Command: @charges <object> = <count> 
  Attribute: Charges 
  
  This attribute allows you to limit the number of times an object can be 
  used.  If there is a charges attribute it is decremented each time an 
  action on the object is triggered.  Once it reaches zero, normal triggering 
  stops and the Runout attribute (if one is present) is run instead. 
  
  Example: @charges Fireball wand = 5 
  See also: @runout. 
 
&@cost 
 
  Command: @cost <object> = <amount> 
  Attribute: Cost 
  
  Sets the number of coins that need to be given to an object to trigger the 
  Pay, Opay, and Apay attributes.  If the object is given more than this 
  amount, the excess is returned to the giver, while if less than this amount 
  is given the entire amount is returned, a snide message is sent to the 
  giver, and the Apay, Opay, and Pay attributes are not used. 
  
  This attribute is only meaningful for things, and will never be 
  automatically triggered on other object types. 
  
  Example: @cost Coke machine = 25 
  See also: give, @apay, @opay, @pay. 
 
&@daily 
  
  Command: @daily <object>=<command-list> 
  Attribute: Daily 
  
  This attribute is automatically triggered once per day. No guarantees are 
  made as to what time it will execute. 
  
&@describe 
 
  Command: @describe <object> = <description> 
  Attribute: Desc 
  
  Sets the description for <object>, which others see when they look at the 
  object.  Giving all your objects, rooms, and exits good descriptions is 
  considered to be good building practice. 
  
  Function references and %-substitutions are allowed in descriptions, and 
  are evaluated when someone looks at the object.  In function references, 
  'me' refers to the object being looked at, while %-substitutions that refer 
  to the enactor (such as %n, %#, %p, etc) refer to the looker. 
  
  Examples: 
    <object> @desc vase = You see a delicate Ming vase. 
    <exit>   @desc elevator = There is an elevator to the east. 
  See also: look, @adescribe, @odescribe. 
 
&@dfail 
 
  Command: @dfail <object> = <message> 
  Attribute: Dfail 
  
  Sets the message that a player sees when he tries to drop the object but 
  fails because he didn't pass the object's drop lock. 
  
  Function references and %-substitutions are allowed in drop failure 
  messages, and are evaluated when someone drops the object.  In function 
  references, 'me' refers to the object being dropped, while %-substitutions 
  that refer to the enactor (such as %n, %#, %p, etc) refer to the dropper. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @dfail sword = The sword has welded itself to your hand. 
  See also: drop, @adfail, @odfail, @lock. 
 
&@drop 
 
  Command: @drop <object> = <message> 
  Attribute: Drop 
  
  Sets the message that a player sees when he drops the object, or after he 
  goes through the exit. 
  
  Function references and %-substitutions are allowed in drop messages, and 
  are evaluated when someone drops the object.  In function references, 
  'me' refers to the object being dropped, while %-substitutions that refer 
  to the enactor (such as %n, %#, %p, etc) refer to the dropper. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Examples: <object> @drop vase = You gently put down the delicate vase. 
            <exit>   @drop elevator = The elevator doors close behind you. 
  See also: drop, @adrop, @odrop, DROP-TO, EXITS. 
 
&@ealias 
 
  Command: @ealias <object> = <entrance-list> 
  Attribute: Ealias 
  
  Sets up a set of alternate commands that may be used as synonynms for the 
  command 'enter <object>' when you are in the same location as the object. 
  The alternate commands are separated by semicolons just like in exit names. 
  
  Entry aliases are checked for after exitnames, builtin MUX commands, and 
  leave aliases for the current location, but before $-commands.  If more than 
  one object has an entry alias that matches a player's command, the one on 
  the object that occurs first in the location contents list is used. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically looked at on rooms or exits. 
  
  Example: @ealias car = get in car; car; climb in; go for a ride 
  See also: @lalias, enter, leave. 
 
&@efail 
 
  Command: @efail <object> = <command-list> 
  Attribute: Efail 
  
  Sets the message that a player sees when he tries to enter the object but 
  fails because the object is not ENTER_OK or the player fails the 
  object's enter lock. 
  
  Function references and %-substitutions are allowed in efail messages, and 
  are evaluated when someone fails to enter the object.  In function 
  references, 'me' refers to the object that the enactor tried to enter, while 
  %-substitutions that refer to the enactor (such as %n, %#, %p, etc) refer to 
  the the player who tried (and failed) to enter. 
  
  The enter lock only affects the 'enter' command and its aliases (set via 
  the @ealias command), it does not affect exits that lead to the object or 
  teleporting in. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically triggered on rooms or exits. 
  
  Example: @efail car = The car's door is locked. 
  See also: @aefail, @aenter, @ealias, @enter, @oefail, @oenter, enter, 
            ENTER_OK. 
 
&@enter 
 
  Command: @enter <object> = <message> 
  Attribute: Enter 
  
  Sets the message that a player sees when entering an object or room, 
  whether by using an exit, the enter or leave commands, or by teleporting. 
  
  Function references and %-substitutions are allowed in enter messages, and 
  are evaluated when someone enters the object.  In function references, 
  'me' refers to the object being entered, while %-substitutions that refer 
  to the enactor (such as %n, %#, %p, etc) refer to the player entering the 
  object. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @enter car = You climb into the car and buckle your seatbelt. 
  See also: enter, @aenter, @oenter, ENTER_OK. 
 
&@fail 
 
  Command: @fail <object> = <message> 
  Attribute: Fail 
  
  Sets the failure message for <object>.  This message is seen by the actor 
  when one of these events occurs: 
  
    - For exits: Someone tries to traverse the exit but cannot because they 
      fail the exit's default lock or the exit is not linked. 
    - For players and things: Someone tries to pick up the object but cannot 
      because they fail the object's default lock. 
    - For rooms, players, and things: Someone looks around inside the room, 
      player, or thing and fails the object's default lock. 
  
  Substitution and evaluation is performed on the message before it is shown. 
  
  Example: 
    > @fail table = It's too heavy to lift!                            <thing> 
    > @fail doorway = The doorknob does not turn.                       <exit> 
  See also: get, @afail, @ofail, FAILURE. 
 
&@filter 
 
  Command: @filter <object> = <pattern>[, <pattern>...] 
  Attribute: Filter 
  
  This attribute specifies a series of patterns to be used to suppress 
  text normally forwarded by the AUDIBLE flag.  If the desired pattern 
  contains a comma, the pattern may be enclosed in curly braces {}. 
  
  Example: 
    > @fo test=out 
    > @set #378=puppet 
    test> test grows ears and can now hear. 
    > @filter out = {* has arrived.},{* has left.} 
    Set. 
    > :has not arrived. 
    Wizard has not arrived. 
    test> From a distance, Wizard has not arrived. 
    > :has arrived. 
    Wizard has arrived. 
  See also:  AUDIBLE, @forwardlist, @infilter, @inprefix, @prefix. 
 
&@forwardlist 
 
  Command: @forwardlist <object> = <dbref-list> 
  Attribute: Forwardlist 
  
  Specifies a list of locations (specified by their db numbers) that are to 
  receive messages heard by <object> (filtered by the @filter attribute and 
  prefixed by the @prefix attribute).  The messages are only forwarded if 
  <object> has its AUDIBLE flag set. 
  See also: @filter, @prefix, AUDIBLE. 
 
&@gfail 
 
  Command: @gfail <object> = <message> 
  Attribute: Gfail 
  
  Sets the message that a player sees when he tries to give away the object 
  but fails because he didn't pass the object's give lock. 
  
  Function references and %-substitutions are allowed in give failure 
  messages, and are evaluated when someone tries to give away the object. 
  In function references, 'me' refers to the object being given away, while 
  %-substitutions that refer to the enactor (such as %n, %#, %p, etc) refer 
  to the (attempted) giver. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @gfail sword = You can't give away a cursed sword! 
  See also: give, @agfail, @ogfail, @lock. 
 
&@idesc 
 
  Command: @idesc <object> = <message> 
  Attribute: Idesc 
  
  Sets the internal description for <object>.  The internal description of an 
  object will be shown to any player entering it.  If not set, the regular 
  description in the Desc attribute is shown instead. 
  
  Function references and %-substitutions are allowed in inside descriptions, 
  and are evaluated when someone fails to get or look at the object.  In 
  function references, 'me' refers to the object being looked at, while 
  %-substitutions that refer to the enactor (such as %n, %#, %p, etc) 
  refer to the player doing the looking. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @idesc car = You are sitting in the driver's seat of a Volkswagen 
                        Beetle. 
  See also: enter, @describe, ENTER_OK. 
 
&@idle 
 
  Command: @idle <object> = <message> 
  Attribute: Idle 
  
  This attribute is sent as a message to anyone who successfully pages you. 
  It can be used to tell someone who pages you when you will return 
  (if you are going to be away for a while). 
  
  This attribute is only meaningful for players, and will never be 
  automatically referenced on other object types. 
  
  Example: @idle me = At dinner.  Back about 7PM. 
  See also: @away, @reject, page. 
 
&@infilter 
 
  Command: @infilter <object> = <pattern>[, <pattern>...] 
  Attribute: Infilter 
  
  This attribute specifies a series of patterns to be used to suppress 
  text normally sent to the contents of <object> by @listen.  If the desired 
  pattern contains a comma, the pattern may be enclosed in curly braces {}. 
  
  Example: 
    > @listen sports car=* 
    > @fo test=enter sports car 
    test has left. 
    test> Sports Car(#383Q) 
    > :waves. 
    test> Wizard waves. 
    Wizard waves. 
    > @infilter sports = *waves* 
    > :waves. 
    Wizard waves. 
    > :knocks on the window. 
    test> Wizard knocks on the window. 
    Wizard knocks on the window. 
  See also:  @filter, @inprefix, @listen, @prefix. 
 
&@inprefix 
 
  Command: @inprefix <object> = <prefix text> 
  Attribute: Inprefix 
  
  This attribute, when set, will prefix all text that is sent to the contents 
  of <object> by @listen.  The default is to have no prefix, the text is 
  forwarded unadorned. 
  
  Example: 
    > @listen sports car=* 
    > @fo test=enter sports car 
    test has left. 
    test> Sports Car(#383Q) 
    > :waves. 
    test> Wizard waves. 
    Wizard waves. 
    > @inprefix sports car = In the mundane world outside, 
    test> In the mundane world outside, Wizard waves some more. 
    Wizard waves some more. 
  See also: @filter, @infilter, @listen, @prefix. 
 
&@kill 
 
  Command: @kill <object> = <message> 
  Attribute: Kill 
  
  This command sets the message that is shown to anyone who kills <object>. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Function references and %-substitutions are allowed in kill messages, and 
  are evaluated when someone kills the object.  In function references, 'me' 
  refers to the object that was killed, while %-substitutions that refer to 
  the enactor (such as %n, %#, %p, etc) refer to the player doing the killing. 
  
  Example: @kill guard = The guard says "I'll get.. you... for... this... %n" 
                         as he falls down and dies. 
  See also: kill, @akill, @okill, BEING KILLED, IMMORTAL, WIZARD. 
 
&@Lalias 
 
  Command: @lalias <object> = <entrance-list> 
  Attribute: Lalias 
  
  Sets up a set of alternate commands that may be used as synonynms for the 
  command 'leave' when you are inside a player or a thing.  The alternate 
  commands are separated by semicolons just like in exit names. 
  
  Leave aliases are checked for after exitnames and builtin MUX commands, but 
  before enter aliases and $-commands. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically looked at on rooms or exits. 
  
  Example: @lalias car = get out;climb out;out;open door;outside 
  See also: @ealias, enter, leave. 
 
&@leave 
 
  Command: @leave <object> = <message> 
  Attribute: Leave 
  
  Sets the message that a player sees when leaving an object or room, whether 
  by using an exit, the enter or leave commands, or by teleporting. 
  
  Function references and %-substitutions are allowed in leave messages, and 
  are evaluated when someone leaves the object.  In function references, 
  'me' refers to the object being left, while %-substitutions that refer 
  to the enactor (such as %n, %#, %p, etc) refer to the player leaving the 
  object. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @leave car = You unbuckle your seatbelt and climb out of the car. 
  See also: leave, @aleave, @oleave. 
 
&@lfail 
 
  Command: @lfail <object> = <command-list> 
  Attribute: Lfail 
  
  Sets the message that a player sees when he tries to leave it but fails 
  because the player fails the object's leave lock. 
  
  The leave lock only affects the 'leave' command and its aliases (set via 
  the @ealias command), it does not affect going home, using an exit in the 
  location, or teleporting out. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically triggered on rooms or exits. 
  
  Example: @lfail plane = You don't have a parachute! 
  See also: @aleave, @alfail, @lalias, @leave, @oleave, @olfail, leave. 
 
&@listen 
 
  Command: @listen <object> = <string> 
  Attribute: Listen 
  
  This attribute contains a wildcard pattern that the object listens for. 
  Anything spoken, posed, emitted, or whispered in the room that <object> is 
  in, as well as messages resulting from using objects (such as Opay and Succ 
  messages) are checked against the Listen attribute.  When the object hears  
  something that matches the pattern, it triggers the Ahear attribute, as 
  well as either the Amhear or Aahear attributes, as appropriate, 
  substituting %0 the string that matched the first wildcard character in the 
  Listen, %1 for the second. etc.  If the pattern in the Listen attribute is 
  matched, objects in <object>'s inventory will also hear the message and 
  have a chance to match it.  Objects whose Listen attribute is set to 
  anything will be listed when a @sweep command is run by someone in the 
  same room. 
  
  If the @listen pattern is matched, then the object's contents will 
  hear the message also, prefixed by the text in @inprefix if it is set.  Any 
  text that matches any pattern specified in @infilter will not be sent to 
  the contents. 
  
  Example: @listen camera = * has arrived. 
           @ahear camera = @va me = %va %0 
  See also: @aahear, @ahear, @amhear, @sweep, @inprefix, @infilter. 
 
&@move 
 
  Command: @move <object> = <command-list> 
  Attribute: Move 
  
  Sets the message that an object sees after it moves from one location to 
  another, whether by using an exit, entering or leaving an object, 
  teleporting, or going home. 
  
  This attribute is meaningful for players, and things and will never be 
  automatically triggered on other object types. 
  
  Example: @move bopper = OK.  You're there now. 
  See also: @amove, @omove. 
 
&@odescribe 
 
  Command: @odescribe <object> = <message> 
  Attribute: Odesc 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the room when someone looks at <object>. 
  
  Example: @odesc vase = carefully inspects the vase. 
  See also: look, @adescribe, @describe, @idesc. 
 
&@odfail 
 
  Command: @odfail <object> = <message> 
  Attribute: Odfail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room when someone tries to drop <object> but fails because they 
  didn't pass the object's drop lock. 
  
  Function references and %-substitutions are allowed in drop failure 
  messages, and are evaluated when someone drops the object.  In function 
  references, 'me' refers to the object being dropped, while %-substitutions 
  that refer to the enactor (such as %n, %#, %p, etc) refer to the dropper. 
  
  Example: @odfail sword = tries to put down the sword but it leaps back 
                                       into %p hand. 
  See also: drop, @adfail, @dfail, @lock. 
 
&@odrop 
 
  Command: @odrop <object> = <message> 
  Attribute: Odrop 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the room when someone drops <object>, or to others in the room that the 
  player arrives in after taking an exit. 
  
  Example: <object> @odrop loadstone = puts down the loadstone and then 
                                       wipes sweat from %p brow. 
           <exit>   @odrop elevator = enters the elevator from the lobby. 
  See also: drop, @adrop, @drop, DROP-TO, EXITS. 
 
&@oefail 
 
  Command: @oefail <object> = <command-list> 
  Attribute: Oefail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room as the player when he tries to enter the object but fails 
  because the object is not ENTER_OK or the player fails the 
  object's enter lock. 
  
  The enter lock only affects the 'enter' command and its aliases (set via 
  the @ealias command), it does not affect exits that lead to the object or 
  teleporting in. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically triggered on rooms or exits. 
  
  Example: @oefail car = tries to open the car's door, but it is locked. 
  See also: @aefail, @aenter, @ealias, @efail, @enter, @oenter, enter, 
            ENTER_OK. 
 
&@oenter 
 
  Command: @oenter <object> = <message> 
  Attribute: Oenter 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the location being entered when someone enters <object>.  Note that the 
  message is shown to those inside the object, not those outside. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @oxenter wormhole = enters the wormhole from normal space. 
  See also: enter, @aenter, @enter, @oxenter. 
 
&@ofail 
 
  Command: @ofail <object> = <message> 
  Attribute: Ofail 
  
  Sets the others failure message for <object>.  This message is seen others 
  in the same location as the actor when one of these events occurs: 
  
    - For exits: Someone tries to traverse the exit but cannot because they 
      fail the exit's default lock or the exit is not linked. 
    - For players and things: Someone tries to pick up the object but cannot 
      because they fail the object's default lock. 
    - For rooms, players, and things: Someone looks around inside the room, 
      player, or thing and fails the object's default lock. 
  
  Substitution and evaluation is performed on the message before it is shown. 
  
  Examples: 
    > @ofail table = tries to pick up the table, but it is too heavy.  <thing> 
    > @ofail doorway = tries the knob on the door, to no avail.         <exit> 
  See also: get, look, @afail, @fail, FAILURE. 
 
&@ogfail 
 
  Command: @ogfail <object> = <message> 
  Attribute: Ogfail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room when someone tries to give away <object> but fails because 
  they didn't pass the object's give lock. 
  
  Function references and %-substitutions are allowed in give failure 
  messages, and are evaluated when someone tries to give away the object. 
  In function references, 'me' refers to the object being given away, while 
  %-substitutions that refer to the enactor (such as %n, %#, %p, etc) refer 
  to the (attempted) giver. 
  
  Example: @ogfail blob = tries to give away a sticky blob of goo. 
  See also: give, @agfail, @gfail, @lock. 
 
&@okill 
 
  Command: @okill <object> = <message> 
  Attribute: Okill 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the room when someone kills <object>. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @okill guard = bashes in the guard's skull, killing him. 
  See also: kill, @akill, @kill, BEING KILLED, IMMORTAL, WIZARD. 
 
&@oleave 
 
  Command: @oleave <object> = <message> 
  Attribute: Oleave 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the location being left when someone leaves <object>.  Note that the 
  message is shown to those inside the object, not those outside. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @oleave wormhole = departs the wormhole to return to normal space. 
  
  See also: leave, @aleave, @leave, @oxleave. 
 
&@olfail 
 
  Command: @olfail <object> = <command-list> 
  Attribute: Olfail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room as the player when he tries to leave it but fails because the 
  player fails the object's leave lock. 
  
  The leave lock only affects the 'leave' command and its aliases (set via 
  the @ealias command), it does not affect going home, using an exit in the 
  location, or teleporting out. 
  
  This attribute is meaningful for players and things, and will never be 
  automatically triggered on rooms or exits. 
  
  Example: @olfail plane = thinks about jumping out of the plane without a 
                           parachute, but wisely reconsiders. 
  See also: @aleave, @alfail, @lalias, @leave, @lfail, @oleave, leave. 
 
&@omove 
 
  Command: @omove <object> = <command-list> 
  Attribute: Move 
  
  Sets the message that others in the same location see after the object has 
  moved to that location from somewhere else, whether by using an exit, 
  entering or leaving an object, teleporting, or going home. 
  
  This attribute is meaningful for players, and things and will never be 
  automatically triggered on other object types. 
  
  Example: @omove car = coasts to a stop. 
  See also: @amove, @move. 
 
&@opay 
 
  @opay <object> = <message> 
  Attribute: Opay 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the room when someone pays <object> enough to satisfy its Cost attribute. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @opay Coke machine = slips some change into the coin slot on the 
                                Coke machine.  You hear some rumbling from 
                                inside the machine and a can of Coke appears 
                                in the tray at the bottom of the machine. 
  See also: give, @cost, @apay, @pay. 
 
&@orfail 
 
  Command: @orfail <object> = <message> 
  Attribute: Orfail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room when someone tries to give <object> a thing that does not 
  pass <object>'s receive lock. 
  
  Function references and %-substitutions are allowed in receive failure 
  messages, and are evaluated when someone tries to give away the object. 
  In function references, 'me' refers to the intended recipient of the object, 
  while %-substitutions that refer to the enactor (such as %n, %#, %p, etc) 
  refer to the (attempted) giver. 
  
  Example: @orfail merchant = tries to unload some worthless trash on Astinous. 
  See also: give, @agfail, @arfail, @gfail, @ogfail, @rfail, @lock. 
 
&@osuccess 
 
  Command: @osuccess <object> = <message>] 
  Attribute: Osucc 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the room when someone picks up the named player or thing, goes through the 
  named exit, or looks at the room and passes the room's lock. 
  
  Setting Osuccess messages on all takeable objects and usable exits is 
  considered good building practice. 
  
  Examples: <object> @osucc vase = carefully picks up the vase. 
            <exit>   @osucc doorway = opens the door and leaves the room. 
                                      The door closes behind %o with a click. 
  See also: get, look, @asuccess, @success, SUCCESS. 
 
&@otfail 
 
  Command: @otfail <object> = <message> 
  Attribute: Otfail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room when someone tries to teleport to somewhere he does not have 
  permission.  You do not see this message if they couldn't teleport out of 
  their present location. 
  
  Function references and %-substitutions are allowed in teleport failure 
  messages, and are evaluated when someone attempts to teleport to the 
  specified destination.  In function references, 'me' refers to the teleport 
  destination, while %-substitutions that refer to the enactor (such as %n, 
  %#, %p, etc) refer to the player attempting the teleport. 
  
  When a player teleports another object (@tel <object>=<destination>), the 
  lock is checked against the player, not the object. 
  
  Example: @otfail here = thinks about teleporting to the Magic Room, but 
                          decides against it at the last moment. 
  See also: @teleport, @atfail, @tfail, @lock. 
 
&@otofail 
 
  Command: @otofail <object> = <message> 
  Attribute: Otofail 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the same room when someone tries to teleport out of somewhere they do not 
  have permission. 
  
  Function references and %-substitutions are allowed in teleport failure 
  messages, and are evaluated when someone attempts to teleport from their 
  location.  In function references, 'me' refers to the player's location, 
  while %-substitutions that refer to the enactor (such as %n, 
  %#, %p, etc) refer to the player attempting the teleport. 
  
  Example: @otofail here = thinks about teleporting from the Magic Room, but 
                          decides against it at the last moment. 
  See also: @teleport, @atofail, @tofail, @lock. 
 
&@otport 
 
  Command: @otport <object> = <message> 
  Attribute: Otport 
  
  Sets the message (prefixed by your name) that others in the room to which 
  the object goes see when the object teleports there. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
   
  Example: @otport me = appears in a flash of non-wizardly brilliance. 
  
  See also: @atport, @oxtport, @tport, @teleport. 
 
&@oufail 
 
  Command: @oufail <object> = <message> 
  Attribute: Oufail 
  
  Sets the message that others in the same room see when someone tries to 
  use object but fails the object's use lock.  Note that the other functions 
  controlled by the use lock (paying, listening, and $-commands) do not 
  trigger Oufail. 
  
  Example: @oufail robot = tries to activate the robot, but to no avail. 
  
  See also: @aufail, @ufail, @use. 
 
&@ouse 
 
  Command: @ouse <object> = <message> 
  Attribute: Ouse 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the room when someone uses <object>. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @ouse camera = takes a picture with the camera. 
  See also: use, @ause, @use. 
 
&@oxenter 
 
  Command: @oxenter <object> = <message> 
  Attribute: Oxenter 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the location being left when someone enters <object>.  Note that the 
  message is shown to those outside the object, not those inside. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @oxenter wormhole = climbs into the wormhole and vanishes. 
  See also: enter, @aenter, @enter, @oenter. 
 
&@oxleave 
 
  Command: @oxleave <object> = <message> 
  Attribute: Oxleave 
  
  Sets the message (prefixed by the player's name) that is shown to others in 
  the location being entered when someone leaves <object>.  Note that the 
  message is shown to those outside the object, not those inside. 
  
  This attribute is meaningful for players, things, and rooms, and will never 
  be automatically triggered on exits. 
  
  Example: @oxleave wormhole = steps out of a hyperspatial wormhole. 
  
  See also: leave, @aleave, @leave, @oleave. 
 
&@oxtport 
 
  Command: @oxtport <object> = <message> 
  Attribute: Oxtport 
  
  Sets the message (prefixed by your name) that others in the room from which 
  the object comes see when the object teleports out. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
   
  Example: @oxtport me = disappears in a flash of non-wizardly brilliance. 
  
  See also: @atport, @otport, @tport, @teleport. 
 
&@pay 
 
  Command: @pay <object> = <message> 
  Attribute: Pay 
  
  Sets the message that is shown to the player who gives <object> enough 
  money to satisfy its Cost attribute. 
  
  This attribute is only meaningful for things, and will never be 
  automatically triggered on other object types. 
  
  Example: @pay Coke machine = You slip some change into the slot. 
  See also: give, @apay, @cost, @opay. 
 
&@prefix 
 
  Command: @prefix <object> = <prefix text> 
  Attribute: Prefix 
  
  This attribute, when set, will be used as a prefix for all text forwarded 
  by the 'audible' flag on an object or exit.  The default if this attribute 
  is not set is 'From <object name>,' for objects, and 'From a distance,' 
  for exits. 
  
  Example: 
    > @fo test=out 
    > @set #378=puppet 
    test> test grows ears and can now hear. 
    > :does something silly. 
    Wizard does something silly. 
    test> From a distance, Wizard does something silly. 
    > @prefix out=From some strange place 
    Set. 
    > :does something even sillier. 
    Wizard does something even sillier. 
    test> From some strange place Wizard does something even sillier. 
  See also: AUDIBLE, @filter, @forwardlist, @infilter, @inprefix. 
 
&@reject 
 
  Command: @reject <object> = <message> 
  Attribute: Reject 
  
  This attribute is sent as a message to anyone who tries to page you but 
  you have prevented them from paging you via your page lock (@lock/page). 
  
  This attribute is only meaningful for players, and will never be 
  automatically referenced on other object types. 
  
  Example: @reject me = I _told_ you not to page me anymore... 
  See also: @away, @idle, page. 
 
&@rfail 
 
  Command: @rfail <object> = <message> 
  Attribute: Rfail 
  
  Sets the message that a player sees when he tries to give an object to 
  someone else, but the receiver refuses to accept the object because 
  the object didn't pass its receive lock. 
  
  Function references and %-substitutions are allowed in receive failure 
  messages, and are evaluated when someone tries to give away the object. 
  In function references, 'me' refers to the intended recipient of the object, 
  while %-substitutions that refer to the enactor (such as %n, %#, %p, etc) 
  refer to the (attempted) giver. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
  
  Example: @gfail merchant = The merchant doesn't want your worthless trash. 
  See also: give, @agfail, @arfail, @gfail, @ogfail, @orfail, @lock. 
 
&@runout  
 
  Command: @runout <object> = <command list> 
  Attribute: Runout 
  
  Sets the actions to be taken by <object> when another of its attributes is 
  triggered (either automatically or via the @trigger command) and its 
  Charges attribute is zero.  When this occurs, the Runout attribute is run 
  INSTEAD OF the attribute that would have run normally. 
  
  Example: @runout magic wand = :fizzles and turns to dust.; @destroy me 
  See also: @charges. 
 
&@sex 
 
  Command: @sex <object> = <gender> 
  Attribute: Sex 
  
  Sets the gender for <object>, which is used to determine which pronouns to 
  use when replacing %p, %o, %s, and %a parameters in messages that apply to 
  <object>.  Genders that start with M or m are considered male, those 
  starting with F, f, W, or w are considered female, those starting with 
  P or p are considered plural, and anything else is considered neuter. 
  
  Example: @sex me = female 
           @sex me = No thank you (Silly, but possible.  Treated as neuter) 
  See also: GENDER. 
 
&@startup 
 
  Command: @startup <object> = <command list> 
  Attribute: Startup 
  
  Sets a list of commands to be performed by <object> when the game is 
  started up.  Typical actions include going home, cleaning visitors out of 
  a room, resetting a puzzle or complex object to its initial state, or 
  starting up an object that wants to run continuously. 
  
  Example: @startup me = @vz me=MUX was last restarted at [time()]. 
           @startup me = home 
 
&@success 
 
  Command: @success <object> = <message> 
  Attribute: Succ 
  
  Sets the message that is shown to the player who successfully picks up the 
  named player or thing, goes through the named exit, or looks at the room 
  and passes the room's lock. 
  
  Example: <object> @succ vase = You carefully pick up the delicate vase. 
           <exit>   @succ doorway = You open the door and walk through the 
                                    doorway. 
  See also: get, look, @asuccess, @osuccess, SUCCESS. 
 
&@tfail 
 
  Command: @tfail <object> = <message> 
  Attribute: Tfail 
  
  Sets the message that a player sees when he tries to teleport to somewhere 
  he does not have permission.  You do not see this message if you couldn't 
  teleport out of your present location. 
  
  Function references and %-substitutions are allowed in teleport failure 
  messages, and are evaluated when someone attempts to teleport to the 
  specified destination.  In function references, 'me' refers to the teleport 
  destination, while %-substitutions that refer to the enactor (such as %n, 
  %#, %p, etc) refer to the player attempting the teleport. 
  
  When a player teleports another object (@tel <object>=<destination>), the 
  lock is checked against the player, not the object. 
  
  Example: @tfail here = A psychic barrier prevents you from teleporting there. 
  See also: @teleport, @atfail, @otfail, @lock. 
 
&@tofail 
 
  Command: @tofail <object> = <message> 
  Attribute: Tofail 
  
  Sets the message that a player sees when he tries to teleport from somewhere 
  he does not have permission. 
  
  Function references and %-substitutions are allowed in teleport failure 
  messages, and are evaluated when someone attempts to teleport out of their 
  location.  In function references, 'me' refers to the player's current 
  location, while %-substitutions that refer to the enactor (such as %n, 
  %#, %p, etc) refer to the player attempting the teleport. 
  
  Example: @tofail here = A psychic barrier prevents you from teleporting 
           out. 
  See also: @teleport, @atofail, @otofail, @lock. 
 
&@tport 
 
  Command: @tport <object> = <message> 
  Attribute: Tport 
  
  Sets the message that an object sees whenever it teleports. 
  The message is displayed after the object moves to its new location. 
  
  This attribute is only meaningful for players and things, and will never be 
  automatically triggered on other object types. 
   
  Example: @tport me = Hey! I teleported. Wow! 
  
  See also: @atport, @otport, @oxtport, @teleport. 
 
&@ufail 
 
  Command: @ufail <object> = <message> 
  Attribute: Ufail 
  
  Sets the message that someone sees when they try to use object but fail 
  the object's use lock.  Note that the other functions controlled by the use 
  lock (paying, listening, and $-commands) do not trigger Oufail. 
  
  Example: @ufail robot = The robot pointedly ignores you. 
  
  See also: @aufail, @oufail, @use. 
 
&@use 
 
  Command: @use <object> = <message> 
  Attribute: Use 
  
  Sets the message that is shown to the player who uses <object>. 
  
  This attribute is only meaningful for players and things, and will never 
  be automatically triggered on other object types. 
  
  Example: @use camera = You take a picture with the camera.  Click. 
  See also: use, @ause, @ouse. 
 
&ABODE 
 
  Flag: ABODE (A) 
   
  If a room is set ABODE, players can set their homes there, and can set the 
  homes of objects there.  It does not mean that a player can open an exit 
  to that room, only that they can set their home there. 
 
&AUDIBLE 
 
  Flag: AUDIBLE (a) (all types) 
  
  When set on an object, player, or room everything from a say, pose, or emit 
  inside the object will be sent to every object in the location of that 
  object (except for rooms which have no location) as well as to all objects 
  mentioned in the object's Forwardlist attribute.  When set on an exit, 
  everything from a say, pose, or emit in the room the exit is in will be 
  forwarded to the room the exit points to.  In both cases the @prefix 
  attribute will be inserted in front of the text, or a default prefix if no 
  @prefix attribute is set.  If the @filter attribute is present, it will be 
  used to suppress those messages matching any of the patterns specified. 
  See also: @filter, @forwardlist, @prefix. 
 
&CHOWN_OK 
 
  Flag: CHOWN_OK (C) 
  
  This flag, when set, allows you to transfer ownership to another player. 
  To set it, you must be carrying the object.  You also have to be in the 
  room if you want to set this flag on rooms or exits.  After this flag is 
  set, the new player may gain ownership of the object by using the @chown 
  command (See @chown). 
 
&CONNECTED 
 
  Flag: CONNECTED (c) 
    
  This flag applies only to players and it shows if the player is connected 
  or not. Thus, each time you are connected to the game, you should see the 
  'c' flag set, otherwise, you are DEAD!  You cannot reset this flag, and it 
  is used internally by the code for things like tabulating players for the 
  WHO list, etc. 
 
&DARK 
 
  Flag: DARK (D) 
   
  If a room is DARK, then no items are shown when a person 'looks' there. 
  If a thing is DARK, then "look" does not list that object in the room's 
  Contents:, and if an exit is DARK, it doesn't show up in the Obvious 
  Exits: list.  Puppets and objects that can listen cannot be DARK. 
 
&DESTROY_OK 
 
  Flag: DESTROY_OK (d) 
    
  When set on an object, it allows any player to destroy it as long as the 
  object is not locked against them. This is good for things like notes, 
  whereby the recipient can destroy the note after reading it, instead of 
  having to look for you to destroy it.  The DESTROY_OK flag overrides the 
  SAFE flag, so that you do not need to give the /override switch to @destroy 
  to destroy a thing that is both DESTROY_OK and SAFE. When it is set on any 
  object or the owner of that object, that object is destroyed immediately, 
  without delay. 
   
  See also: @destroy, SAFE. 
 
&ENTER_OK 
 
  Flag: ENTER_OK (e) 
   
  If an object or person is ENTER_OK, other players may enter the object or 
  person by using 'enter <object/person>.  Players must also have the 
  ENTER_OK set if they wish to be able to receive things given to them by 
  other players via the 'give <player> = <object>'.  
 
&GOING 
 
  Flag: GOING (G) 
   
  Used internally for the @destroy command, it is set on rooms that are set 
  to be destroyed.  In the event that a player decides they don't want to 
  destroy the room after all then they can unset it.  
 
&HAVEN 
 
  Flag: HAVEN (H) 
   
  @set here=haven;@set me=haven.  If a location is HAVEN, you cannot kill in 
  that location.  The HAVEN flag no longer blocks pages or @pemits, use 
  @lock/page instead. 
    
  See also: @lock/page. 
 
&KEY 
 
  Flag: KEY (K) 
   
  When set on an object prevents puppets from picking it up. 
 
&LINK_OK 
   
  Flag: LINK_OK (L) 
   
  If a room is LINK_OK, anyone can link exits to it (but still not from it). 
  It has no meaning for people, things, or exits. 
   
  See @link. 
 
&UNFINDABLE 
   
  Flag: UNFINDABLE (U) 
   
  If a player is set UNFINDABLE, he cannot be found by the loc() or room() 
  functions.  If a room is set UNFINDABLE, players in that room (or inside 
  objects in the room) cannot be found by loc()/room(). 
   
&FLOATING 
 
  Flag: FLOATING (F) 
   
  If a room is set floating, you will not be notified every 10 minutes or so 
  that you have a disconnected room. 
   
&OPAQUE 
 
  Flag: OPAQUE (O) 
    
  When set on a player, it prevents other players from seeing what you are 
  carrying in your inventory.  The only exception is when the object you are 
  carrying belongs to the other player looking at you. 
 
&PLAYER 
 
  Flag: PLAYER (P) 
   
  The PLAYER flag identifies you as a player.  This flag cannot be reset by 
  any player, not even a Wizard (not, yet, anyway *grin*).  It is used 
  mainly by the MUX code to identify your commands, check for validity of 
  commands or locks etc.  Generally, just pretend it isn't even there. 
   
&JUMP_OK 
 
  Flag: JUMP_OK (J) 
   
  When a room or thing is set JUMP_OK, then that location can be teleported 
  into by anyone. See @teleport. 
 
&PUPPET 
 
  Flag: PUPPET (p) 
   
  @set <object> = puppet. Causes an object to grow eyes and ears, and relay 
  all it sees and hears to its owner. 
   
  See: @force, PUPPETS 
 
&ROOM 
   
  Flag: ROOM (R) 
     
  This flag is automatically set on rooms when you @dig a new room.  It 
  cannot be changed. Rooms have the added advantage that they can be saved 
  from destruction by setting the room to !GOING (SEE GOING).  However, this 
  can only be done if no other room/object was created that overwrote your 
  room when it was set for destruction. 
   
&VISUAL  
 
  Flag: VISUAL (V) 
   
  The flag a lot of players have been waiting for.  When set on your object, 
  it allows other players to examine it and see all the object's attributes 
  as if they owned the object.  They cannot make any changes to the object.  
   
&VACATION 
    
  Flag: VACATION (|) 
     
  This flag can only be set by wizards.  It is usually used to mark players 
  who will be inactive for a long period of time.  It is automatically 
  cleared when the character logs on. 
    
&QUIET 
 
  Flag: QUIET (Q) 
    
  This flag when set on yourself prevents you from hearing the 'set' or 
  'triggered' messages from any objects you own.  When set on an object, 
  only that object will not relay its messages. 
    
&HALTED 
 
  Flag: HALTED (h) 
   
  While this flag is set, the object cannot perform any MUX actions, listen, 
  be triggered, etc. 
   
&STICKY 
 
  Flag: STICKY (S) 
   
  If a thing is STICKY, it goes home when dropped (See HOMES).  If a room 
  is STICKY, its drop-to is delayed until the last person leaves (See 
  DROP-TOs).  The flag is only meaningful for things and rooms.  
  
&TEMPLE 
    
  Flag: TEMPLE 
   
  The TEMPLE flag is no longer a part of TinyMUX. 
  
&ROYALTY 
   
  Flag: ROYALTY (Z) 
   
  If a person is ROYALTY, they can see and examine things, and teleport 
  anywhere or anything, like a wizard can.  They cannot modify objects or 
  players they do not control, and cannot use wizard commands.  This flag 
  may only be set by a wizard. 
     
&AUDITORIUM 
    
  Flag: AUDITORIUM (b) 
    
  When set on a room, object, or player, it enables the checking of 
  speechlocks. 
   
&STAFF 
   
  Flag: STAFF (w) 
   
  This flag can be used to mark players who serve as staff on the MUX.  It 
  is wizard-settable only. 
   
&ANSI 
 
  Flag: ANSI (X) 
   
  When set on a player, it will enable the player to see ANSI color.  If you 
  have TinyFugue and you do not wish to see ANSI color, please leave this 
  flag set and /set catch_ctrls=ansi.  The reason for this is when the ANSI 
  flag is unset, the server must go through every line of text you see and 
  strip the ANSI codes from it. With the ANSI flag set and /set 
  catch_ctrls=ansi, TinyFugue will strip the ANSI and save the MUX from 
  having to do it, resulting in less lag for everyone. 
    
  See also: ansi(), NOBLEED. 
    
&NOBLEED 
 
  Flag: NOBLEED (-) 
   
  When set on a player, it will append an ANSI white character to the normal 
  ANSI 'normal' character, so it will fix ANSI color 'bleed' on most 
  terminals.  (Bleed occurs when a color extends into text it was not meant 
  to).  Do not set this flag unless you have to, it tends to slow down the 
  text display for the MUX. 
      
&HEAD 
  
  Flag: HEAD (?) 
    
  This is another marker flag, for faction heads and the like.  As with 
  STAFF, no powers come with it, since it is purely a marker. 
   
&FIXED 
 
  Flag: FIXED (f) 
    
  No object may teleport or go home when this flag is set.  This flag may 
  only be set by a wizard. If set on a player, neither they nor any of their 
  objects may teleport or go home. 
    
&UNINSPECTED 
 
  Flag: UNINSPECTED (g) 
   
  This flag is typically set on rooms that need to be inspected for good 
  building practices.  This flag may only be set by wizards and royalty. 
    
&no_command 
 
  Flag: NO_COMMAND (n) 
   
  The NO_COMMAND flag disables the checking of $-commands on an object. 
  Most MUXes will be configured to automatically set this flag on rooms and 
  players.  The server runs faster when fewer objects are checked for 
  $-commands; thus, any object which does not have $-commands on it should 
  be set NO_COMMAND. 
    
&ANSI() 
 
  ansi(<codes>,<string>) 
  
  This allows you to highlight a string using ANSI terminal effects. The 
  string is terminated with a "return to normal" code, and the codes are 
  utilized in the order they are specified. The codes are: 
  
        f - flash                       i - inverse 
        h - hilite                      n - normal 
  
        x - black foreground            X - black background 
        r - red foreground              R - red background 
        g - green foreground            G - green background 
        y - yellow foreground           Y - yellow background 
        b - blue foreground             B - blue background 
        m - magenta foreground          M - magenta background 
        c - cyan foreground             C - cyan background 
        w - white foreground            W - white background 
  
  For example, "ansi(fc, Test)" would hilight "Test" in flashing cyan. 
<Continued in HELP ANSI2>
      
&ANSI2 
 
  The percent substitution %c<color code> can be used instead of ansi(), and 
  is more efficient.  
  
  For example, the equivalent to [ansi(rBf,Color!)] would be: 
  %cr%cB%cfColor!%cn 
  
  The %cn (to return to normal) is not necessary, but if it is not specified 
  the ansi color codes will continue to the end of the string. 
 
  See also: ANSI   
  
&BUILDER 
 
  Flag: BUILDER 
     
  The BUILDER flag has been changed into a power.  See help powers list. 
    
&WIZARD 
 
  Flag: WIZARD (W) 
 
  If a person is WIZARD, they are a wizard, unkillable, subject to fewer 
  restrictions, and able to use wizard commands.  In general, WIZARDs can do 
  anything using #<number> or *<player>.  Only player #1 can set and unset 
  the WIZARD flag of other players.  No WIZARD can turn their own WIZARD 
  flag off. 
   
&IMMORTAL 
 
  Flag: IMMORTAL (i) 
      
  Objects set immortal cannot be killed and don't use up money.  Only 
  settable by wizards.  This is useful when an object's location shouldn't 
  be changed by Joe Player, but you don't want to have to relink it to its 
  current location whenever it moves. 
    
&VERBOSE 
 
  Flag: VERBOSE (v) 
   
  This flag causes all commands executed by the object having the flag to be 
  sent to the owner of the object.  i.e.: 
   
  @create foo 
  @set foo=VERBOSE 
  @force foo="Hi. 
  foo] "Hi. 
  foo says "Hi." 
   
  See also: TRACE 
 
&INHERIT 
 
  Flag: INHERIT (I) 
     
  Previously, Wizard-owned objects had wizard powers.  This was a problem in 
  many cases, so that behavior has changed.  Now, only Wizard objects or 
  Wizard-owned Inherit-set objects have wizard powers.  Only players can set 
  the Inherit flag, and the Inherit flag is reset during @chown.  If a 
  player is set Inherit, all his stuff is assumed to be inherit, so his 
  objects can control him.  If a player is NOT Inherit, his stuff does NOT 
  control him.  (i.e. cannot @force him).  This flag is not especially 
  useful for non-wizards. 
 
&MONITOR 
 
  Flag: MONITOR (M) 
  
  When set on an object, anytime the object hears something from someone who 
  passes the object's use lock, the object's attributes are scanned for 
  attributes of the form '^<pattern>:<commandlist>'.  If the message matches 
  the wildcarded <pattern>, then <commandlist> is executed, substituting %0 
  for the text that matched the first wildcard, %1 for the second, and so 
  on.  All matching attributes are executed, not just the first.  Parents of 
  MONITOR objects are never checked for ^-patterns. 
     
  When set on a player, this flag notifies that player whenever someone 
  connects or disconnects from the MUX. It is valid only for players, and 
  must be set by a wizard. 
     
  See also: LISTENING. 
 
&TRACE 
 
  Flag: TRACE (T) 
     
  When a thing is set TRACE, it will report to its owner the result of all 
  substitutions that it performs that change the original string.  The order 
  for displaying nested evaluations (such as when evaluating the arguments to 
  a function) is a site-selected configuration parameter. 
     
  Example: 
  > @set object = trace 
  > @va object = say The result is [add(4,mul(3,%0))]. 
  > @trig object/va = 7 
  object(#322)} '%0' -> '7' 
  object(#322)} 'mul(3,%0)' -> '21' 
  object(#322)} 'add(4,mul(3,%0))' -> '25' 
  object(#322)} 'The result is [add(4,mul(3,%0))].' -> 'The result is 25.' 
  object says "The result is 25." 
<Continued in HELP TRACE2>
     
&trace2 
    
  When trace output is displayed in top-down order (final evaluation first, 
  followed by the 'smaller' evaluations needed to perform it), then the total 
  number of trace ouput lines that may be produced by an evaluation is limited 
  to 200.  Bottom-up trace output is not limited. 
   
  See also: VERBOSE. 
   
&NOSPOOF 
 
  Flag: NOSPOOF (N) 
    
  This flag gives you mucho output when people @emit.  It can be annoying, 
  but you'll know who's spoofing. 
    
  See also: @emit, @femit, @oemit, @pemit. 
 
&PARENT_OK 
    
  Flag: PARENT_OK (Y) 
      
  If an object is set PARENT_OK, then any other object that passes the 
  object's ParentLock may make this object a parent of any object that it 
  controls.  Caution: allowing others to use your objects as parents lets 
  them read the attributes on the object (as well as any parents of the 
  object). 
   
  See also: @lock/parent. 
   
&LIGHT 
 
  Flag: LIGHT (l) 
    
  An object or exit that is set LIGHT is visible even when inside a DARK 
  location.  If an object is set both DARK and LIGHT, then its contents are 
  visible even though the object itself is not. 
   
&MYOPIC 
 
  Flag: MYOPIC (m) 
      
  If you are set MYOPIC, then you are treated as if you did not own anything 
  when you use the LOOK command or when you automatically look at a location 
  when entering it.  Other commands (such as EXAMINE) are not affected. 
     
&TERSE 
     
  Flag: TERSE (q) 
      
  If you are set TERSE then you are not shown the description, success or 
  failure messages, contents, or exits of locations you enter.  You must use 
  the LOOK or EXAMINE commands to see this information.  Others in the 
  location still get the osucc/ofail messages and the asucc or afail command 
  list is still run. 
    
  See also: examine, look. 
   
&ROBOT 
 
  Flag: ROBOT (r) 
    
  If set on a player, indicates that the player is a robot and is allowed to 
  use the OUTPUTPREFIX and OUTPUTSUFFIX commands that many publicly available 
  robot programs require.  Some MUXes do not restrict access to the 
  OUTPUTPREFIX and OUTPUTSUFFIX commands. 
      
  If set on an exit or a thing, indicates that robot players may not use the 
  exit or pick up the thing, the player is treated as having failed the lock. 
  See also: OUTPUTPREFIX, OUTPUTSUFFIX, @robot. 
     
&SAFE 
     
  Flag: SAFE (s) 
       
  When set, requires the use of the /override switch to @destroy in order to 
  destroy the object.  It does not prevent the destruction of the object, 
  but merely requires some additional effort.  If a thing is set DESTROY_OK, 
  its SAFE flag is ignored and it may be destroyed without using the /override 
  switch. 
     
  See also: @destroy, DESTROY_OK. 
 
&TRANSPARENT 
 
  Flag: TRANSPARENT (t) 
      
  If an exit is TRANSPARENT, then when you look at it you see the description 
  of the room on the other side of the exit in addition to the description 
  of the exit. 
     
&SLAVE 
     
  Flag: SLAVE (x) 
      
  If set on a player, neither the player nor any of his objects may perform 
  any commands that change the database.  Some sites may restrict additional 
  commands.  This flag may only be set or cleared by wizards. 
     
&ARBITRARY COMMANDS 
 
  Topic: ARBITRARY COMMANDS 
  
  You may define commands that are triggered whenever someone enters a command 
  that matches the command template (wildcarding allowed).  These commands 
  are called arbitrary commands, user-defined commands, or $-commands (for how 
  they are defined), and they are checked for only after the check for 
  single-character commands, exits, and internal commands have been performed 
  and have failed (so an arbitrary command that matches 'page *' will never 
  be performed). 
  
  You define an arbitrary command by storing a string of the form 
  '$<template>:<commandlist>' in an attribute of an object, then the command 
  will be available to anyone who carries the object, is in the same room as 
  the object, or is inside the object.  Only use user-named attributes and 
  VA-VZ for arbitrary commands, as many of the predefined attributes are not 
  for arbitrary commands.  <template> is the pattern to check for (it may 
  contain wildcards), and <commandlist> is a semicolon-separated list of 
  commands to perform.  The text that the wildcard characters matched are 
  available in the variables %0 through %9. 
<Continued in HELP ARBITRARY2>
     
&arbitrary2 
 
  Example: 
    > @va testobj = $foobar *:"I was foobar'ed with %0. 
    Set. 
    > foobar xyzzy 
    testobj says "I was foobar'ed with xyzzy" 
  
  You can prevent individual attributes from being checked for $-commands 
  with the command '@set <obj>/<attr> = no_program'.  Attributes so set 
  are reported with ($) following the attribute name when examined. 
  The command '@set <obj>/<attr> = !no_program' clears the flag. 
  
  The following attributes are never checked for $-commands: ALIAS CHARGES 
  DESC DROP FAIL IDESC ODESC ODROP OFAIL OSUCC SEX SUCC. 
  
  See also: @set. 
 
&ATTRIBUTE OWNERSHIP 
 
  Topic: ATTRIBUTE OWNERSHIP 
  The attributes on an object may be owned independently from the object. 
  Normally, the owner of the object owns all of its attributes. 
  In addition to an owner, each attribute also has a locked flag, 
  set or cleared with @lock <obj>/<attr> and @unlock <obj>/<attr>. 
  This flag controls whether or not the owner of the object may 
  @chown the attribute to himself with @chown <object>/<attrib>, 
  as well as whether or not the attribute is automatically @chowned to 
  the new owner when the object is @chowned. 
  
  You may lock and unlock attributes that you own on any object (whether 
  you own the object or not), and you may @chown an attribute that you own 
  to the owner of the object if it is unlocked.  The examine command 
  will show you all attributes that you own on an object, even if you 
  don't own the object. 
<Continued in HELP ATTRIB2>
     
&attrib2 
 
  Locked attributes may not be modified or removed, and do not change ownership 
  when the object containing them is @chowned. 
  
  You may not modify or remove attributes that you own that are stored 
  on objects that you do not own, but you may modify or remove attributes 
  owned by others on your objects (if you do this, the attribute becomes owned 
  by you). 
  
  If an attribute is owned by someone other than the object's owner, then 
  the number of the attribute's owner is shown in parentheses immediately 
  after the attribute name.  If there are any flags set on the attribute, 
  those flags are indicated in the parentheses too. 
  
  The + flag means means that the attribute is locked (so that it will not 
  change ownership of the object is @chowned), the $ flag means that 
  $-commands are not checked for that attribute.  The I flag indicates that 
  the attribute is not inherited by children of the object, and the V flag 
  shows that the attribute is publically visible. 
<Continued in HELP ATTRIB3>
     
&attrib3 
  
  When checking an attribute lock against an object, the lock will always 
  fail if the locked object is not owned by the same player as the attribute 
  being tested.  The comparison specified in the lock is only performed if 
  the owner of the locked object also owns the attribute on the object 
  being checked. 
  
  See also: @chown, @lock, @set, @unlock, examine. 
 
&BEING KILLED 
 
  Topic: BEING KILLED   
  
  On the Babylon 5 MUX, being killed is final.  If you die, barring a major 
  rules violation by the player who killed you in the way he or she killed 
  you, your character will remain dead.  If you wish to continue playing, 
  you must create a new character after your dead player is nuked. 
     
  See also: kill, @akill, @kill, @okill, IMMORTAL, WIZARD. 
 
&BOGUS COMMANDS 
 
  Topic: BOGUS COMMANDS     
   
  Bogus commands can be made using exits. For example, to make a 'sit' 
  command, one could "@open sit", then "@link sit=here" (because unlinked 
  exits can be stolen), "@lock sit=#0" (impossible for a room to pass a lock, 
  #0 is always a room, therefore the lock always fails), and "@fail sit=You 
  sit on the chair."; "@ofail sit=sits on the chair.".  Since nobody can go 
  through it, it always fails. The @fail message is displayed  to the player, 
  and the @ofail message (preceded by the player's name) to  everyone else.   
  See also: @afail, @fail, @link, @lock, @ofail, @open. 
 
&BOOLEAN VALUES 
 
  Topic: BOOLEAN VALUES 
  
  Boolean values are internally considered to be either 1, generally 
  interpreted as being true, and 0, which is generally interpreted as being 
  false. Now, any string is interpreted as true(1), except for the null 
  string (whose length is 0), which is false(0).  A #-1 is interpreted as 
  false(0), and any other #<dbref> is interpreted as true(1).  Any number 
  except 0 is interpreted as true(1), except 0 which is false(0). (Yes, even 
  negative numbers are true(1)) 
  
  Examples: 
  not(foo) = 0             not(<null string>) = 1   not(-66) = 0 
  not(0) = 1               not(#-1) = 1             not(#12) = 0 
  And so on... 
  
  Note: These rules only apply when a function expects a Boolean  
  value, not for strings that expect other values. 
 
&CONTROL 
 
  Topic: CONTROL       
  
  There are 6 rules to controlling objects: 
   1) You control anything you own. 
   2) Anything you own that has its INHERIT flag set controls anything you  
      own (including you). 
   3) Anything you own that does not have its INHERIT flag set only controls 
      other things that you own that do not have their INHERIT flag set and 
      do not control you, unless YOU have your inherit flag set. 
   4) A wizard controls everything. 
   5) Anybody controls an unlinked exit, even if it is locked. 
   6) The object is in a part of a zone tree that you control. 
 
  Builders should beware of 5, lest their exits be linked or stolen. 
  
  Most of the commands for altering the database and many commands and 
  functions that retrieve information only work on objects that you control. 
 
&COSTS       
 
  Topic: COSTS 
  
  Certain commands cost money to use, they will fail if you don't have 
  enough.  Use the @list costs command to find out what these commands are 
  and how much they cost. 
  See also: @list. 
 
&CREDITS 
 
  Topic: CREDITS 
  
TinyMUX 1.0 is derived from TinyMUSH 2.0.10 patchlevel 6. It is maintained 
by Lauren (Children of the Atom) and would not exist without the generous 
contributions of many individuals. Ideas for features (and occasionally 
code) came from many places, including TinyMUSE, and PennMUSH. 
  
We would like to thank the following people: 
  
- Dave Peterson (Evinar) who maintained TinyMUSH 2.0 in its later
  incarnations.
  
- James Callahan (Darkenelf), who contributed many patches, and ideas 
  (@teleport/quiet, @readcache fixes, side effect functions, many bug fixes) 
  
- Chris (Children of the Atom) who had many, many, many ideas and found 
  many, many, many bugs, in his own gleeful manner of crashing our site. 
  
- Alan Schwartz (Javelin/Paul) and Lydia Leong (Amberyl), whose extended 
  mailer from PennMUSH is the basis for MUX's @mail system. Also, 
  Brandy (CrystalMUSH) who's +mail system inspired many of the features. 
  
- Ethaniel and Kayan Telva (BTech3056) for the basic comsystem and macro code. 
<Continued in HELP CREDITS2>
      
&CREDITS2 
  
- Kalkin(DarkZone) and Harlock(StarWarsII) who extended the comsystem and 
  added tons of new commands, which is basically unchanged here. 
  
- Kalkin(DarkZone) for writing the mail alias and guest code. 
   
- Mike(StarWars), idea for not saving GOING objects. 
  
Following is the original credits for TinyMUSH 2.0: 
  
TinyMUSH 2.0 is derived from Larry Foard's TinyMUSH (which was itself derived 
from TinyMUD, written by Jim Aspnes).  Ideas for features (and occasionally 
code) came from many places, including TinyMUSE, PernMUSH, and TinyTIM. 
  
We would like to thank the following people: 
  
- Jim Aspnes, for the original TinyMUD (from which TinyMUSH was derived) 
  
- Larry Foard, for the original implementation of TinyMUSH. 
<Continued in HELP CREDITS3>
      
&CREDITS3 
  
- Marcus Ranum for the original Untermud database layer code, and  Andrew 
  Molitor for getting it to work with TinyMUSH. 
  
- Andrew Molitor (again) for the VMS port. 
  
- Russ(Random) and Jennifer(Moira) Smith for ideas, comments and coding help. 
  
- R'nice(TinyTIM) for more good ideas than we could shake a wand of coding 
  at.  (@doing, @edit enhancements, a REAL use command, lotsa minor fixes and 
  tweaks) 
  
- Coyote(TinyTIM, DungeonMUSH, NarniaMUSH), for finding some nasty bugs and 
  NOT using them for evil purposes. 
  
- Ambar, Amberyl, Sh'dow, Jellan, and Miritha (all from PernMUSH) for numerous 
  bug fixes, enhancements, and ideas. 
  
- Sketch(TinyTIM) for rewriting some of the more confusing help file entries. 
  
- Hcobb(TinyTIM) and Furie(DungeonMUSH) for inspiring the parser rewrite and 
  other security-related fixes and enhancements. 
  
- The many other people who have contributed ideas, comments, or complaints 
  about bugs. 
  
&DROP-TOS 
 
  Topic: DROP-TOS 
  
  When the @link command is used on a room, it sets a drop-to location.  Any 
  object dropped in the room (if it isn't STICKY) will go to that location. 
  If the room is STICKY, the drop-to will be delayed until the last person in 
  the room has left. 
  See also: @link, STICKY. 
 
&ENACTOR 
 
  Topic: ENACTOR 
  
  The enactor is the object that caused an action list to be performed. 
  So, the enactor of the Ahear action list is the player or object who 
  said/emoted/etc the message that matched the Listen attribute, the 
  enactor of the Apay attribute is the player who gave the object money, etc. 
  The enactor of an attribute that is run by a @trigger command is the  
  object that ran the @trigger command.  The following substitutions can be 
  performed in an action list to return information about the enactor: 
  
    %# or [v(#)]           - Database number of the enactor 
    %N/%n or [v(N)]/[v(n)] - Name of the enactor. 
    %O/%o ...              - Objective pronoun for the enactor 
                             (him her it them) 
    %P/%p ...              - Possessive pronoun (his her its their) 
    %S/%s ...              - Subjective pronoun (he she it they) 
    %A/%a ...              - Absolute possessive pronoun (his hers its theirs) 
  See also: SUBSTITUTION. 
 
&MOVING 
 
  Topic: MOVING 
  
  A number of things happen when you leave one location and enter another 
  (assuming you pass the lock on the exit or have permission to enter the 
  object or to teleport to the location).  The following list describes the 
  actions that MUX takes when an object moves from one place to another. 
  Note that if an indicated attribute is not set, no message is displayed 
  (or no action is performed). 
  
  - If you are using an exit (as opposed to teleporting, entering an object, 
    or going home), You receive the SUCC message for the exit, others in the 
    old location receive the exit's OSUCC message, and the exit runs its 
    ASUCC action list. 
  - If you are teleporting or being teleported, others in the old location 
    receive your OXTPORT attribute. 
  - If you are a player or have your LISTEN attribute set to something, 
    and if the old location is not dark and you are not dark, you receive the 
    LEAVE message for the old location, others in the old location receive 
    the OLEAVE message, and the old location runs its ALEAVE action list. 
    Others in the new location receive the OXENTER message from the old 
    location, and others in the old location receive the message '<yourname> 
    has left.' 
<Continued in HELP MOVING2>
         
&moving2 
 
  - You are moved to the new location.  If you are entering an object, 
    teleporting, or going home, all KEY objects are stripped from you. 
  - If the new location is a room, you receive the room's DESC, others in the 
    room receive the ODESC, and the room runs its ADESC.  If you pass the 
    room's lock do the same with SUCC, OSUCC, and ASUCC, otherwise use FAIL, 
    OFAIL, and AFAIL. 
  - If the new location is a player or an object, you receive the location's 
    IDESC (or DESC if the IDESC is not set).  In either event, others in the 
    same location see the ODESC message and the location runs its ADESC  
    action list. 
  - You are shown the contents and visible exits if the location is not DARK. 
  - If you used an exit, then you receive the DROP message for the exit, 
    others in the new room receive the exit's ODROP message, and the exit 
    runs its ADROP action list. 
  - If you are teleporting or being teleported, you receive your TPORT 
    attribute, others in your new location receive your OTPORT attribute, 
    and your ATPORT attribute is run. 
  - You receive your MOVE attribute, others in your new location receive 
    your OMOVE attribute, and your AMOVE attribute is run. 
<Continued in HELP MOVING3>
     
&moving3 
 
  - If you are a player, or have your LISTEN attribute set to something, 
    and if the old location is not dark and you are not dark, you receive the 
    ENTER message for the new room, others in the new room receive the OENTER 
    message, and the new room runs its AENTER action list. Others in the room 
    you just left receive the new room's OXLEAVE message, and others in the 
    old location receive the message '<yourname> has arrived.' 
  - If the old location is a STICKY room and has its drop-to set, see if 
    objects in that room should be sent to the drop-to location.  If so, 
    do it. 
  - If you are a player, you have a chance of finding some money. 
  
  See also: @adesc, @adrop, @aenter, @afail, @aleave, @asucc, @atport, @desc, 
            @drop, @enter, @fail, @leave, @listen, @odesc, @odrop, @oenter, 
            @ofail, @oleave, @osucc, @oxenter, @oxleave, @oxtport, @succ, 
            @tport, move, @teleport, home, KEY, STICKY, DROP-TOS, FAILURE, 
            SUCCESS. 
 
&EXITS 
 
  Topic: EXITS 
  
  An exit links one location to another location, providing a way to travel 
  on the MUX.  Although normally used to link rooms together, exits can be 
  made to and from players and objects. 
  
  You may pick up exits that you own, and drop exits into locations that 
  you own.  When you pick up or drop an exit, anyone in the exit's new 
  location may use the exit and travel to its destination. 
  
  If an exit is set DARK it will not show up in the list of obvious exits in 
  a room. 
  See also: @link, @open. 
 
&FAILURE 
 
  Topic: FAILURE   
  
  You fail to use a player or a thing when you cannot take it (because it's 
  lock fails).  You fail to use an exit when you cannot go through it 
  (because it is unlinked or locked). You fail to use a room when you fail 
  to look around (because it's locked). 
  See also: get, look, @afail, @fail, @lock, @ofail, STRINGS. 
 
&FLAGS 
 
  Topic: FLAGS 
  
  Everything in the universe of this MUX (Rooms, Exits, Things, Players, 
  etc) are represented in the same way at the program level.  A room merely 
  has the room flag set and a player has the player flag set.  In addition, 
  flags also give objects abilities or qualities.  For instance, a wizard 
  has the wizard flag set.  That is what lets the program know he may use 
  wizard abilities.  An object or room may have the dark flag set. In the 
  case of an object, this makes the object invisible to normal eye-sight. 
  In the case of a room, the room becomes too dark to see other objects or 
  players.  To get a list of the flags that are available, type '@list flags' 
  or 'help flag list'. For more specific information on a particular flag, 
  request help on the flag's name, as in 'help ENTER_OK'. 
 
&FUNCTIONS 
    
  Topic: FUNCTIONS 
  
  Functions are specialized commands used to manipulate strings and other 
  input. The format for a function is of this form: [fun-name(<input>)] 
  Although usually the []'s indicate an input that is optional, in this case 
  they are necessary and tell the MUX that this is a function, although 
  nested functions (like [first(rest(This is a nice day))] returns 'is') do 
  not require more than one pair of []'s.  Nested brackets may be used when 
  it is necessary to insert a function call in the middle of an argument, 
  like [get(me/[get(me/vz)])], which returns the contents of the attribute 
  named in the VZ attribute. 
  
  For help on a particular function, type 'help <functionname>'.  You may 
  need to include the parentheses with the function name, ie. 
  'help <functionname>()'.  Type 'help function list' or '@list functions' 
  for a list of the available functions.  'help function classes' will show 
  a list of the functions broken down into classes. 
  
  See also: @list functions, FUNCTION CLASSES, FUNCTION LIST. 
 
&FUNCTION LIST 
 
  Topic: FUNCTION LIST 
  
  Help is available for the following functions: 
    ABS()       ACOS()      ADD()       AFTER()     ALPHAMAX()  ALPHAMIN() 
    AND()       ANDFLAGS()  ANSI()      APOSS()     ART()       ASIN() 
    ATAN()      BEEP()      BEFORE()    CAPSTR()    CAT()       CEIL() 
    CENTER()    CHILDREN()  COLUMNS()   COMP()      CON()       CONN() 
    CONTROLS()  CONVSECS()  CONVTIME()  COS()       CREATE()    CWHO() 
    DEC()       DECRYPT()   DEFAULT()   DELETE()    DIE()       DIST2D() 
    DIST3D()    DIV()       E()         EDEFAULT()  EDIT()      ELEMENTS() 
    ELOCK()     EMPTY()     ENCRYPT()   EQ()        ESCAPE()    EXIT() 
    EXP()       EXTRACT()   EVAL()      FDIV()      FILTER()    FINDABLE() 
    FIRST()     FLAGS()     FLOOR()     FOLD()      FOREACH()   FULLNAME() 
    GET()       GET_EVAL()  GRAB()      GREP()      GREPI()     GT() 
    GTE()       HASATTR()   HASATTRP()  HASFLAG()   HASPOWER()  HASTYPE() 
    HOME()      IDLE()      IFELSE()    INC()       INDEX()     INSERT() 
    INZONE()    ISDBREF()   ISNUM()     ISWORD()    ITER()      ITEMS() 
    LAST()      LATTR()     LCON()      LCSTR()     LDELETE()   LEXITS() 
    LIST()      LIT()       LJUST()     LN()        LNUM()      LPARENT() 
    LOC()       LOCATE()    LOCK()      LOG()       LT()        LTE() 
    LWHO()      MAIL()      MAILFROM()  MAP()       MATCH()     MATCHALL() 
    MAX()       MEMBER()    MERGE()     MID() 
<Continued in HELP FUNCTION LIST2>
     
&FUNCTION LIST2 
  
    MIN()       MIX()       MOD()       MONEY()     MUDNAME()   MUL() 
    MUNGE()     NAME()      NEARBY()    NEQ()       NEXT()      NOT() 
    NUM()       OBJ()       OBJEVAL()   OBJMEM()    OR()        ORFLAGS() 
    OWNER()     PARENT()    PARSE()     PEEK()      PEMIT()     PI() 
    PLAYMEM()   PMATCH()    POP()       PORTS()     POS()       POSS() 
    POWER()     PUSH()      R()         RAND()      REMOVE()    REPEAT() 
    REPLACE()   REST()      REVERSE()   REVWORDS()  RJUST()     RLOC() 
    ROOM()      ROUND()     S()         SCRAMBLE()  SEARCH()    SECS() 
    SECURE()    SET()       SETDIFF()   SETINTER()  SETQ()      SETR() 
    SETUNION()  SHL()       SHR()       SHUFFLE()   SIGN()      SIN() 
    SORT()      SORTBY()    SPACE()     SPLICE()    SQRT()      STARTTIME() 
    STATS()     STRCAT()    STRIPANSI() STRLEN()    STRMATCH()  STRTRUNC() 
    SUB()       SUBJ()      SWITCH()    TAN()       TIME()      TRIM() 
    TRUNC()     TYPE()      U()         ULOCAL()    UCSTR()     UDEFAULT() 
    V()         VADD()      VDIM()      VERSION()   VISIBLE()   VMAG() 
    VMUL()      VSUB()      VUNIT()     WHERE()     WORDPOS()   WORDS() 
    XGET()      XOR()       ZONE()      ZWHO() 
   
&FUNCTION CLASSES 
 
  Topic: FUNCTION CLASSES 
  
  Arithmetic:                ABS ADD DEC DIE DIV FDIV INC MOD MUL POWER RAND 
                             SHL SHR SIGN 
                             SUB SQRT 
  Database Information:      EXIT INZONE LOC LOCATE NEARBY NEXT NUM RLOC ROOM 
                             SEARCH STATS WHERE MAIL ZONE ZWHO 
  Floating Point Conversion: FLOOR ROUND TRUNC 
  Game Information:          MUDNAME VERSION CWHO 
  Lists:                     COLUMNS EXTRACT ELEMENTS FOREACH FILTER FIRST 
                             FOLD GRAB INDEX ITER LAST LNUM MAP MATCH MATCHALL 
                             MEMBER MIX MUNGE PARSE REMOVE REST REVWORDS 
                             SETDIFF SETINTER SETUNION SHUFFLE SORT SORTBY 
                             SPLICE WORDS 
  Logarithms:                E EXP LOG LN 
  Logical:                   AND NOT OR XOR 
  Miscellaneous:             ART R SETQ ANSI BEEP CREATE ISDBREF ISNUM ISWORD 
                             LIT SETR 
  Object Information:        ANDFLAGS APOSS CONTROLS DEFAULT EDEFAULT ELOCK 
                             FLAGS GET GET_EVAL GREP GREPI HASATTR HASATTRP 
                             HASFLAG HASPOWER HASTYPE HOME LATTR LCON LEXITS 
                             LPARENT LOCK MONEY NAME OBJ OBJEVAL 
                             OBJMEM ORFLAGS OWNER PARENT PMATCH POSS S SUBJ 
                             TYPE U UDEFAULT ULOCAL V VISIBLE 
<Continued in HELP FUNCTION CLASSES2>
      
&FUNCTION CLASSES2 
 
  Player Information:        CONN FINDABLE IDLE LWHO PLAYMEM PORTS 
  Relational:                EQ GT GTE LT LTE MAX MIN NEQ SORT 
  Strings:                   AFTER ALPHAMAX ALPHAMIN BEFORE CAPSTR CAT COMP 
                             DELETE EDIT ESCAPE IFELSE LCSTR MERGE MID POS 
                             REPEAT REPLACE REVERSE SCRAMBLE SECURE SPACE 
                             SQUISH STRCAT STRLEN STRMATCH 
                             STRTRUNC SWITCH UCSTR ENCRYPT DECRYPT 
  Time:                      CONVSECS CONVTIME SECS STARTTIME TIME 
  Trigonometry:              ACOS ASIN ATAN COS DIST2D DIST3D PI SIN TAN 
                             VADD VDIM VMAG VMUL VSUB VUNIT 
&GENDER 
 
  Topic: GENDER 
  
  A player's (virtual) gender is specified in the Sex attribute.  This 
  attribute controls how gender-specific pronoun substitutions are evaluated 
  for the player.  If the player's Sex attribute starts with an 'M' or an 'm' 
  then the player is assumed to be male,  'F', 'f', 'W', and 'w' indicate 
  female, and anything else indicates neuter. 
  See also: SUBSTITUTIONS.   
 
&GOALS 
 
  Topic: GOALS 
  
  There is no ultimate goal to this game, except to have fun.  There are 
  objects and places to build, puzzles to solve, scenery to visit, and people 
  to meet. There are no winners or losers, only fellow players.  Enjoy. 
 
&HERE 
 
  Topic: HERE  
  
  The word 'here' refers to the room you are in (if you are inside an object, 
  it refers to the object that you are in, not the room that the object is 
  in).  For example, to rename the room you are in (if you control it), you 
  could enter '@name here= <new name>'. 
 
&HOMES 
 
  Topic: HOMES 
  
  Every thing or player has a home.  This is where players when they go home, 
  or things with the STICKY flag set go when dropped.  Homes are set with the 
  @link command. A thing's home defaults to the room where it was created, if 
  you control that room, or your home. You can link an exit to send players 
  home with '@link <dir>=home'.  Drop-tos can also be set to 'home'. 
  See also: @link, DROP-TO, STICKY. 
 
&LINKING   
 
  Topic: LINKING 
  
  You can link to a room if you control it, or if it is set LINK_OK or ABODE. 
  Being able to link means you can set the homes of objects or yourself to 
  that room if it is set ABODE, and that you can set the destination of exits 
  to that room if it is LINK_OK. 
  See also: @link, ABODE, LINK_OK. 
 
&LISTENING 
 
  Topic: LISTENING 
  
  Thee are two ways to listen for something in a room. The easiest way 
  is to use a combination of @listen and @ahear/@aahear/@amhear. The 
  second way is to use a "^" pattern in an attribute, similar to the way 
  "$" is used for user-defined commands. The attribute takes the form: 
  '^<pattern>:<action>'. 
  
  The ^-pattern check is only performed on objects with their MONITOR flag 
  set.  The criterion for triggering a pattern-listen is the same as that for 
  triggering an @ahear - the object cannot trigger its own listen patterns. 
  All matching attributes have their <action>s performed, not just the first. 
  Also, attributes with the no_command flag set are not checked for ^-patterns, 
  and neither are objects' parents. 
  
  Example: 
    > @va test = ^* says "foo *":say I got a foo with %1!. 
    Set. 
    > @set test=monitor 
    test grows ears and can now hear. 
    > say foo bar 
    You say "foo bar" 
    test says "I got a foo with bar!." 
  See also: @ahear, @listen, @set. 
 
&LISTS 
 
  Topic: LISTS 
  
  A list is a string, usually stored in an attribute (currently any of the 
  va-vz attributes), which is a series of words, separated by one or more 
  spaces.  The following would be a list (denoted on the ends by ', which is 
  not actually in the string): 'one two three four five'.  The functions 
  first(), rest(), cat(), member(), and remove(), all work on lists. 
  
  See also: cat(), first(), member(), remove(), rest(). 
 
&LOOPING 
 
  Topic: LOOPING 
  
  Looping in an object can have its good parts and its bad parts.  The good 
  part is when you activate part of a program multiple times to exhaustively 
  perform an operation.  This is usually done by: 
     @va object =  <list of commands>;@trigger me/vb 
     @vb object =  @switch <test> = <false>,@trigger me/va,<otherwise go on> 
  
  Looping can be a problem when it goes on without stopping.  The @ps command 
  can be used to see if you are looping.  Beware!  A looping machine that 
  isn't @halt'ed will drain your money supply while you are away! 
  See also: @halt, @ps. 
 
&ME 
 
  Topic: ME 
  The word 'me' refers to yourself. Some things to do when starting out:  
  1) give yourself a description with  
     '@describe me = <description>', then look at yourself with 'look me'. 
  2) set your gender, if you wish it known, with 
     '@set me=male' or '@set me=female'  (or '@set me=neuter' to be an 'it'). 
 
&MONEY 
 
  Topic: MONEY 
  
  You need money to build within the game, to run programmed objects or use 
  certain other commands, or to buy things from vendors set up by other 
  players.  You can get money via one or more of these methods: 
    1.  You receive a daily allowance for each day you connect. 
    2.  You have a chance of finding money as you wander around areas that 
        other people have built. 
    3.  Some MUXes may implement a place where you can sell valuable objects 
        for money. 
  See also: @list costs, COSTS. 
 
&PUPPETS 
 
  Topic: PUPPETS 
  
  An object is made into a puppet by doing '@set <object>=puppet', once an 
  object is a puppet it will relay all that it sees and hears to its master. 
  All objects created by a puppet are owned by its master, when puppets spend 
  or earn money, they use their master's money supply.  In order to prevent 
  puppets from screwing up puzzles, objects may have the KEY flag set, this 
  will prevent puppets from picking the object up. A puppet may be commanded 
  by its master by '@force <object>=command', or by the shorthand version,  
  '#<number of puppet> command'.  The puppet flag is handy for debugging, as 
  it allows you to see the result messages your object generates. 
  
  Example:        
  @force fred="hi there.  -or-  #4342 "hi there. 
  See also:  VERBOSE. 
 
&ROBBERY 
 
  Topic: ROBBERY 
  
  Robbing is not allowed on this MUX. If you really need money, ask your 
  friendly neighborhood wizard. 
  See also: MONEY. 
 
&search classes 
 
  Topic: SEARCH CLASSES 
  
  You may use the following classes in @search commands and search() 
  function calls: 
   
  TYPE      - Restricts to objects of the indicated type (OBJECTS, ROOMS, 
              EXITS, PLAYERS, GARBAGE).  THINGS may be used as an alias for 
              OBJECTS. 
  NAME      - Restricts to objects whose names start with <restriction>. 
  OBJECTS   - A combination of TYPE=OBJECT and NAME=<restriction>. 
  THINGS    - An alias for OBJECTS. 
  ROOMS     - A combination of TYPE=ROOM and NAME=<restriction>. 
  EXITS     - A combination of TYPE=EXIT and NAME=<restriction>. 
  PLAYERS   - A combination of TYPE=PLAYER and NAME=<restriction>. 
  FLAGS     - Restricts to objects which have the flags listed in 
              <restriction> set.. 
  POWER     - Restricts to objects which have the specified power. 
  EVAL      - Evaluates the restriction for each object, replacing ## 
              with the object's database number.  Evaluations that return 
              TRUE (ie, not 0 or #-1) are selected. 
  ZONE      - Restricts to objects that are in the indicated zone. 
<Continued in HELP SEARCH CLASSES2>
      
&search classes2 
 
  EOBJECT   - A combination of TYPE=OBJECT and EVAL=<restriction>. 
  ETHING    - An alias for OBJECTS. 
  EROOM     - A combination of TYPE=ROOM and EVAL=<restriction>. 
  EEXIT     - A combination of TYPE=EXIT and EVAL=<restriction>. 
  EPLAYER   - A combination of TYPE=PLAYER and EVAL=<restriction>. 
  PARENT    - Restricts to the parent designated by <restriction>. 
  ZONE      - Restricts to the zone designated by <restriction>. 
  
&SEMAPHORES 
 
  Topic: SEMAPHORES 
  
  Semaphores may be used for synchronizing complex objects or for enforcing 
  mutual exclusion.  You may use any object you own or any LINK_OK object as 
  a semaphore, and any type of object (thing, room, player, or exit) may be 
  used. 
  
  The semaphore state of an object is shown by the Semaphore attribute (which 
  is read-only); a positive number indicates the number of commands awaiting 
  notifies, and a negative number indicates the number of waits on that 
  semaphore that will not block. 
  
  Use the '@wait <object>' form of the @wait command to request a command be 
  delayed until <object> is notified with the @notify command.  The @drain 
  and @notify/all commands clear the semaphore on <object>, either 
  discarding or executing all pending commands.  Remember that the 
  object performing the @wait executes the command, not the object used 
  as a semaphore.  
<Continued in HELP SEMAPHORES2>
     
&semaphores2 
 
  You may also combine the semaphore and timer options of @wait with 
  '@wait <object>/<timeout> = <command>'  If the time period expires before 
  the semaphore is notified, then the command is executed and the semaphore 
  count is decremented, just as if the command had been run because the 
  semaphore had been notified. 
  
  Examples: <simple>     @wait semaphore="Foo 
                         @notify semaphore 
            <mutex lock> @va mutex lock=@wait me=@trig me/vb 
                         @vb mutex lock="Got it!;@notify me 
                         @startup mutex lock=@notify me 
            <timed wait> @wait timer/60 = "Sixty Second Timer. 
  
  In the above examples you will say "Foo" after semaphore is notified, 
  you will say "Got it" when you have the mutual exclusion lock mutex lock 
  (You could have also modified object registers that need to be protected 
  from concurrent update), and you will say "Sixty Second Timer." either when 
  timer is notified or after sixty seconds pass. 
  
  See also: @drain, @notify, @wait. 
 
&SPOOFING 
 
  Topic: SPOOFING 
  
  Spoofing is the act of making other characters think that a person said or 
  did something that they did not.  This is very easy to accomplish, and has 
  some good effects, which is why it is allowed.  Note that the NOSPOOF flag 
  allows players to see exactly who is spoofing what. 
  
  Example: 
    ... From TinyJerk's perspective ... 
    > @emit Wizard is a jerk! 
    Wizard is a jerk. 
  
   ... From Wizard's perspective, Wizard is set NOSPOOF ... 
   [TinyJerk(#226)] Wizard is a jerk! 
   > @boot tinyjerk 
   You booted TinyJerk off! 
   TinyJerk has disconnected. 
   1 connection closed. 
  
   ... TinyJerk's perspective again ... 
   Wizard gently shows you the door. 
  
   *** Disconnected *** 
 
&STACK 
 
  Topic: STACK 
  
  Command lists that are run on objects can have up to 10 stack values 
  named %0 through %9 (or [v(0)] through [v(9)]).  Stack values can be set 
  by the @trigger command, or by matching wildcard characters in the Listen 
  attribute (in the case of the Ahear, Aahear, and Amhear attributes). 
  
  Example: 
    > @listen item = * foo * 
    Set. 
    > @ahear item = "-->[v(1)]<-- bar -->[v(0)]<-- 
    Set. 
    > say Fee fie foo fum 
    You say "Fee fie foo fum" 
    item says "-->fum"<-- bar -->Wizard says "Fee fie<--" 
 
&SUBSTITUTIONS 
 
  Topic: SUBSTITUTIONS 
  
  All messages may contain %-substitutions, which evaluate to gender-specific 
  pronouns if the player's gender is set or to other useful information. 
  Information returned is based on the player that caused the message to be 
  displayed, not the object that stored the message or which is running the 
  action list.  The substutitions available are: 
  
    %s, %S  = Name, he, she, it, they.        (subjective) 
    %o, %O  = Name, him, her, it, them.       (objective) 
    %p, %P  = Name's, his, her, its, their.   (possessive) 
    %a, %A  = Name's, his, hers, its, theirs. (absolute possessive) 
    %n, %N  = the player's name. 
    %r      = carriage return 
    %t      = tab character 
    %b      = space character 
    %%      = literal '%' character 
    %0-%9   = Value of positional parameter/stack location 0 through 9. 
    %q0-%q9 = Value of temporary (setq) register 0 through 9. 
    %va-%vz = Contents of attribute va through vz 
<Continued in HELP SUBSTITUTIONS2>
     
&substitutions2 
 
    %#      = Database number of the object that caused the message to be 
              displayed or the action list to be run. 
    %l      = Database number of the location of the object that caused the 
              message to be displayed or the action list to be run. 
    %!      = Database number of the object holding the message or running 
              the action list. 
    %c      = ANSI color codes. See 'help ansi()' for more information. 
 
  If the letter following the % is capitalized, the first letter of the 
  result of the substitution is also capitalized. 
  
  Note: %<whatever> is equivalent to [v(<whatever>)], but is more efficient. 
  See also: GENDER, V(). 
 
&SUCCESS 
 
  Topic: SUCCESS 
  
  You successfully use a player or a thing when you take it (because you 
  passed the lock).  You successfully use an exit when you go through it. 
  You successfully use a room when you look around and the room is not locked 
  against you. 
  See also: get, look, @asuccess, @lock, @osuccess, @success. 
 
&SWITCHES 
 
  Topic: SWITCHES 
  
  Some commands have command switches associated with them that can be used 
  to modify their behavior.  For instance, switches on the @ps command 
  control the amount of information displayed, and switches on the @switch 
  command indicate whether to perform all actionlists whose targets match 
  the search string, or just the first. 
  See also: @list. 
 
&OBJECT TYPES 
 
  Topic: OBJECT TYPES 
  
  There are 4 types of objects: things, players, exits, and rooms. The first 
  letter following an object's ID number indicates the type: P(layer), 
  E(xit), R(oom), otherwise, thing.  Things are inanimate objects that can 
  be carried.  Players are animate objects that can move and carry. Exits 
  are the means by which objects move from room to room. Rooms are locations 
  that contain objects and linked exits. 
 
&COMMAND EVALUATION 
 
  Topic: COMMAND EVALUATION 
 
  When you submit a command to be executed by MUX (whether by typing it in or 
  by having a machine run it, the following steps are performed, in sequence. 
  If the command matches something in a step, the matching actions are 
  performed and the walk down the list stops. 
  
  - The first letter of the command is checked to see if it is a single- 
    character command (", :, etc).  If so, %-substitution and function 
    evaluation may be performed (depending on the command), and the command 
    is executed. 
  - Macros are checked, and then the comsystem checks for an alias. 
  - The command is checked to see if it is the 'home' command.  If so, the 
    player or object performing the command goes home. 
  - The command is checked against the exits in its current room.  If one 
    matches, it is performed.  If more than one matches, one is picked randomly 
    from the exits for which the player passes the lock (If the player does not 
    pass any locks, then the exit to be tried is picked randomly. 
<Continued in HELP COMMAND EVALUATION2>
     
&command evaluation2 
 
  - The first word of the command is checked to see if it is an internal MUX 
    command.  If so, the remainder of the command is broken up into arguments, 
    %-substitution and function evaluation may be performed on the (split up) 
    arguments, and the command is executed. 
  - %-substitution and function evaluation is performed on the command. 
  - All objects in the player's inventory, all objects in the player's 
    location, and the location itself are searched for $-commands that match 
    the command.  All that match are performed.  The player may or may not be 
    checked, depending on how the MUX is configured. 
  - The commands defined in the zone tree you or your location is in. 
 
  Note: Commands that can cause other commands to be executed (such as @wait, 
  @switch, @trigger, etc) never perform substitution on their arguments, they 
  leave the evaluation to the command that is to be executed.  This prevents 
  most of the problems with getting objects to perform unintended commands by 
  putting a ';', '}', or ',' in an argument.  The @force command is an 
  exception in that it evaluates its argument, so it should be used with 
  caution (preferably by never using it to pass information that someone else 
  entered, use @trigger instead). 
  
  Also, the construct '$xx *:%0' does not work (and is very dangerous 
  programming), use '$xx *:@force me=%0' if you need this functionality. 
 
&VERBS 
 
  Topic: VERBS 
  
  For many verbs there are three attributes that specify messages and actions 
  associated with the verb in addition to the verb's builtin action. 
  The attributes are named Verb, Overb, and Averb.  Verb is the message that 
  the enactor sees, Overb is the message that everyone else in the same room 
  as the enactor sees, and Averb is a list of commands that are run. 
  These attributes may be set using the @<attribute> command, so the commands 
  to set the attributes related to the 'drop' command are @drop, @odrop, and 
  @adrop. 
 
&WIZARDS 
 
  Topic: WIZARDS 
  
  Wizards are the people that help run the game and make sure that everything 
  is working properly.  They have special powers to tweak reality in ways 
  mortals can only dream of.  Be nice to them, they are going out of their 
  way to help keep the game running smoothly. And remember, if you have any 
  problems or just want to talk to someone, they will be there for you as 
  well. 
 
&V() 
 
  Function: v(<string>) 
  The V function can be used as an alternative for percent (%) substitution 
  and also as a replacement for get(me/<arg>).  If the argument is two 
  characters long or longer and starts with a letter, then the object 
  performing the v() call (and its parent, if necessary) is searched for the 
  named attribute, and its value is returned if possible.  Otherwise, a 
  percent substitution is performed on the argument (so that v(o) is 
  equivalent to %o, for instance).  The percent form (%o in the previous 
  example) is preferred as it is faster, and there are no longer any security 
  problems associated with it.  Note that attributes with single-character 
  names cannot be retrieved with v(). 
  See also: GENDER, SUBSTITUTION, PARENT OBJECTS. 
 
&beep() 
 
  Function: beep() 
  This function simply outputs the beep character, which on most terminals 
  with sound, will emit a short beep. Only wizards may use this function. 
  
&create() 
 
  Function: create(<object>, <cost>[, <type>]) 
  Works the same as @create <object>, but returns the database number of 
  the object created. <cost> is the cost of making the object. <type> 
  is an optional parameter, 'r' for rooms, 't' for things, and 'e' for  
  exits. If no <type> is specified, then a thing will be created by 
  default. This is a side effect function, and should only be  
  used when necessary. 
  
&set() 
 
  Function: set(<name>, <string>) 
  Works the same as @set, <name> and <string> are equivalent to what comes 
  before and after the '=' sign. Returns nothing. This is a side effect 
  function, and should only be used when necessary. 
  
&cwho() 
 
  Function: cwho(<channel>) 
  
  This returns a list of connected players who are on <channel>. Note 
  that this function returns the _names_ of the players, not the dbrefs. 
  When used by mortals, hidden ("dark") players do not appear on the list. 
  
&wordpos() 
 
  Function: wordpos(<string>, <charpos>[, <delim>) 
  
  Returns the number of the word within <string> where the character position 
  <charpos> falls.  Spaces between words are treated as belonging to the word 
  that follows them.  If <charpos> is not within the string, the value #-1 is 
  returned.  Both words and characters are numbered starting at 1. 
  
  <delim> may be used to specify a delimiter other than a space. 
  
  Example: 
    > say wordpos(This is a test, 4) 
    You say "1" 
    > say wordpos(This is a test, 5) 
    You say "2" 
    > say wordpos(This is a test, 6) 
    You say "2" 
    > say wordpos(This is a test, 20) 
    You say "#-1" 
 
&type() 
 
  Function: type(<object>) 
  Returns a string indicating the object type of <object>, either EXIT, 
  PLAYER, ROOM, or THING. 
  
  Example: 
    > say type(me) 
    You say "PLAYER" 
    > say type(here) 
    You say "ROOM" 
 
&hasflag() 
 
  Function: hasflag(<object>,<flag>) 
  Returns true if object <object> has the flag named <flag> set on it. 
  You may not be able to retrieve information for objects that you do not 
  own. 
  
  Example: 
    > say hasflag(me, wizard) 
    You say "0" 
    > say hasflag(me, connect)  
    You say "1" 
  
&haspower() 
 
  Function: haspower(<object>,<power>) 
  Returns true if object <object> has the power named <power> set on it. 
  You may not be able to retrieve information for objects that you do not 
  own. 
  
  Example: 
    > say haspower(me, announce) 
    You say "0" 
    > say hasflag(me, extended_who)  
    You say "1" 
  
&delete() 
 
  Function: delete(<string>,<first>,<len>) 
  Returns <string>, but with <len> characters starting after the character 
  at position <first> removed.  In other words, this function copies <first> 
  characters, skips <len> characters, and then copies the remainder of the  
  string. 
  
  Example: 
    > say delete(abcdefgh, 3, 2) 
    You say "abcfgh" 
    > say delete(Would you like coffee or perhaps tea?, 15, 18) 
    You say "Would you like tea?" 
 
&lock() 
 
  Function: lock(<object>[/<whichlock>]) 
  
  Returns the named lock on <object>.  If you don't specify the lock to get, 
  the default lock is returned.  You must control <object>. 
 
&elock() 
 
  Function: elock(<object>[/<whichlock>],<victim>) 
  Checks if <victim> would pass the named lock on <object>.  Only the object's 
  owner may test locks other than the default lock. 
 
&lwho() 
 
  Function: lwho() 
  Returns a list of the db numbers of connected players. 
  
  Example: 
    > WHO 
    Player Name          On For Idle  Doing 
    Mortal                00:11   0s   
    Evinar                00:12   6m   
    Wizard                00:32   6s   
    3 Players logged in. 
    > say lwho() 
    You say "#226 #271 #1" 
  See also: WHO, conn(), idle(). 
 
&OBJ() 
 
  Function: obj(<object>) 
  
  Returns the proper objective pronoun (him, her, it, them) for referring to 
  <object>, based on the object's Sex attribute.  You must either control 
  or be near <object>. 
 
&POSS() 
 
  Function: poss(<object>) 
  
  Returns the proper possessive pronoun (his, her, its, their) for referring 
  to <object>, based on the object's Sex attribute.  You must either control 
  or be near <object>. 
 
&APOSS() 
 
  Function: aposs(<object>) 
  
  Returns the proper absolute possessive pronoun (his, hers, its, theirs) for 
  referring to <object>, based on the object's Sex attribute.  You must either 
  control or be near <object>. 
 
&SUBJ() 
 
  Function: subj(<object>) 
  
  Returns the proper subjective pronoun (he, she, it, they) for referring to 
  <object>, based on the object's Sex attribute.  You must either control 
  or be near <object>. 
 
&LIT() 
  lit(<string>) 
 
  This function returns the string literally - without even squishing 
  spaces, and without evaluating *anything*. This can be useful for 
  writing ASCII maps with spaces or whatever. 
 
  It can be a bit tricky to get a literal string with spaces into an 
  attrib, however, since spaces are usually squished in setting an 
  attribute. This example illustrates how to make it work: 
 
    > @va me=$test: think {[lit(near       far)]} 
    Set. 
    > ex me/va 
    VA [#1]: $test: think {[lit(near       far)]} 
    > test 
    near       far 
 
  Leaving out the {}'s will not work in the above. 
 
&GREPI() 
  grepi(<object>,<attrs>,<pattern>) 
  
  This function works exactly like grep, but is case-insensitive. 
  See "help grep()" for details.  
&GREP() 
  grep(<object>,<attrs>,<pattern>) 
   
  This function returns a list of attributes on <object> containing 
  <pattern>.  <attrs> is a wildcard pattern for attribute names to 
  search; if you want to search all attributes, use "*". 
   
  Parsing _does_ occur before this function is invoked. Therefore, "special"
  characters will need to be escaped out.  <pattern> is NOT wildcard matched. 
  This function is case-sensitive. grepi() is a case-insensitive version. 
    
&LPARENT()
  lparent(<object>) 
   
  This function returns a list consisting of the object's db# (as per 
  num()), the db# of its parent, grandparent, greatgrandparent, etc. 
  The list will not, however, show parents of objects which the player 
  is not privileged to examine. 
 
&STRCAT() 
  strcat(<string1>, <string2>) 
  
  Concatanates two strings together, with no space between them. 
  For example, strcat(foo bar,baz blech) will return the string 
  "foo barbaz blech". 
  
&STRIPANSI() 
  stripansi(<string>) 
  
  Strips the ansi codes from <string>. 
  
&PMATCH() 
  pmatch(<string>) 
  
  Given the partial name of a player, it returns that player's dbref 
  number. This partial name completion works identically to the partial 
  name completion of the "page" command - i.e. it first attempts to match 
  the normal names of all players (connected or not), and if that fails, 
  it tries to match the partial names of connected players. If no player 
  is matched, it returns "#-1". If more than one match is possible for 
  a partial name, it returns "#-2". 
   
  Pmatch() will also accept *<player> or #<db#>. If given a non-player 
  dbref #, pmatch() will return #-1. 
  
&DIE() 
  die(<number of times to roll die>, <number of sides on die>) 
  
  This function simulates rolling dice. It "rolls" a die with a given 
  number of sides, a certain number of times, and sums the results. 
  For example, DIE(2, 6) would roll "2d6" - two six-sided dice, 
  generating a result in the range 2-12. 
&ALPHAMIN() 
  alphamin(<word1>, <word2>, <word3>, ...) 
 
  Takes up to ten word arguments, and returns the word which is 
  lexicographically smallest. 
    
&ALPHAMAX()
  alphamax(<word1>, <word2>, <word3>, ...) 
 
  Takes up to ten word arguments, and returns the word which is 
  lexicographically biggest. 
    
&ART()
  art(<string>) 
 
  This function returns the proper article, "a" or "an", based on whether 
  or not <string> begins with a vowel. 
    
&HASATTR()
  hasattr(<object>, <attribute name>) 
  
  Returns 1 if the object has the named attribute, and 0 if it does 
  not. If the object does not exist or the player does not have the 
  ability to examine the object, #-1 will be returned. 
  
  Hasattr() doesn't check for attributes inherited from parent 
  objects. Use hasattrp() for that. 
    
&HASATTRP()
  hasattrp(<object>, <attribute name>) 
  
  Returns 1 if the object or its parent has the named attribute, 
  and 0 if it does not. If the object does not exist or the player 
  does not have the ability to examine the object, #-1 will be returned. 
  
  Use hasattr() to check for attributes without checking parents. 
    
&HASTYPE()
  hastype(<object>, <type>) 
 
  Returns 1 if the object is of the named type, otherwise 0. 
  Valid types are: ROOM, EXIT, PLAYER, THING. 
  If an invalid type is given, #-1 is returned. 
    
&SHL()
  shl(<number>,<count>) 
 
  Performs a leftwards bit-shift on <number>, shifting it <count> times. 
  This is equivalent to mul(<number>,pow(2,<count>), but much faster. 
    
&SHR()
  shr(<number>,<count>) 
 
  Performs a rightwards bit-shift on <number>, shifting it <count> times. 
  This is equivalent to div(<number>,pow(2,<count>), but much faster. 
    
&VADD()
  vadd(<vector>,<vector>[,<delimiter>]) 
 
  Returns the sum of two vectors. A vector is a list of numbers 
  separated by spaces or a delimiter, and may be up to 20-dimensional. 
 
  > think vadd(1 2 3,4 5 6) 
  5 7 9 
  > think vadd(0|0|0,1|2|3,|) 
  1|2|3 
    
&VDIM()
  vdim(<vector>[,<delimiter>]) 
 
  Returns the dimensionality of a vector. 
 
  > think vdim(1 2 3 4) 
  4 
    
&VMAG()
  vmag(<vector>[,<delimiter>] 
 
  Returns the magnitude of a vector, using a euclidean distance metric. 
  That is, for vector a b c d, returns sqrt(a^2+b^2+c^2+d^2). 
 
  > think vmag(3 4)  
  5 
    
&VMUL()
  vmul(<vector|number>,<vector|number>[,<delimiter>]) 
 
  Returns the result of either multiplying a vector by a number, 
  or the "dot product" (elementwise product) of two vectors. 
  The dot product of a b c by w x z is aw bx cz 
 
  > think vmul(1 2 3,2) 
  2 4 6 
  > think vmul(1 2 3,2 3 4) 
  2 6 12 
    
&VSUB()
  vsub(<vector>,<vector>[,<delimiter>]) 
 
  Returns the difference between two vectors. 
 
  > think vsub(3 4 5,3 2 1) 
  0 2 4 
    
&VUNIT()
  vunit(<vector>[,<delimiter>] 
 
  Returns the unit vector (a vector of magnitude 1), which points 
  in the same direction as the given vector. 
 
  > think vunit(2 0 0) 
  1 0 0 
  > think vmul(vunit(5 6 7),vmag(5 6 7)) 
  5 6 7 
    
&NEARBY()
 
  Function: nearby(obj1,obj2) 
  
  Tests if obj1 is near obj2 (if it is in the same location, in obj2's 
  inventory, or is obj2's location).  You must control either obj1 or obj2, or 
  be near either one of them, if both of these tests fail then 0 is returned. 
  This function returns 1 if the two objects are nearby and 0 if not. 
 
&GET() 
 
  Function: get(<object>/<attribute>) 
  
  The get function fetches the specified attribute from the named object. 
  It can be used to get attributes from objects you own, public and visual 
  attributes of objects near you, and public and visual attributes other 
  than the description of players wherever they may be.  If the attribute is 
  not present on <object>, its parent is searched for the attribute. 
  
  Example: 
    > read me 
    > say get(me/desc) 
  See also: get_eval(), eval(), xget(). 
 
&XGET() 
 
  Function: xget(<object>,<attribute>) 
  
  This function works exactly like get(), but uses the object and attribute 
  seperated into two arguments. 
  
  See also: get(), eval(), get_eval(). 
  
&EVAL() 
 
  Function: eval(<object>,<attribute>) 
            eval(<string>) 
  
  The first form of the eval function works exactly like the get_eval 
  function, but takes the object and attribute in two seperate arguments 
  instead of an obj/attr pair. It is mainly used for compatibility with 
  PennMUSH 1.50. The second form simply evaluates <string>. This is normally 
  done when a function is called, however, it is useful in evaluating %q and 
  %v substitutions. 
  See also: get_eval(), get(), xget(). 
  
&GET_EVAL() 
 
  Function: get_eval(<object>/<attribute>) 
  
  The get_eval function returns the specified attribute from the named object 
  (just like the get function), except that function references and 
  %-substitutions have already been performed.  In function references,  
  'me' refers to the object being looked at, and %-substitutions that refer 
  to the enactor (such as %n, %#, etc) refer to the object making the get_eval 
  call.  If the attribute is not present on <object>, its parent is searched 
  for the attribute. 
  
  Example: 
    > @va test = This is a get_eval test on %n.  The vb is [get(me/vb)] 
    > @vb test = VB from test 
    > @vb me = VB from me 
    > say get(test/va) 
    You say "This is a get_eval test on %n. The vb is [get(me/vb)]" 
    > say get_eval(test/va) 
    You say "This is a get_eval test on Foobar. The vb is VB from test" 
  See also: get(), get_eval(), xget(). 
 
&TIME() 
 
  Function: time() 
  
  Gives you the current time. 
  WARNING!  This is the time on the machine that the mud is running on, and 
  not where you are. 
  
  Example: 
    > say time() 
    You say "Thu Dec 19 09:48:06 1991" 
  See also: convsecs(), convtime(), secs(). 
 
&RAND() 
 
  Function: rand(<num>) 
  
  Rand returns an integer between 0 and num-1. 
  
  Example: 
    > say rand(10) 
    You say "6" 
    > say rand(10) 
    You say "1" 
    > say rand(10) 
    You say "4" 
    > say rand(10) 
    You say "9" 
    > say rand(10) 
    You say "1" 
 
&EXIT() 
 
  Function: exit(<object>) 
  
  Exit returns the first exit on the list of exits in the object.  Dark exits 
  are not listed, unless you own the object.  Unlike LEXITS(), this function 
  does not provide information about exits in parent objects. 
  
  See also: con(), lcon(), lexits(), next(). 
 
&ABS() 
 
  Function: abs(<number>) 
  
  Returns the absolute value of its argument. 
  <number> may be a floating point number, and a floating point result 
  is returned. 
  
  Examples: 
    > say abs(4) 
    You say "4" 
    > say abs(-4) 
    You say "4" 
    > say abs(0) 
    You say "0" 
 
&MAX() 
 
  Function: max(<number1>,<number2>[,<numberN]...) 
  
  Returns the largest integer from among its arguments. 
  Up to 30 arguments may be specified. 
  <numberN> may be a floating point number, and a floating point result 
  is returned. 
  
  Examples: 
    > say max(2,4) 
    You say "4" 
    > say max(-100,50,0,25) 
    You say "50" 
  
  See also: min() 
 
&MIN() 
 
  Function: min(<number1>,<number2>[,<numberN]...) 
  
  Returns the smallest integer from among its arguments. 
  Up to 30 arguments may be specified. 
  <numberN> may be a floating point number, and a floating point result 
  is returned. 
  
  Examples: 
    > say min(2,4) 
    You say "2" 
    > say min(-100,50,0,25) 
    You say "-10" 
  
  See also: max() 
 
&ADD() 
 
  Function: add(<number1>,<number2>[,<numberN>]...) 
  
  Returns the result of adding its arguments together. 
  You may add up to 30 numbers in one add() call. 
  <numberN> may be a floating point number, and a floating point result 
  is returned. 
  
  Example: 
    > say add(2,4) 
    You say "6" 
    > say add(5,3,7,-4) 
    You say "11" 
  See also: inc(), dec(), div(), mod(), mul(), sub(). 
 
&INC() 
 
  Function: inc(<number>) 
  
  Returns <number> plus 1. Much faster and more efficient than 
  add(<number>,1). 
  
  See also: add(), sub(), dec(). 
  
&DEC() 
 
  Function: dec(<number>) 
  
  Returns <number> minus 1. Much faster and more efficient than 
  sub(<number>,1). 
  
  See also: sub(), add(), inc(). 
  
&SUB() 
 
  Function: sub(<number1>,<number2>) 
  
  Returns the result of subtracting <number2> from <number1>. 
  The numbers may be floating point numbers, and a floating point result 
  is returned. 
  
  Example: 
    > say sub(5,2) 
    You say "3" 
  See also: inc(), dec(), add(), div(), mod(), mul(). 
 
&MUL() 
 
  Function: mul(<number1>,<number2>[,<numberN>]...) 
  
  Returns the result of multiplying its arguments together. 
  <numberN> may be a floating point number, and a floating point result 
  is returned. 
  
  Example: 
    > say mul(3,5) 
    You say "15" 
    > say mul(3,5,-2) 
    You say "-30" 
  See also: add(), div(), fdiv(), mod() round(), sub(), trunc(). 
 
&DIV() 
 
  Function: div(<number1>,<number2>) 
  
  Returns the integer quotient from dividing <number1> by <number2>. 
  <numberN> may be a floating point number, and an integer result is returned. 
  
  Example: 
    > say div(15,3) 
    You say "5" 
    > say div(16,3) 
    You say "5" 
    > say div(17,3) 
    You say "5" 
    > say div(18,3) 
    You say "6" 
    > say div(-17,3) 
    You say XXXXX 
  This function may also be called as idiv(). 
  See also: add(), fdiv(), mod(), mul(), round(), sub(), trunc(). 
 
&FDIV() 
 
  Function: fdiv(<number1>,<number2>) 
  
  Returns the floating point quotient from dividing <number1> by <number2>. 
  <number> may be a floating point number, and a floating point result is 
  returned. 
  
  Results: 
    > say fdiv(15,3) 
    You say "5" 
    > say fdiv(16,3) 
    You say "5.333333" 
    > say fdiv(17,3) 
    You say "5.666667" 
    > say fdiv(18,3) 
    You say "6" 
    > say fdiv(-17,3) 
    You say "-5.666667" 
    > say fdiv(10,3.5) 
    You say "2.857143" 
  See also:   See also: add(), div(), mod(), mul(), round(), sub(), trunc(). 
  
&MOD() 
 
  Function: mod(<integer1>,<integer2>) 
  
  Returns the integer remainder from dividing <integer1> by <integer2>. 
  
  Example: 
    > say mod(15,3) 
    You say "0" 
    > say mod(16,3) 
    You say "1" 
    > say mod(17,3) 
    You say "2" 
    > say mod(18,3) 
    You say "0" 
  See also: add(), fdiv(),div(), mul(), round(), sub(), trunc(). 
 
&DIST2D() 
 
  Function: dist2d(x1, y1, x2, y2) 
  
  Returns the integer distance between the Cartesian points in two dimensions 
  (x1,y1) and (x2,y2). 
  
  Example: 
    > say dist2d(0,0,3,4) 
    You say "5" 
  See also: dist3d() 
 
&DIST3D() 
 
  Function: dist3d(x1, y1, z1, x2, y2, z2) 
  
  Returns the integer distance between the Cartesian points in three 
  dimensions (x1,y1,z1) and (x2,y2,z2). 
  
  Example: 
    > say dist3d(0,0,0,10,15,20) 
    You say "27" 
  See also: dist2d() 
 
&FIRST() 
 
  Function: first(<string>[, <delim>]) 
  
  Returns the first word of a string, that is, everything to the left 
  of the first space in the string, or the entire string if there are 
  no spaces in the string. 
 
  <delim> may be used to specify a word delimiter other than a space. 
  
  Example: 
    > say first(This is a test) 
    You say "This" 
    > say first(Would you like coffee, or perhaps tea) 
    You say "Would" 
    > say first(List&with&nonstandard&delimiters,&) 
    You say "List" 
  See also: rest(). 
 
&REST() 
 
  Function: rest(<string>[, <delim>]) 
  
  The rest function takes a string, returns all the string except the first 
  word, that is, everything to the right of the first space, or an empty  
  string, or the empty string if there are no spaces in the string.   
  
  <delim> may be used to specify a word delimiter other than a space. 
  
  Example: 
    > say rest(This is a test)  
    You say "is a test" 
    > say rest(Would you like coffee, or perhaps tea)  
    You say "you like coffee, or perhaps tea" 
    > say rest(List!with!different!delimiters,!) 
    You say "with!different!delimiters" 
  See also: first(). 
 
&STRLEN() 
 
  Function: strlen(<string>) 
  
  Returns the number of characters in <string>. 
  
  Example: 
    > say strlen(This is a test) 
    You say "14" 
    > say strlen(Would you like coffee, or perhaps tea) 
    You say "37" 
 
&STRTRUNC() 
 
  Function: strtrunc(<string>,<number>) 
  
  This function returns <string> truncated if it is longer than <number>. If 
  <number> is greater than the length of <string>, it just returns <string>. 
  Much more efficient than the equivalent mid(). 
  
  See also: mid(), ljust(). 
  
&MID() 
 
  mid(<string>, <first>, <length>) 
  
  Mid returns a segment of the string, the <length> characters to the 
  right of the <first> character.  Note that the first character in a 
  string is numbered zero, and not one. 
 
&COMP() 
 
  comp(<string1>, <string2>) 
  
  Comp compares two strings.  It returns 0 if they are the same, 1 if 
  string2 is less than/precedes alphabetically string1, and -1  
  otherwise. 
 
&S() 
 
  s(string) 
  
  This function performs pronoun substitution in a string, and then returns 
  that string.  As usually, %n is the name, %s the subjective pronoun, %o the 
  objective, %p the possessive, and %a the absolute possessive.  It is 
  important to note that the pronoun is that of the triggering object. 
  
  So, if the ve of an object were: "[s(This is %n)], and I were to  
  type @trigger <object>/ve, it would return "This is <myname>", but  
  if vf were @trigger me/ve, then triggering the vf makes the ve  
  return "This is <object>" 
 
&POS() 
 
  pos(<string1>,<string2>) 
  
  This function returns the position that string1 begins in string2, 
  with the first position being 1. 
  If string1 is not in string2, then it returns -1. 
  
  Example: pos(man,superman) returns 6 
 
&MATCH() 
 
  Function: match(<string>, <pattern>[, <delim>]) 
  
  This function matches <pattern> against each word of <string>, returning 
  the number of the first word that matches.  If no words match then 0 is 
  returned.  The case of the characters being matched is not significant. 
  
  The pattern may contain the wildcards '*' and '?'.  '?' matches any one 
  character, while '*' matches any number of characters, including none. 
  So 's?x' would match 'sex' or 'six', but not to 'socx', but 's*x' would 
  match any of them. 
 
  <delim> may be used specified to specify a delimiter other than a space. 
 
  Examples: 
    > say match(This is a test, test) 
    You say "4" 
    > say match(This is a test, is) 
    You say "2" 
    > say match(This is a test, *is*) 
    You say "1" 
    > say match(This is a test, *not*) 
    You say "0" 
    > say match(This is a test, is a) 
    You say "0" 
  See also: LISTS, member(), strmatch(). 
 
&STRMATCH() 
 
  Function: strmatch(<string>,<pattern>) 
  
  This function matches <pattern> against the entire <string>, returning 1 
  if it matches and 0 if it does not.  The case of the characters being 
  matched is not significant. 
  
  The pattern may contain the wildcards '*' and '?'.  '?' matches any one 
  character, while '*' matches any number of characters, including none. 
  So 's?x' would match 'sex' or 'six', but not to 'socx', but 's*x' would 
  match any of them. 
  
  Examples: 
    > say strmatch(This is a test,*Test) 
    You say "1" 
    > say strmatch(This is a test,*This) 
    You say "0" 
    > say strmatch(This is a test,*is*is*) 
    You say "1" 
  See also: match(), member(). 
 
&COLUMNS() 
 
  columns(<list>, <width>[, <delim>]) 
  
  Columns displays <list> formatted into columns containing <width> number of
  characters. As many columns as possible will be fit onto the screen.
  Columns takes an optional delimiter.
  
&FOREACH() 
 
  foreach([<object>/]<attribute>,<string>) 
  
  Maps a function onto a string. 
  
  Each character in <string> has the user-defined function of the first 
  argument performed on it; the character is passed to the function as 
  %0. The results are concatenated. 
  
  Examples: 
  
    > &add_one me=[add(%0,1)] 
    > say [foreach(add_one, 54321)] 
    You say, "65432" 
  
    > &is_alphanum me=[or(isword(%0),isnum(%0))]%b 
    > say [foreach(is_alphanum,jt1o+)] 
    You say, "1 1 1 1 0 " 
  
&MIX() 
  
  mix([<object>/]<attribute>,<list 1>,<list 2>[,<delim>]) 
  
  This function is similar to MAP(), except that it takes the elements 
  of both lists, one by one, and passes them to the user-defined function 
  as %0 and %1, respectively, for elements of <list 1> and <list 2>. 
  <delim> is used to separate elements; if it is not specified, it 
 defaults to a space. The lists must have the same number of elements. 
  
  Examples: 
  
  > &add_nums me=[add(%0,%1)] 
  
  > say [mix(add_nums,1 2 3 4 5,2 4 6 8 10)] 
  You say, "3 6 9 12 15" 
  
  > say [mix(add_nums,1:3:5:7,0:2:4:6,:)] 
  You say, "1:5:9:13" 
  
&MUNGE() 
  
  munge([<object>/]<attribute>,<list 1>,<list 2>[,<delimiter>]) 
  
  This function takes two lists of equal length. It passes the entirety of 
  <list 1> to the user-defined function as %0. Then, this resulting list 
  is matched with elements in <list 2>, and the rearranged <list 2> is 
  returned. This is useful for doing things like sorting a list, and then 
  returning the correspoding elements in the other list. If a resulting 
  element from the user-defined function doesn't match an element in the 
  original <list 1>, a corresponding element from <list 2> does not appear 
  in the final result. 
  
  For example: Consider attribute PLACES, which contains "Fort Benden Ista", 
  and another attribute DBREFS contains the dbrefs of the main JUMP_OK 
  location of these areas, "#20 #9000 #5000".  We want to return a list of 
  dbrefs, corresponding to the names of the places sorted alphabetically. The 
  places sorted this way would be "Benden Fort Ista", so we want the final 
  list to be "#9000 #20 #5000". The functions, using munge(), are simple: 
  
  > &sort_alpha me=[sort(%0)] 
  > say [munge(sort_alpha,v(places),v(dbrefs))] 
  You say, "#9000 #20 #5000" 
  
&OBJEVAL() 
 
  objeval(<object>,<expression>) 
  
  Allows you to evaluate <expression> from the viewpoint of <object>. 
  You must be a wizard to use this function. If <object> does not exist or 
  you don't meet the criterion, the function evaluates with your privileges. 
  
  This function is useful for securing objects which need to evaluate 
  attributes on things owned by others. 
  
&OBJMEM(<object>) 
 
  Returns the size in bytes of <object>. 
  Note that this is the complete struct size of the object, and 
  not just the attribute values. 
  
&PLAYMEM(<player>) 
  
  Returns the size in bytes of <player>. 
  Note that this is the total number of bytes that the player uses, 
  including all objects that they own. You must be a Wizard, or have 
  the search power to use this function on another player. 
  
&ANDFLAGS() 
 
  andflags(<object>,<list of flags>) 
  
  This function returns 1 if <object> has all the flags in a specified 
  list, and 0 if it does not. The list is specified with a single letter 
  standing for each flag, like the output of the FLAGS() function. A '!' 
  preceding a flag letter means "not flag". 
  
  Thus, ANDFLAGS(me,WD) would return 1 if I was set WIZARD and DARK. 
  ANDFLAGS(me,W!Dc) would return 1 if I was set WIZARD, not DARK, 
  and CONNECTED. 
  
  If a letter does not correspond to any flag, <object> doesn't have 
  it, so the function returns 0. There can be an arbitrary number of 
  flags. Do not put spaces between flag letters. 
  
&ORFLAGS() 
 
  orflags(<object>,<list of flags>) 
  
  This function returns 1 if <object> has at least one of the flags in 
  a specified list, and 0 if it does not. The list is specified with a 
  single letter standing for each flag, like the output of the FLAGS() 
  function. A '!' preceding a flag letter means "not flag". 
  
  Thus, ORFLAGS(me,Wr) would return 1 if I am set WIZARD or ROYALTY. 
  ORFLAGS(me,D!c) would return 1 if I am DARK or not CONNECTED. 
  
  If a letter does not correspond to any flag, <object> doesn't have 
  it, so it is simply ignored. There can be an arbitrary number of 
  flags. Do not put spaces between flag letters. 
  
&EXTRACT() 
 
  extract(<string>, <first>, <length>[, <delim>]) 
  
  Extract returns a string of length words, starting with the first  
  word. Unlike letters, the first word in a string is number 1,  
  instead of 0. 
  
  <delim> may be used to specify a delimiter other than a space. 
 
  Examples: 
    > say extract(This is a really neat example, 4, 2) 
    You say "really neat" 
    > say extract(Another@funky@test@for@extract, 3, 3) 
    You say "test@for@extract"  
  See also: index(), insert(), ldelete(), replace(). 
 
&INDEX() 
 
  Function: index(<list>,<character>,<first>,<length>) 
   
  This function is similar to EXTRACT(), except that an item in the 
  list may be more than one word; instead of a space being used to 
  separate items in the list, <character> is used. The function returns  
  <length> items starting from that in the <first> position. Trailing 
  spaces are trimmed. The comma cannot be used as the <character> separator.  
  
  Example: 
    > say [index(Cup of Tea | Mug of Beer | Glass of Wine, |, 2, 1)] 
    You say, "Mug of Beer" 
  See also: extract(). 
 
&FLAGS() 
 
  flags(<object>) 
  
  Flags returns a string consisting of the flags attached to the  
  object. The string is, however, just one word.  Note that @switch 
  is case-INsensitive.  i.e. p=P as far as it is concerned.  I wish 
  that P=NP.... 
 
&NUM() 
 
  num(<object>) 
  
  Returns the dbref number of <object>. 
  
  See also: locate(). 
 
&CON() 
 
  con(<object>) 
  
  Con returns the first object in the list of objects carried by  
  thing. Just the first, and only the first.  See NEXT. 
 
&LOC() 
 
  Function: loc(<object>) 
  
  Returns the number of the location where <object> is.  You must either 
  control the object or be nearby for it to work.  When used on an exit it 
  returns the destination of the exit.  You can also use loc() to find the 
  location of players that are not set UNFINDABLE. 
  
  Example: 
    > look 
    Mortal's Room(#367R) 
    A bare room with nothing in it but a bed and a chair. 
    Contents: 
    hat(#368) 
    > say loc(me) 
    You say "#367" 
    > enter hat 
    hat(#368) 
    Contents: 
    cat(#325) 
    > say loc(me) 
    You say "#368" 
    > say loc(here) 
    You say "#367" 
  See also: rloc(), room(), where(). 
 
&RLOC() 
 
  Function: rloc(<object>,<levels>) 
  
  This function may be used to get the location of an object's location 
  (for which you would previously use 'loc(loc(<object>))', which fails if you 
  don't control <object>'s location).  <levels> indicates the number of 
  nested 'loc' calls to make, so 'loc(loc(<object>))' could be replaced with 
  'rloc(<object>,2)'.  If rloc() encounters a room, the dbref of the room 
  is returned. 
  
  You must either control the object or be nearby for it to work.  When used 
  on an exit it returns the destination of the exit.  You can also use rloc() 
  to find the location of players that are not set UNFINDABLE. 
  
  rloc(<object>,0) is the same as num(<object>), and rloc(<object>,1) is the 
  same as loc(<object>). 
  
  See also: loc(), where(). 
 
&WHERE() 
 
  Function: where(<object>) 
  
  This function returns the "true" location of an object. You must control 
  the object or be near it in order for it to work. For players and things, 
  the "true" location is the normal location of the object. For exits, the 
  "true" location is the source room. For rooms, it is #-1. 
  See also: loc(), rloc(). 
 
&OWNER() 
 
  Function: owner(<object>) 
            owner(<object>/<attrib>) 
  
  The first form of the owner() function returns the dbref of the owner of the 
  object.  The object must either be yours or nearby. 
  
  The second form returns the owner of an attribute on the named object. 
  You must own either the object or the attribute. 
 
&NAME() 
 
  name(<dbref>) 
  
  This function returns the name of the indicated object.  When called with 
  an exit it returns the only the first alias. 
 
  See also: fullname(). 
 
&FULLNAME() 
 
  Function: fullname(<dbref>) 
   
  This function returns the full name of the indicated object.  This is the 
  same as name() in all cases except when <dbref> is an exit, then all the 
  aliases are returned as well. 
  
  See also: name(). 
 
&NEXT() 
 
  next(<thing>) 
  
  If thing is an exit in a room, then next will return the next  
  nondark exit in the list of exits for that room.  If thing is an  
  object, then next will return the next object in the inventory list  
  that the object is in.  Otherwise, it returns a '#-1' string. 
 
&AND() 
 
  Function: and(<boolean1>,<boolean2>[,<booleanN>]...) 
  
  Takes two or more booleans, and returns 1 if they are all each equivalent 
  to true(1). 
  
  See also: BOOLEAN VALUES, or(), not(), xor(). 
 
&OR() 
 
  Function: or(<boolean1>,<boolean2>[,<booleanN>]...) 
  
  Takes two or more booleans, and returns 1 if at least one is equivalent 
  to true(1). 
  
  See also: BOOLEAN VALUES, and(), not(), xor(). 
 
&NOT() 
 
  Function: not(<boolean>) 
  
  Takes a boolean value, and returns its inverse.  So, if the input is 
  equivalent to true(1) it returns a 0, and if the input is equivalent to 
  false(0), it returns a 1. 
  
  See also: BOOLEAN VALUES, and(), or(), xor(). 
 
&XOR() 
 
  Function: xor(<boolean1>,<boolean2>[,<booleanN>]...) 
  
  Takes two or more booleans, and returns 1 if an odd number of them are 
  equivalent to true(1). 
  
  See also: BOOLEAN VALUES, and(), nor(), or(). 
 
&gt() 
 
  Function: gt(<integer1>,<integer2>) 
  
  Takes two integers, and returns 1 if and only if <integer1> is greater than 
  <integer2>, and 0 otherwise.  Warning: passing anything but integers will 
  produce unexpected results, as non-numeric strings usually are treated 
  as numeric 0. 
  
  Example: 
    > say gt(4,5) 
    You say "0" 
    > say gt(5,5) 
    You say "0" 
    > say gt(6,5) 
    You say "1" 
    > say gt(foo, bar) 
    You say "0" 
  See also: lt(), lte(), gte(), eq(), neq(). 
 
&gte() 
 
  Function: gte(<integer1>,<integer2>) 
  
  Takes two integers, and returns 1 if and only if <integer1> is greater than 
  or equal to <integer2>, and 0 otherwise.  Warning: passing anything but 
  integers will produce unexpected results, as non-numeric strings usually are 
  treated as numeric 0. 
  
  Example: 
    > say gte(4,5) 
    You say "0" 
    > say gte(5,5) 
    You say "1" 
    > say gte(6,5) 
    You say "1" 
    > say gte(foo, bar) 
    You say "1" 
  See also: lt(), lte(), gt(), eq(), neq(). 
 
&lt() 
 
  Function: lt(<integer1>,<integer2>) 
  
  Takes two integers, and returns 1 if and only if <integer1> is less than 
  <integer2>, and 0 otherwise.  Warning: passing anything but integers will 
  produce unexpected results, as non-numeric strings usually are treated 
  as numeric 0. 
  
  Example: 
    > say lt(4,5) 
    You say "1" 
    > say lt(5,5) 
    You say "0" 
    > say lt(6,5) 
    You say "0" 
    > say lt(foo, bar) 
    You say "0" 
  See also: lte(), gte(), gt(), eq(), neq(). 
 
&lte() 
 
  Function: lte(<integer1>,<integer2>) 
  
  Takes two integers, and returns 1 if and only if <integer1> is less than or 
  equal to <integer2>, and 0 otherwise.  Warning: passing anything but integers 
  will produce unexpected results, as non-numeric strings usually are treated 
  as numeric 0. 
  
  Example: 
    > say lte(4,5) 
    You say "1" 
    > say lte(5,5) 
    You say "1" 
    > say lte(6,5) 
    You say "0" 
    > say lte(foo, bar) 
    You say "1" 
  See also: lt(), gte(), gt(), eq(), neq(). 
 
&EQ() 
 
  Function: eq(<integer1>,<integer2>) 
  
  Takes two integers, and returns 1 if they are equal and 0 if they are not. 
  Warning: passing anything but integers will produce unexpected results, 
  as non-numeric strings usually are treated as numeric 0. 
  
  Example: 
    > say eq(1,-1) 
    You say "0" 
    > say eq(5,5) 
    You say "1" 
    > say eq(foo, bar) 
    You say "1" 
  See also: lt(), lte(), gte(), gt(), neq(). 
 
&NEQ() 
 
  Function: neq(<integer1>,<integer2>) 
  
  Takes two integers, and returns 1 if they are not equal and 0 if they are 
  equal.  Warning: passing anything but integers will produce unexpected 
  results, as non-numeric strings usually are treated as numeric 0. 
  
  Examples: 
    > say neq(1,-1) 
    You say "1" 
    > say neq(5,5) 
    You say "0" 
    > say neq(foo, bar) 
    You say "0" 
  See also: lt(), lte(), gte(), gt(), eq(), not(). 
 
&CAT() 
 
  Function: cat(<string>[,<stringN>]) 
  
  cat returns a string made up of the contents of string1 through stringN, 
  with each string separated from its neighbors by a space. 
  
  Example: 
    > say cat(this is, a test) 
    You say "this is a test" 
    > say cat(This is,another,test of the,CAT function) 
    You say "This is another test of the CAT function" 
 
&MEMBER() 
 
  Function: member(<list>, <word>[, <delim>]) 
  
  Member takes a list and a word, and returns the position of that word 
  within the list.  If the word does not occur in the list, then 0 is 
  returned.  Unlike match(), member() does not check for wildcarding, 
  and the cases of <list> and <word> are significant.  A word is defined as 
  a string which has no interior spaces.  So 'hello' would be one word, 
  while 'hello there' would be two. 
 
  <delim> may be used to specify a delimiter other than a space. 
  
  Example: 
    > say member(This is a member test, member) 
    You say "4" 
    > say member(This is a member test, Member) 
    You say "0" 
    > say member(This is a member test, *e*)    
    You say "0" 
    > say member(This is a member test, is a) 
    You say "#-1 CAN ONLY TEST ONE ELEMENT" 
  
  See also: LISTS, findelem(), match(), strmatch(). 
 
&REMOVE() 
 
  Function: remove(<list>, <word>[, <delim>]) 
  
  Remove takes a list and a word, and returns the list, with the word deleted 
  from it.  <delim> may be used to specify a delimiter other than a space. 
  
  Example: 
    > say remove(this is a test, is) 
    You say "this a test" 
    > say remove(You can't remove, this) 
    You say "You can't remove" 
    > say remove(You can't remove multiple words, You can't) 
    You say "#-1 CAN ONLY DELETE ONE ELEMENT" 
    > say remove(How about an o-separated list, w ab, o)  
    You say "Hout an o-separated list" 
 
&STARTTIME() 
 
  Function: starttime() 
  
  Returns a string which is the time the MUX last rebooted.  The time 
  is in the same format as the TIME() function returns. 
  
  Example: 
    > say starttime() 
    You say "Sat Dec  7 00:09:13 1991 
  See also: convtime(). 
 
&SECS() 
 
  Function: secs() 
  
  Returns the number of elapsed seconds since midnight, January 1, 1970. 
  This is an easy way to time things. 
  
  Example: 
     > say secs() 
     You say "692636020" 
     ... wait a bit ... 
     > say secs() 
     You say "692636043" 
  See also: convsecs(), convtime(), time(). 
 
&WORDS() 
 
  words(<string>[, <delim>]) 
  
  Returns the number of words in <string>.  <delim> may be used to specify 
  a delimiter other than a space. 
  
  Example: 
    > say words(This is a test) 
    You say "4" 
    say words(Would you like coffee or perhaps tea?) 
    > You say "7" 
    say words(This:is:a:colon:separated:list,:) 
    > You say "6" 
 
&VERSION() 
 
  Function: version() 
  
  Returns a string which contains various version information for the MUX 
  you're on. 
  
  Example: 
     > version 
     TinyMUX Beta version 2.0 patchlevel 0 #3 
     Build date: Thu Dec  5 10:10:07 EST 1991 
     > say version() 
     You say "TinyMUX Beta version 2.0 patchlevel 0 #3" 
 
&HOME() 
 
  home(<object>) 
  
  Returns the object's home. 
  
  Example: 
    > exam me 
    Mortal(#226Pc) 
    Type: PLAYER Flags: CONNECTED 
    Desc:Just a plain, old boring Mortal. You know. 
    Owner: Mortal  Key: VA:foobar Clams: 920 
    Last:Thu Dec 19 08:57:21 1991 
    Home: Mortal's Room(#367R) 
    Location: The Town Square 
    > say home(me) 
    You say "#367" 
 
&MONEY() 
 
  Function: money(<object>) 
  
  Returns an integer equal to the amount of money <object> has (if it is a 
  player) or is worth (otherwise). 
  Example: 
    > score 
    You have 1052 clams. 
    > say money(me) 
    You say "1052" 
    > exam sac test 
    Sac Test(#287V) 
    Type: THING Flags: VISUAL 
    Owner: Beaker  Key: *UNLOCKED* Clams: 20 
    Home: Limbo(#0RLDAJ) 
    Location: The Town Square 
    > say money(sac test) 
    You say "20" 
 
&LCON() 
 
  Function: lcon(<object>) 
  
  Returns a space-separated list of the contents of <object>. 
  
  Example: 
    > i 
    t1(#366) 
    radio(#223) 
    The Wizard's Pointy Hat(#188SO) 
    You have 42463 clams. 
    > say lcon(me) 
    You say "#366 #223 #188" 
  See also: lexits(), @dolist. 
 
&LEXITS() 
 
  Function: lexits(<loc>) 
  
  Returns a space-separated list of the exits in <loc> and its parents. 
  Dark exits are not returned unless you own the location. 
  
  Example: 
    > look here 
    The Town Square 
    You are in the town square.  All around you ..... 
    Obvious exits: 
    foo  up  southeast  sw  north   
    > say lexits(here) 
    You say "#302 #10 #9 #8 #6" 
  See also: lcon(), @dolist, PARENT OBJECTS. 
 
&SECURE() 
 
  Function: secure(<string>) 
  
  Returns <string> after replacing the characters [](){};%\$ with spaces. 
  This prevents strings entered by players from causing undesired side 
  effects when used, such as making your object perform unintended commands 
  or give out information to which you have access.  Note that this function 
  is only needed when the resulting string is to be passed through the @force 
  command or be used as an attribute for an object (like the success message 
  for a mail message object). 
  
    > @va me=Sneak a peek at Wiz's desc... [get(#1/desc)] 
    > say secure(%va) 
    You say "Sneak a peek at Wiz's desc...  get #1/desc  " 
    > say secure($foobar:this {is} a really, tough ; test.) 
    You say " foobar:this is a really tough   test." 
  
  Note: 'say secure(Sneak a peek at Wiz's desc... [get(#1/desc)])' does not 
  produce the expected result because the argument is evaluated BEFORE being 
  processed by secure(), therefore the [get()] call has already been 
  performed. 
  See also: escape(). 
 
&ESCAPE() 
 
  Function: escape(<string>) 
  
  Returns <string> after adding an escape character (\) at the start of the 
  string and also before each of the characters %;[]{}\ that appear in the 
  string.  This prevents strings entered by players from causing undesired 
  side effects when used, such as making your object perform unintended 
  commands or give out information to which you have access.  Note that this 
  function is only needed when the resulting string is to be passed through 
  the @force command or be used as an attribute for an object (like the 
  success message for a mail message object).  This function has the  
  advantage over the secure() function in that the string the user sees 
  after evaluating it is the same as the original string. 
  
  Example: 
    You say "\Sneak a peek at Wiz's desc... \[get(#1/desc)\]" 
  
  Note: 'say escape(Sneak a peek at Wiz's desc... [get(#1/desc)])' does not 
  produce the expected result because the argument is evaluated BEFORE being 
  processed by escape(), therefore the [get()] call has already been 
  performed. 
  See also: secure(). 
 
&MUDNAME() 
  Function: mudname() 
  
  Returns the name of the MUD.  This is usually (but not necessarily) the name 
  that appears in the various mud lists, and is the name that the mud is 
  listed under in reports from RWHO servers (that is, if the mud sends its 
  WHO information to an RWHO server). 
  
  Example: 
    > say mudname() 
    You say "TestMUX" 
 
&CAPSTR() 
 
  Function: capstr(<string>) 
  
  Returns <string> with the first character capitalized.  If the first 
  character is not a letter, this function returns the string unmodified. 
  
  Example: 
    > say capstr(this is a string I want capitalized) 
    You say "This is a string I want capitalized" 
  See also: lcstr(), ucstr(). 
 
&LCSTR() 
 
  Function: lcstr(<string>) 
  
  Returns <string> with all letters converted to lowercase. 
  
  Example: 
    > say lcstr(This is something I want to TEST) 
    You say "this is something i want to test" 
  See also: capstr(), ucstr(). 
 
&UCSTR() 
 
  Function: ucstr(<string>) 
  
  Returns <string> with all letters converted to uppercase. 
  
  Example: 
    > say ucstr(This is a test, really!) 
    You say "THIS IS A TEST, REALLY!" 
  See also: capstr(), lcstr(). 
 
&LNUM() 
 
  Function: lnum(<number>) 
  
  Returns a list of numbers from 0 to <number>-1. 
  
  Example: 
    > say lnum(5)  
    You say "0 1 2 3 4" 
 
&LATTR() 
 
  Function: lattr(<object>[/<wild-pattern>]) 
  
  Returns a list of the attributes set on <object>.  If <wild-pattern> is 
  given, only attributes matching it are returned. 
  
  Example: 
    > ex me 
    Mortal(#226Pc) 
    .... 
    VC:Mon Sep  9 12:09:01 1991 
    VE:baz 
    Last:Thu Dec 19 08:57:21 1991 
    VV(#2+):Foof! 
    Domain:Abusees 
    .... 
    > say lattr(me) 
    You say "Desc VC VE Last VV Domain" 
    > say lattr(me/v*) 
    You say "VC VE VV" 
  
  See also: @dolist. 
 
&REVERSE() 
 
  Function: reverse(<string>) 
  
  Reverses the order of the characters of <string>. 
  
  Examples: 
    > say reverse(This is a test) 
    You say "tset a si sihT" 
    > say reverse(This is a test, Really...) 
    You say "...yllaeR ,tset a si sihT" 
    > say reverse(A man, a plan, a canal -- Panama!) 
    You say "!amanaP -- lanac a ,nalp a ,nam A" 
  See also: revwords(). 
 
&REVWORDS() 
 
  Function: revwords(<string>[, <delim>]) 
  
  Reverses the order of the words of <string>.  A word is considered to be 
  any sequence of nonblank characters, separated by blanks, so punctuation 
  characters that follow a word are considered part of the word. 
 
  <delim> may be used to specify a delimiter other than a space. 
  
  Examples: 
    > say revwords(This is a test, Really...) 
    You say "Really... test, a is This" 
    > say revwords(Was it a cat I saw?) 
    You say "saw? I cat a it Was" 
  See also: reverse(). 
 
&BEFORE() 
 
  Function: before(<string1>, <string2>) 
  
  Returns the portion of <string1> that occurs before <string2>.  If <string2> 
  does not occur in <string1>, the entire string is returned. 
  If you want to return the portion of the string after the first space, 
  use the first() function instead. 
  
  Examples: 
    > say before(This is a test,a) 
    You say "This is " 
    > say before(This is a test,is) 
    You say "Th" 
    > say before(This is a test, nope)  
    You say "This is a test" 
  See also: after(), first(), rest(). 
 
&AFTER() 
 
  Function: after(<string1>, <string2>) 
  
  Returns the portion of <string1> that occurs after <string2>.  If <string2> 
  does not occur in <string1>, a null string is returned. 
  If you want to return the portion of the string after the first space, 
  use the rest() function instead. 
  
  Examples: 
    > say after(This is a test,a) 
    You say " test" 
    > say after(This is a test,is) 
    You say " is a test" 
    > say after(This is a test, nope) 
    You say "" 
  See also: before(), first(), rest(). 
 
&ROOM() 
 
  Function: room(obj) 
  
  Returns the number of the room that <obj> is in, or would be in if it 
  executed LEAVE commands until it got to a room.  You can find out the 
  containing room of objects you own, nearby objects, and findable players. 
  
  Example: 
    > i 
    You are carrying: 
    hat(#368) 
    cat(#325) 
    > look 
    Mortal's Room(#367R) 
    A bare room with nothing in it but a bed and a chair. 
    > say I am in [room(me)], the cat is in room [room(cat)]. 
    You say "I am in #367, the cat is in room #367." 
    > @fo hat=get cat  
    cat has left. 
    > say The cat is in [loc(#325)] within room [room(#325)]. 
    You say "The cat is in #368 within room #367." 
  See also: loc(), UNFINDABLE. 
 
&SEARCH() 
 
  Function: search([<player>] [<class>=<restriction>[,<low>[,<high>]]]) 
  
  The search() function returns a list of objects that match the search 
  criteria, which are the same as with the @search command.  This function 
  costs as much as the @search command, so repeated use is expensive. 
  
  Caution: if you use the [ and ] characters in an Eval selection you will 
  need to escape them. 
  
  Examples: 
    > say search() 
    You say "#226 #289 #325 #364 #368 #369" 
    > @stats me 
    6 objects = 0 rooms, 0 exits, 5 things, 1 players. (0 garbage) 
    > say search(eval=\[eq(money(##),1)\]) 
    You say "#289 #325 #364 #368 #369" 
    > say search(player=wizard) 
    You say "#1" 
  See also: @search, SEARCH CLASSES. 
 
&STATS() 
 
  Function: stats([<player>]) 
  
  This function returns information about the number of objects on the MUX, 
  much like the @stats command.  If the argument is omitted or is 'all', then 
  the stats for the entire MUX are returned, otherwise the stats for the 
  named player are returned.  You can only get stats for yourself. 
  
  The stats are returned as a set of 6 numbers, in the same order as reported 
  by the @stats command: total objects, rooms, exits, things, players, and 
  garbage.  This command costs as much as the equivalent @stats command (ie: 
  '@stats/all' or '@stats <player>', not the free '@stats'). 
  
  Examples: 
    > @stats me 
    6 objects = 0 rooms, 0 exits, 5 things, 1 players. (0 garbage) 
    > say stats(me) 
    You say "6 0 0 5 1 0" 
    > say stats() 
    You say "377 51 165 134 20 7" 
    > @stats/all 
    377 objects = 51 rooms, 165 exits, 134 things, 20 players. (7 garbage) 
  See also: @stats. 
 
&ITER() 
 
  Function: iter(<list>, <eval>[, <delim>]) 
  
  <list> is a <delimter>-separated list of strings, which can be object 
  numbers, attributes, or arbitrary words.  <eval> is a string that is to be 
  evaluated once for each item in <list>, replacing the special symbol ## with 
  the corresponding item from <list>.  A space-separated list of the results 
  of these evaluations is returned to the caller.  The effect is very similar 
  to @dolist, except that the results are made into a list and returned, not 
  executed. 
  
  Examples: 
    > say iter(This is a test,strlen(##)) 
    You say "4 2 1 4" 
    > say iter(This is a test,{strlen(##)}) 
    You say "4 2 1 4" 
    > say iter(lnum(10),mul(mul(##,##),10)) 
    You say "0 10 40 90 160 250 360 490 640 810" 
    > say iter(lcon(me),[name(##)]..[money(##)]) 
    You say "test..1 t1..1 radio..1 The Wizard's Pointy Hat..1" 
    > say iter(Was it a cat I saw,words(##),s) 
    You say "1 4 1" 
  See also: @dolist, list(), parse(). 
 
&LIST() 
  
  Function: list(<list>, <eval>[, <delim>]) 
  
  This function is exactly like iter() but serves a specialized purpose: 
  MUX has a buffer limit, and for things like lists of players, iter() can 
  quickly become inadequate, since the output is cut off before the listing 
  is finished. The normal way to handle this is to use a @dolist/@pemit 
  combination, but that takes many queue cycles. list() takes <list>, 
  <eval>, and an optional delimiter, and evaluates them exactly like 
  iter(). The difference is the output: iter() produces a space seperated 
  list, while list() outputs each list item on a new row of the screen. 
  
  NOTE: This is a side effect function. It does not return anything, 
  instead, it prints its output directly to the screen of the player causing 
  the function to be evaluated. Since it does this, it is not hampered by 
  the buffer limit. 
  
  See also: iter(), @dolist, parse(). 
  
&LOCATE() 
 
  Function: locate(<looker>,<string>,<where>) 
  
  The locate function is used to look for an object from the perspective of 
  <looker> (You must own <looker>).  The database number of the item that 
  is found is returned.  The <where> parameter specifies a list of places to 
  look, from this list: 
    a    - Look for absolute references (#<number>) 
    c    - Look for exits carried by <looker> (and by <looker>'s parents). 
    e    - Look for exits in <looker>'s location (and the location's parents). 
    h    - Look for 'here', which matches <looker>'s location. 
    i    - Look in <looker>'s inventory. 
    m    - Look for 'me', which matches <looker>. 
    n    - Look for <looker>'s neighbors (other objects in the same location). 
    p    - Look for player names prefixed by a '*' 
    *    - Look for everything in the above list. 
<Continued in HELP LOCATE2>
     
&locate2 
 
  You may also specify qualifiers in <where> to help resolve possible 
  ambiguities: 
    E    - Prefer exits over other types. 
    L    - Prefer unlocked exits over locked exits. 
    P    - Prefer players over other types. 
    R    - Prefer rooms over other types. 
    T    - Prefer things over other types. 
    V    - Report "Can't find..." and "Which one..." errors to <looker>. 
    X    - Select randomly if search finds multiple matches. 
  
  If nothing matches, the value #-1 is returned.  If more than one thing 
  of the preferred type matches, but nothing matches exactly, the value #-2 
  is returned, except if the X qualifier was specified in which case one is 
  chosen at random.  If more than one thing exactly matches, one is chosen 
  at random.  If you specify more than one type preference (E, P, R, or T), 
  then the last one entered is the one that is obeyed.  The default is for 
  no type to be preferred. 
<Continued in HELP LOCATE3>
     
&locate3 
 
  Examples: 
    > i 
    test1(#378) 
    test(#376) 
    You have 42463 clams. 
    > look 
    Nullspace(#250R) 
    test1(#382) 
    > say locate(me,test,i)                > say locate(me,tes,in) 
    You say "#376"                         You say "#-2" 
    > say locate(me,test,n)                > say locate(here,tes,*) 
    You say "#382"                         You say "#382" 
    > say locate(me,test1,in)              > say locate(me,out,e) 
    You say "#378"                         You say "#252" 
    > say locate(me,test1,in)              > say locate(me,here,*) 
    You say "#382"                         You say "#250" 
 
  See also: num(), PARENT OBJECTS. 
 
&EDIT() 
 
  Function: edit(<string>,<from>,<to>) 
  
  This function edits <string>, replacing all occurrences of the substring 
  <from> with the string <to>.  If <from> is '$', then <to> is appended to 
  <string>, while if <from> is '^', then it is prepended. 
  
  Examples: 
    > say edit(This is a test,is,x)    
    You say "Thx x a test" 
    > say edit(Atlantic,^,Trans) 
    You say "TransAtlantic" 
  See also: @edit. 
 
&U() 
 
  Function: u([<obj>/]<attr>[,<arg>]...) 
  
  The u function evaluates an attribute, either from the object performing the 
  function or from another object you own, passing in arguments and returning 
  the result. 
 
  When evaluating the fetched attribute, %# refers to the original enactor and 
  not the 'calling' object, and 'me' refers to the object that supplied the 
  attribute. 
  
  Examples: 
    > @va me=Word is [extract(v(vb),add(%0,1),1)], arg2 is %1. 
    > @vb me=This is a test of the u function. 
    > say u(va,4,Testing 123) 
    You say "Word is of, arg2 is Testing 123." 
    > say u(va,7) 
    You say "Word is function., arg2 is ." 
    > say u(me/va,6,Foobar) 
    You say "Word is u, arg2 is Foobar." 
  See also: s(), v(), get(), get_eval(), map(). 
 
&SWITCH() 
 
  Function: switch(<str>[,<pat1>,<res1>]...[,<dflt>]) 
  
  The switch function compares <str> against <pat1>, <pat2>, etc (allowing * 
  to match any number of characters and ? to match any 1 character), and 
  returns the corresponding <resN> parameter for the first <patN> pattern 
  that matches.  If none match, then the default result <dflt> is returned. 
  
  Example: 
    > say switch(c,*a*,A,*b*,B,*c*,C,*d*,D,E) 
    You say "C" 
    > say switch(f,*a*,A,*b*,B,*c*,C,*d*,D,E) 
    You say "E" 
    > say switch(cab,*a*,A,*b*,B,*c*,C,*d*,D,E) 
    You say "A" 
    > say switch(f,*a*,A,*b*,B,*c*,C,*d*,D)   
    You say "" 
  See also: @switch, match(), ifelse(). 
 
&IFELSE() 
 
  Function: ifelse(<expression>,<true string>,<false string>) 
  
  This function returns <true string> if <expression> is true (greater than 
  0), <false string> otherwise. Much more efficient than an equivalent 
  switch(). It can also return different messages based on whether 
  <expression> is nothing or contains text. For example,  
      ifelse(v(test),Test exists!,Test doesn't exist.) 
  
  See also: switch(). 
  
&SPACE() 
 
  Function: space(<count>) 
  
  Returns the number of indicated spaces.  If <count> is missing, negative, 
  or cannot be converted to a number, one space is returned.  This function 
  is useful when you want to pass a single space (or more than one) as a 
  function to an argument, because normally leading and trailing spaces are 
  stripped from function arguments. 
  
  Examples: 
    > say space(4) 
    You say "    " 
    > say edit(Foo bar bletch, space(), X) 
    You say "FooXbarXbletch" 
 
&PARENT() 
 
  Function: parent(<obj>) 
  
  Returns the parent of <obj>.  Returns #-1 if <obj> cannot be found or 
  if you do not own <obj> and it is not set VISUAL. 
  
  Example: 
    > say parent(me) 
    You say "#-1" 
    > say My va is [v(va)]. 
    You say "My va is " 
    > @parent me=test 
    Parent set. 
    > say parent(me) 
    You say "#323" 
    > say My va is [v(va)]. 
    You say "My va is Testing 123" 
  See also: @parent, PARENT OBJECTS. 
 
&SIGN() 
 
  Function: sign(<number>) 
  
  Returns -1, 0, or 1 depending on whether its argument is negative, zero, or 
  positive (respectively). 
  
  Example: 
  > say sign(-4) 
  You say "-1" 
  > say sign(4) 
  You say "1" 
  > say sign(0) 
  You say "0" 
  > say sign(-1) 
  You say "-1" 
 
&CONN() 
 
  Function: conn(<player>) 
  
  Returns the number of seconds that <player> has been connected.  If <player> 
  is not connected then -1 is returned.  If <player> is connected more than 
  once, the longest connect time is returned. 
  
  Example: 
    > WHO 
    Player Name          On For Idle  Doing 
    Wizard                00:04   1m 
    Mortal                00:11   0s   
    Evinar                00:12   6m  Idle. :)   
    frobozz               00:32   6s   
    4 Players logged in. 
    > say conn(wiz) 
    You say "251" 
    > say conn(e) 
    You say "770" 
    > say conn(frobozz) 
    You say "-1" 
  See also: WHO, idle(), lwho(). 
 
&IDLE() 
 
  Function: idle(<player>) 
  
  Returns the number of seconds that <player> has been idle.  If <player> 
  is not connected then -1 is returned.  If <player> is connected more than 
  once, the smallest idle time is returned. 
  
  Example: 
    > WHO 
 
    Player Name          On For Idle  Doing 
    Wizard                00:04   1m 
    Mortal                00:11   0s   
    Evinar                00:12   6m   
    frobozz               00:32   6s   
    4 Players logged in. 
    > say idle(wiz) 
    You say "6" 
    > say idle(e) 
    You say "371" 
    > say idle(frobozz) 
    You say "-1" 
  See also: WHO, conn(), lwho(). 
 
&CONVSECS() 
 
  Function: convsecs(<seconds>) 
  
  This function converts seconds to a time string, based on how many 
  seconds the number is after Jan 1, 1970. 
  
  Example: 
    > say secs() 
    You say "709395750" 
    > say convsecs(709395750) 
    You say "Wed Jun 24 10:22:54 1992" 
  This function may also be called as secs2time(). 
  See also: convtime(), secs(), time(). 
 
&CONVTIME() 
 
  Function: convtime(<time string>) 
  
  This functions converts a time string to the number of seconds since 
  Jan 1, 1970. A time string is of the format: Ddd MMM DD HH:MM:SS YYYY 
  where Ddd is the day of the week, MMM is the month, DD is the day 
  of the month, HH is the hour in 24-hour time, MM is the minutes, 
  SS is the seconds, and YYYY is the year. 
  If you supply an incorrectly formatted string, it will return -1. 
  
  Example: 
    > say time() 
    You say "Wed Jun 24 10:22:54 1992" 
    > say convtime(Wed Jun 24 10:22:54 1992) 
    You say "709395774" 
  This function may also be called as time2secs(). 
  See also: convsecs(), secs(), time(). 
 
&SORT() 
 
  Function: sort(<list>[, <sort type>[, <delim>]]) 
  
  Takes a list of words, numbers, or dbref, and sorts them into ascending 
  order.  Lexicographic order is used for words, and numeric order is used 
  for numbers and dbrefs. 
  
  <sort type> may be used to specify the type of sort to perform (use d for 
  dbref, n for integer numeric, f for floating numeric, and a for 
  alphanumeric).  If omitted or left blank, the sort() function will 
  automatically determine the type of sort to perform. 
  
  If <delim> is specified, it (rather than a space) is used to separate items 
  in the list.  You may specify an alternate delimiter without specifying 
  a sort type by passing a null <sort type> parameter. 
  
  Examples: 
    > say sort(This is a test) 
    You say "This a is test" 
    > say sort(98 99 100 101) 
    You say "98 99 100 102" 
    > say sort(foo-bar-bletch,,-) 
    You say "bar-bletch-foo" 
 
&SETDIFF() 
 
  Function: setdiff(<list1>, <list2>[, <delim>]) 
  
  This function returns the difference of two sets -- i.e., the elements in 
  <list1> that aren't in <list2>. The list that is returned is sorted. 
  
  If <delim> is specified, it (rather than a space) is used to separate items 
  in the list. 
  
  Example: 
    > say setdiff(foo baz gleep bar, bar moof gleep) 
    You say, "baz foo" 
  See also: setinter(), setunion(), sort(). 
 
&SETINTER() 
 
  Function: setinter(<list1>, <list2>[, <delim>]) 
  
  This function returns the intersection of two sets -- i.e., the elements 
  that are in both <list1> and <list2>. The list that is returned is sorted. 
 
  If <delim> is specified, it (rather than a space) is used to separate items 
  in the list. 
  
  Example: 
    > say setinter(foo baz gleep bar, bar moof gleep) 
    You say, "bar gleep" 
  See also: setdiff(), setunion(), sort(). 
 
&SETUNION() 
 
  Function: setunion(<list1>, <list2>[, <delim>]) 
  
  This function returns the union of two sets -- i.e., all the elements of 
  both <list1> and <list2>, minus any duplicate elements. Think of it as 
  CAT() without duplicated words.  The list returned is sorted. 
  
  If <delim> is specified, it (rather than a space) is used to separate items 
  in the list. 
  
  Example: 
    > say setunion(foo baz gleep bar, bar moof gleep) 
    You say, "bar baz foo gleep moof" 
  See also: setdiff(), setinter(), sort(). 
 
&MERGE() 
 
  Function: merge(<string1>,<string2>,<character>) 
   
  This function merges <string1> and <string2>, depending on <character>. 
  If a character in <string1> is the same as <character>, it is replaced 
  by the character in the corresponding position in <string2>.  The two 
  strings must be of the same length. 
   
  Spaces need to be treated specially. A null character is considered to 
  equal a space, for <character>. 
   
  Examples: 
    > say merge(AB--EF,abcdef,-) 
    You say, "ABcdEF" 
    > say merge(AB[space(2)]EF,abcdef,) 
    You say, "ABcdEF" 
  See also: splice(). 
 
&REPEAT() 
 
  Function: repeat(<string>,<number>) 
   
  This function simply repeats <string>, <number> times.  No spaces are 
  inserted between each repetition. 
   
  Example: 
    > say repeat(Test, 5) 
    You say, "TestTestTestTestTest" 
 
&SPLICE() 
 
  Function: splice(<list1>, <list2>, <word>[, <delim>]) 
   
  This function splices <list1> and <list2> together. <list1> and <list2> 
  are space-separated lists of words 
   
  If a word in <list1> is the same as <word>, it is replaced by the word 
  in the corresponding position in <list2>.  Both lists must have the 
  same number of words. 
 
  <delim> may be used to specify a delimiter other than a space.   
  
  Example: 
    > say splice(foo bar baz,eek moof gleep,bar) 
    You say, "foo moof baz" 
  See also: merge(). 
 
&PI() 
 
  Function: pi() 
  
  Returns the value of the trigonometric constant pi to nine decimal places. 
  
  Example: 
    > say pi() 
    You say "3.141562654" 
  See also: acos(), asin(), atan(), cos(), sin(), tan(). 
 
&E() 
 
  Function: e() 
  Returns the value of the numeric constant e to nine decimal places. 
  
  Example: 
    > say e() 
    You say "2.718281828" 
  See also: exp(), ln(), log(), power(). 
 
&SIN() 
 
  Function: sin(<number>) 
  
  Returns the sine of <number>, expressed in radians. 
  
  Examples: 
    > say sin(0) 
    You say "0" 
    > say sin(fdiv(pi(),2)) 
    You say "1" 
    > say sin(fdiv(pi(),4)) 
    You say "0.707107" 
    > say sin(fdiv(pi(),6)) 
    You say "0.5" 
  See also: acos(), asin(), atan(), cos(), pi(), tan(). 
 
&COS() 
 
  Function: cos(<number>) 
  
  Returns the cosine of <number>, expressed in radians. 
  
  Examples: 
    > say cos(0) 
    You say "1" 
    > say cos(fdiv(pi(),2)) 
    You say "0" 
    > say cos(fdiv(pi(),4)) 
    You say "0.707107" 
    > say cos(fdiv(pi(),6)) 
    You say "0.866025" 
  See also: acos(), asin(), atan(), pi(), sin(), tan(). 
 
&TAN() 
 
  Function: tan(<number>) 
  
  Returns the tangent of <number>, expressed in radians. 
  
  Examples: 
    > say tan(0) 
    You say "0" 
    > say tan(1) 
    You say "1.557408" 
    > say tan(fdiv(pi(),4)) 
    You say "1" 
  See also: acos(), asin(), atan(), cos(), pi(), sin(). 
 
&ASIN() 
 
  Function: asin(<number>) 
  
  Returns the arcsine of <number>, expressed in radians. 
  
  Examples: 
    > say asin(0) 
    You say "0" 
    > say asin(1) 
    You say "1.570796" 
    > say asin(0.707101) 
    You say "0.78539" 
    > say asin(0.5) 
    You say "0.523599" 
  See also: acos(), atan(), cos(), pi(), sin(), tan(). 
 
&ACOS() 
 
  Function: acos(<number>) 
  
  Returns the arc-cosine of <number>, expressed in radians. 
  
  Examples: 
    > say acos(0) 
    You say "1.570796" 
    > say acos(1) 
    You say "0" 
    > say acos(0.707101) 
    You say "0.785406" 
    > say acos(0.866025) 
    You say "0.5236" 
  See also: asin(), atan(), cos(), pi(), sin(), tan(). 
 
&ATAN() 
 
  Function: atan(<number>) 
  
  Returns the arctangent of <number>, expressed in radians. 
  
  Examples: 
    > say atan(0) 
    You say "0" 
    > say atan(1) 
    You say "0.785398" 
    > say atan(1.557408) 
    You say "1" 
  See also: acos(), asin(), cos(), pi(), sin(), tan(). 
 
&FLOOR() 
 
  Function: floor(<number>) 
  
  Returns the largest integer less than or equal to <number>.  <number> may be 
  a floating point number, and an integer result is returned. 
  
  Examples: 
    > say floor(5) 
    You say "5" 
    > say floor(5.2) 
    You say "5" 
    > say floor(5.8) 
    You say "5" 
    > say floor(-5) 
    You say "-5" 
    > say floor(-5.2) 
    You say "-6" 
  See also: ceil(), div(), mod(), round(), trunc(). 
 
&CEIL() 
 
  Function: ceil(<number>) 
  
  Returns the smallest integer greater than or equal to <number>.  <number> 
  may be a floating point number, and an integer result is returned. 
  
  Examples: 
    > say ceil(5) 
    You say "5" 
    > say ceil(5.2) 
    You say "6" 
    > say ceil(5.8) 
    You say "6" 
    > say ceil(-5) 
    You say "-5" 
    > say ceil(-5.2) 
    You say "-5" 
  See also: div(), floor(), mod(), round(), trunc(). 
 
&TRUNC() 
 
  Function: trunc(<number>) 
  
  Returns the value of <number> after truncating off any fractional value. 
  <number> may be a floating point number, and an integer result is returned. 
  
  Examples: 
    > say trunc(5) 
    You say "5" 
    > say trunc(5.2) 
    You say "5" 
    > say trunc(5.8) 
    You say "5" 
    > say trunc(-5) 
    You say "-5" 
    > say trunc(-5.2) 
    You say "-5" 
  See also: div(), floor(), mod(), round(). 
 
&ROUND() 
 
  Function: round(<number>,<places>) 
  
  Rounds <number> to <places> decimal places.  <number> may be 
  a floating point number, and an integer result is returned. 
  
  Examples: 
    > say round(5,0) 
    You say "5" 
    > say round(5.123,1) 
    You say "5.1" 
    > say round(9.8765,3) 
    You say "9.877" 
    > say round(5.5,0) 
    You say "6" 
    > say round(-5.5,0) 
    You say "-6" 
  See also: div(), floor(), mod(), trunc(). 
 
&SQRT() 
 
  Function: sqrt(<number>) 
  
  Returns the square root of <number>.  <number> may be a floating point 
  number, and a floating point result is returned.  <number> may not be 
  negative. 
  
  Examples: 
    > say sqrt(2) 
    You say "1.414214" 
    > say sqrt(100) 
    You say "10" 
    > say sqrt(0) 
    You say "0" 
    > say sqrt(-1) 
    You say "#-1 SQUARE ROOT OF NEGATIVE" 
  See also: power(). 
 
&POWER() 
 
  Function: power(<number>, <power>) 
  
  Returns the result of raising <number> to the <power>'th power. 
  <number> may not be negative.  <number> and <power> may be floating point 
  numbers, and a floating point result is returned. 
  
  Examples: 
    > say power(2,3) 
    You say "8" 
    > say power(9, 0.5) 
    You say "3" 
    > say power(100,pi()) 
    You say "1919487.587204" 
    > say power(5, 0) 
    You say "1" 
    > say power(0, 0) 
    You say "1" 
    > say power(2,-3) 
    You say "0.125" 
    > say power(-2,3) 
    You say "#-1 POWER OF NEGATIVE" 
  See also: exp(), ln(), log(), sqrt() 
 
&LN() 
 
  Function: ln(<number>) 
  
  Returns the result of taking the natural logarithm (base e) of <number>. 
  <number> may be a floating point number, and a floating point result 
  is returned. 
  
  Examples: 
    > say ln(0) 
    You say "#-1 LN OF NEGATIVE OR ZERO" 
    > say ln(1) 
    You say "0" 
    > say ln(e()) 
    You say "1" 
    > say ln(10) 
    You say "2.302585" 
  See also: e(), exp(), log(), power(). 
 
&LOG() 
 
  Function: log(<number>) 
  
  Returns the result of taking the common logarithm (base 10) of <number>. 
  <number> may be a floating point number, and a floating point result 
  is returned. 
  
  Examples: 
    > say log(0) 
    You say "#-1 LOG OF NEGATIVE OR ZERO" 
    > say log(1) 
    You say "0" 
    > say log(10) 
    You say "1" 
    > say log(e()) 
    You say "0.434294" 
  See also: e(), exp(), ln(), power(). 
 
&EXP() 
 
  Function: exp(<power>) 
  
  Returns the result of raising the numeric constant e to <power>. 
  <power> may be a floating point number, and a floating point result 
  is returned. 
  
  Examples:  
    > say exp(0) 
    You say "1" 
    > say exp(1) 
    You say "2.718282" 
    > say exp(2) 
    You say "7.389056" 
  See also: e(), log(), ln(), power(). 
    
&PARSE()
 
  Function: parse(<list>,<eval>[,<delimiter>]) 
 
  This function takes each element of <list>, evaluates <eval> after 
  substituting it for ##, and constructs a space-separated list of the 
  results. 
 
  Examples: 
    > say parse(1 2 3 4 5,add(##,1)) 
    You say "2 3 4 5 6" 
    > say parse(This|is|a|string|length|test,strlen(##),|) 
    You say "4 2 1 6 6 4" 
  See also: @dolist, iter(), map(). 
 
&CONTROLS() 
 
  Function: controls(<object>,<victim>) 
  
  Returns 1 if <object> controls <victim>, 0 otherwise. 
  
  Examples: 
  > say controls(me,me) 
  You say "1" 
  > say controls(me,#1) 
  You say "0" 
  > say controls(#1,me) 
  You say "1" 
  
  See also: CONTROL. 
 
&map() 
 
  Function: map([<obj>/]<attr>, <list>[, <delim>]) 
   
  This function is nearly identical to an iter() operating on u() function. 
  Each member of <list> is passed to the result of fetching <attr> as %0, and 
  the results are used to form a new list, separated by the delimiter 
  character. 
   
  <delimiter> may be used to specify a delimiter other than space. 
   
  Examples:  
  > &ADD_ONE object=add(%0,1) 
  > say map(object/add_one,1 2 3 4 5) 
  You say "2 3 4 5 6" 
   
  See also: filter(), fold(), iter(), parse(), u(). 
 
&filter() 
 
  Function: filter([<obj>/]<attr>, <list>[, <delim>]) 
 
  This function evaluates the contents of <attr> for each element of <list>, 
  passing it in as %0.  A <delimiter>-separated list is returned of those 
  elements for which the evaluation returns the value 1. 
 
  <delimiter> may be used to specify a delimiter other than space. 
   
  Examples: 
    > &IS_ODD object=mod(%0,2) 
    > say filter(object/is_odd,1 2 3 4 5) 
    You say "1 3 5" 
  See also: u(), map(), fold() 
 
&fold() 
 
  Function: fold([<obj>/]<attr>, <list>[, <base-case>[, <delim>]) 
 
  This function iteratively processes a list through a function, feeding 
  the result of one step into the next step as %0, passing in the next element 
  from the list as %1. 
 
  If a base case is provided, it is used as the initial %0.  If not, the first 
  list element is passed as %0 and the second is passed as %1, and subsequent 
  iterations proceed normally. 
   
  <delimiter> may be used to specify a delimiter other than space, but you 
  must specify a base case in order to specify the delimiter. 
  
  Examples: 
    > &REP_NUM object=[%0][repeat(%1,%1)] 
    > say fold(object/rep_num,1 2 3 4 5,->) 
    You say "->122333444455555" 
    > &ADD_NUMS object=add(%0,%1) 
    > say fold(object/add_nums,1 2 3 4 5) 
    You say "15" 
  See also: u(), iter(), map(), filter() 
 
&RJUST() 
 
  Function: rjust(<string>, <length>[, <fill>]) 
  
  This function pads a string with leading <fill> characters, or with spaces 
  if no fill character is given) ("right-justifies") so it is <length> long. 
  If <string> is longer than <length>, the <string> is returned; it is not 
  truncated. 
  
  Examples: 
    > say -[rjust(foo,6)]- 
    You say "-   foo-" 
    > say %r0[rjust(foo,6)]7%r01234567 
    You say " 
    0   foo7 
    01234567" 
    > say =[rjust(bar,5,.)]= 
    You say "=..bar=" 
  See also: ljust(), strlen(). 
 
&LJUST() 
 
  Functions: ljust(<string>, <length>[, <fill>]) 
  
  This function pads a string with trailing <fill> characters, or with spaces 
  if no fill character is given) ("left-justifies") so it is <length> long. 
  If <string> is longer than <length>, the <string> is returned; it is not 
  truncated. 
  
  Examples: 
    > say -[ljust(foo,6)]- 
    You say "-foo   -" 
    > say %r0[ljust(foo,6)]7%r01234567 
    You say " 
    0foo   7 
    01234567" 
    > say =[ljust(bar,5,.)]= 
    You say "=bar..=" 
  See also: rjust(), strlen(). 
 
&R() 
 
  Function: r(<number>) 
  
  The r() function is used to access "local registers", and returns 
  the contents of the specified register. There are ten such registers, 
  numbered 0 through 9.  The local registers are normally cleared at the 
  start of each command, but are preserved across the commands that compose 
  an actionlist, as well as commands that directly trigger actionlists, such 
  as @switch, @trigger, and @dolist. 
  
  See also: setq(), setr(). 
 
&SETQ() 
 
  Function: setq(<number>,<string>) 
  
  The setq() function is used to copy strings into local registers. 
  It returns a null string; it is a purely "side effect" function. 
 
  There are ten local registers, numbered 0 through 9. They are cleared 
  at the start of each interactive command, but are preserved across the 
  command queue. They are most useful for storing complex function 
  evaluations which are used repeatedly within a single command. 
  The local registers may be read via the r() function, and a common use 
  of setq()/r() is to temporarily store the result of a complex evaluation 
  whose result is needed more than once. 
  
  setq() can be used to improve the readability of MUX code, as well as to 
  cut down the amount of time needed to do complex evaluations. 
  
  Example: 
    > &TEST me=Test on [mudname()] at [time()]. 
    > say [setq(0,u(TEST))]'[r(0)]' has length [strlen(r(0))]. 
    You say "'Test on TestMUX at Tue Feb 23 17:00:51 1993.' has length 45." 
  See also: r(), setr(). 
 
&SETR() 
 
  Function: setr(<number>,<string>) 
  
  This function is identical to setq(), but returns <string>. 
  
  See also: setq(), r(). 
  
&SHUFFLE() 
 
  Function:  shuffle(<word1> <word2> <...<wordN>[,<delimiter>]) 
  
  This function shuffles the order of words in a list, returning a random 
  permutation of its elements. 
  
  Example: 
    > say shuffle(foo bar baz gleep) 
    You say "baz foo gleep bar" 
  
&SCRAMBLE 
 
  Function:  scramble(<string>) 
  
  This function scrambles a string, returning a random permutation of its 
  characters. Note that this function does not pay any attention to spaces 
  or other special characters; it will scramble these characters just like 
  normal characters. 
  
  Example: 
    > say scramble(abcdef) 
    You say "cfaedb" 
  
  See also:  SHUFFLE() 
 
&SORTBY() 
 
  Function: sortby([<obj>/]<attrib>,<list>[,<delimiter>]) 
  
  This sorts an arbitrary list according to the u-function <obj>/<attrib>. 
  This u-function should compare two arbitrary elements, %0 and %1, and 
  return zero (equal), a negative integer (element 1 is less than element 2) 
  or a positive integer (element 1 is greater than element 2). 
  
  A simple example, which imitates a normal alphabetic sort: 
    > &ALPHASORT test=[comp(%0,%1)] 
    > say [sortby(test/ALPHASORT,foo bar baz)] 
    You say "bar baz foo" 
  
  A slightly more complicated sort. #1 is "God", #2 is "Amby", "#3" is "Bob": 
    > &NAMESORT me=[comp(name(%0),name(%1))] 
    > say [sortby(NAMESORT,#1 #2 #3)] 
    You say "#2 #3 #1" 
  
  Warning: the function invocation limit applies to this function. If 
  this limit is exceeded, the function will fail _silently_. List and 
  function sizes should be kept reasonable. 
  
&TRIM() 
 
  Function: trim(<string> [,<trim style> [,<trim character>]]) 
  
  This function will trim trailing and/or lead characters on the string 
  that you specify.  <trim character> specifies the character to trim (default 
  is space), and <trim style> tells the kind of trimming to perform (default 
  is trim both sides of the string). 
  
  The following values for <trim style> are recognized: 
      'b' :   Trim both ends of the string (default) 
      'l' :   Trim the left end of the string. 
      'r' :   Trim the right end of the string. 
  Note: anything else specified for <trim style> will trim both sides. 
  
  Example: 
    > say trim(;;;Wacka;;;,;) 
    You say "Wacka" 
    > say trim(%b%b%b Polly Parrot %b%b%b%b,,r) 
    You say "    Polly Parrot" 
    > say trim(---Trim Rules!---,-,l) 
    You say "Trim Rules!---" 
  See also: center(), ljust(), rjust(). 
 
&CENTER() 
 
  Function: center(<string>,<width>[,<fill>]) 
  
  This function will center a string in a string <width> characters wide, 
  using <fil> characters for padding on either end of the string for 
  centering.  If no fill character is specified then a space is used. 
  If <string> is longer than <width> characters, the string is returned 
  unmodified. 
  
  Example: 
    > say center(a,5,-) 
    You say "--a--" 
    > say center(*BAMF*,15) 
    You say "    *BAMF*     " 
 
&INSERT() 
 
  Function: insert(<list>, <pos>, <word>[, <sep>]) 
  
  This function inserts a word into <list> so that the word becomes the 
  <pos>'th element of the list, and all subsequent list elements are moved 
  down.  This means that it appears between the <pos-1>'th and <pos>'th 
  elements of the original list.  This function may also be used to append 
  a word to a list. 
  
  <delim> may be used to specify a delimiter other than a space. 
  
  Examples: 
    > say insert(This is a test, 4, new) 
    You say "This is a new test" 
    > say insert(Yet@Another@List, 3, Funky, @) 
    You say "Yet@Another@Funky@List" 
  See also: extract(), ldelete(), replace(). 
 
&REPLACE() 
 
  Function: replace(<list>, <pos>, <word>[, <sep>]) 
  
  This function inserts a word into <list> so that the word becomes the 
  <pos>'th element of the list, and the word previously in that position 
  is removed.  This means that it appears between the <pos-1>'th and 
  <pos+1>'th elements of the original list, replacing the word at that 
  position.  This function may not be used to append a word to a list. 
  
  <delim> may be used to specify a delimiter other than a space. 
  
  Examples: 
    > say replace(This is a test, 4, quiz) 
    You say "This is a quiz" 
    > say replace(Yet@Another@Mundane@List, 3, Funky, @) 
    You say "Yet@Another@Funky@List" 
  See also: extract(), insert(), ldelete(). 
 
&LDELETE() 
 
  Function: ldelete(<list>, <pos>[, <sep>]) 
  
  This function removes a word from <list> by position. 
  <delim> may be used to specify a delimiter other than a space. 
  
  Examples: 
    > say ldelete(This is not a test, 3) 
    You say "This is a test" 
    > say ldelete(Yet@Another@Mundane@List, 3, @) 
    You say "Yet@Another@List" 
  See also: extract(), insert(), replace(). 
 
&ISDBREF() 
 
  Function: isdbref(<string>) 
  
  This function will return 1 if the string passed to it is a valid dbref. 
  To be a valid dbref the string must begin with '#' and be followed by an 
  interger.  Also, the dbref must exist in the current database as a valid 
  object.  If the object fails either of these criteria, then a 0 is 
  returned. 
  
  Example: 
     > say isdbref(#-1) 
     You say "0" 
     > say isdbref(#1) 
     You say "1" 
     > say isdbref(This is not a dbref) 
     You say "0" 
 
&ISNUM() 
  
  Function: isnum(<string>) 
  
  This function will return return 1 if the argument is a valid number and 0 
  if it is not. 
  
  Example: 
     > say isnum(22223.0000) 
     You say "1" 
     > say isnum(77) 
     You say "1" 
     > say isnum(22 L) 
     You say "0" 
     >say isnum(Bad Numbers!) 
     You say "0" 
  
&ZONE() 
 
  Function: zone(<object>) 
  
  Returns the object's 'zone'. This is the dbref of the master object 
  which defines the zone. 
 
&ZWHO() 
 
  Function: zwho(<object>) 
  
  Returns a list of players who are in the zone defined by <object>. 
  Currently a wizard/royalty only function. 
  
&INZONE() 
 
  Function: inzone(<object>) 
  
  Returns a list of rooms in the zone defined by <object>. Currently a 
  wizard/royalty only function. 
   
&CHILDREN() 
 
  Function: children(<object>) 
  
  Returns a list of objects that are parented to <object>. Currently a 
  wizard/royalty only function. 
  
&ENCRYPT() 
 
  Function: encrypt(<text>,<key>) 
  
  Encrypts <text> using <key>. The text can only be unlocked with <key>, and 
  <key> is case-sensitive. 
  
&DECRYPT() 
 
  Function: decrypt(<text>,<key>) 
  
  Decrypts <text> using <key>. <key> should be the same one used to encrypt 
  the text, and is case sensitive. 
  
&MAIL() 
 
  mail(<mail message #>) 
  mail(<player name>) 
  mail(<player>, <mail message #>) 
  mail() 
 
  The first form returns a message corresponding to that mail message 
  number in your MUX mailbox. This function can be used to forward 
  mail, or as a way to simply transfer mail messages to attributes 
  on an object. 
  
  The second form returns two numbers, corresponding to the number of 
  read and unread messages <player> has. 
  The third form returns <player>'s <mail message #>. It works like 
  the first form except it applies to another player. 
  The last form returns the number of messages the evaluating player has. 
  Only wizards can use the second and third forms of the function 
  on other players. 
  
&MAILFROM() 
 
  Function: mailfrom(<msg #>) 
  
  Returns the dbref # of the player who sent you <msg #>. Wizards may 
  specify mailfrom(<player>,<msg #>). 
  
&DEFAULT() 
 
  Function:  default(<obj>/<attr>,<default case>) 
  
  This function returns the value of <obj>/<attr>, as if retrieved via 
  the get() function, if the attribute exists and is readable by you. 
  Otherwise, it evaluates the default case, and returns that. 
  Note that the default case is only evaluated if the attribute does 
  not exist or cannot be read. 
  
  This is useful for code that needs to return the value of an attribute, 
  or an error message or default case, if that attribute does not exist. 
  
  Examples: 
    > &TEST me=apple orange banana 
    > say default(me/Test, No fruits!) 
    You say "apple orange banana" 
    > &TEST ME 
    > say default(me/Test, No fruits!) 
    You say "No fruits!" 
  
  See also:  get(), get_eval(), u(), edefault(), udefault(). 
  
&EDEFAULT() 
 
  Function:  edefault(<obj>/<attr>,<default case>) 
  
  This function returns the evaluated value of <obj>/<attr>, as if 
  retrieved via the get_eval() function, if the attribute exists and 
  is readable by you. Otherwise, it evaluates the default case, and 
  returns that. The default case is only evaluated if the attribute 
  does not exist or cannot be read. 
  
  Example: 
    > &TEST me=You have lost [rand(10)] marbles. 
    > say edefault(me/Test,You have no marbles.) 
    You say "You have lost 6 marbles." 
    > &TEST me 
    > say edefault(me/Test,You have no marbles.) 
    You say "You have no marbles." 
   
  See also:  get(), get_eval(), u(), default(), udefault(). 
  
&UDEFAULT() 
 
  Function:  udefault([<obj>/]<attr>,<default case>[,<arg>]...) 
  
  This function returns the value of the user-defined function 
  as defined by <attr> (or <obj>/<attr>), as if retrieved via 
  the u() function, with <args>, if the attribute exists and is 
  readable by you. 
  
  Otherwise, it evaluates the default case, and returns that. The 
  default case is only evaluated if the attribute does not exist 
  or cannot be read. 
  
  Examples: 
    > &TEST me=[center(%0,5,*)] 
    > say udefault(Test,-- BOOM --,ACK) 
    You say "*ACK*" 
    > &TEST me 
    > say udefault(me/Test,-- BOOM --,ACK) 
    You say "-- BOOM --" 
  
  See also:  get(), get_eval(), u(), default(), edefault(). 
 
 
&ULOCAL() 
 
  Function:  ulocal([<obj>/]<attr>[,<arg>]...) 
  
  The ulocal() function is almost identical to u() in function:  it 
  evaluates an attribute, either from the object performing the function, 
  or another object that you control or has the same owner as you, passing 
  in arguments and returning the result. When evaluating the fetched 
  attribute, %# refers to the original enactor and not the 'calling' object; 
  'me' refers to the object that supplied the attribute. 
  
  However, unlike the u() function, the global registers r(0) through r(9) 
  (%q0 - %q9) are preserved in their initial state. This means that functions 
  "below" the level of the u() can reset global registers for temporary 
  calculations, without needing to worry about "clobbering" the original 
  values. 
  
  This makes ulocal() particularly useful for global or shared code which 
  calls arbitrary u() functions, where global register values need to be 
  preserved from accidental user clobbering. 
<Continued in HELP ULOCAL2>
      
&ULOCAL2 
 
  Example of ulocal(): 
    > &FRUIT me=apples bananas oranges pears 
    > &SUB-FUNCTION me=[setq(0,v(FRUIT))][extract(%q0,match(%q0,%0),1)] 
    > &TOP-FUNCTION me=[setq(0,are delicious!)][ulocal(SUB-FUNCTION,%0)] %q0 
    > say u(TOP-FUNCTION,b*) 
    You say "bananas are delicious!" 
  
  If SUB-FUNCTION had been called with u() instead of ulocal(): 
    > &TOP-FUNCTION me=[setq(0,are delicious!)][u(SUB-FUNCTION,%0)] %q0 
    > say u(TOP-FUNCTION,b*) 
    You say "bananas apples bananas oranges pears" 
  
  In this second example, in SUB-FUNCTION, %q0 was set to "apples bananas 
  oranges pears", so that when the u() "returned" and TOP-FUNCTION evaluated 
  %q0, this is what was printed. In the first example, ulocal() reset the 
  value of %q0 to its original "are delicious!" 
  
  See also:  u(), setq(), r() 
 
&FINDABLE() 
 
  Function:  findable(<object>,<victim>) 
  
  Returns 1 if <object> can locate <victim>, or 0 otherwise. This checks 
  wizard status of <object>, UNFINDABLE status of <victim>, and other 
  related factors. 
  
&VISIBLE() 
 
  Function:  visible(<object>,<victim>[/<attr>]) 
  
  Returns 1 if <object> can examine <victim>, or 0 otherwise. If 
  <object> or <victim> do not exist, 0 is returned. 
  
  If an object-attribute pair is provided, 1 is returned if <object> 
  can see <attr> on <victim>. If <attr> is not present on <victim>, 
  1 is returned if <object> can examine <victim>. 
  
&LAST() 
 
  Function: last(<string>[, <delim>]) 
  
  Returns the last word of a string, that is, everything to the right 
  of the last space in the string, or the entire string if there are no  
  spaces in the string. 
  
  <delim> may be used to specify a word delimiter other than a space. 
  
  Example: 
    > say last(This is a test) 
    You say "test" 
    > say last(Happy-Fun-Test-Thing,-) 
    You say "Thing" 
  
  See also:  first(), rest(). 
 
&MATCHALL() 
 
  Function: matchall(<string>,<pattern>[,<delim>]) 
  
  This function works identically to the match() function, save that it 
  returns all matches, not just the first: It returns the index numbers of 
  all words in the list <string> which match <pattern>. 
  
  Examples: 
  
  > say matchall(This is a test of a test,test) 
  You say "4 7" 
  > say matchall(This is testing a test,tes*) 
  You say "3 5" 
  
  See also: LISTS, match(), strmatch().  
 
&PORTS() 
 
  ports(<player name>) 
  
  This function returns the list of descriptors ("ports") that a player, 
  specified by full player name, or by dbref, is connected to. Only Wizards 
  may use this function; if a user lacks the privileges, or the player is 
  not connected, an empty list is returned. Otherwise, a list of ports is 
  returned in order of most recent connection to least recent connection. 
  These ports correspond to those given by the SESSION command. 
   
&ELEMENTS() 
 
  elements(<list of words>,<list of numbers>[,<delim>]) 
  
  This function returns the words in <list of words> that are in the 
  positions specified by <list of numbers>. Optionally, a list delimiter 
  other than a space can be separated. 
  
  Examples: 
    > say elements(Foo Ack Beep Moo Zot,2 4) 
    You say "Ack Moo" 
    > say elements(Foof|Ack|Beep|Moo,3 1,|) 
    You say "Beep|Foof" 
 
&GRAB() 
 
  Function:  grab(<list>, <pattern>[, <delim>]) 
   
  This function matches <pattern> against each word in <list>, returning 
  the first word that matches. If no words match, then an empty string 
  is returned. The match is not case-sensitive, and wildcard characters 
  are permitted. <delim> may be used to specify a list delimiter other 
  than a space. 
  
  Examples: 
    > say grab(This is a new test,?e*) 
    You say "new" 
    > say grab(Holodeck:#10~Airlock:#58~Dorm:#12~Brig:#83,Airlock:*,~) 
    You say "Airlock:#58" 
  
  See also: LISTS, match(). 
  
&EMPTY() 
   
  Function: empty([<object>]) 
   
  This function completely empties the stack for the calling object. If 
  <object> is specified, and you control it, it empties the stack for 
  <object>. 
  
  See also: items(), peek(), pop(), push(), OBJECT STACK. 
  
&ITEMS() 
  
  Function: items([<object>]) 
  
  items() returns the number of items that the stack of the calling object 
  contains. If <object> is specified and you control it, then it returns the 
  number of items in the stack of that object. 
  
  See also: empty(), peek(), pop(), push(), OBJECT STACK. 
  
&PEMIT() 
  
  Function: pemit(<list of objects>, <message>) 
  
  A side effect function, with the same effect as @pemit/list <list of 
  objects> = <message>. 
  
  See also: @pemit. 
  
&PEEK() 
  
  Function: peek([<object>], [<position>]) 
  
  peek() returns an item from the caller's stack without removing it from 
  the stack. If <position> is specified, it returns the item from that 
  position in the stack (items in the stack are numbered with 0 being the most 
  recently push()ed item), otherwise, it returns position 0. If <object> is 
  specified and you control it, then it returns an item from <object>'s 
  stack. 
  
  See also: empty(), items(), pop(), push(), OBJECT STACK. 
  
&POP() 
  
  Function: pop([<object>], [<position>]) 
  
  pop() returns an item from the caller's stack and removes it from 
  the stack. If <position> is specified, it returns the item from that 
  position in the stack (items in the stack are numbered with 0 being the most 
  recently push()ed item) and removes it, otherwise, it returns position 0. 
  If <object> is specified and you control it, then it returns an item from 
  <object>'s stack. 
  
  See also: empty(), items(), peek(), push(), OBJECT STACK. 
  
&PUSH() 
  
  Function: push(<data>) 
            push(<object>, <data>) 
  
  push() places <data> onto the calling object's stack. If the second form 
  is used, it places data onto <object>'s stack. 
  
  See also: empty(), items(), peek(), pop(), OBJECT STACK. 
  
&OBJECT STACK 
  
  NOTE: The object stack is completely different from the command stack 
  ('help stack'). 
  
  A stack is a LIFO structure, meaning that the last, most recent thing you 
  place into it is the first thing you get out of it. You 'push' an item 
  onto the stack, and you can 'pop' it off, or merely take a 'peek' at it. 
  If you pushed the word 'foo', and then the word 'bar', and popped 
  something off the stack, you would first pop 'bar', then 'foo'. You pop 
  or peek in the reverse order that you pushed. 
  
  The object stack can hold any kind of information. In this manner they are 
  similar to r-registers, but are more flexible. There is a high limit to the 
  number of stack entries you can have (usually 100), and stack entries are 
  preserved until you pop them off or empty the stack. 
<Continued in HELP OBJECT STACK2>
      
&OBJECT STACK2 
   
  Example: 
   
  > say [push(world!)][push(Hello)]We'll print these... 
  We'll print these... 
  > say [pop()] [pop()] 
  Hello world! 
  
  empty() is used to clear the stack, items() shows the number of entries in 
  the stack. 
  
  See also: empty(), items(), push(), peek(), pop(). 
              
&CONSOLE 
 
  Flag: CONSOLE ($) 
     
  A room set CONSOLE enables ship console commands.  This flag can only 
  be set by wizards. 
     
&IC 
   
  Flag: IC (<) 
    
  A player has this flag when they are in IC mode, meaning when in combat, 
  roleplaying, or at an IC location. 
     
&REGISTERED 
     
  Flag: REGISTERED (>) 
     
  A player will be set set REGISTERED after he registers with the MUX. 
     
&PREREG 
     
  Flag: PREREG (]) 
    
  A player is set PREREG when he enters the registration room, but before 
  he completes the registration process. 
         
&FOOD 
          
  Flag: FOOD (;) 
         
  This flag is set on objects to tell the MUX they are edible food that can
  be consumed with the EAT and DRINK commands.  Type HELP EAT and HELP DRINK
  for an explanation of these commands.
             
&WEAPON 
      
  Flag: WEAPON (!) 
         
  This flag is set on objects to tell the MUX they are weapons and enable 
  the weapon code and registers.  This flag can only be set by wizards. 
 
&hardcode items 
+===========================================================================+ 
|             B A B C O M   H a r d c o d e   I t e m   H e l p             | 
+---------------------------------------------------------------------------+ 
|     Available topics are organized by date.  Type 'help hard <topic>'     | 
|                                                                           | 
| DATE            TOPIC            DESCRIPTION                              |
| 02-26-97        summary          Description of the various B5 MUX items  | 
| 02-26-97        commands         List of item commands                    | 
+===========================================================================+ 
           If you wish to add something to the news read News Subs 
        
&hard summary 
Much like personal combat weapons, you need to use and unuse these weapons 
with specific commands once you have them in your inventory.  These items 
are hardcoded on our MUX to avoid filling the command queue with hundreds 
of players' item commands.  Since players do not have quota or the ability 
to softcode objects, this will prevent queue lag experienced on most other 
MU*.  Listed below is a description of the various hardcoded items used on 
Babylon 5 MUX. 
      
LINKS: 
Links are the Babylon 5 version of Star Trek communicators.  They are worn 
on the back of the user's hand and have several frequencies available for 
use.  Links also have page functions and when you answer a page request, it 
is like answering a telephone - you are locked in to the new frequency after 
you move off your normal one.  When you end the page session with the CPAGE 
OFF command, you are moved back to your former frequency. 
 
MEDICAL KITS: 
Medical kits, in the form of first aid kits, med kits and surgical kits, are
the primary means of healing a character.  Note that only medics should be
using first aid kits or med kits and only surgeons should be using surgical
kits.  Anyone found ignoring this rule will have their medical kit destroyed
and action taken.
    
&hard commands 
This help topic will be expanded as soon as the coders provide info on 
personal combat code and commands. 
    
GENERAL ITEM COMMANDS: 
GRAB <item> - wield <item> to use.  Players notice anything being wielded 
              when looking at you.  This works for items, not weapons. 
RELEASE <item> - unwield <item> to no longer use.  This works for items, not 
                 weapons. 
 
LINKS: 
CPAGE <player> - beep <player> to start a page session. 
CPAGE ANS - start page session with the player beeping you. 
CPAGE OFF - ends a page session. 
CPAGE HIDE - set yourself unable to receive link pages. 
CPAGE UNHIDE - set yourself able to receive link pages. 
 
MEDICAL KITS: 
AFFECT <player> - attempt a skill-based heal of <player>.  You need to know
                  the appropriate medtech skill to heal the target player.
    
&topics 
    
  Help available on the following Topics: 
         
  ARBITRARY COMMANDS  ATTRIBUTE OWNERSHIP    BEING KILLED    BOGUS COMMANDS 
  BOOLEAN VALUES      COMMAND EVALUATION     COMSYS          CONTROL  
  COSTS               CREDITS                DROP-TO         ENACTOR 
  EXITS               FAILURE                FLAG LIST       FLAGS  
  FUNCTION LIST       FUNCTIONS              GENDER          GOALS  
  HARDCODE ITEMS      HERE                   HOMES           LINKING 
  LISTENING           LISTS                  LOOPING         MACRO 
  ME                  MONEY                  MOVING          OBJECT STACK 
  OBJECT TYPES        PARENT OBJECTS         PARENT ROOMS    POWERS LIST
  PUPPETS             ROBBERY                SEARCH CLASSES  SEMAPHORES
  SKILLS              SPOOFING               STACK           SUBSTITUTIONS
  SUCCESS             SWITCHES               VERBS           WIZARDS
  ZONE OBJECTS        BBOARD                 MUDNET
            
&FLAG LIST 
  Topic: FLAG LIST 
  
 Flag  Title        Flag  Title        Flag  Title        Flag  Title 
 -----------------+------------------+---------------=--+------------------- 
  A - ABODE       |  C - CHOWN_OK    |  D - DARK        |  E - EXIT 
  F - FLOATING    |  G - GOING       |  H - HAVEN       |  I - INHERIT 
  I - ITEM        |  J - JUMP_OK     |  K - KEY         |  L - LINK_OK 
  M - MONITOR     |  N - NOSPOOF     |  O - OPAQUE      |  P - PLAYER 
  Q - QUIET       |  R - ROOM        |  S - STICKY      |  T - TRACE 
  U - UNFINDABLE  |  V - VISUAL      |  W - WIZARD      |  X - ANSI 
  Y - PARENT_OK   |  Z - ROYALTY     |  a - AUDIBLE     |  b - AUDITORIUM 
  c - CONNECTED   |  d - DESTROY_OK  |  e - ENTER_OK    |  f - FIXED 
  g - UNINSPECTED |  h - HALTED      |  i - IMMORTAL    |  l - LIGHT 
  m - MYOPIC      |  n - NO_COMMAND  |  p - PUPPET      |  q - TERSE 
  r - ROBOT       |  s - SAFE        |  t - TRANSPARENT |  u - SUSPECT 
  v - VERBOSE     |  w - STAFF       |  x - SLAVE       |  z - CONTROL_OK 
  ? - HEAD        |  - - NOBLEED     |  | - VACATION    |  $ - CONSOLE 
  < - IC          |  > - REGISTERED  |  ] - PREREG      |  ! - WEAPON 
  ; - FOOD        |                  |                  |
 -----------------+------------------+------------------+------------------ 
        For information on a particular flag, type 'help <flagname>'. 
            Some flags may be disabled at the MUX you are located. 
     
&+view
The +view series of commands are (for now) softcoded commands designed to
enhance the roleplaying experience on various planets by allowing virtual
objects you can look at by using this command.  A list of the commands
follows:
     
COMMANDS
 +views                       -- lists the views in your current room
 +views <object>              -- views on that object
 +view <name of view in room> -- look at that view in current room
 +view <view> on <object>     -- look at that view on the object
 +views(<object/room dbref>)  -- a function that returns the list of views
     
These commands allow you to create and look at detailed descriptions of
various objects that would otherwise have to be represented with props.
     
To create a view on any object, simply set an attribute starting
with &VIEW_ on the object, such as &VIEW_NAME~OF~VIEW <object>=<description
of view>
     
Use '~' wherever you would have a space if you want to have spaces in the
name of the view.
     
CREDITS: This view code was originally written by Ralph Melton
(Rhyanna@Castle D'Image), modified heavily by Naomi Novik (DV@SWISH), and
fixed for Babylon 5 MUX by Mizak.
     
&+IC
The +IC command, softcoded by Valdar, returns you to your in-character
location.  Note that you must be IC to use personal combat weapons, use
ships, stores, factories, communication relay stations, warehouses, and
so on.  Note that while IC, all OOC commands such as page, @pemit, @emit,
@mail, home, @tel, and so on will be disabled.
               
If this is your first time using the +ic and +ooc commands, go to your IC
location and type +IC.  Your IC location is now stored and you may start
using the +OOC command.
    
&+OOC
The +OOC command, softcoded by Valdar, teleports you to the out-of-character
HUB, where you do not need to act in-character and can chat freely with
location.  Note that you must be IC to use personal combat weapons, use
ships, stores, factories, communication relay stations, warehouses, and
so on.
    
Anyone found abusing the +IC or +OOC commands to get around the ban on OOC
commands while set IC will be @nuked and perhaps even user or site locked if
the incident is serious enough.
       
If this is your first time using the +IC and +OOC commands, go to your IC
location and type +IC.  Your IC location is now stored and you may start
using the +OOC command.
         
&+ICTIME
The +ICTIME command, softcoded by Valdar, gives you the IC time in the
Babylon 5 universe.  It is the time you can use while in IC mode and need
an IC time and date.
               
&+SELFBOOT
The +SELFBOOT command, softcoded by Mike Whitaker (Michael@Conspiracy!),
@boots all but the most recent login of your character.  This is useful for
those nasty incidents where your internet provider boots you every thirty
minutes four six hours and leaves you with multiple connects, such as often
happens with Megahits Internet (Omega Solutions).

&PICK
The PICK command, softcoded by JohnD, lets you try and pick the lock on an
exit.  The format is PICK <EXIT>, for example, PICK out.  Note that you may
just leave a trace behind to let people know someone picked the lock and
picking of locks is generally considered to be illegal in any part of the
universe and by picking a lock you will generally leave proof of your
identity.  Note that ANYONE found abusing this command by using loops or
any other means to attempt the command a number of times in a short period
of time will be @nuked.
        
&+ELIST
Command: +elist
    
This command, coded by Valdar, will list players in your empire, along with
their rank and last connect time.
    
&+EREFRESH
Command: +erefresh
    
This command, coded by Valdar, will refresh the list of players in your
empire so that the +ELIST command is accurate and up to date.  Note that this
command can only be used by empire heads.
    
&+CALL SECURITY
Command: +call security
    
This command will call security to your location, if you are on Babylon 5.
Do not abuse this command, or you may be arrested and/or fined.  This command
was coded by JohnD
    
&+STAFF
Command: +staff
    
This command will tell you which staff members are connected and which
connected staff members are on or off duty.  Please do not attempt to
contact off duty or offline staff members other than via @mail.  This command
was coded by JohnD and wizzes and admins should set their job in &admin_pos.
        
&+TRAIN
Command: +train <player> <skill>
    
This command is used to teach a player some skill you possess.  Note that
for this command to succeed, you need to be in the same room as a connected
player, the student must have the skill below level one, the trainer must
have the skill at or above level five, you must have the appropriate training
skill and finally, the student must not have been taught or had someone
attempt to teach him in the past twenty-four hours.  This command was coded
by JohnD and Valdar.
    
&+QUOTAME
Command: +quotame <currency>
    
Gives you two quota for 600 units of currency specified by <currency>.  Note
that if you type this multiple times, you will still have two quota, but
will keep losing the currency.  Note that money will not be refunded in case
you type it multiple times and inane or offensive objects will be @destroyed
by the wiz staff, so please do not abuse this new command.  For example,
+quotame Credits will remove 600 credits from you and give you a total of two
quota.  This command was softcoded by Valdar.
        
&SPEAK
Command: speak <language>
        
Sets you up to speak in the language with the skill number you specify in
<language>.  You can not speak in a non-language skill or in a language for
which you have no skill.  For example, SPEAK 52 will set you up to speak in
English.  Note that language code does not trigger while you are OOC, so hub
conversation is still possible.
    
&+WHO
Command: +WHO
    
This command gives you a list of people online and includes information
such as IC/OOC status, rank, race and chargen registration status.  It was
softcoded by Valdar.
    
&+WHAT
Command: +WHAT
    
This command gives you a list of people online and includes information
such as IC/OOC status, rank, race and chargen registration status.  It was
softcoded by Valdar.
    
&+WHERE
Command: +WHERE
        
This command gives you a list of people online and includes information
such as IC/OOC status, current location, online time and idle time.  It was
softcoded by JohnD.
    
&+BCAST
Command: +BCAST <MESSAGE>
    
This command, softcoded by JohnD, lets the B5 command staff broadcast a
message over the station intercom system.
    
&+3WHERE
Command: +3WHERE
    
This command, grabbed from generic softcode archives, lists locations
occupied by online players and how many of those players are present at each
location.
    
&+DYELL
Command: +DYELL <exit>=<message>
        
The +DYELL command, softcoded by Jenn Vesperman, allows you to yell the
message specified by <message> through an exit specified by <exit>.
    
&+FEATURES
Command: +FEATURES
    
The +FEATURES command, softcoded by JohnD, lists the feature characters on
the game available for applications.  An application can be found at
http://www.pcnet.com/~jdutka/b5/char/regchar.html and, when applying, you
should be extremely detailed, extremely accurate, use information only
from before our cutoff date (NEWS SETTING) and canon material (located in the
web page's roleplay section), do not make stereotypical claims or judgements
and back every single fact and claim you make with evidence from the show
and canon materials from before the cutoff date.  Do not ask for or apply
for feature characters not on this list.
    
&+NOM
Command: +NOM <player>=<reason>
        
The +NOM command, softcoded by JohnD with most of the code given by John
Sheridan, can be used once a month to vote for the one player who you think
performed the best roleplay in that month.  Note that you can only use the
command once per month and any votes without a valid reason or player name
will be disgarded and you will be unable to vote until the next month.
You should only vote for active and current players and provide an actual
reason why he or she should receive the vote.  People are only eligible
to receive votes once a quarter and awards will be decided upon by the
wizzes.
    
&+INFO
Command: +info <player>
        
The +INFO command, softcoded by JohnD, gives you OOC information about a
player.  While it uses some of the same info as +FINGER, +INFO also lets you
set the &HOMEPAGE register to list your homepage on the world wide web,
then &ICQ_UIN to list your ICQ UIN number and &AVAIL_TIMES to list the times
you are available online.  Note that when using +INFO, use the player's full
name, not his or her alias.  The command usage is +INFO <playername>, such as
+INFO JohnD.  There are a number of configurable fields you can enter for
+INFO, such as @SEX, @ALIAS, &NOTE, &EMAIL, &ICQ_UIN, &FULLNAME, &HOMEPAGE
and &AVAIL_TIMES.  Do not attempt to set any awards on your character, as
that is an OOC attribute used by wizards to assign roleplaying and other
awards.
            
&+FINGER
Command: +finger <player>
        
The +FINGER command, softcoded by JohnD, gives you IC information and other
info, such as connect and @mail status, for any B5 MUX player.  Note that
when using +FINGER, use the player's full name, not his or her alias.  The
command usage is +FINGER <playername>, such as +FINGER JohnD.  There are a
number of configurable fields you can enter for +FINGER, such as @sex,
@alias, &note, &email, &fullname, &age, &height, &weight, &hair, &eyes,
and further, &empire, &affiliation, and &position.
     
For example, Susan Ivanova would have her &empire set by typing &empire
me=Earth Alliance, her &affiliation set to Babylon 5 (her current
assignment), &position set to Executive Officer, and her @rank set by a wiz
to Lieutenant Commander.  &note is a place to include a brief note about
yourself, a favorite quote, or whatever.
     
Note that @race is set when you go through chargen and @rank can only be set
by a wizard on a request by your empire head.
    
&+WSEARCH
Command: +wsearch <player>
    
This command searches for weapons on the player with name <player>.  It is
rather simple and was softcoded by Valdar.
    
&+SMELL
Command: +smell <thing>
    
This command lets you smell the room, player or object.  <thing> should be
the name of a player or "here" if you want to smell the room or area.  Coded
by OOC.  Do not smell anyone without their permission, and if someone says
no, it means no.  Anyone ignoring this will be booted or @nuked and site
locked.
        
In order for this command to work, you must set three attributes on yourself
or the object or room to be smelled: &smell (shown to you when you +SMELL),
and &osmell (shown to everyone else in the room as the person using +SMELL),
and &usmell (shown to the person being smelled).
        
&+TASTE
Command: +taste <thing>
    
This command lets you taste the room, player or object.  <thing> should be
the name of a player or "here" if you want to taste the room or area.  Coded
by OOC.  Do not taste anyone without their permission, and if someone says
no, it means no.  Anyone ignoring this will be booted or @nuked and site
locked.
      
In order for this command to work, you must set three attributes on yourself
or the object or room to be tasteed: &taste (shown to you when you +TASTE),
and &otaste (shown to everyone else in the room as the person using +TASTE),
and &utaste (shown to the person being tasteed).
    
&@whine
Command: @whine
    
This command, softcoded by JohnD, makes you say a TrekMUSE style whine with
a Babylon 5 MUX theme.
    
&+TOUCH
Command: +touch <thing>
    
This command lets you touch the room, player or object.  <thing> should be
the name of a player or "here" if you want to touch the room or area.  Coded
by OOC.  Do not touch anyone without their permission, and if someone says
no, it means no.  Anyone ignoring this will be booted or @nuked and site
locked.
             
In order for this command to work, you must set three attributes on yourself
or the object or room to be touched: &touch (shown to you when you +TOUCH),
and &otouch (shown to everyone else in the room as the person using +TOUCH),
and &utouch (shown to the person being touched).
        
&KNOCK
Command: knock <door>
            
This command will knock upon a door, causing a message to be displayed to the
room on the other side.  Four seperate attributes must be set on the exit for
it to be able to be knocked on.
    
1) &door <exit>=Anything (You may set any text in this attribute.  It simply
                must have this attribure for it to be knockable).
2) &ksucc <exit>=Message shown to player knocking.
3) &kosucc <exit>=Message shown to all others in the same room as the
                  player knocking, prefixed by the player's name.
4) &kinside <exit>=Message displayed to the occupents of the room on the
                   other side of the door.
    
For both KOSUCC and KINSIDE, %0 resolves to the dbref of the player knocking.
    
Knock code was written by Forever King @ TalesMUSH (fk@tales.net).
        
&+WEAR
This system is designed to assist players who enjoy frequently changing their
character descriptions.  It stores multiple descriptions, outfits and extra
features which can be changed independently of one another.  To learn more
about the global wear system, type:
    
help +wear create      To create new descs
help +wear wear        To wear or clear a desc
help +wear list        To list all descs or delete a single desc 
help +wear example     Additional examples 
help +wear options     To view options
        
&+WEAR CREATE
TOPIC:  Creating new descs for Global Wear System
SYNTAX: +<gen | wear | fx>-new <title> = <desc> 
EX:     +gen-new normal = A mean hombre, Jolly Green Giant stands over forty
                          feet.
        +wear-new usual = He is clad in a sorong of enormous green felt
                          leaves.
        +fx-new hoho = His normal mode of address is Ho Ho Ho. 

Using the +wear system involves the creation of a GEN (general) description,
at least one wear outfit and if desired at least one extra FX which may
include information about present mood, health, or the like.  Each of these
text items are stored under a user-named attribute on your character.
    
&+WEAR EXAMPLE
TOPIC: Examples of the Global Wear System
To set up a set of new descriptions, the character Selena would type in the
following commands:
        
+gen-new Insomnia = Selena looks exhausted, her face pale and her eyes
  gleaming fanatically as she mumbles "code... must code..."
+wear-new Yesterday = She is still dressed in yesterday's clothes, making it
  obvious she hasn't slept.
+fx-new Coffee = In one trembling hand she holds a cup of cappucino, the
  steam wending its way up from it.
         
Then she would type separately, +gen Insomnia, +wear Yesterday, and
+fx Coffee and her desc would be set to:
        
Selena looks exhausted, her face pale and her eyes gleaming fanatically as
she mumbles "code... must code..."  She is still dressed in yesterday's
clothes, making it obvious she hasn't slept.  In one trembling hand she holds
a cup of cappucino, the steam wending its way up from it.
    
&+WEAR LIST
TOPIC:  List and delete descs in Global Wear System
SYNTAX: +<gen | wear | fx>-list 

Lists stored information by <name>.  This will help you if you can't remember
the names of the descriptions you have created for yourself.
    
       +<gen | wear | fx>-delete <name> 
    
Deletes desc <name> permanently from your list of available descs. 
    
&+WEAR WEAR
TOPIC:  Wear and clear stored descs in Global Wear System
SYNTAX: +<gen | wear | fx> <name>       Sets that portion of your desc
        +<gen | wear | fx>-clear        Clears that portion of your desc
EX:     +gen normal          +wear usual          +fx hoho 
    
Once you have created a general description, an outfit or an extra, the first
command will change your description to wear it.  The second clears that
portion of the description, setting it to nothing.  Both commands affect your
description, so be prepared to lose any text currently stored there that
isn't specifically stored as part of the Global Wear System.
            
&+WEAR OPTIONS
TOPIC:   +Wear Options
SYNTAX:  +wear-option <option>
SUMMARY: The option command enables you to choose from one of the following
         options:
    
Public  This sets your description to be publically viewable, even by people
          who are not in the same room as you, by using the 'e/f' or get()
          and get_eval() functions.  (MUSH Default)
Private This option requires that the looker is in the same location as the
          looked at in order to view the looked at's description.
        
& bboard
==============================================================================
                Commands for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
     Requiem's BBS is a global, multi-threaded board with a rich set of
     features. To see help on a particular topic, type 'help <topic>'
     (Example: help bbread).
  
     TOPIC                 DESCRIPTION
     ~~~~~                 ~~~~~~~~~~~
     bbread                Reading bulletin board messages.
     bbpost                Posting bulletin board messages.
     bbmisc                Other commands (removing messages, unsubscribing
                             groups, resubscribing to groups, etc)
     bbtimeout             Expanded help on the topic of message timeouts.
==============================================================================
        
& bbread
==============================================================================
                  Commands for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
     +bbread                         Scans joined bulletin board groups.
     +bbread <#>                     Scans messages in group <#>.
     +bbread <#>/<list>              Reads message(s). <list> can be a single
                                        number, multiple numbers, or a range
                                        of numbers (ie. 1-6), or any combo.
     +bbread <#>/u                   Reads all unread messages in group <#>.
     +bbcatchup <#>                  Marks all messages in group <#> as read.
                                        You can use multiple group #'s/names
                                        or may use the word 'all' to catchup
                                        on all messages on all boards.
  
     +bbscan        Totals unread postings (if any) in each joined group. You
                    can place this command in your @aconnect, and it's
                    recommended you do so.
  
Note: You can use the boards name (or abbreviation) in place of it's number.
------------------------------------------------------------------------------
See also: help bbpost, help bbmisc
==============================================================================
        
& bbpost
==============================================================================
                  Commands for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
     +bbpost <#>/<title>             This starts a post to group <#>.
     +bbwrite <text>                 This adds text to an already started post.
     +bb <text>                      Same as +bbwrite.
     +bbedit <area>=<old>/<new>      Edits your post in progress. Valid areas
                                       are: text, title
     +bbproof                        Displays your current post in progress.
     +bbtoss                         Discards your current post in progress.
     +bbpost                         This will post your current post in
                                       progress.
  
     +bbpost <#>/<subject>=<body>    Posts a message to group <#>. This is a
                                       quick way of posting a message with
                                       one command.
     +bbedit <#>/<#>=<old>/<new>     Edits one of your posted messages.
  
Note: You can use the boards name (or abbreviation) in place of it's number.
------------------------------------------------------------------------------
See also: help bbread, help bbmisc
==============================================================================
        
& bbmisc
==============================================================================
                  Commands for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
     +bbremove <#>/<list>            Removes a message by you. <list> can be a
                                       single number, a group of numbers, or a
                                       range (10-14).
     +bbmove <#>/<#> to <#>          Moves one of your messages to a new group.
     +bbleave <#>                    Unsubscribe from group <#>.
     +bbjoin <#>                     Joins a group you've previously 'left'.
     +bblist                         Listing of all groups available to you
                                       along with their timeout values.
     +bbsearch <#>/<name>            Shows you a list of <name>'s postings on
                                       group <#>.
     +bbtimeout <#>/<#>=<days>       Changes timeout for a message to <days>.
     +bbnotify <#>=<on|off>          Turn post notification for group <#> on
                                       or off.
      
Note: You can use the board's name (or abbreviation) in place of its number.
For a '.sig', set an attribute on you called BB_SIG, and place your signature
in that.
------------------------------------------------------------------------------
See also: help bbread, help bbpost, help bbtimeout, help bbchanges
==============================================================================
        
& bbtimeout
==============================================================================
   Expanded Help on Message Timeouts for Myrddin's Bulletin Board (1 of 2)
------------------------------------------------------------------------------
There's only a couple of things that need to be understood in order to take
full advantage of message timeouts.
  
1: Once a day, the TR_TIMEOUT attribute on the bbpocket should be triggered.
   Some games already have a way of accomplishing this. For games that do not,
   simply have a wizard execute set the 'autotimeout' global parameter:
      +bbconfig autotimeout=on
   Turning that parameter on sets up the board to take care of its own daily
   triggering.  Setting the paramenter to 'off' turns off the BBS's internal
   triggering.
  
------------------------------------------------------------------------------
Concluded in: help bbtimeout2
==============================================================================
    
& bbtimeout2
==============================================================================
   Expanded Help on Message Timeouts for Myrddin's Bulletin Board (2 of 2)
------------------------------------------------------------------------------
  
2: There are 3 different timeout values:
  
   The global parameter 'timeout' (set via the '+bbconfig timeout=<days>'
   command) sets a default timeout that will be set on any new bb groups
   created after the execution of this command.
  
   The group parameter 'timeout' (set via the '+bbconfig <#>/timeout=<days>'
   command) sets a default timeout for the group <#>. Any new messages
   posted to this group will inherit that timeout.
  
   The user command '+bbtimeout <group>/<message list>=<days>' will set the
   specified timeout on individual messages. Players can only modify their
   own messages, wizards can modify any messages. Players can only set
   timeouts equal to or less than the default timeout for the board, wizards
   can set any timeout.
  
   In all cases, a timeout of '0' indicates no timeout.
==============================================================================
    
& bbchanges
==============================================================================
                    Changes to Myrddin's Bulletin Board
------------------------------------------------------------------------------
The most recent version of this code, bug fixes, and patches can be found at:
                     www.best.com/~merlin/mushcode.html
  
4.0.5:
     Improved +bbscan (Amberyl)
     Improved number range error handling (Kareila@ChaoticMUX)
     BugFix: +bbmove - better error handling, and replaced missing '}'
     BugFix: FN_SETR behaves better for those that need it.
4.0.4:
     BugFix: +bbsearch now checks permissions properly
     BugFix: base 36 to base 10 conversion tweaked to be friendlier to Penn
             (added a base case of '0' to fold()).
     BugFix: Posting to an anonymous board no longer appends your BB_SIG.
     BugFix: BBS is now aware of the 8k MUX buffer limit. This affects the
             'percentage' full meter.
     PennFix: +bbmove tweaked to be friendlier to PennMUSH.
     PennFix: Various other PennMUSH fixes, most involving flags. Should help
              the BBS run correctly on PennMUSH's.
     Feature: Post notification now includes [board]/[#]
     Help: Help files have been expanded in the areas of message timeouts and
           locking groups.
4.0.3:
     BugFix: +bbcleargroup now checks permissions properly
     BugFix: +bbcleargroup will no longer re-order remaining groups
     BugFix: Automatic post notification for anonymous boards now uses
             the anonymous 'title' instead of the poster's name.
4.0.2:
     BugFix: +bbsearch will now work properly on all servers
     Some attribute cleanup
4.0.1:
     BugFix: Message ID's no longer improperly sorted by certain commands
     BugFix: Update-Installer should no longer scramble message ID's
4.0.0:
     Misc. security enhancements.
     Up to 25% increase in storage capacity.
     Support for message timeouts. Fully configurable.
     Support for anonymous boards. Configurable 'From' field title. Obviously,
       MUSH staff can determine original poster.
     Post notification: online players are notified of new posts. Configurable
     New Command: +bbsearch. Allows user to search a group for posts by a
       specific author.
     New Command: +bbnotify. Allows user to toggle post notification for
       boards.
     New Staff Command: +bbconfig. For setting global/group timeout values,
       anonymous boards, built-in timeout monitor.
==============================================================================
    
& bbwiz
==============================================================================
               Wizard Commands for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
     +bbnewgroup <title>             Creates a new group.
     +bbcleargroup <#>               Clears group <#> and all it's messages.
     +bblock <#>=<lock>/<key>        Locks group <#>. Lock can be 'flag' or
                                       an attribute name.
                                       Examples: +bblock 4=flag/wizard
                                                 +bblock 5=race/were
     +bbwritelock <#>=<lock>/<key>   Same as above, but controls who may write
                                       to the group.
     +bbconfig                       Shows values of all config parameters.
                                       See 'help bbconfig' for help on
                                       config parameters and how to set them.
------------------------------------------------------------------------------
See also: help bbconfig, help bblock (contains expanded help for locks)
==============================================================================
    
& bblock
==============================================================================
           Expanded Help on Group Locks for Myrddin's Bulletin Board
------------------------------------------------------------------------------
A few notes about locking BB Groups.
  
The +bblock/+bbwritelock commands are only meant to take care of the simplest
of locks.  There is simply no way to write one bblock'ing command that can
deal with all the different ways people want to lock their BB Groups, and it
certainly isn't practical to keep adding different locking commands for each
locking method I come across.
  
Coders can set up locks on Groups that are as customized or exotic as you like
quite easily, however.  Each Group has its own object.  If you look inside
the global BBS object, you'll see them.  Each Group object has a pair of
attributes that control who may read and who may write to that Group.  The
attributes are named CANREAD and CANWRITE, respectively.  The dbref of the
player attempting to read/write is passed to the appropriate attribute as %0.
As long as the attribute returns a non-zero result, the player can read/write.
  
CANREAD Examples:
   CANREAD: 1                               Anyone can read
   CANREAD: hasflag(%0,wizard)              Only wizards can read
   CANREAD: strmatch(name(%0),*z*)          Only characters with a 'z' in
                                              their name can read
==============================================================================
    
& bbconfig
==============================================================================
          Configuration Parameters for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
There are two types of configuration parameters: global and group.  Global
configuration parameters affect the BB system as a whole, while group 
configuration parameters affect a single Group.
To set a global parameter:
  
     +bbconfig <param>=<value>       Sets global config parameter.
  
Global Parameters:
  
     timeout            This sets the default timeout (in days) for any new
                          groups created. A timeout of '0' means messages
                          won't timeout. (ex. +bbconfig timeout=30)
     autotimeout        If you don't have a way to trigger the TR_TIMEOUT
                          attribute on the bbpocket (daily) to clean out
                          expired messages, you can use the autotimeout param
                          instead. Setting this param 'on' enables the BB's
                          built in timer. Set this param to 'off' to disable.
------------------------------------------------------------------------------
See 'help bbconfig2' for info on Group parameters
==============================================================================
    
& bbconfig2
==============================================================================
          Configuration Parameters for Myrddin's Bulletin Board 4.0.5
------------------------------------------------------------------------------
To set a Group parameter:
  
     +bbconfig <#>/<param>=<value>   Sets config parameter for board <#>.
  
Group Parameters:
  
     anonymous          Setting this value turns the Group 'anonymous'.  This
                          means that any future posting's 'Author' field will
                          have the value of this param instead of the name of
                          the author. Wizards will also see the actual name of
                          author.  (examples:
                          +bbconfig newspaper/anonymous=NewsPaper Staff,
                          +bbconfig house rules/anonymous=The Staff)
     timeout            Sets the default timeout value for the Group.  Any new
                          messages will have this new value.  A value of '0'
                          means messages won't timeout.
==============================================================================
             
&mudnet
     
MudNet (mlink.c) was originally written by David P. Albert (Aslan@MicroMUSE).
It was modified for DarkZone by Kalkin@DarkZone.  It was then modified again
by Cyclonus@2k5 who added a bunch of servers to it.  Corum@StormWORLD added
the mnpagelock, mnstatus, and mnhaven commands.  It was modified again for a
bunch of servers by Bobby, Zenty, and Corum.  Zenty continued adding things,
including mnpwho and a counter at the bottom of the mnworlds list.  Many other
things were added to MudNet infcluding a way to keep it from not starting up
when a MUSH on the list (by sTiLe@Forgotten Isle).  MudNet is maintained by
Bobby and Zenty@OmniMUX.  If you would like your MUSH on the list, please
contact one of them, or email omni@mux.net.
    
NOTE: to get a list of MudNet commands, type MNHELP anywhere on the MUX.

&places
Places are virtual places to sit, stand or occupy.  You remain in the same
room, but join a group of people within that room who may or may not be
having a quiet conversation only with others placed with them.
    
Commands:
---------
Mv from <#> to <#>          Moves a vacancy from one place to another.
+Join <place name>          Puts you at <place name>
+Join at #<num>             Puts you at place #<num>.
+Join with <name>           Puts you at the place with <name>.
Depart                      Removes you from your place.
Places                      Lists who's present at all places.
Place <num>                 Lists who's present at place <num>.
Plook                       Lists in column format everyone around the room.
tt <message>                (Tete a tete) Relays a message to all those at
                            your place.  This command takes the usual
                            say/pose tokens, and TT |<message> will emit.
Update <#>/<Option>=<text>  See HELP PLACES OPTIONS
    
For installation help, type HELP PLACES CONFIG.  This code is provided
courtesy of Deirdre, Meg, and Osric of AmberMUSH.

&places options
HELP PLACES OPTIONS:
  Update <Place #>/<Option>=<Configuration Text>
    
  Option Description    <Option>        Default Configuration Text
  ------------------    --------        --------------------------
  Place Name            NAME            Table x
  Maximum # of places   MAXPLACES       Random
  Current # of places   CURPLACES       Random (1 >= # >= MAXPLACES)
  Fixed fail message    FIXED           <NULL>
  Full fail message     FULL            That table has no more room.
  Join message          JOIN            You sit down at <place>.
  Ojoin message         OJOIN           sits down at <place>.
  Depart message        DEPART          You stand and leave <place>.
  Odepart message       ODEPART         stands and leaves <place>.
  Say prefix            PREFIX          At your table
    
&places config
PLACES configuration:
  Configure <num> places
  Unconfigure places

Notes: A null fixed message means vacancies can be moved freely to and from
the place.  This does not make sense for things like couches and rugs.  Set
it to something like "That makes no sense." if you are using such a place.
(O)Join and (O)depart messages take like this: %%N. All Join and Depart
messages are appended with the place name.
    
Functions:
  WHICHPLACE(<loc num>,<dbnum>) gives the number of a place where <dbnum> is.
  ATPLACE(<loc num>,<place num>) gives you a list of things at a place.
  PLACEINFO(<loc num>,<place num>,<option>) gives the value of <option> at
    place.
      
&mutter
mutter <target>=<string>
mutter/tt <target>=<string>
mutter/place <place number>=<string>
    
The first form of this command behaves identically to whisper, except that
the other players in the room will see that you have said something.  A
regular message, or part of a pose enclosed in quotes, will have some of its
words or groups of words replaced by "..."  If you enclose a phrase with
<angle brackets>, it will not be replaced.  Poses without quotes will simply
show that you have muttered something.  <target> can be any player in the
same room as you.
<Continued in MUTTER2>
                   
&mutter2
The second form of this command behaves like the first, except that instead
of the entire room hearing the mutter, only people at a place will do so.  If
you are at a place, those at your place will hear the mutter; if you are not,
and the target is, those at that place will hear the mutter.  If neither of
you are at a place, an error message will be generated.  The final version of
this command allows everyone at a place to hear the message in full, while
the rest of the room hears the mutter.
     
This code was written by Deirdre@AmberMUSH.
<Continued in MUTTER3>
                       
&mutter3
Examples:
     mutter Finndo=Can you loan me thirty Pence? I'm broke!
     Meg mutters to Finndo, "Can... loan... thirty... broke!"
    
     mutter Bleys=:frowns. "What a <cheapskate> he is!" She shrugs.
     Meg frowns. She mutters to Bleys, "What... cheapskate..." She shrugs.
     
     mutter/place 1=:chuckles. "Thank you very much."
     Meg chuckles. She mutters to the long, mahogany bar, "Thank you..."
    
     mutter/tt Deirdre=Where did you hide those Trumps?
     At the bar, Meg mutters to Deirdre, "Where... Trumps?"
    
