& HELP
HELP

  This is the MUX online help facility.

     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:
       help [<command>]

  -  To get a list of MUX topics:
       help topics

  -  To get a list of Comsystem commands:
       help comsys

  -  To get a list of MUX Commands:
       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 an Admin.

& "
"

  COMMAND: "<message>

  Says <message> out loud to everyone in your current location (usually a
  room).

  Example:
    > "Where is the movie theater?
    You say, "Where is the movie theater?"

  Note that the closing double quote is automatically added.

  Related Topics: 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.

  Related Topics: @force.

& $-COMMANDS
$-COMMANDS

  These commands are called arbitrary commands, user-defined commands, or
  $-commands (for how they are defined).  See 'arbitrary commands' for the
  full description.

  Related Topics: arbitrary commands

& &

  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>').

  Related Topics: @set.

& :
:

  COMMAND: :<message>

  Displays <message> to everyone in your current room, preceded by your name
  and a space.

  Example:
    >:jumps for joy.
    Player jumps for joy.

  Related Topics: page, pose, say, whisper, ;, ".

& ;
;

  COMMAND: ;<message>

  This command is much like the ':' command, except that no space is inserted
  between your name and the action. 
 
  Example:
    > ;'s watch beeps.
    Player'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.

  Related Topics: page, pose, say, whisper, :, ".

& @@
@@

  COMMAND: @@ <args>

  This command and everything after it (excluding the command-separator
  ';') is not evaluated by the parser. This is useful for adding comments
  in softcode or, more commonly, writing comment headers for softcode
  installers (such as /quotable text files).  Note that @@ must be
  followed by a space or it will return an error message.

  Always be doubly sure that ()'s and {}'s in the (otherwise ignored)
  arguments are nested correctly, so that any semicolons used to separate it
  from subsequent code in the line are recognized by the parser.

  Example:
     > @va me=$foobar *:@fo #1234=%0;@@ This controls my foobar puppet.
     > foobar say Hello World!
     foobar says "Hello World!"
     > @@ --- Begin Code ---
     > @emit Hello World!
     > @@ --- End Code ---
     Hello World!

  Related Topics: think, @@(), null().

& @@()
@@()

  FUNCTION: @@(<text>)

  The <text> is not evaluated and returns nothing.

  Example:
    > think @@(pemit(me,Hello))
    > think @@(abc)

  Related Topics: @@, null().

& @AAHEAR
@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!

  Related Topics: @ahear, @amhear, @listen.

& @ACLONE
@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

  Related Topics: @clone.

& @ACONNECT
@ACONNECT

  COMMAND:   @aconnect <object> = <command-list>
  ATTRIBUTE: Aconnect

  Sets the actions to be taken by a player upon connecting to the MUX. The
  following steps occur in the following order whenever a player connects to
  the MUX. Parentage is observed.

   - Execute the connecting player's @aconnect.
   - Execute the master room's @aconnect.
   - Execute any @aconnect found on any of the master room's contents.
   - If the location that the player is connecting into belongs to a zone,
     then

     a) if the zone object is a thing, execute its @aconnect.
     b) if the zone object is a room, execute any @aconnect found on any of
        that room's contents.

  Example:
    > @aconnect me = check.my.mailbox

  Related Topics: @adisconnect.

& @ADESCRIBE
@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.

  Related Topics: look, @desc, @idesc, @odesc, think

& @ADFAIL
@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.

  Related Topics: drop, @dfail, @odfail, @lock.

& @ADISCONNECT
@ADISCONNECT

  COMMAND:   @adisconnect <object> = <command-list>
  ATTRIBUTE: Adisconnect

  Sets the actions to be taken by a player upon disconnecting from the MUX.
  The following steps occur in the following order whenever a player connects
  to the MUX. Parentage is observed.

   - Execute the connecting player's @adisconnect.
   - Execute the master room's @adisconnect.
   - Execute any @adisconnect found on any of the master room's contents.
   - If the location that the player is connecting into belongs to a zone,
     then

     a) if the zone object is a thing, execute its @adisconnect.
     b) if the zone object is a room, execute any @adisconnect found on any of
        that room's contents.

  Example:
    > @adisconnect me = home

  Related Topics: @aconnect.

& @ADROP
@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

  Related Topics: drop, @drop, @odrop, DROP-TO, EXITS.

& @AEFAIL
@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.
  Related Topics: @aenter, @efail, @ealias, @enter, @oefail, @oenter, enter,
      ENTER_OK.

& @AENTER
@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!

  Related Topics: enter, @enter, @oenter, ENTER_OK.

& @AFAIL
@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

  Related Topics: @fail, @ofail, FAILURE.

& @AGFAIL
@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.

  Related Topics: give, @gfail, @ogfail, @lock.

& @AHEAR
@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 <<

  Related Topics: @aahear, @amhear, @listen.

& @AKILL
@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

  Related Topics: kill, @kill and @okill, BEING KILLED, IMMORTAL, WIZARD.

& @ALEAVE
@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.

  Related Topics: leave, @leave, @oleave.

& @ALFAIL
@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.

  Related Topics: @aleave, @lalias, @leave, @lfail, @oleave, @olfail, leave.

& @ALIAS
@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.

Related Topics: @name.

& @AMAIL
@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.

  Related Topics: @mailsucc, @signature, @mail.

& @AMHEAR
@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!

  Related Topics: @aahear, @ahear, @listen.

& @AMOVE
@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)]

  Related Topics: @move, @omove.

& @APAY
@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.

  Related Topics: give, @cost, @opay, @pay.

& @ARFAIL
@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

  Related Topics: give, @agfail, @gfail, @ogfail, @orfail, @rfail, @lock.

& @ASUCCESS
@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.

  Related Topics: @osucc, @success, SUCCESS.

& @ATFAIL
@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.

  Related Topics: @teleport, @tfail, @otfail, @lock.

& @ATOFAIL
@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.

  Related Topics: @teleport, @tofail, @otofail, @lock.

& @ATPORT
@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)

  Related Topics: @otport, @oxtport, @tport, @teleport.

& @AUFAIL
@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

  Related Topics: @oufail, @ufail, @use.

& @AUSE
@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
  Related Topics: use, @ouse, @use.

& @AWAY
@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?

  Related Topics: @idle, @idletimeout, @reject, page.

& @BREAK
@BREAK

  COMMAND: @break <boolean>

  @break stops the execution of further commands in the current action
  list if its argument is a true value. It doesn't affect new queue
  entries made by previous commands in the action list. Very useful to
  people who don't like @switch.

  Examples:
    > @va obj=$testme *:@pemit %#=Before;@break %0;@pemit %#=After
    > testme 0
    Before
    After
    > testme 1
    Before

    > @force me={@switch 1=1,think 3rd;think 1st;@break 1;think 2nd}
    1st
    3rd

  In the last example, the @switch is run, which queues 'think 3rd',
  'think 1st' is run, displaying '1st', command execution is broken
  (so we never 'think 2nd', and then the queued 'think 3rd' is run,
  displaying '3rd'.

  If you follow that, you have a very good understanding of the
  TinyMUX queue. :)

  Related Topics: BOOLEAN VALUES

& @CBOOT
@CBOOT

  COMMAND: @cboot[/quiet] <channel>=<object>

  Only wizards or the owner of the channel can use this command. It
  forcefully removes an object from that channel.

  You may specify a player name as <object> if you prefix it with an '*'
  (e.g., '*Player1'), otherwise <object> should be a dbref or if you are
  in the same room, the name of an object or player.

  Example:
    > @cboot Public=Player1
    [Public] Staff1 boots Player1 off the channel.
    [Public] Player1 has left this channel.

  Related Topics: comsys commands

& @CCHARGE
@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.

  Example:
    > @ccharge Public=1
    Set.

  Related Topics: comsys commands

& @CCHOWN
@CCHOWN

  COMMAND: @cchown <channel>=<player>

  Changes ownership of <channel> to <player>. If the player is not in the
  same room, you will need to add a '*' before the name (e.g., '*player1').

  Example:
    >@cchown Public=Staff1
    Set.

  Related Topics: @clist, @cwho.

& @CCREATE
@CCREATE

  COMMAND: @ccreate <channel name>

  Only Wizards can create new channels.

  Creates a new channel with default settings. Once the channel is created,
  it can be associated with a object with the @cset command. That object can
  be used to set locks and descriptions on the channel.

  Example:
    > @ccreate Public
    Channel Public created.

  Related Topics: comsys, @cset, @cdestroy, @clist, @cchown.

& @CDESTROY
@CDESTROY

  COMMAND: @cdestroy <channel>

  Deletes <channel> permanently from the comsystem database. It does not
  destroy all aliases that exist for <channel> -- those are left to the
  owners of those aliases. Players are notified both at login when they   
  own aliases for which a channel no longer exists and when they try to 
  use them. Even if a Channel is destroyed and then recreated, the alias 
  will still be non functioning. The alias must be removed with the 
  'delcom' command and added with the 'addcom' command.

  Example:
    > @cdestroy Staff
    Channel Staff destroyed.

  Related Topics: @clist, @ccreate, @cchown, addcom, delcom.

& @CEMIT
@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.

  Example:
    > @cemit Public=This is a test!
    [Public] This is a test!

    > @cemit/noheader Public=This is a test!
    This is a test.

  Related Topics: comsys commands, alias, addcom, cemit()

& @CHARGES
@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

  Related Topics: @runout.

& @CHOWN
@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.

  Related Topics: @lock, @Unlock, CHOWN_OK, ATTRIBUTE OWNERSHIP.

& @CHZONE
@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.

  Related Topics: ZONE OBJECTS

& @CLIST
@CLIST

  COMMAND: @clist[/<option>]

  Without any switches, it will display the list of public channels with
  their owner and description. It will also display all channels you own.

  <option>, if given, may be either of the following:

    full    - @clist will display more detailed information including
              the channel object's dbref.

    headers - Shows the @clist report with the description column
              replaced by the a column of the channel headers.

  Examples:
    >@clist
    *** Channel Owner Description
    --- Public God No description.
    --- Staff God No description.

    >@clist/full
    *** Channel      --Flags--  Obj   Own   Charge  Balance  Users   Messages
    --- Public        JXR/jxr    -1    11        0        0     45        129
    --- Staff         JXR/jxr    -1    11        0        0     10         65

  Related Topics: @ccreate, @cdestroy, @cchown, @coflags, @cpflags.

& @CLONE
@CLONE

  COMMAND: @clone[/<switches>] <object>[=<newname/cost>]

  Creates a almost 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.

  The modification and creation times will necessarily be different.  Also,
  depending on the parent lock and permissions, the possibility exists that
  the clone object will be left unparented.

  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.

{ 'help @clone2' for more }

& @CLONE2
@CLONE (continued)

  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 are not cloned, and LOCKED attributes are not
  copied.

  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.

  Related Topics: @create, @decompile, @destroy, VISUAL.

& @COFLAGS
@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 (speak) over the channel.
    join       Whether an object can join the channel.
    receive    Whether an object can receive messages over the channel.

  NOTE: Flags must be lower case.

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

  Example:
    > @coflags Public=join
    @coflags: Set.

  Related Topics: @cpflags, @clist, CHANNEL OBJECT.

& @CONFORMAT
@CONFORMAT

  COMMAND: @conformat <object> [=<format>]

  Replaces the usual "Contents:" or "Carrying:" format when an object
  is looked at, by a player-specified contents format. This is evaluated
  as if it were a description or other similar message on the room.
  The objects that the looker would normally be able to see is passed
  as a dbref list in %0; all contents can be acquired through 'lcon(me)'.
  The contents name is passed in %1.

  One could change the format to 'Contents: Object1 Object2 Object3'
  through '@conformat here = %1 [iter(%0,name(##))]',
  for example. More complex things are possible.

  Related Topics: @exitformat, @nameformat

& @COST
@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

  Related Topics: give, @apay, @opay, @pay.

& @CPATTR
@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 fourth
  form copies <attr> from the object that executes the @cpattr to the
  objects in the list, with the name <attr>.

& @CPFLAGS
@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 (speak) over the channel.
    join       Whether a player can join the channel.
    receive    Whether a player can receive messages over the channel.

  NOTE: Flags must be lower case.

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

  Example:
    > @cpflags Public=join
    @coflags: Set.

  Related Topics: @coflags, @clist, CHANNEL OBJECT.

& @CREATE
@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.

  Related Topics: @destroy, OBJECT TYPES

& @CSET
@CSET

  COMMAND: @cset/<option> <channel>[=<value>]

  Changes the way a channel behaves. <option> can be one of the
  following:

    public  - channel is listed in everyone's @clist.
    private - channel is hidden from the @clist.
    loud    - channel announces player connects/disconnects.
    mute    - shuts connects/disconnects off.
    quiet   - same as mute.
    spoof   - allows the comtitle to replace the player's name.
    anon    - same as spoof.
    nospoof - channel will append the player's name to the comtitle.
    header  - Changes the prefix text used to announce a channel emit to
              <value>. <value> may contain color.
    object  - Sets the channel object to <value>. You must create an object
              before associating a channel with it.
    log     - Sets the maximum number of channel messages to log. 
              The channel must have an object.

  You can set a description for the channel by changing the description
  of the channel object. Also, the channel object's lock will be used
  to check to see if people should be able to join the channel or not.

  Examples:
    > @cset/public Public
    @cset: Channel Public placed on the public listings.
    > @cset/object Public=#5
    Channel Public is now using Garou Channel Object(#5) as channel object.

  Related Topics: CHANNEL OBJECT, @ccreate, @create

& @CWHO
@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.

  Example:
    > @cwho Public/all
    Name Status Player
    Beowulf on yes
    Ronan on yes

  Related Topics: @clist.

& @DAILY
@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.

& @DECOMPILE
@DECOMPILE

  COMMAND: @decompile[/dbref] <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.
  If you specify the /dbref switch, you will get output using the dbref
  number instead of the object name.

  Related Topics: examine, look.

& @DESCRIBE
@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.

  Related Topics: look, @adescribe, @odescribe.

& @DESCFORMAT
@DESCFORMAT

  COMMAND: @descformat <object> [=<format>]

  Normally, the description of an object is controlled by the content and
  formatting found in the DESCRIBE attribute.  With the WOD_REALMS package
  enabled, DESCRIBE can be substituted in favor of other attributes.

  However, in all cases, @descformat provides one final pass over the
  appearance of an object.  The evaluated description text is passed as %0,
  and the attribute name where this text can be found is passed as %1.  The
  unevaluated description can be acquired using v(%1).

  This is useful to achieve a consistent 'look' using room parents.

  Related Topics: @conformat, @exitformat, @nameformat.

& @DESTROY
@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 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 its owner is set DESTROY_OK, the thing will be destroyed
  with no delay. This can also be performed with the /instant switch.

  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.
    /instant   - Destroy with no delay.

  Related Topics: DESTROY_OK, SAFE.

& @DFAIL
@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.

  Related Topics: drop, @adfail, @odfail, @lock.

& @DIG
@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.

  Related Topics: @destroy, @link, @open, LINKING, OBJECT TYPES.

& @DOING
@DOING

  COMMAND: @doing[/<switches>] [<message>]

  Sets your DOING message, which appears after your name in the WHO
  report.

  The following switches are available:

    /poll             - Displays the current poll message from the WHO report.
    /header <message> - Sets a new poll message in the WHO report.
    /unique           - Only set DOING message for the current connection.
    /quiet            - Suppress 'Set.' notification message.

  Related Topics: WHO, @poll.

& @DOLIST
@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>, and the symbol #@ with the position in the list, starting with
  one. 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>.
    /notify  - Queues an '@notify' after all commands in the list.

  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!!!!
    @wait me="This is a semaphore.
    @dolist/notify lnum(3)=say ##
    > You say, "This is a semaphore."
    > You say, "0"
    > You say, "1"
    > You say, "2"

  Related Topics: iter(), parse(), @notify, SEMAPHORES.

& @DRAIN
@DRAIN

  COMMAND: @drain <object>

  Discards all commands waiting on the semaphore <object> and resets the
  semaphore to its initial state.

  Related Topics: @notify, @ps, SEMAPHORES

& @DROP
@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.

  Related Topics: drop, @adrop, @odrop, DROP-TO, EXITS.

& @EALIAS
@EALIAS

  COMMAND:   @ealias <object> = <entrance-list>
  ATTRIBUTE: Ealias

  Sets up a set of alternate commands that may be used as synonyms 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

  Related Topics: @lalias, enter, leave.

& @EDIT
@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.

& @EFAIL
@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 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.

  Related Topics: @aefail, @aenter, @ealias, @enter, @oefail, @oenter, enter,
      ENTER_OK.

& @EMIT
@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.
     /html  - Sends the message to HTML-flags players.
     /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.

  Related Topics: @femit, @oemit, @pemit, @npemit, @remit, SPOOFING.

& @ENTER
@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.

  Related Topics: enter, @aenter, @oenter, ENTER_OK.

& @ENTRANCES
@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.

  Related Topics: @link, @unlink.

& @EXITFORMAT
@EXITFORMAT

  COMMAND: @exitformat <object> [=<format>]

  Replaces the usual "Obvious Exits:" format when an object is looked
  at, by a player-specified exits format. This is evaluated as if it
  were a description or similar message on the room.  The objects that
  the looker would normally be able to see is passed as a dbref list
  in %0; all exits can be acquired through 'lexits(me)'.

  One could change the format to 'Exits: Exit1 Exit2 Exit3' through
  '@exitformat here = Exits: [iter(%0,name(##))]', for example.

  Related Topics: @conformat, @nameformat

& @EXITTO
@EXITTO

  COMMAND:   @exitto <object> = <dbref function>
  ATTRIBUTE: Exitto

  This attribute is used to create variable exits.  If an @exitto is present
  on an exit, and the <dbref function> returns a number or a dbref, the exit
  behaves as if the returned dbref is the exit's destination.

  Because this can be used to go anywhere, @exitto is a wizard-only
  attribute.

  Even though @exitto take precendence over the static destination of an exit,
  don't forget to @link all exits anyway.  Anyone can @link an unlinked exit
  and therefore 'own' and @destroy it.

  Example:
    > @open FooExit
    Opened.
    > @exitto FooExit=#123
    Set.
    > FooExit
    Room123(#123)

  Related Topics: EXITS.

& @FAIL
@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>

  Related Topics: get, @afail, @ofail, FAILURE.

& @FEMIT
@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.

  Related Topics: @remit, @emit, @fpose, @fsay, INHERIT, SPOOFING.

& @FILTER
@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.

  Related Topics:  AUDIBLE, @forwardlist, @infilter, @inprefix, @prefix.

& @FIND
@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

  Related Topics: @search.

& @FORCE
@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>'.

  Related Topics: puppets.

& @FORWARDLIST
@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.

  Related Topics: @filter, @prefix, AUDIBLE.

& @FPOSE
@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>').

  Related Topics: @femit, @fsay, pose, :, ;, INHERIT.

& @FSAY
@FSAY

  COMMAND: @fsay <object>=<message>

  Forces <object> to say <message>.  This command is similar to the command
  '@force <object> = say <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.

  Related Topics: @femit, @fpose, INHERIT, say.

& @GFAIL
@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!

  Related Topics: give, @agfail, @ogfail, @lock.

& @HALT
@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.

  Related Topics: @drain, @notify, kill, HALTED, SEMAPHORES.

& @IDESC
@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.

  Related Topics: enter, @describe, ENTER_OK.

& @IDLE
@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.

  If an @idletimeout is set on the person being paged, you will only see
  the @idle message if that person is more idle than the specified amount
  of time.

  Example: @idle me = At dinner.  Back about 7PM.

  Related Topics: @away, @idletimeout, @reject, page.

& @IDLETIMEOUT
@IDLETIMEOUT

  COMMAND:   @idletimeout <object> = <seconds>
  ATTRIBUTE: IdleTimeout

  This attribute is used to determine if your @idle message is sent to
  a player who successfully pages you.
  If you're online and working at the same time, you can set the minimum
  idle time to allow your message to show. so whilst you're not idle your
  @idle message will not show without you having to delete it to hide it.

  This attribute is only meaningful for players, and will never be
  automatically referenced on other object types.

  Example: @idle me = Working IRL. Monitoring this window from time to time.
           @idletimeout me = 60

  Related Topics: @away, @idle, @reject, page.

& @IFELSE
@IF

  COMMAND: @if <string>=<true>[,<false>]

  Checks if <string> evaluates to a true value. If so, the command <true>
  is performed. If not, <false> is (if present).
  This command can also be called as @ifelse.

  Examples:
    > think money(me)
    150
    > @if [gte(money(me),1)]=say I have money., say I'm broke!
    You say, "I have money."

  Related topics: @switch, ifelse(), switch().

& @INFILTER
@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.

  Related Topics: @filter, @inprefix, @listen, @prefix.

& @INPREFIX
@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.

  Related Topics: @filter, @infilter, @listen, @prefix.

& @KILL
@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.

  Related Topics: kill, @akill, @okill, BEING KILLED, IMMORTAL, WIZARD.

& @LALIAS
@LALIAS

  COMMAND:   @lalias <object> = <entrance-list>
  ATTRIBUTE: Lalias

  Sets up a set of alternate commands that may be used as synonyms 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

  Related Topics: @ealias, enter, leave.

& @LAST
@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.

& @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.

  Related Topics: leave, @aleave, @oleave.

& @LFAIL
@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!

  Related Topics: @aleave, @alfail, @lalias, @leave, @oleave, @olfail, leave.

& @LINK
@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 former owner 1 coin
  (making the total cost to you 2 coins).

{ 'help @link2' for more }

& @LINK2
@LINK (continued)

  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.

  Related Topics: @dig, @open, @unlink, DROP-TOS, HOMES, LINKING, OBJECT TYPES.

& @LIST
@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.

& @LISTEN
@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

  Related Topics: @aahear, @ahear, @amhear, @sweep, @inprefix, @infilter.

& @LISTMOTD
@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
@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.

  Related Topics: @chown, @unlock, @lock keys, @lock locks

& @LOCK ATTRIBUTE
@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.

{ 'help @lock attribute2' for more }

& @LOCK ATTRIBUTE2
@LOCK ATTRIBUTE (continued)

  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:*@*

  Related Topics: ATTRIBUTE OWNERSHIP, @lock evaluation.

& @LOCK CARRY
@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).

  Related Topics: @lock is, @lock normal.

& @LOCK COMPOUND
@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 message.

& @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.

{ 'help @lock evaluation2' for more }

& @LOCK EVALUATION2
@LOCK EVALUATION (continued)

  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.

  Related Topics: @lock attributes.

& @LOCK INDIRECT
@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.

  Related Topics: @lock normal.

& @LOCK IS
@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.

  Related Topics: @lock carry, @lock normal.

& @LOCK KEYS
@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 LOCKS
@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.
     GetFromLock:  All but Exits:  controls who may gets things from a given
                                   location.
     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)
     MailLock:     Players:        controls who may @mail the player.
     OpenLock:     All but Exits:  controls who may open an exit.
     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.

{ 'help @lock locks2' for more }

& @LOCK LOCKS2
@LOCK LOCKS (continued)

     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 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

  Related Topics: @lock is, @lock carry.

& @LOCK OWNERSHIP
@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.

  Related Topics: @lock normal.

& @MAIL
@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: *Hunger)
        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".

  Related Topics:
    mail-sending    mail-reading     mail-folders      mail-other
    mail-admin      @malias          mail-reviewing    mail-examples

& @MAILSUCC
@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.

  Related Topics: @amail, @signature, @mail.

& @MALIAS
@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, Personal
  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 command.
  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>.

{ 'help @malias2' for more }

& @MALIAS2
@MALIAS (continued)

  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>.
  @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.

& @MFAIL
@MFAIL

  COMMAND:   @mfail <object> = <message>
  ATTRIBUTE: Mfail

  This attribute is sent as a message to anyone who tries to @mail you but you
  have prevented them via your @mail lock (@lock/mail).

  Example: @mfail me = I _told_ you not to @mail me anymore...

  Related Topics: @lock, @mail, @reject.

& @MONIKER
@MONIKER

  Command: @moniker <object> = <string>
  Attribute: Moniker

  The @moniker command allows you to set accented, multi-color names for
  an item.  This affects contents, inventories, the normal 'look', and
  many other cases.

  The name in @moniker MUST match the name returned by name() minus ANSI
  codes and accent marks or the moniker is ignored in favor of name().

  Examples:
    > @name object=99 Red Balloons
    Name set.
    > @moniker object=99 [ansi(hr,Red)] Baboons
    String entered must match name of target, '99 Red Balloons'.
    > @moniker object=99 [ansi(hr,Red)] Balloons
    Ansi string entered for 99 Red Balloons of '99 Red Balloons'.

  Related Topics: accent(), ansi(), chr(), moniker(), @name, NOACCENT, ord(),
                  stripaccents(), and stripansi().

& @MOVE
@MOVE

  COMMAND:   @move <object> = <message>
  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.

  Related Topics: @amove, @omove.

& @MVATTR
@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.

  Related Topics: @set.

& @NAME
@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.

& @NAMEFORMAT
@NAMEFORMAT

  COMMAND: @nameformat <object> [=<format>]

  By default, when an object is looked at, the object's name is shown.
  And, if you can link to the object, it's flag letters and dbref are also
  shown. However, with @nameformat, you can control exactly what is shown.

  Related Topics: @conformat, @exitformat

& @NEMIT
@NEMIT

  COMMAND: @nemit[/<switches>] <message>

  Sends <message> to everyone in your current location without prefixing it by
  your character name and without evaluating it.  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.
     /html  - Sends the message to HTML-flags players.
     /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.

  Related Topics: @emit, @femit, @oemit, @pemit, @npemit, @remit, SPOOFING.

& @NOTIFY
@NOTIFY

  COMMAND: @notify[/<switches>] <object>[/<attribute>][=<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. @notify may also take an argument of the form
  <object>/<attribute>, which notifies commands that are being blocked on
  an attribute other than the default 'Semaphore'. This allows blocking of
  multiple sets of commands on a single object, using different attributes.

  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.
     /quiet - Suppress the 'Notified.' message associated with the command.

  Related Topics: @drain, @ps, @wait, SEMAPHORES

& @NPEMIT
@NPEMIT

  COMMAND: @npemit[/switches] <what>=<message>

  Almost exactly like @pemit and it takes the same switches. However,
  it does not evaluate <message> at all. So, @npemit differs from
  @npemit/noeval in that no space compression is done.

  Related Topics: @pemit

& @ODESCRIBE
@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.

  Related Topics: look, @adescribe, @describe, @idesc.

& @ODFAIL
@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.

  Related Topics: drop, @adfail, @dfail, @lock.

& @ODROP
@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.

  Related Topics: drop, @adrop, @drop, DROP-TO, EXITS.

& @OEFAIL
@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.

  Related Topics: @aefail, @aenter, @ealias, @efail, @enter, @oenter, enter,
      ENTER_OK.

& @OEMIT
@OEMIT

  COMMAND: @oemit <player>=<message>

  Emits <message> to everyone in the current location of <player> except
  <player>.

  Related Topics: @remit, @emit, @pemit, @npemit, SPOOFING.

& @OENTER
@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: @oenter wormhole = enters the wormhole from normal space.

  Related Topics: enter, @aenter, @enter, @oxenter.

& @OFAIL
@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>

  Related Topics: get, look, @afail, @fail, FAILURE.

& @OGFAIL
@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.

  Related Topics: give, @agfail, @gfail, @lock.

& @OKILL
@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.

  Related Topics: kill, @akill, @kill, BEING KILLED, IMMORTAL, WIZARD.

& @OLEAVE
@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.

  Related Topics: leave, @aleave, @leave, @oxleave.

& @OLFAIL
@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.

  Related Topics: @aleave, @alfail, @lalias, @leave, @lfail, @oleave, leave.

& @OMOVE
@OMOVE

  COMMAND:   @omove <object> = <message>
  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.

  Related Topics: @amove, @move.

& @OPAY
@OPAY

  COMMAND:   @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.

  Related Topics: give, @cost, @apay, @pay.

& @OPEN
@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.

  Related Topics: @dig, @link, LINKING, OBJECT TYPES.

& @ORFAIL
@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.

  Related Topics: give, @agfail, @arfail, @gfail, @ogfail, @rfail, @lock.

& @OSUCCESS
@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.

  Related Topics: get, look, @asuccess, @success, SUCCESS.

& @OTFAIL
@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.

  Related Topics: @teleport, @atfail, @tfail, @lock.

& @OTOFAIL
@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.

  Related Topics: @teleport, @atofail, @tofail, @lock.

& @OTPORT
@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.

  Related Topics: @atport, @oxtport, @tport, @teleport.

& @OUFAIL
@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.

  Related Topics: @aufail, @ufail, @use.

& @OUSE
@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.

  Related Topics: use, @ause, @use.

& @OXENTER
@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.

  Related Topics: enter, @aenter, @enter, @oenter.

& @OXLEAVE
@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.

  Related Topics: leave, @aleave, @leave, @oleave.

& @OXTPORT
@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.

  Related Topics: @atport, @otport, @tport, @teleport.

& @PARENT
@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 either own
  <parent> or pass the ParentLock on a parent that is set PARENT_OK.

  Related Topics PARENT OBJECTS.

& @PASSWORD
@PASSWORD

  COMMAND: @password <old password> = <new password>

  This command changes your password.

& @PAY
@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.

  Related Topics: give, @apay, @cost, @opay.

& @PEMIT
@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 /list switch to this command allows you to @pemit a message to
  a list:  @pemit/list <object 1> [<object 2> <object N>] = <message>
  There can be any number of objects in the list. The objects must be
  specified by dbref number. This can be combined with other switches.

  The following switches are also available:
    /contents - Send the message to the contents of the named object.
    /html     - Send the message in HTML format (Pueblo).
    /noeval   - Do not parse the message.
    /object   - Send the message to the named object.

  Related Topics: page, @remit, @emit, @oemit, SPOOFING.

& @POLL
@POLL

  COMMAND: @poll [<message>]

  Sets a new poll message in the WHO report. The command is an
  alias for @doing/header.

  Related Topics: who, @doing

& @POWER
@POWER

  COMMAND: @power <object>=[!]<power>

  This command allows the granting of special powers to objects of any type.

  Related Topics: powers list

& @PREFIX
@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.

  Related Topics: AUDIBLE, @filter, @forwardlist, @infilter, @inprefix.

& @PROGRAM
@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:

  @va 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!

{ 'help @program2' for more }

& @PROGRAM2
@PROGRAM (continued)

  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'.

  Related Topics: @quitprogram.

& @PS
@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.

  Related Topics: @notify, @wait.

& @QUEUEMAX
@QUEQUEMAX

  COMMAND:   @quequemax <object> = <number>
  ATTRIBUTE: QueueMax

  This attribute sets an upper limit on the number, <number>, of
  outstanding commands in the queue for this <object>.  This attribute
  is only setable by a Wizard.

  In fact, the server has three overlapping constraints for developing
  an upper limit per player on the number of oustanding commands in the
  queue.  This attribute is part of just one of these constraints.  The
  rules (in priority order) are:

  1) @queuemax <number> described here.
  2) Current size of database (only applies if executor is Wizard).
  3) game-wide limit controlled by the player_queue_limit configuration option.

  That is, if @quequemax is set, it overrides the next two rules.  If
  <object> is a Wizard, the maximum number of outstanding queue entries
  is player_queue_limit or the size of the database (whichever is
  larger).  All other cases are covered by player_queue_limit.

  Related Topics: config(), player_queue_limit in wizhelp, @wait.

& @QUITPROGRAM
@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').

  Related Topics: @program.

& @QUOTA
@QUOTA

  COMMAND: @quota

  Lists your total building quota and the amount you have remaining.
  Creating objects, digging rooms, and opening exits all consume quota.

  Related Topics: @create, @dig, @open.

& @REJECT
@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...

  Related Topics: @away, @idle, page.

& @REMIT
@REMIT

  COMMAND: @remit <room dbref#> = <message>

  Sends <message> to the contents of <room>.

  Related Topics: @femit, @oemit, @pemit, @npemit, @emit, SPOOFING.

& @RFAIL
@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.

  Related Topics: give, @agfail, @arfail, @gfail, @ogfail, @orfail, @lock.

& @ROBOT
@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 some publicly
  available robot programs require.  This command costs 1000 coins.
  Note that some sites do not restrict outputprefix and outputsuffix to
  robots.

  Related Topics: outputprefix, outputsuffix, ROBOT, OBJECT TYPES.

& @RUNOUT
@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

  Related Topics: @charges.

& @SAYSTRING
@SAYSTRING

  Command: @saystring <object> = <string>

  Sets the substitute string that is used instead of the default 'says,'
  when you talk in a location or on the comsys. The message is passed
  as %0 and the command (say, @fsay, or channel) as %1.

  Example:
    > @saystring me=barks
    > "Hello.
    Player barks "Hello."
    > @saystring me=case(right(%0,1),!,exclaims\,,?,asks\,,says\,)
    > "Hello!
    Player exclaims, "Hello!"

  Related Topics: say, ", @speechmod.

& @SEARCH
@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.
  Related Topics: @find, search().

& @SET
@SET

  COMMAND: @set[/<switch>] <object>=[!]<flag1> [!][<flag2>
           @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 or flags 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.

{ 'help @set2' for more }

& @SET2
@SET (continued)

  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 visible to wizards.
     regexp     - When $-commands are matched, treat the pattern as a
                  regular expression rather than a wildcard glob pattern.
     wizard     - The attribute may only be changed by wizards.

  The @set command takes the following switch:
     quiet      - Inhibit 'Set.' acknowledgement messages.

  Related Topics: @lock, @lock, examine, FLAGS, &.

& @SEX
@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)

  Related Topics: GENDER.

& @SIGNATURE
@SIGNATURE

  COMMAND:   @signature <player> = <message>
  ATTRIBUTE: Signature

  Sets a message to be appended to every @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.)

  Related Topics: @mailsucc, @amail, @mail.

& @SPEECHMOD
@SPEECHMOD

  Command: @speechmod <object> = <string>
  Attribute: SpeechMod

  Sets a filter to be applied to all of <object>'s speech. <string> is
  evaluated with the original speech as %0 and the command as %1. It is
  then displayed in place of the original speech. You can use this to
  colorize each word of what you say, say things backwards, etc. 

  @speechmod affects: "  \\  ;  :  page  pose  say  whisper  @fpose  
     @fsay  @wall  on-channel speech

  %1 may be one of: channel  channel/pose  page  pose  say  whisper
    @emit (for \\)  @fpose  @fpemit  @fsay  @wall

  Example:
    > @speechmod me=ucstr(%0)
    > "Hello.
    Player says "HELLO."

  Related Topics: say, ", @saystring.

& @STARTUP
@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

& @STATS
@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.

  Related Topics: stats().

& @SUCCESS
@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.

  Related Topics: get, look, @asuccess, @osuccess, SUCCESS.

& @SWEEP
@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.

  Related Topics: @listen, AUDIBLE, PUPPETS.

& @SWITCH
@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.

  #$ is substituted with the value of <string>. In this way, the commands in
  <c1>..<cN>..<cD> have a short-hand way of getting at the matched value.

  Wildcards match strings, and the < and > operators allowing matching by
  numeric value.  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>.

  Related Topics: switch(), ifelse().

& @TELEPORT
@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 switches are available:
     /quiet - Teleports without setting off success or failure messages.
     /list  - Interpret <object> as a space-delimited list of objects.

  Related Topics: JUMP_OK, @lock (tport and telout), @tfail, @otfail, @atfail,
      @tofail, @otofail, @atofail.

& @TFAIL
@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.

  Related Topics: @teleport, @atfail, @otfail, @lock.

& @TOFAIL
@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.

  Related Topics: @teleport, @atofail, @otofail, @lock.

& @TPORT
@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!

  Related Topics: @atport, @otport, @oxtport, @teleport.

& @TRIGGER
@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.

  Related Topics: LOOPING.

& @UFAIL
@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 ufail.

  Example: @ufail robot = The robot pointedly ignores you.

  Related Topics: @aufail, @oufail, @use.

& @UNLINK
@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.

  Related Topics: @link, LINKING, OBJECT TYPES.

& @UNLOCK
@UNLOCK

  COMMAND: @unlock[/<whichlock>] <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.

  Related Topics: @chown, @lock, @lock keys, @lock locks,
      ATTRIBUTE OWNERSHIP.

& @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.

  Related Topics: use, @ause, @ouse.

& @VERB
@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.

{ 'help @verb2' for more }

& @VERB2
@VERB (continued)

  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.

{ 'help @verb3' for more }

& @VERB3
@VERB (continued)

  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."

  Related Topics: locate().

& @WAIT
@WAIT

  COMMAND: @wait[/until] <seconds>=<command>
           @wait[/until] <object>[/<seconds>]=<command>
           @wait <object>/<attribute>=<command>

  Generally, @wait defers the execution of <command> until some future
  condition or combination of conditions.

  The first form of @wait executes <command> at some future time.

  The second form executes <command> when the object's semaphore is
  notified. If <seconds> is specified in this second form, <command> is
  executed at some future time even if the object's semaphore isn't
  notified. This is sometimes referred to as a 'timeout'.

  The third form allows the use of an attribute other than 'semaphore'. It
  allows multiple sets of semaphore-blocked commands to use the same object.

  This command charges a deposit of 10 coins which is refunded when
  <command> is executed or otherwise leaves the queue.

  By default, <seconds> is relative to the time @wait is processed, however
  if /until used, <seconds> is taken as absolute (See secs, convtime and
  convsecs). <seconds> can also express fractional seconds.

  Examples:
     > @wait 2.001=think FooBar
     FooBar
     > think secs()
     1004732313
     > @wait/until 1004732400.5=think FooBar
     FooBar
     > @dolist [setq(0,iadd(secs(),2))]75 0 25=@wait/until %q0.##=think ##
     0
     25
     75

  Related Topics: @drain, @notify, @ps, SEMAPHORES, secs, convtime, convsecs.

& @WIPE
@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.

& ABODE
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.

  Related Topics:

& ABS()
ABS()

  FUNCTION: abs(<number>)

  Returns the absolute value of its argument.

  The number may be a floating point number, in which case 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"

  Related Topics: iabs(), isign(), sign().

& ACCENT()
ACCENT()

  FUNCTION: accent(<string>, <template>)
  
  The accent() function will return <string>, with characters in it
  possibly changed to accented ones according to <template>. Both
  arguments must be the same number of characters.

  Whether or not the resulting string is actually displayed correctly
  is client-dependent. Some OSes uses different character sets than
  the one assumed (ISO 8859-1), and some clients strip these 8-bit
  characters.

("help accent2" for more)

& ACCENT2
ACCENT() (continued)

  For each character in <string>, the corresponding character of
  <template> is checked according to the table below, and a replacement
  done. If either the current <string> or <template> characters aren't
  in the table, the <string> character is passed through unchanged.
 
  Accent                         Template   String
  Name       Description         Character  Character
  -----------------------------------------------------------------
  grave      Backward slant      `          A,E,I,O,U,a,e,i,o,u
             above letter
  acute      Forward slant       '          A,E,I,O,U,Y,a,e,i,o,u,y
             above letter
  tilde      Wavy line above     ~          A,N,O,a,n,o
             letter
  circumflex carat above         ^          A,E,I,O,U,a,e,i,o,u
             letter
  umlaut     Two dots above      :          A,E,I,O,U,a,e,i,o,u
  diaeresis  letter
  ring       Small circle above  o          A,a
             letter
  cedilla    Small tail below    ,          C,c
             letter

("help accent3" for more)

& ACCENT3
ACCENT() (continued)

  These are non-accent special characters, mostly punctuation and
  non-roman letters.
 
                      Template   String
  Description         Character  Character
  --------------------------------------------------------------
  Upside-down ?       u          ?
  Upside-down !       u          !
  << quote mark       "          <
  >> quote mark       "          >
  German sharp s      B          s
  Capital thorn       |          P
  Lower-case thorn    |          p
  Capital eth         -          D
  Lower-case eth      &          o

  Examples:

    > think accent(Aule, ---:)
    Aul(e-with-diaeresis)
 
    > think accent(The Nina was a ship, The Ni~a was a ship) 
    The Ni(n-with-~)a was a ship

("help accent4" for more)

& ACCENT4
ACCENT() (continued)

    > think accent(Khazad ai-menu!, Khaz^d ai-m^nu!)
    Khaz(a-with-^)d ai-m(e-with-^)nu!

  Related Topics: NOACCENT, chr(), ord(), stripaccents().

& ACOS()
ACOS()

  FUNCTION: acos(<number>[, <units>])

  Returns the arc-cosine of <number>. The value returned will be expressed in
  <units>.  <units> may be 'radians', 'degrees', or 'gradians' or just the
  first letter of any of these. By default, <units> is 'radians'.

  In a circle, there are 2*pi() radians, 360 degrees, and 400 gradians.

  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"

  Related Topics: asin(), atan(), cos(), pi(), sin(), tan().

& ADD()
ADD()

  FUNCTION: add(<number1>[,<numberN>]...)

  Returns the result of adding its arguments together. You may add up
  to 100 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"

  Related Topics: dec(), iadd(), idiv(), imul(), inc(), isub(),
            fdiv(), mod(), mul(), sub().

& ADDCOM
ADDCOM

  COMMAND: addcom <alias>=<channel>

  The alias and the channel name are case sensitive.

  Using this command, you can join a pre-existing channel by specifying the
  alias you wish to use. If the channel is named 'Public', then you must type
  it with the same case. Likewise the alias is case sensitive. If you use
  'addcom Pub=Public', then to use the channel you must type 'Pub Hello'
  instead of 'pub Hello'.

  One other thing to be careful of: adding a channel multiple times with
  different aliases. While this is possible, it is also discouraged. You
  will receive a warning when it happens.

  Example:
    >addcom pub=Public
    Channel Public added with alias pub.

  Related Topics: delcom, @clist, comlist, alias, comtitle.

& AFTER()
AFTER()

  FUNCTION: after(<string1>[,<string2>])

  This function is case sensitive.

  Returns the portion of <string1> that occurs after <string2> or after
  the first word if <string2> isn't given. 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 ""

  Related Topics: before(), first(), rest().

& ALIAS
ALIAS

  COMMAND: <channel alias> <on|off|who|message|:pose|;pose>

  The channel alias allows you to use the channel, to turn it on and off and
  check who is online. If you have forgotten what your aliases are, see the
  help for 'comlist'.

    'on'   allows you to turn an alias/channel on.
    'off'  lets you turn off that alias/channel.
    'who'  shows you who is on that channel, which the channel name appended
           to the bottom.

  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>

  Example:
    > pub Hello, World!
    [Public] Player say, "Hello, World!"

  Related Topics: allcom, comlist, addcom, delcom.

& ALLCOM
ALLCOM

  COMMAND: allcom <on|off|who>

  This works like using a single alias except that 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.

  Example:
    > allcom who
    -- Players --
    Player1
    Player2
    -- Objects --
    -- Public --
    -- Players --
    Staff1
    Player1
    -- Objects --
    -- Staff --

  Related Topics: alias, comtitle, delcom, addcom.

& ALPHAMAX()
ALPHAMAX()

  FUNCTION: alphamax(<word1>, <word2>, <word3>, ...)

  Returns the word whose order is lexicographically last.

  Related Topics: alphamin().

& ALPHAMIN()
ALPHAMIN()

  FUNCTION: alphamin(<word1>, <word2>, <word3>, ...)

  Returns the word whose order is lexicographically first.

  Related Topics: alphamax().

& AND()
AND()

  FUNCTION: and(<boolean1>[,<booleanN>]...)

  Takes one or more BOOLEAN-Z values, and returns 1 (TRUE) if all arguments
  are TRUE.

  Related Topics: andbool(), BOOLEAN VALUES, or(), not(), t(), xor().

& ANDBOOL()
ANDBOOL()

  FUNCTION: andbool(<boolean1>[,<booleanN>]...)

  Takes one or more BOOLEAN values, and returns 1 (TRUE) if all arguments
  are TRUE.

  Related Topics: and(), BOOLEAN VALUES, or(), not(), t().

& ANDFLAGS()
ANDFLAGS()

  FUNCTION: andflags(<object>,<list of flags>)

  This function returns 1 (TRUE) if <object> has all the flags in a specified
  list, and 0 (FALSE) 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 were set WIZARD and DARK.
  ANDFLAGS(me,W!Dc) would return 1 if I were 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.

  Related Topics: flags(), orflags().

& ANSI
ANSI

  FLAG: ANSI(X)

  When set on a player, it will enable the player to see ANSI color.
  Otherwise, MUX will strip the ANSI color codes from text before it's sent to
  the client.

  Related Topics: ansi(), ANSI CODES, ANSI SUBSTITUTION, NOBLEED.

& ANSI CODES
ANSI CODES

        f - flash                       i - inverse
        h - hilite                      n - normal
        u - underline

        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.

  Related Topics: ansi(), ANSI SUBSTITUTION.

& ANSI SUBSTITUTION
ANSI SUBSTITUTION
  
  The percent substitution %x<color code> can be used instead of 
  ansi(), and is more efficient. 
 
  For example, the equivalent to [ansi(rBf,Color!)] would be:
  %xr%xB%xfColor!%xn
 
  The %xn (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.

  %x is preferred, however %c may also be used. They are equivalent.

  Related Topics: ansi(), ANSI CODES  

& ANSI()
ANSI()

  FUNCTION: ansi(<codes>,<string>[,<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.

  Related Topics: ANSI CODES, ANSI SUBSTITUTION.

& APOSS()
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>.

  Related Topics: obj(), poss(), subj(), SUBSTITUTIONS.

& ARBITRARY COMMANDS
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.

{ 'help arbitrary2' for more }

& arbitrary2
ARBITRARY COMMANDS (continued)

  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.

  You can also match a regular expression rather than wildcards. See
  'help Regular Expressions' for details.

  The following attributes are never checked for $-commands: ALIAS CHARGES
  DESC DROP FAIL IDESC ODESC ODROP OFAIL OSUCC SEX SUCC.

  Related Topics: @set.

& ART()
ART()

  FUNCTION: art(<string>)

  This function returns the proper article, "a" or "an", for the <string> by
  attempting to match it against a set of rules. This function isn't always
  right, but it makes a good guess most of the time.

  Example:
    > say art(TinyMUX)
    You say "a"
    > say art(umbrella)
    You say "an"
    > say art(unicycle)
    You say "a"
    > say art(ytterbium)
    You say "an"
    > say art(one-sided)
    You say "a"
    > say art(avocado)
    You say "an"

  Related Topics: article_rule.

& ASIN()
ASIN()

  FUNCTION: asin(<number>[, <units>])

  Returns the arcsine of <number>. The value returned will be expressed in
  <units>.  <units> may be 'radians', 'degrees', or 'gradians' or just the
  first letter of any of these. By default, <units> is 'radians'.

  In a circle, there are 2*pi() radians, 360 degrees, and 400 gradians.

  Examples:
    > say asin(0)
    You say, "0"
    > say asin(1)
    You say, "1.5707963267948966"
    > say asin(fdiv(sqrt(2),2),d)
    You say, "45"
    > say asin(0.5,d)
    You say, "30"

  Related Topics: acos(), atan(), ctu(), cos(), pi(), sin(), tan().

& ATAN()
ATAN()

  FUNCTION: atan(<number>[, <units>])

  Returns the arctangent of <number>. The value returned will be expressed in
  <units>.  <units> may be 'radians', 'degrees', or 'gradians' or just the
  first letter of any of these. By default, <units> is 'radians'.

  In a circle, there are 2*pi() radians, 360 degrees, and 400 gradians.

  Examples:
    > say atan(0)
    You say, "0"
    > say atan(1)
    You say, "1.5574077246549023"
    > say atan(1.5574077246549023)
    You say, "1"

  Related Topics: acos(), asin(), cos(), ctu(), pi(), sin(), tan().

& ATTRCNT()
ATTRCNT()

  FUNCTION: attrcnt(<object>[/<wild-pattern>])

  Returns a count of the attributes set on <object>.  If <wild-pattern> is
  given, only attributes matching it are counted.

  Related Topics: lattr()

& attrib2
ATTRIBUTE OWNERSHIP (continued)

  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.

{ 'help attrib3' for more }

& attrib3
ATTRIBUTE OWNERSHIP (continued)

  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.

  Related Topics: ATTRIBUTE FLAGS, @chown, examine, @lock, @set,
                  @unlock.

& ATTRIBUTE FLAGS
ATTRIBUTE FLAGS

    The following lists the possible flags on attributes:

    case (C)       - $-command matching will not be case-sensitive.
                     Non-functional unless the 'R' flag is also set.

    const          - No one can change this attribute.

    no_command ($) - 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.

    dark           - Only God can see this attribute.

    god            - Only God can modify this attribute.

    hidden (M)     - Only wizards and royalty can see this attribute.

    html (H)       - Emits from attr, oattr, aattr are not HTML-escaped.


{ 'help attribute flags2' for more }

& ATTRIBUTE FLAGS2
ATTRIBUTE FLAGS (cont)

    no_inherit (I) - This attribute is not inherited by children of the
                     object.

    locked (+)     - The attribute is locked, it does not change
                     ownership when the object is @chowned and may not
                     be modified.

    no_parse (P)   - $-commands and ^-listens matching is performed against
                     the unparsed (non-evaluated) string.

    private        - Only attribute owner and wizards can see this
                     attribute.

    regexp (R)     - $-command matching on this attribute uses
                     PCRE-style regular expressions.

    visual (V)     - The attribute is visible to anyone who examines
                     you.  Note that the predefined attributes DESC,
                     SEX, and LAST are always VISUAL 

    wizard (W)     - Only wizards can modify this attribute.


  Related Topics: examine, ATTRIBUTE OWNERSHIP

& ATTRIBUTE OWNERSHIP
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.

{ 'help attrib2' for more }

& AUDIBLE
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.

  Related Topics: @filter, @forwardlist, @prefix.

& AUDITORIUM
AUDITORIUM

  FLAG: AUDITORIUM(b)  ()

  When set on a room, object, or player, it enables the checking
  of speechlocks.

  Related Topics:

& BAND()
BAND()

  FUNCTION: band(<number>[, <number>[, ...]])

  Arguments must be an integer and are treated as a bitfield.  It performs a
  bitwise logical AND between these two bitfields and returns the resulting
  bitfield as an integer which can be further treated as an integer, a
  bitfield, or a logical boolean depending on your intentions.

     > think band(922,785)
     784

  In the above example, 922 in base 10 is equivalent to 39A in base 16 or
  0011 1001 1010 in base 2.  Likewise, 785 in base 10 is the same as 311 in
  base 16 and or 0011 0001 0001 in base 2.

         0011 1001 1010 (922)
  (BAND) 0011 0001 0001 (785)
         --------------
         0011 0001 0000 (784)

  The result may be expressed as 310 in base 16 or 784 in base 10.

  So, this function is useful for testing whether a particular bit in the
  field is 'on' or 'off'.  More than one bit can be tested at a time.  If all
  bits are 'off', the result is zero which can also be interpreted as a
  boolean false in softcode.

  Related Topics: shl(), shr(), bnand(), bor(), bxor().

& BEEP()
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.

  Related Topics:

& BEFORE()
BEFORE()

  FUNCTION: before(<string1>, <string2>)

  This function is case sensitive.

  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"

  Related Topics: after(), first(), rest().

& BEING KILLED
BEING KILLED

  Getting killed is no big deal. If you are killed, you return to your home,
  and all things you carry return to their homes. You also collect 50 coins
  in insurance money (unless you have >= 10000 coins or you were killed via
  the Wizard slay command).  Generally, killing is not encouraged unless
  absolutely necessary. (Note: Killing a wizard is a quick way to discover
  the many uses of the @boot command...  and killing anyone can be very
  rude.)

  Related Topics: kill, @akill, @kill, @okill, IMMORTAL, WIZARD.

& BITTYPE()
BITTYPE()

  Function: bittype([<object>])

  Returns a number from the following table based on the owner of <object>.

    God                7
    Wizard             5
    Royalty            4
    Staff/Builder      3
    Head/Immortal      2
    Mortal             1
    Uninspected/Guest  0
    ERROR              #-1

  If a player has more than one bit flag set, their highest one takes
  precedence. If no argument is given, <object> defaults to 'me'.
  This function is from RhostMUSH, there is no 6 because MUX has no
  equivalent for Rhost's Immortal.

  Related Topics: hasflag(), orflags(), andflags(). 

& BLIND
BLIND

  FLAG: BLIND(B)

  This flag suppresses the '<who> has arrived.' and '<who> has left.' messages.
  When set on a player, the messages caused by their movement are suppressed.
  When set on a location, the messages for everyone entering or leaving that
  location are suppressed.

  This flag can only be set by Wizards.

  Related Topics: DARK

& BNAND()
BNAND()

  FUNCTION: bnand(<number1>, <number2>)

  Both arguments are an integer that is treated as a bitfield. It
  performs a bitwise logical AND between <number1> and the complement
  of <number2> which has the effect of forcing certain bits in
  <number1> off in the result.

     > think bnand(922,785)
     138

  In the above example, 922 in base 10 is equivalent to 39A in base
  16 or 0011 1001 1010 in base 2. Likewise, 785 in base 10 is the same
  as 311 in base 16 and or 0011 0001 0001 in base 2. The complement
  of 785 (specifically the one's complement) is 1100 1110 1110 in base
  2, and is a simple bitwise reversal of 1's and 0's.

          0011 1001 1010 (922)
  (BAND)  1100 1110 1110 (Complement of 785)
          --------------
          0000 1000 1010 (138)

  The result may be expressed as 08A in base 16 or 138 in base 10.

  Related Topics: shl(), shr(), band(), bor(), bxor().

& BOGUS COMMANDS
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.

  Related Topics: @afail, @fail, @link, @lock, @ofail, @open.

& BOOLEAN VALUES
BOOLEAN VALUES

  There are three types of Boolean Values in MUX: BITS, BOOLEAN, and
  BOOLEAN-Z. In each case, a Boolean Value is either TRUE or FALSE, and all
  possible strings are mapped onto one of those two.

   1. The most comprehensive definition of Boolean Value is denoted simply as
      BOOLEAN. Newer functions and features use the BOOLEAN definition of a
      Boolean Value.  MUX maps the following to FALSE:

       -  Numbers (integer and floating-point) with a value of zero.
       -  The Special floating-point values of NaN, Ind, +Inf, and -Inf.
       -  Strings with zero-length.
       -  Any error message of the form "#-N <msg>".

      All other strings are understood as TRUE including negative numbers and
      dbrefs.

   2. BITS is another form of a Boolean value.  An integer can be broken down
      into BITS. Taken together, the server shows them as an integer, but
      there are functions which indirectly manipulate individual BITS.

   3. BOOLEAN-Z defines FALSE as an integer zero.  This definition still
      appears in MUX for softcode compatibility.

      Alphabetic strings are FALSE.  Everything after the decimal point in a
      floating-point number is ignored.  Dbrefs are not recognized but mapped
      to FALSE.  TRUE is then any non-zero number.

  NOTE: T() allows a BOOLEAN value to be used with a BOOLEAN-Z function, and
  Boolean Values from functions can be interpreted correctly by either BOOLEAN
  or BOOLEAN-Z definitions.

  Examples:

    not(foo) --> 0      not()    --> 1     not(-66) --> 0
    not(0)   --> 1      not(#-1) --> 1     not(#12) --> 0
    t(1)     --> 1      t(#-1)   --> 0     t(-66)   --> 1

  Related Topics: not(), t()

& BOR()
BOR()

  FUNCTION: bor(<number>[, <number>[, ...]])

  Arguments must be an integer and are treated as a bitfield.  It performs a
  bitwise logical OR which has the effect of forcing certain bits on in the
  result.

     > think bor(922,785)
     923

  In the above example, 922 in base 10 is equivalent to 39A in base 16 or
  0011 1001 1010 in base 2. Likewise, 785 in base 10 is the same as 311 in
  base 16 and or 0011 0001 0001 in base 2.

         0011 1001 1010 (922)
  (BOR)  0011 0001 0001 (785)
         --------------
         0011 1001 1011 (923)

  The result may be expressed as 39B in base 16 or 923 in base 10.

  Related Topics: shl(), shr(), band(), bnand(), bxor().

& BXOR()
BXOR()

  FUNCTION: bxor(<number>[, <number> [, ...]])

  Arguments must be integers and they are treated as a bitfield.  It performs
  a bitwise logical eXclusive-OR which has the effect of toggling certain bits
  on in the result.

     > think bxor(922,785)
     139 

  Related Topics: shl(), shr(), band(), bnand(), bor().

& CAND()
CAND()

  FUNCTION: cand(<boolean1>[,<booleanN>]...)

  Takes one or more BOOLEAN-Z values, and returns 1 (TRUE) if all arguments
  are TRUE. cand() evaluates its arguments from left to right until either
  all arguments evaluate to TRUE or one of the arguments evaluate to FALSE.
  This is unlike and() in that some arguments may not be evaluated.

  Related Topics: and(), candbool(), BOOLEAN VALUES, cor().

& CANDBOOL()
CANDBOOL()

  FUNCTION: candbool(<boolean1>[,<booleanN>]...)

  Takes one or more BOOLEAN values, and returns 1 (TRUE) if all arguments are
  TRUE.  candbool() evaluates its arguments from left to right until either
  all arguments return TRUE or one of the arguments returns FALSE. This is
  unlike andbool() in that some arguments may not be evaluated.

  Related Topics: andbool(), cand(), BOOLEAN VALUES, corbool().

& CANSEE()
CANSEE()

  FUNCTION: cansee(<looker>, <lookee>[,<lookee_action>])

  NOTE: This function is not available unless either WOD Realms or Reality
  Levels was enabled at compile-time.

  For WOD Realms:

  CANSEE returns 1 or 0 depending on whether it's possible for the looker
  to see the lookee or not. This is useful for wizard code in the master
  room, help it decide who/what should be able to see who/what, and saves
  the softcoders the hassle of duplicating these rules in softcode.

  The third parameter is optional, but if present should be 0 for standing
  still, 1 for moving, and 2 for talking.

  For Reality Levels:

  Returns 1 if <victim>'s Rx levels intersect with <target>'s Tx levels. It
  does not take into account the location of the objects or other flags like
  DARK.

  Related Topics:

& CAPSTR()
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"

  Related Topics: lcstr(), ucstr().

& CASE()
CASE()

  FUNCTION: case(<str>[,<pat1>,<res1>]...[,<dflt>])

  case() is similar to switch() but does not perform wildcard matching
  (i.e., using * or ? in the pattern).  In cases where wildcards are not
  needed, it performs marginally faster.

  Before <resI> is evaluated for return, #$ is substituted with the value
  of <str>.  In this way, <resI> has a short-hand way of getting at the
  <str> that matched its corresponding pattern.

  Related Topics: @switch, match(), ifelse(), switch().

& CAT()
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"

  Related Topics:

& CEIL()
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"

  Related Topics: fdiv(), floor(), idiv(), mod(), round(), trunc().

& CEMIT()
CEMIT()

  FUNCTION: cemit(<channel>, <message>)

  Sends <message> over <channel> prefixed by the channel's name. You must own
  or control the channel to do this.  This is a functional equivalent of
  @cemit.

  Related Topics: @cemit

& CENTER()
CENTER()

  FUNCTION: center(<string>, <width>[, <fill>])
 
  This function centers <string> within a <width>-sized field.

  The background of this field is specified by a repeating pattern of <fill>
  characters. The origin of this repeating pattern is at the first position
  of the field. Another way of saying this is that the repeating pattern
  starts in first position and repeats to the right. The last <fill> pattern
  may be truncated.

  By default, <fill> is a single, normal-colored space. The color of
  <string> and <fill> is maintained.

  If the visual width of <string> is longer than <width> characters, it is
  truncated to fit.
 
  Example:
    > say center(a,5,-)
    You say "--a--"
    > say center(*BAMF*,15)
    You say "    *BAMF*     "
    > say center(%xh%xrR%xgG%xbB,31,%xy--%xm+)
    --+--+--+--+--RGB+--+--+--+--+-

  Related Topics: ljust(), rjust().

& CHANNEL OBJECT
CHANNEL OBJECT

  In the comsystem, you may specify a channel object for each channel.
  (@cset/object channel=<object>). See 'help @cset' for help.

  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 or @coflags, those 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.

  Related Topics: @ccreate, @create, @cset.

& CHANNELS()
CHANNELS()

  FUNCTION: channels([player])

  This function lists channels that you can see, much like @clist. If the
  argument is omitted or is 'all', then all are returned, otherwise only
  those owned by the named player are returned.

  Example:
    > say channels()
    You say, "Wizard, Staff, Guest, Public, Code"
    > say channels(#1)
    You say, "Wizard, Staff, Guest, Public"
    > say channels(me)
    You say, "Code"

  Related Topics: comalias(), comtitle(), cwho()

& CHILDREN()
CHILDREN()

  FUNCTION: children(<object>)

  Returns a list of objects that are parented to <object>. Currently a
  wizard/royalty only function.

  Related Topics:

& CHIMERA
CHIMERA

  The CHIMERA flag is used to denote an object who is invisible to all but
  those set CHIMERA and FAE.

& CHOOSE()
CHOOSE()

  FUNCTION: choose(<item list>, <weight list>[, <delim>])

  This function picks an item from <item list> at random controlled by the
  distribution given in <weight list>.

  Examples:
    > think choose(1 2 3,1 0 0)
    1

& CHOWN_OK
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.

  Related Topics: @chown

& CHR()
CHR()

  FUNCTION: chr(<ord>)

  Returns a single character that corresponds to the <ord>'th position in the
  character set.

  Related Topics: ord().

& CLEARCOM
CLEARCOM

  COMMAND: clearcom

  This command will erase all channel information.

  The 'clearcom' command is equivalent to typing 'delcom <alias>' for each
  channel. It will remove you from all channels and erase your status and
  title.

  Example:
    > clearcom
    You have left channel Public.
    Channel Public deleted.
    You have left channel Staff.
    Channel Staff deleted.

  Related Topics: addcom, delcom.

& CMDS()
CMDS()

  FUNCTION: cmds(<player>)

  Returns the number of commands entered by a connected <player|port>.  If
  <player|port> is not connected or the enactor has insufficient permissions,
  then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the first connection is returned.

  Example:
    > say cmds(me)
    You say "100"
    > say cmds(me)
    You say "101"

  Related Topics:

& COLUMNS()
COLUMNS()

  FUNCTION: columns(<list>, <width>[, <delim>[, <indent>]])

  Formats a delimited <list> into fixed-width columns.  Any element
  longer than <width> is truncated.  <indent> specifies a left margin.
  This function fits the margin and as many columns as possible into a
  78-wide screen.

    The input delimiter, <delim>, defaults to a space.
    The left margin width, <indent>, defaults to zero.

  Related Topics: table()

& COMALIAS()
COMALIAS()

  FUNCTION: comalias(<player>, <channel>)

  comalias() returns the alias the player uses to access the named channel.
  Wizards can retrieve the comalias for anyone. Players and objects can check
  for themselves. Objects that Inherit can check for their owners.

  Example:
    > say comalias(me,Public)
    You say "pub"

  Related Topics: channels(), comtitle(). cwho().

& COMLIST
COMLIST

  COMMAND: comlist

  This command displays a list of all the channels you are connected to, the
  alias you're using for the channel, whether you are 'on' or 'off' on the
  channel and what your comtitle is.

  Example:
    > comlist
    Alias     Channel            Status   Title
    pub       Public             off      Roleplay Staff
    staff     Staff              on

  Related Topics: comtitle, addcom, alias, delcom.

& COMMAND EVALUATION
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.
  - The comsystem checks for a channel 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.

{ 'help command evaluation2' for more }

& command evaluation2
COMMAND EVALUATION (continued)

  - 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.

& COMMANDS
COMMANDS

  Help available for MUX Commands:

  drop         enter        examine      get          give         goto
  help         INFO         inventory    kill         leave        LOGOUT
  look         move         news         OUTPUTPREFIX OUTPUTSUFFIX page
  pose         QUIT         read         report       say          score
  SESSION      take         think        throw        train        use
  version      whisper      WHO          "            :            ;
  &            #            \\

  @@           @backup      @break       @cemit       @chown       @chzone
  @clone       @cpattr      @create      @decompile   @destroy     @dig
  @doing       @dolist      @drain       @edit        @emit        @entrances
  @femit       @find        @force       @fpose       @fsay        @halt
  @if          @last        @link        @list        @listmotd    @lock
  @mail        @mvattr      @name        @nemit       @notify      @npemit
  @oemit       @open        @parent      @password    @pemit       @power
  @program     @ps          @quitprogram @quota       @remit       @robot
  @search      @set         @stats       @sweep       @switch      @teleport
  @timecheck   @trigger     @unlink      @unlock      @verb        @wait
  @wipe

{ 'help commands2' for more }

& COMMANDS2
COMMANDS (continued)

  The following are @-related:

  @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     @conformat
  @cost        @daily       @descformat  @describe    @dfail       @drop
  @ealias      @efail       @enter       @exitformat  @exitto      @fail
  @filter      @forwardlist @gfail       @idesc       @idle        @idletimeout
  @infilter    @inprefix    @kill        @lalias      @leave       @lfail
  @listen      @mailsucc    @mfail       @moniker     @move        @nameformat
  @odescribe   @odfail      @odrop       @oefail      @oenter      @ofail
  @ogfail      @okill       @oleave      @olfail      @omove       @opay
  @orfail      @osuccess    @otfail      @otofail     @otport      @oufail
  @ouse        @oxenter     @oxleave     @oxtport     @pay         @prefix
  @queuemax    @reject      @rfail       @runout      @saystring   @sex
  @signature   @speechmod   @startup     @success     @tfail       @tofail
  @tport       @ufail       @use

& COMP()
COMP()

  FUNCTION: 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.

  Related Topics:

& COMSYS
COMSYS

  This is the help for the MUX comsystem. Note that the channel names and
  aliases are case-sensitive. Many games are configured to have a new player
  automatically join the 'Public' channel, and a Guest join the 'Guest'
  channel. If you are a wizard, see 'wizhelp config' for the parameters
  relating to this.

  A comsys allows the various players to communicate with each other. A
  comsys can consist of one Public channel for all players, or various
  channels set aside for various groups within the game, thus allowing each
  group to communicate with the other members of that group.

  Two of the most accepted reasons for using a comsys are to allow players to
  interact with members of their group, and to provide a venue for OOC
  chatting.

  Related Topics: comsys commands, comsys examples

& COMSYS COMMANDS
COMSYS COMMANDS AND FUNCTIONS

  These are the topics for the MUX comsystem:

  User Commands:            @clist, addcom, alias, allcom, comlist, comtitle,
                            clearcom, delcom

  Administrative Commands:  @cboot, @ccharge, @cchown, @ccreate, @cdestroy,
                            @cemit, @clist, @coflags, @cpflags, @cset, @cwho

  Functions:                channels(), comalias(), comtitle(), cwho()

  General Information:      channel object, comsys examples

& COMSYS EXAMPLES
COMSYS EXAMPLES

  Examples:
    > addcom public=Public
    Channel Public added with alias public.

    > 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!"

    > pub last 10
    -- Begin Comsys Recall --
    [Public] Foobar has joined this channel.
    [Public] Foobar has left this channel.
    [Public] Foobar has joined this channel.
    [Public] Foobar says, "Hello world!"
    -- End Comsys Recall --

  Related Topics: comsys commands

& COMTITLE
COMTITLE

  COMMAND: comtitle <alias>=<title>
           comtitle[/<option>] <alias>

  This command allows you to prefix your name on a channel with a title.
  The second form contains a switch that allow you to turn on or off 
  the ability to see comtitles. <option> can be on of the following:

    on      - comtitles are shown to you.
    off     - poses are shown to you without their comtitles.

  Anonymous channels (@cset/anon) do not allow their comtitles to be
  turned off.

  Examples:
    > 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.

  Related Topics: comlist, addcom, alias, delcom, @cset

& COMTITLE()
COMTITLE()

  FUNCTION: comtitle(<player>, <channel>)

  comtitle() returns the comtitle the player has set on the named channel.
  Non-wizards can only use it to return their own comtitles.

  Example:
    > say comtitle(me,Public)
    You say "The mighty Wizard"

  Related Topics: channels(), comalias(), cwho()

& CON()
CON()

  FUNCTION: con(<object>)

  Con returns the first object in the list of objects carried by
  thing. Just the first, and only the first.

  Related Topics: next().

& CONFIG()
CONFIG()

  FUNCTION: config([<parameter name>])

  Most server configuration options are exposed programmatically via
  this function.  Given a <parameter name>, this function returns the
  value currently in force.  If no args are given, the function returns
  a list of all options the player has permission to view.

  For boolean configuration options, config() does not return 'yes' or
  'no'.  It returns the boolean in the form compatible with BOOLEAN.

  Configuration options are determined in order by:

    - Server defaults,
    - Configuration file, and
    - @admin changes.

  Related Topics: BOOLEAN, CONFIG PARAMETERS in wizhelp

& CONN()
CONN()

  FUNCTION: conn(<player|port>)

  Returns the number of seconds that <player|port> has been connected.  If
  <player|port> is not connected then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named 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. :)
    3 Players logged in.
    > say conn(wiz)
    You say "251"
    > say conn(e)
    You say "770"
    > say conn(frobozz)
    You say "-1"

  Related Topics: WHO, idle(), lwho().

& CONNECTED
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.

  Related Topics:

& CONNLAST()
CONNLAST()

  FUNCTION: connlast(<player>)

  Returns the number of seconds that <player>'s last connection to
  the MUX was.

  Related Topics: conntotal(), connmax(), connnum(), connleft(), secs(),
      conn().

& CONNLEFT()
CONNLEFT()

  FUNCTION: connleft(<player>)

  Returns the time stamp (number of seconds elapsed since midnight,
  January 1, 1970) that represents when the <player> last
  disconnected from the MUX.

  Related Topics: conntotal(), connmax(), connlast(), connnum(), secs(),
      conn().

& CONNMAX()
CONNMAX()

  FUNCTION: connmax(<player>)

  Returns the longest connection time that <player> has been
  connected to the MUX -- perhaps even the current session.

  Related Topics: conntotal(), connlast(), connnum(), connleft(), secs(),
      conn().

& CONNNUM()
CONNNUM()

  FUNCTION: connnum(<player>)

  Returns the number connections that <player> has had to the MUX
  including the current connection.

  Related Topics: conntotal(), connmax(), connlast(), connleft(), secs(),
      conn().

& CONNRECORD()
CONNRECORD()

  FUNCTION: connrecord()

  Returns the record number of connections to the game since the database was
  created.

& CONNTOTAL()
CONNTOTAL()

  FUNCTION: conntotal(<player>)

  Returns the number of seconds that <player> has been connected to
  the MUX. This also includes the current connection time.

  Related Topics: connmax(), connlast(), connnum(), connleft(), secs(),
      conn().

& CONTROL
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.

& CONTROLS()
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"

  Related Topics: CONTROL.

& CONVSECS()
CONVSECS()

  FUNCTION: convsecs(<seconds> [, <zonename>][, <precision>])

  By default, this function converts an integer (representing a count
  of seconds from Jan 01 00:00:00 1970 UTC) to a local time string --
  where local time is the time at the machine running the MUX. This
  conversion includes a timezone/daylight savings time conversion
  between UTC and the local time zone.

  If a second argument is given, it is the <zonename>:

   local - indicates that a conversion for timezone/DST of the 'local'
           server time should be applied (the default).

   utc   - indicates that no timezone/DST conversions should be applied.
           When used this way, there is a unique one-to-one relationship
           between an integer and it's corresponding text-string which
           may be useful for handling other timezones and fictional
           settings.

  <precision> determines the number of fractional seconds shown.
  By default, no fractional seconds are shown.

  Example:
    > say secs()
    You say "957558109"
    > say secs(local)
    You say "957532909"
    > say convsecs(957558109)
    You say "Fri May 05 13:21:49 2000"
    > say convsecs(957532909, utc)
    You say "Fri May 05 13:21:49 2000"

  Related Topics: convtime(), secs(), time().

& CONVTIME()
CONVTIME()

  FUNCTION: convtime(<time string> [, <zonename>][, <precision>])

  By default, this function converts a time string (of format
  [Ddd] Mmm DD HH:MM:SS YYYY) into an integer which represents a
  count of seconds since Jan 01 00:00:00 1970 UTC not including leap
  secs. Where Ddd, if given, is the day of the week. Mmm is the month
  name, 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.

  Keep in mind that the year may not be exactly four characters and
  it can also be negative. This server provides a proleptic Gregorian
  calendar with a range of supported years between 27257 BC and
  30826 AD. Year 0 is 1 BC, -1 is 2 BC, ..., so 27257 BC should be
  given as -27256. This follows the astronomical conventions.

  Note: The time string can also be freeform and this function will
  attempt to parse.

  If a second argument is given, it is the <zonename>:

   local - indicates that a conversion for timezone/DST of the 'local'
           server time should be applied (the default).

   utc   - indicates that no timezone/DST conversions should be applied.
           When used this way, there is a unique one-to-one relationship
           between an integer and it's corresponding text-string which
           may be useful for handling other timezones and fictional
           settings.

  <precision> determines the number of fractional seconds shown.
  By default, no fractional seconds are shown.

  Examples:
    > say time()
    You say "Wed Jun 24 10:22:54 1992"
    > say convtime(Wed Jun 24 10:22:54 1992)
    You say "709406574"
    > say convtime(Wed Jun 24 10:22:54 1992, utc)
    You say "709381374"
    > say convtime(June 24th 1992 10:22:54.0001am Z)
    You say "709381374"
    > say convtime(Wed 24 Jun 1992 10:22:54 -0700)
    You say "709406574"
    > say convtime(2001-01-01T100000Q)
    You say "978357600"
    > say convtime(-1605-120T123456M)
    You say "-112805738704"
    > say convtime(23456W12-1T123456T)
    You say "678039276896"

  Related Topics: convsecs(), secs(), time().

& COR()
COR()

  FUNCTION: cor(<boolean1>[,<booleanN>]...)

  Takes one or more BOOLEAN-Z values, and returns 1 (TRUE) if at least one
  argument is TRUE.  cor() evaluates its arguments from left to right until
  either all arguments evaluate to FALSE or one of the arguments evaluates to
  TRUE. This is unlike or() in that some arguments may not be evaluated.

  Related Topics: BOOLEAN VALUES, cand(), corbool(), not(), or(), t().

& CORBOOL()
CORBOOL()

  FUNCTION: corbool(<boolean1>[,<booleanN>]...)

  Takes one or more BOOLEAN values, and returns 1 (TRUE) if at least one
  argument is TRUE.  corbool() evaluates its arguments from left to right
  until either all arguments evaluate to FALSE or one of the arguments
  evaluates to TRUE. This is unlike orbool() in that some arguments may not
  be evaluated.

  Related Topics: BOOLEAN VALUES, candbool(), cor(), not(), orbool(), t().

& COS()
COS()

  FUNCTION: cos(<number>[, <units>])

  Returns the cosine of <number> where <number> is expressed in <units>.
  <units> may be 'radians', 'degrees', or 'gradians' or just the first letter
  of any of these. By default, <units> is radians.

  In a circle, there are 2*pi() radians, 360 degrees, and 400 gradians.

  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"

  Related Topics: acos(), asin(), atan(), pi(), sin(), tan().

& COSTS
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.

  Related Topics: @list.

& CRC32()
CRC32()

  FUNCTION: crc32(<string1>, ..., <stringN>)

  Returns the Cyclic Redundancy Check of the strings or sequences of
  strings as a positive number. The answer for the same sequence of
  strings is always the same.

  The usefulness of this number is broad, but could provide a unique
  fingerprint, checksum pattern, or high-quality hash function.

  Example:
    > think crc32(MUX)
    629126998

& CREATE()
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.

  Related Topics:

& CREDITS

  Topic: CREDITS

TinyMUX 2.4 is based on TinyMUX 2.3. It is currently maintained by
Stephen Dennis (AKA Brazil). There is a more complete list of credits
in the README files for the server itself.

See http://www.tinymux.com for an on-line version of these README files.
 
& CTIME()
CTIME()

  FUNCTION: ctime(<object>)

  Returns <object>'s creation time as a time() string.

  Example:
    > think ctime(me)
    Mon Oct 08 18:33:03 2001

  Related Topics: @create, @dig, @open, @pcreate, time().

& CTU()
CTU()

  Function: ctu(<number>, <units-from>, <units-to>)

  The ctu() function will convert <number> that was originally in the units
  of <units-from> into the units of <units-to>.

  The units available are (r)adians, (g)radians, and (d)egrees.

  180 degrees = PI (3.141592653589793) radians = 200 gradians.

  Examples:
    > say ctu(180,d,g)
    You say, "200"
    > say ctu(180,d,r)
    You say, "3.141592653589793"

  Related Topics: sin(), cos(), tan(), asin(), acos(), atan(), pi()

& CWHO()
CWHO()

  FUNCTION: cwho(<channel> [, <select>])

  Returns a list of dbrefs from that channel. Use of this function is limited
  to wizards and channel owners. If not given, <select> defaults to 'on',
  but if given, may be any of the following:

    on  - all objects and connected players who are 'on' the channel.
    off - all objects and connected players who are 'off' the channel.
    all - all objects and players associated with the channel.

  Example:
    > say cwho(Public)
    You say "#13 #11"

  Related Topics: alias, channels(), comalias(), comtitle().

& DARK
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.

  Related Topics:

& DEAD
DEAD

  This flag does not alter any behavior of the server itself. However, it may
  be useful for softcode. This flag is only available if realms is enabled.

  Related Topics:

& DEC()
DEC()

  FUNCTION: dec(<number>)

  Returns <number> minus 1. Faster and more efficient than
  sub(<number>,1). Decimal places will be truncated.

  Related Topics: sub(), add(), inc().

& DECRYPT()
DECRYPT()

  FUNCTION: decrypt(<text>,<key>)

  Decrypts <text> using <key>. <key> should be the same one used to encrypt
  the text, and is case sensitive.

  Related Topics: encrypt().

& DEFAULT()
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!"

  Related Topics: get(), get_eval(), u(), edefault(), udefault().

& DELCOM
DELCOM

  COMMAND: delcom <alias>

  Deletes <alias> from your list of channel aliases. If the <alias> was the
  only alias for the channel, then the channel has now been effectively
  removed. In order to use that channel again, you will need to re-add the
  channel with the 'addcom' command. If you only wish to have the channel
  quiet for a time, then a better command is '<alias> off'.

  Example:
    >delcom pub
    Channel Public deleted.

  Related Topics: addcom, alias, comlist, clearcom.

& DELETE()
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?"

  Related Topics:

& DESTROY_OK
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.

  Related Topics: @destroy, SAFE.

& DIE()
DIE()

  FUNCTION: 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.

  Related Topics: lrand(), pickrand(), rand(), shuffle()

& DIGITTIME()
DIGITTIME()

  FUNCTION: digittime(<seconds>)

  This function converts a number of <seconds> to a digital time
  string and prepends the number of days if the time is greater than
  23:59.

  Example:
    > say digittime(2345)
    You say "00:39"
    > say digittime(123456)
    You say "1d 10:18"

  Related Topics: writetime(), singletime(), exptime(), secs(), time().

& DIST2D()
DIST2D()

  FUNCTION: dist2d(x1, y1, x2, y2)

  Returns the distance between the Cartesian points in two dimensions
  (x1,y1) and (x2,y2).

  Example:
    > say dist2d(0,0,3,4)
    You say "5"

  Related Topics: dist3d()

& DIST3D()
DIST3D()

  FUNCTION: dist3d(x1, y1, z1, x2, y2, z2)

  Returns the 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"

  Related Topics: dist2d()

& DIV()
DIV()

  FUNCTION: div(<number1>,<number2>)

  div() is an alias for idiv().

  Related Topics: idiv().

& DOING()
DOING()

  FUNCTION: doing(<player|port>)

  Returns the @doing entry for the requested <player|port>.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION). Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the @doing from the first connection is returned.

  Related Topics: poll()

& DROP
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'.

  Related Topics: get, @adrop, @drop, @odrop, DROP-TO, STICKY.

& DROP-TOS
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.

  Related Topics: @link, STICKY.

& DUMPING()
DUMPING()

  FUNCTION: dumping()

  Return a boolean indicator of whether a forked @dump is currently
  in progress.

  Example:
    > think dumping()
    0

  Related Topics: @dump

& E()
E()

  FUNCTION: e()

  Returns the value of the numeric constant e to nine decimal places.

  Example:
    > say e()
    You say "2.718281828"

  Related Topics: exp(), ln(), log(), power().

& EDEFAULT()
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."

  Related Topics: get(), get_eval(), u(), default(), udefault().

& EDIT()
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"

  Related Topics: @edit.

& ELEMENTS()
ELEMENTS()

  FUNCTION: elements(<list of words>,<list of numbers>[,<idelim>[,<odelim>]])

  This function returns the words in <list of words> that are in the
  positions specified by <list of numbers>.  <list of numbers> is always
  delimited by spaces.  <idelim> is the delimiter for <list of words>,
  and the output is delimited by <odelim>

  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"

  Related Topics:

& ELOCK()
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.

  Related Topics:

& EMIT()
EMIT()

  FUNCTION: emit(<message>)

  A side effect function that has the same effect as @emit <message>.

  Related Topics: @emit

& EMPTY()
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>.

  Related Topics: lstack(), items(), peek(), pop(), push(), OBJECT STACK.

& ENACTOR
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)

  Related Topics: SUBSTITUTION.

& ENCRYPT()
ENCRYPT()

  FUNCTION: encrypt(<text>,<key>)

  Encrypts <text> using <key>. The text can only be unlocked with <key>, and
  <key> is case-sensitive.

  Related Topics: decrypt().

& ENTER
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.

  Related Topics: leave, @aefail, @aenter, @efail, @enter, @idesc, @lock,
                  @oefail, @oenter, @oxleave, ENTER_OK.

& ENTER_OK
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>'.

  Related Topics:

& ENTRANCES()
ENTRANCES()

  FUNCTION: entrances([<loc>[,<type>[,<low>[,<high>]]]])
 
  Returns a space-separated list of links from elsewhere to <loc>.  The
  results may include exits and drop-to's leading to <loc> as well as players
  and objects whose home is <loc>.  Unlike @entrances, entrances() does not
  report parent/child relationships.  Use children() to obtain this
  information.  <type> can be used to restrict the type of entrances returned:
  E (exit), T (thing), R (room), P (player).  There is a search cost to this
  function.  <low> and <high> can be used to indicate where to start and stop
  the search, respectively.
 
  You may only use this command on locations that you control, or else the
  results will be limited to items you can examine.

  Defaults:
    <loc>  -  your current room.
    <type> -  A (all).
    <low>  -  beginning of database.
    <high> -  end of database.
 
  Examples:
    > say entrances()           <- all links to here
    > say entrances(object)     <- all links to object
    > say entrances(here,tp)    <- everything that lives here
    > say entrances(me,a,1000)  <- all links to me from #1000 and above.
 
  Related Topics: @entrances, @link, link(), children(), lexits().

& EQ()
EQ()

  FUNCTION: eq(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), gt(), neq().

& ERROR()
ERROR()

  FUNCTION: error(<string>)

  This function is useful in softcoded commands, especially @addcommand'ed ones.
  If the global_error_obj config parameter is not set, this will return the
  default error message. If it is, it passes <string> as if the player had typed
  it and gotten a bad command.

  Example:
    > say error()
    You say "Huh?  (Type 'help' for help.)"

    > say error(@pmit)
    You typed '@pmit'.

  Related Topics: 

& 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:
    > @va me=Sneak a peek at Wiz's desc... [get(#1/desc)]
    > say escape(%va)
    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.

  Related Topics: secure().

& 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 separate 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.

  Related Topics: get_eval(), get(), xget().

& EXAMINE
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.  A list of
  this flag letters is given in the references.


{ 'help examine2' for more }

& 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.

  Related Topics: look, @decompile, VISUAL, ATTRIBUTE FLAGS,
                  ATTRIBUTE OWNERSHIP.

& EXIT()
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.

  Related Topics: con(), lcon(), lexits(), next().

& EXITS
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.  Exits may also
  be @teleported from one room to another.

  If an exit is set DARK it will not show up in the list of obvious exits in
  a room.

  If multiple exits match in name, MUX chooses between them randomly.

  Another way of creating 'variable' exits is to use the @exitto attribute.

  Related Topics: @exitto, @link, @open.

& EXP()
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"

  Related Topics: e(), log(), ln(), power().

& EXPTIME()
EXPTIME()

  FUNCTION: exptime(<seconds>)

  This function converts seconds to a number of time elements (hours,
  minutes, seconds) that is equivalent to the given number of
  <seconds>.

  This is very similar to the writetime() function, but the elements
  are given their short names instead of long names.

  Example:
    > say exptime(45)
    You say "45s"
    > say exptime(12345)
    You say "3h 25m 45s"
    > say exptime(123456)
    You say "1d 10h 17m 36s"

  Related Topics: writetime(), singletime(), digittime(), secs(), time().

& EXTRACT()
EXTRACT()

  FUNCTION: extract(<string>, <first>, <length>[,<idelim>[,<odelim>]])

  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.

  The input delimiter for <string> is <idelim>.  The output list
  delimiter is <odelim>.  <idelim> defaults to 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"

  Related Topics: index(), insert(), ldelete(), replace().

& FAE
FAE

  The FAE flag is used to denote an object which is visible to others with
  a regular description but sees FAEDESC's and those set CHIMERA. Most
  commonly used for Changelings and those who have been Enchanted by one.

& FAILURE
FAILURE

  You fail to use a player or a thing when you cannot take it (because its
  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).

  Related Topics: get, look, @afail, @fail, @lock, @ofail, STRINGS.

& FCOUNT()
FCOUNT()

  FUNCTION: fcount()

  This function returns the current state of the function invocation
  counter.  Softcode can use this result to guage its distance from the
  configured function invocation limit.

  Related Topics: fdepth(), function_invocation_limit in wizhelp

& FDEPTH()
FDEPTH()

  FUNCTION: fdepth()

  This function returns the current state of the function recursion
  counter.  Softcode can use this result to guage its distance from the
  configured function recursion limit.

  Related Topics: fcount(), function_recursion_limit in wizhelp

& FDIV()
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.

  Examples:
    > 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"

  Related Topics: add(), mod(), mul(), round(), sub(), trunc().

& FILTER()
FILTER()

  FUNCTION: filter([<obj>/]<attr>, <list>[, <in delim>[, <out delim>]])

  This function evaluates the contents of <attr> for each element of <list>,
  passing it in as %0.  A <out delim>-separated list is returned of those
  elements for which the evaluation returns the value 1.

  <in delim> may be used to specify an input 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"

  Related Topics: u(), map(), fold()

& FILTERBOOL()
FILTERBOOL()

  FUNCTION: filterbool([<obj>/]<attr>, <list>[, <in delim>[, <out delim>]])

  This function evaluates the contents of <attr> for each element of <list>,
  passing it in as %0.  A <out delim>-separated list is returned of those
  elements for which the evaluation returns a boolean-true value.

  <in delim> may be used to specify an input delimiter other than space.

  Examples:
    > &IS_ODD object=mod(%0,2)
    > say filterbool(object/is_odd,1 2 3 4 5)
    You say "1 3 5"

  Related Topics: u(), map(), fold()

& FINDABLE()
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. If <object> would not be able to see <victim> were
  they in the same location a 0 will be returned.

  Related Topics:

& FIRST()
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"

  Related Topics: rest().

& FIXED
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.

  Related Topics:

& FLAG LIST
FLAG LIST

  Flag  Title        Flag  Title        Flag  Title        Flag  Title
  -------------------------------------------------------------------------
    A - ABODE      |   B - BLIND      |   C - CHOWN_OK   |   D - DARK
    E - EXIT(*)    |   F - FLOATING   |   G - GOING      |   H - HAVEN
    I - INHERIT    |   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   |   j - GAGGED
    k - KEEPALIVE  |   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      |   $ - SITEMON    |   z - CONTROL_OK |   ? - HEAD
    - - NOBLEED    |   | - VACATION   |   ~ - NOACCENTS  |   ( - HTML
  ------------------------------------------------------------------------

  (*) Note that these 'flags' are really types.  Also notice that THING
      is not in the list.  That is, andflag(me,P) and hastype(me,PLAYER)
      work, but hasflag(me,THING) does not.

{ 'help flag list2' for more }

& FLAG LIST2
FLAG LIST2

  Flag  Title        Flag  Title        Flag  Title        Flag  Title
  ------------------------------------------------------------------------
  Without Realms Patch Flags:
    0 - MARKER0    |   1 - MARKER1    |   2 - MARKER2    |   3 - MARKER3
    4 - MARKER4    |   5 - MARKER5    |   6 - MARKER6    |   7 - MARKER7
    8 - MARKER8    |   9 - MARKER9    |
  ------------------------------------------------------------------------
  Realms Patch Flags:
    0 - FAE        |   1 - CHIMERA    |   2 - PEERING    |   3 - UMBRA
    4 - SHROUD     |   5 - MATRIX     |   6 - OBF        |   7 - HSS
    8 - MEDIUM     |   9 - DEAD       |
  ------------------------------------------------------------------------

  For information on a particular flag, type 'help <flagname>'.
  Some flags may be disabled at your particular MUX.

  Related Topics: andflags(), hasflag(), hastype(), orflags().

& FLAGS
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'.

& FLAGS()
FLAGS()

  FUNCTION: flags(<object>)
            flags(<object>/<attr>)

  Flags() returns a string of letters as a single word.  Each letter in this
  word represents a flag associated with <object> or with the <attr> on
  <object>.  Some flags are not revealed due to visibility and permissions.

  Related Topics: andflags(), orflags()

& FLOATING
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.

  Related Topics:

& FLOOR()
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"

  Related Topics: ceil(), fdiv(), mod(), round(), trunc().

& FLOORDIV()
FLOORDIV()

  FUNCTION: floordiv(<number1>,<number2>)

  Returns the integer quotient from dividing <number1> by <number2>.

  However, integer division for the case where either <integer1> or
  <integer2> is negative is defined in a specific way -- by choosing
  the largest integer that is less than or equal to the algebraic
  quotient. If <integer1> and <integer2> are the same sign, then
  idiv() and floordiv() are equivalent.

  For example, division of -9 by 5 would give -2 by this definition
  instead of -1. idiv() would return -1. floordiv() would return -2.
  The floordiv() function goes with the mod() function.

    floordiv(x,y)*y + mod(x,y) ==> x

  Examples:
    > say floordiv(15,3)
    You say "5"
    > say floordiv(16,3)
    You say "5"
    > say floordiv(17,3)
    You say "5"
    > say floordiv(18,3)
    You say "6"
    > say floordiv(-17,3)
    You say "-6"

  Related Topics: fdiv(), iadd(), idiv(), imul(), isub(), mod(),
                  remainder().

& FMOD()
FMOD()

  FUNCTION: fmod(<number1>,<number2>)

  Returns the smallest positive floating-point remainder left from dividing
  <number1> by <number2>.

  Example:
    > say fmod(6.1,2.5)
    You say "1.0999999999999996"

  Related Topics: mod()

& 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"

  Related Topics: u(), iter(), map(), filter()

& FOREACH()
FOREACH()

  FUNCTION: foreach([<object>/]<attribute>,<string>[,<begin>, <end>])

  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. If <begin> and <end> are specified,
  only the characters between <begin> and <end> are parsed, other characters
  are concatenated as they are. This allows a rudimentary form of tokens and
  speeds up the evaluation greatly if tokenizing is your purpose.

  Examples:

    > &add_one me=[add(%0,1)]
    > say [foreach(add_one, 54321)]
    You say, "65432"

    > &add_one me=[add(%0,1)]
    > say [foreach(add_one, This adds #0# to numbers in this string,#,#)]
    You say, "This adds 1 to numbers in this string."

  Related Topics:

& 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.

  Related Topics: name().

& FUNCTION CLASSES
FUNCTION CLASSES
 
  Arithmetic:                ABS ADD BAND BNAND BOR BXOR CEIL CRC32 DEC DIE
                             FDIV FLOORDIV FMOD IABS IADD IDIV IMUL INC ISIGN
                             ISUB MOD MUL PACK POWER RAND REMAINDER SHA1 SHL
                             SHR SIGN SUB SQRT UNPACK

  Comsystem Information:     CHANNELS COMALIAS COMTITLE CWHO

  Database Information:      EXIT INZONE LOC LOCATE LROOMS MAIL MAILFROM
                             NEARBY NEXT NUM RLOC ROOM SEARCH STATS VALID
                             WHERE ZFUN ZONE ZWHO

  Floating Point Conversion: FLOOR ROUND TRUNC

  Game Information:          CONFIG DUMPING MOTD MUDNAME POLL VERSION

{ 'help function classes2' for more }

& FUNCTION CLASSES2
FUNCTION CLASSES (continued)

  Lists:                     CHOOSE COLUMNS EXTRACT ELEMENTS FOREACH FILTER
                             FILTERBOOL FIRST FOLD ILEV INDEX INSERT ITEMIZE
                             ITER LADD LAST LDELETE LIST LNUM LRAND MAP MATCH
                             MATCHALL MEMBER MIX MUNGE PARSE PICKRAND REMOVE
                             REST REVWORDS SETDIFF SETINTER SETUNION SHUFFLE
                             SORT SORTBY SPLICE TABLE WORDS

  Logarithms:                E EXP LOG LN

  Logical:                   AND ANDBOOL CAND CANDBOOL COR CORBOOL LAND LOR
                             NOT OR ORBOOL T XOR

  Miscellaneous:             @@ ANSI ART BEEP ERROR FCOUNT ISDBREF ISINT ISNUM
                             ISRAT ISWORD LIT NULL R SETQ SETR SUBEVAL
                             TEXTFILE
 
{ 'help function classes3' for more }

& FUNCTION CLASSES3
FUNCTION CLASSES (continued)

  Object Information:        ANDFLAGS APOSS ATTRCNT BITTYPE CHILDREN CMDS CON
                             CONTROLS CTIME DEFAULT EDEFAULT ELOCK ENTRANCES
                             EVAL FLAGS FULLNAME GET GET_EVAL GREP GREPI
                             HASATTR HASATTRP HASFLAG HASPOWER HASTYPE HOME
                             LATTR LATTRCMDS LATTRP LCMDS LCON LEXITS LFLAGS
                             LPARENT LOCALIZE LOCK MONEY MONIKER MTIME NAME
                             OBJ OBJEVAL OBJMEM ORFLAGS OWNER PARENT PFIND
                             PMATCH POSS POWERS S SUBJ TYPE U UDEFAULT ULOCAL
                             V VISIBLE XGET

  Player Information:        CONN CONNLAST CONNLEFT CONNMAX CONNNUM CONNRECORD
                             CONNTOTAL DOING FINDABLE HASQUOTA HEIGHT HOST
                             IDLE LWHO LPORTS PLAYMEM PORTS WIDTH

  Relational:                EQ GT GTE LT LTE MAX MIN NEQ

  Side-Effect Functions:     CREATE EMIT LINK OEMIT PEMIT REMIT SET TEL

  Stack:                     EMPTY ITEMS LSTACK PEEK POP PUSH

{ 'help function classes4' for more }

& FUNCTION CLASSES4
FUNCTION CLASSES (continued)

  Strings:                   ACCENT AFTER ALPHAMAX ALPHAMIN BEFORE CAPSTR CASE
                             CAT CENTER CHR COMP DECRYPT DELETE EDIT ENCRYPT
                             ESCAPE GRAB GRABALL IF IFELSE LCSTR LJUST LPOS
                             MERGE MID ORD POS REGMATCH REGMATCHI REGRAB
                             REGRABALL REGRABALLI REGRABI REPEAT REPLACE
                             REVERSE RIGHT RJUST ROMAN SCRAMBLE SECURE SPACE
                             SPELLNUM SQUISH STRCAT STRIP STRIPACCENTS
                             STRIPANSI STRLEN STRMATCH STRMEM STRTRUNC SWITCH
                             TRANSLATE TRIM UCSTR WORDPOS WRAP

  Time:                      CONVSECS CONVTIME DIGITTIME EXPTIME SECS
                             SINGLETIME STARTSECS STARTTIME TIME TIMEFMT 
                             WRITETIME

  Trigonometric:             ACOS ASIN ATAN COS CTU DIST2D DIST3D PI SIN TAN
                             VADD VCROSS VDIM VDOT VMAG VMUL VSUB VUNIT

  WOD Realms (optional):     CANSEE

  Reality Levels (optional): HASRXLEVEL HASTXLEVEL LISTRLEVELS RXLEVEL
                             TXLEVEL

& FUNCTION LIST
FUNCTION LIST
 
  Help is available for the following functions:

    @@()        ABS()       ACCENT()    ACOS()      ADD()       AFTER()
    ALPHAMAX()  ALPHAMIN()  AND()       ANDBOOL()   ANDFLAGS()  ANSI()
    APOSS()     ART()       ASIN()      ATAN()      ATTRCNT()   BAND()
    BEEP()      BEFORE()    BITTYPE()   BNAND()     BOR()       BXOR()
    CAND()      CANDBOOL()  CANSEE()    CAPSTR()    CASE()      CAT()
    CEIL()      CENTER()    CHANNELS()  CHILDREN()  CHOOSE()    CHR()
    CMDS()      COLUMNS()   COMALIAS()  COMP()      COMTITLE()  CON()
    CONFIG()    CONN()      CONNLAST()  CONNLEFT()  CONNMAX()   CONNNUM()
    CONNRECORD()CONNTOTAL() CONTROLS()  CONVSECS()  CONVTIME()  COR()
    CORBOOL()   COS()       CRC32()     CREATE()    CTIME()     CTU()
    CWHO()      DEC()       DECRYPT()   DEFAULT()   DELETE()    DIE()
    DIGITTIME() DIST2D()    DIST3D()    DOING()     DUMPING()   E()
    EDEFAULT()  EDIT()      ELEMENTS()  ELOCK()     EMIT()      EMPTY()
    ENCRYPT()   ENTRANCES() EQ()        ERROR()     ESCAPE()    EVAL()
    EXIT()      EXP()       EXPTIME()   EXTRACT()   FCOUNT()    FDEPTH()
    FDIV()      FILTER()    FILTERBOOL()FINDABLE()  FIRST()     FLAGS()
    FLOOR()     FLOORDIV()  FMOD()      FOLD()      FOREACH()   FULLNAME()

("help function list2" for more)

& FUNCTION LIST2
FUNCTION LIST (continued)

    GET()       GET_EVAL()  GRAB()      GRABALL()   GREP()      GREPI()
    GT()        GTE()       HASATTR()   HASATTRP()  HASFLAG()   HASPOWER()
    HASQUOTA()  HASRXLEVEL()HASTXLEVEL()HASTYPE()   HEIGHT()    HOME()
    HOST()      IABS()      IADD()      IDIV()      IDLE()      IF()
    IFELSE()    ILEV()      IMUL()      INC()       INDEX()     INSERT()
    INZONE()    ISDBREF()   ISIGN()     ISINT()     ISNUM()     ISRAT()
    ISUB()      ISWORD()    ITEMIZE()   ITEMS()     ITER()      LADD()
    LAND()      LAST()      LATTR()     LATTRCMDS() LATTRP()    LCMDS()
    LCON()      LCSTR()     LDELETE()   LEXITS()    LFLAGS()    LINK()
    LIST()      LISTRLEVELS() LIT()     LJUST()     LN()        LNUM()
    LOC()       LOCALIZE()  LOCATE()    LOCK()      LOG()       LOR()
    LPARENT()   LPORTS()    LPOS()      LRAND()     LROOMS()    LSTACK()
    LT()        LTE()       LWHO()      MAIL()      MAILFROM()  MAP()
    MATCH()     MATCHALL()  MAX()       MEMBER()    MERGE()     MID()
    MIN()       MIX()       MOD()       MONEY()     MONIKER()   MOTD()
    MTIME()     MUDNAME()   MUL()       MUNGE()     NAME()      NEARBY()
    NEQ()       NEXT()      NOT()       NULL()      NUM()       OBJ()
    OBJEVAL()   OBJMEM()    OEMIT()     OR()        ORBOOL()    ORD()
    ORFLAGS()   OWNER()     PACK()      PARENT()    PARSE()     PEEK()

("help function list3" for more)

& FUNCTION LIST3
FUNCTION LIST (continued)

    PEMIT()     PFIND()     PI()        PICKRAND()  PLAYMEM()   PMATCH()
    POLL()      POP()       PORTS()     POS()       POSS()      POWER()
    POWERS()    PUSH()      R()         RAND()      REGMATCH()  REGMATCHI()
    REGRAB()    REGRABALL() REGRABALLI()REGRABI()   REMAINDER() REMIT()
    REMOVE()    REPEAT()    REPLACE()   REST()      REVERSE()   REVWORDS()
    RIGHT()     RJUST()     RLOC()      ROMAN()     ROOM()      ROUND()
    RXLEVEL()   S()         SCRAMBLE()  SEARCH()    SECS()      SECURE()
    SET()       SETDIFF()   SETINTER()  SETQ()      SETR()      SETUNION()
    SHA1()      SHL()       SHR()       SHUFFLE()   SIGN()      SIN()
    SINGLETIME()SORT()      SORTBY()    SPACE()     SPELLNUM()  SPLICE()
    SQRT()      SQUISH()    STARTSECS() STARTTIME() STATS()     STRCAT()
    STRIP()     STRIPACCENTS() STRIPANSI() STRLEN() STRMATCH()  STRMEM()
    STRTRUNC()  SUB()       SUBEVAL()   SUBJ()      SWITCH()    T()
    TABLE()     TAN()       TEL()       TEXTFILE()  TIME()      TIMEFMT()
    TRANSLATE() TRIM()      TRUNC()     TXLEVEL()   TYPE()      U()
    UCSTR()     UDEFAULT()  ULOCAL()    UNPACK()    V()         VADD()
    VALID()     VCROSS()    VDIM()      VDOT()      VERSION()   VISIBLE()
    VMAG()      VMUL()      VSUB()      VUNIT()     WHERE()     WIDTH()
    WORDPOS()   WORDS()     WRAP()      WRITETIME() XGET()      XOR()
    ZFUN()      ZONE()      ZWHO()

& FUNCTIONS
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.

  Related Topics: @list functions, FUNCTION CLASSES, FUNCTION LIST.

& GAGGED
GAGGED

  FLAG: GAGGED(j)  ()

  When a player is set GAGGED, they cannot speak or pose under any
  circumstances. This flag has no meaning for objects, exits, or rooms.

  Related Topics:

& GENDER
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.

  Related Topics: SUBSTITUTIONS.

& GET
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.

{ 'help get2' for more }

& GET()
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)

  Related Topics: get_eval(), eval(), u(), v(), xget().

& GET2
GET (continued)

  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'.

  Related Topics: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ,
      ENTER_OK, FAILURE, SUCCESS.

& GET_EVAL()
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"

  Related Topics: get(), eval(), u(), v(), xget().

& GIVE
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.

  Related Topics: @apay, @cost, @opay, @pay, ENTER_OK.

& GOALS
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.

& GOING
GOING

  FLAG: GOING(G)  ()

  Used internally for the @destroy command, it is set on objects that are set
  to be destroyed.  In the event that a player decides before the next @dbck
  to spare the object from destruction, they can accomplish this by reseting
  the object's GOING flag.

  Related Topics: @destroy, @dbck (in wizhelp).

& GOTO
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'.

  Related Topics: enter, home, leave

& GRAB()
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 in <pattern>.  <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"

  Related Topics: graball(), LISTS, member(), match(), regrab().

& GRABALL()
GRABALL()

  FUNCTION: graball(<list>, <pattern>[, <idelim>[, <odelim>]])

  This function matches <pattern> against each word in <list>, returning
  the all words that match.  If no words match, then an empty string is
  returned.  The match is not case-sensitive, and wildcard characters
  are permitted in <pattern>.  <idelim> may be used to specify the <list>
  delimiter other than a space.  <odelim> is the output delimiter.

  Examples:
    > say graball(This is a test of a test,test)
    You say "test test"
    > say graball(This is testing a test,tes*)
    You say "testing test"

  Related Topics: grab(), LISTS, regrab(), regraball().

& GREP()
GREP()

  FUNCTION: 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.

  Related Topics:

& GREPI()
GREPI()

  FUNCTION: grepi(<object>,<attrs>,<pattern>)

  This function works exactly like grep, but is case-insensitive.

  Related Topics: grep()

& GT()
GT()

  FUNCTION: gt(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), eq(), neq().

& GTE()
GTE()

  FUNCTION: gte(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gt(), eq(), neq().

& HALTED
HALTED

  FLAG: HALTED(h)  ()

  While this flag is set, the object cannot perform any MUX
  actions, listen, be triggered, etc.

  Related Topics:

& HASATTR()
HASATTR()

  FUNCTION: 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.

  Related Topics:

& HASATTRP()
HASATTRP()

  FUNCTION: 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.

  Related Topics:

& HASFLAG()
HASFLAG()

  FUNCTION: hasflag(<object>[/<attribute>],<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.

  When an <attribute> is given, the following <flag> values can be used.

    const, no_command, dark, god, hidden, html, no_inherit, locked, no_parse,
    regexp, visual, and wizard.

  Example:
    > say hasflag(me, wizard)
    You say "0"
    > say hasflag(me, connect)
    You say "1"

  Related Topics:

& HASPOWER()
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"

  Related Topics: powers()

& HASQUOTA()
HASQUOTA()

  FUNCTION: hasquota(<object>, <quota>[, <type>])

  Returns true if object <object> has enough quota to build anything
  requiring <quota> quota. If <type> is given, the function returns true if
  there is enough quota to build a <type> object requiring <quota> quota.

  Currently, MUX doesn't support typed quotas, but if it did, a type-specific
  query may return true while a generic query would return false.

  Example:
    > say hasquota(me, 100)
    You say "0"
    > say hasquota(me, 1)
    You say "1"

  Related Topics: @quota

& HASRXLEVEL()
HASRXLEVEL()

  FUNCTION: hasrxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Rx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hasrxlevel(me,real)
    You say '1'.

  Related Topics: hastxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTXLEVEL()
HASTXLEVEL()

  FUNCTION: hastxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Tx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hastxlevel(me,real)
    You say '1'.

  Related Topics: hasrxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTYPE()
HASTYPE()

  FUNCTION: 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.

  Related Topics: type().

& HAVEN
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.

  Related Topics: @lock/page.

& HEAD
HEAD

  FLAG: HEAD(?)  ()

  This is another marker flag, for faction heads and the like. As
  with STAFF, no powers come with it, it is purely a marker.

  Related Topics:

& HEIGHT()
HEIGHT()

  FUNCTION: height(<player|port>)

  Returns the height of the client window as reported by Telnet's Negotiate
  About Window Size (NAWS) option. For clients which do not negotiate the
  NAWS option, a value of 24 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the height of the session having the smallest idle
  time is returned.

  You and any object with the See_All @power may obtain the height of your
  sessions.

  Example:
    > think height(me)
    You say "26"

  Related Topics: width().

& HERE
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>'.

& HOME()
HOME()

  FUNCTION: 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"

  Related Topics:

& HOMES
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'.

  Related Topics: @link, DROP-TO, STICKY.

& HOST()
HOST()

  FUNCTION: host(<player|port>)

  Returns the hostname for <player|port> as seen on the SESSION report.

  If <player|port> is numeric, it's taken as a port number.  Otherwise, it's
  treated as a player name.  If the named player is connected more than once,
  the first connection is returned.

  Related Topics: SESSION.

& HSS
HSS

  The HSS flag denotes someone who can see through certain levels of
  invisibility. They must have the HSS_LEVEL attribute set. If they have
  this flag and attribute set they will see anyone with a lower OBF_LEVEL
  then their HSS_LEVEL attribute, they will also see the OBFDESC if it
  is present, showing the invisible character's true appearance. However,
  if HSS_LEVEL is equal to OBF_LEVEL then there is a random chance that
  they will see through the invisibility.

  Related Topics: OBF

& IABS()
IABS()

  FUNCTION: iabs(<integer>)

  Returns the absolute value of its argument.

  Examples:
    > say iabs(4)
    You say "4"
    > say iabs(-4)
    You say "4"
    > say iabs(0)
    You say "0"

  Related Topics: abs(), isign(), sign().

& IADD()
IADD()

  FUNCTION: iadd(<number1>[,<numberN>]...)

  Returns the result of adding its integer arguments together. You may
  add up to 100 numbers in one iadd() call. Similar to add() except
  that the addition is done with integer math.

  Example:
    > say iadd(2,4)
    You say "6"
    > say iadd(5,3,7,-4)
    You say "11"

  Related Topics: add(), dec(), idiv(), imul(), inc(), isub(), mod(),
            mul(), sub().

& IDIV()
IDIV()

  FUNCTION: idiv(<number1>,<number2>)

  Returns the integer quotient from dividing <number1> by <number2>.

  However, integer division for the case where either <integer1> or
  <integer2> is negative is defined in a specific way -- by choosing
  the smallest integer that is greater than or equal to the algebraic
  quotient. If <integer1> and <integer2> are the same sign, then
  idiv() and floordiv() are equivalent.

  For example, division of -9 by 5 would give -1 by this definition
  instead of -2. idiv() would return -1. floordiv() would return -2.

    idiv(x,y)*y + remainder(x,y) ==> x

  Examples:
    > say idiv(15,3)
    You say "5"
    > say idiv(16,3)
    You say "5"
    > say idiv(17,3)
    You say "5"
    > say idiv(18,3)
    You say "6"
    > say idiv(-17,3)
    You say "-5"

  Related Topics: iadd(), imul(), isub(), fdiv(), floordiv(), fmod(), mod(),
                  remainder().

& IDLE()
IDLE()

  FUNCTION: idle(<player|port>)

  Returns the number of seconds that <player|port> has been idle.  If
  <player|port> is not connected then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named 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:1R ORpecific 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.

  Related Topics: SUBSTITUTIONS.

& GET
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.

{ 'help get2' for more }

& GET()
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)

  Related Topics: get_eval(), eval(), u(), v(), xget().

& GET2
GET (continued)

  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'.

  Related Topics: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ,
      ENTER_OK, FAILURE, SUCCESS.

& GET_EVAL()
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"

  Related Topics: get(), eval(), u(), v(), xget().

& GIVE
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.

  Related Topics: @apay, @cost, @opay, @pay, ENTER_OK.

& GOALS
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.

& GOING
GOING

  FLAG: GOING(G)  ()

  Used internally for the @destroy command, it is set on objects that are set
  to be destroyed.  In the event that a player decides before the next @dbck
  to spare the object from destruction, they can accomplish this by reseting
  the object's GOING flag.

  Related Topics: @destroy, @dbck (in wizhelp).

& GOTO
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'.

  Related Topics: enter, home, leave

& GRAB()
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 in <pattern>.  <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"

  Related Topics: graball(), LISTS, member(), match(), regrab().

& GRABALL()
GRABALL()

  FUNCTION: graball(<list>, <pattern>[, <idelim>[, <odelim>]])

  This function matches <pattern> against each word in <list>, returning
  the all words that match.  If no words match, then an empty string is
  returned.  The match is not case-sensitive, and wildcard characters
  are permitted in <pattern>.  <idelim> may be used to specify the <list>
  delimiter other than a space.  <odelim> is the output delimiter.

  Examples:
    > say graball(This is a test of a test,test)
    You say "test test"
    > say graball(This is testing a test,tes*)
    You say "testing test"

  Related Topics: grab(), LISTS, regrab(), regraball().

& GREP()
GREP()

  FUNCTION: 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.

  Related Topics:

& GREPI()
GREPI()

  FUNCTION: grepi(<object>,<attrs>,<pattern>)

  This function works exactly like grep, but is case-insensitive.

  Related Topics: grep()

& GT()
GT()

  FUNCTION: gt(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), eq(), neq().

& GTE()
GTE()

  FUNCTION: gte(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gt(), eq(), neq().

& HALTED
HALTED

  FLAG: HALTED(h)  ()

  While this flag is set, the object cannot perform any MUX
  actions, listen, be triggered, etc.

  Related Topics:

& HASATTR()
HASATTR()

  FUNCTION: 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.

  Related Topics:

& HASATTRP()
HASATTRP()

  FUNCTION: 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.

  Related Topics:

& HASFLAG()
HASFLAG()

  FUNCTION: hasflag(<object>[/<attribute>],<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.

  When an <attribute> is given, the following <flag> values can be used.

    const, no_command, dark, god, hidden, html, no_inherit, locked, no_parse,
    regexp, visual, and wizard.

  Example:
    > say hasflag(me, wizard)
    You say "0"
    > say hasflag(me, connect)
    You say "1"

  Related Topics:

& HASPOWER()
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"

  Related Topics: powers()

& HASQUOTA()
HASQUOTA()

  FUNCTION: hasquota(<object>, <quota>[, <type>])

  Returns true if object <object> has enough quota to build anything
  requiring <quota> quota. If <type> is given, the function returns true if
  there is enough quota to build a <type> object requiring <quota> quota.

  Currently, MUX doesn't support typed quotas, but if it did, a type-specific
  query may return true while a generic query would return false.

  Example:
    > say hasquota(me, 100)
    You say "0"
    > say hasquota(me, 1)
    You say "1"

  Related Topics: @quota

& HASRXLEVEL()
HASRXLEVEL()

  FUNCTION: hasrxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Rx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hasrxlevel(me,real)
    You say '1'.

  Related Topics: hastxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTXLEVEL()
HASTXLEVEL()

  FUNCTION: hastxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Tx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hastxlevel(me,real)
    You say '1'.

  Related Topics: hasrxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTYPE()
HASTYPE()

  FUNCTION: 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.

  Related Topics: type().

& HAVEN
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.

  Related Topics: @lock/page.

& HEAD
HEAD

  FLAG: HEAD(?)  ()

  This is another marker flag, for faction heads and the like. As
  with STAFF, no powers come with it, it is purely a marker.

  Related Topics:

& HEIGHT()
HEIGHT()

  FUNCTION: height(<player|port>)

  Returns the height of the client window as reported by Telnet's Negotiate
  About Window Size (NAWS) option. For clients which do not negotiate the
  NAWS option, a value of 24 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the height of the session having the smallest idle
  time is returned.

  You and any object with the See_All @power may obtain the height of your
  sessions.

  Example:
    > think height(me)
    You say "26"

  Related Topics: width().

& HERE
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>'.

& HOME()
HOME()

  FUNCTION: 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"

  Related Topics:

& HOMES
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'.

  Related Topics: @link, DROP-TO, STICKY.

& HOST()
HOST()

  FUNCTION: host(<player|port>)

  Returns the hostname for <player|port> as seen on the SESSION report.

  If <player|port> is numeric, it's taken as a port number.  Otherwise, it's
  treated as a player name.  If the named player is connected more than once,
  the first connection is returned.

  Related Topics: SESSION.

& HSS
HSS

  The HSS flag denotes someone who can see through certain levels of
  invisibility. They must have the HSS_LEVEL attribute set. If they have
  this flag and attribute set they will see anyone with a lower OBF_LEVEL
  then their HSS_LEVEL attribute, they will also see the OBFDESC if it
  is present, showing the invisible character's true appearance. However,
  if HSS_LEVEL is equal to OBF_LEVEL then there is a random chance that
  they will see through the invisibility.

  Related Topics: OBF

& IABS()
IABS()

  FUNCTION: iabs(<integer>)

  Returns the absolute value of its argument.

  Examples:
    > say iabs(4)
    You say "4"
    > say iabs(-4)
    You say "4"
    > say iabs(0)
    You say "0"

  Related Topics: abs(), isign(), sign().

& IADD()
IADD()

  FUNCTION: iadd(<number1>[,<numberN>]...)

  Returns the result of adding its integer arguments together. You may
  add up to 100 numbers in one iadd() call. Similar to add() except
  that the addition is done with integer math.

  Example:
    > say iadd(2,4)
    You say "6"
    > say iadd(5,3,7,-4)
    You say "11"

  Related Topics: add(), dec(), idiv(), imul(), inc(), isub(), mod(),
            mul(), sub().

& IDIV()
IDIV()

  FUNCTION: idiv(<number1>,<number2>)

  Returns the integer quotient from dividing <number1> by <number2>.

  However, integer division for the case where either <integer1> or
  <integer2> is negative is defined in a specific way -- by choosing
  the smallest integer that is greater than or equal to the algebraic
  quotient. If <integer1> and <integer2> are the same sign, then
  idiv() and floordiv() are equivalent.

  For example, division of -9 by 5 would give -1 by this definition
  instead of -2. idiv() would return -1. floordiv() would return -2.

    idiv(x,y)*y + remainder(x,y) ==> x

  Examples:
    > say idiv(15,3)
    You say "5"
    > say idiv(16,3)
    You say "5"
    > say idiv(17,3)
    You say "5"
    > say idiv(18,3)
    You say "6"
    > say idiv(-17,3)
    You say "-5"

  Related Topics: iadd(), imul(), isub(), fdiv(), floordiv(), fmod(), mod(),
                  remainder().

& IDLE()
IDLE()

  FUNCTION: idle(<player|port>)

  Returns the number of seconds that <player|port> has been idle.  If
  <player|port> is not connected then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named 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:1R ORpecific 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.

  Related Topics: SUBSTITUTIONS.

& GET
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.

{ 'help get2' for more }

& GET()
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)

  Related Topics: get_eval(), eval(), u(), v(), xget().

& GET2
GET (continued)

  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'.

  Related Topics: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ,
      ENTER_OK, FAILURE, SUCCESS.

& GET_EVAL()
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"

  Related Topics: get(), eval(), u(), v(), xget().

& GIVE
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.

  Related Topics: @apay, @cost, @opay, @pay, ENTER_OK.

& GOALS
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.

& GOING
GOING

  FLAG: GOING(G)  ()

  Used internally for the @destroy command, it is set on objects that are set
  to be destroyed.  In the event that a player decides before the next @dbck
  to spare the object from destruction, they can accomplish this by reseting
  the object's GOING flag.

  Related Topics: @destroy, @dbck (in wizhelp).

& GOTO
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'.

  Related Topics: enter, home, leave

& GRAB()
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 in <pattern>.  <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"

  Related Topics: graball(), LISTS, member(), match(), regrab().

& GRABALL()
GRABALL()

  FUNCTION: graball(<list>, <pattern>[, <idelim>[, <odelim>]])

  This function matches <pattern> against each word in <list>, returning
  the all words that match.  If no words match, then an empty string is
  returned.  The match is not case-sensitive, and wildcard characters
  are permitted in <pattern>.  <idelim> may be used to specify the <list>
  delimiter other than a space.  <odelim> is the output delimiter.

  Examples:
    > say graball(This is a test of a test,test)
    You say "test test"
    > say graball(This is testing a test,tes*)
    You say "testing test"

  Related Topics: grab(), LISTS, regrab(), regraball().

& GREP()
GREP()

  FUNCTION: 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.

  Related Topics:

& GREPI()
GREPI()

  FUNCTION: grepi(<object>,<attrs>,<pattern>)

  This function works exactly like grep, but is case-insensitive.

  Related Topics: grep()

& GT()
GT()

  FUNCTION: gt(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), eq(), neq().

& GTE()
GTE()

  FUNCTION: gte(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gt(), eq(), neq().

& HALTED
HALTED

  FLAG: HALTED(h)  ()

  While this flag is set, the object cannot perform any MUX
  actions, listen, be triggered, etc.

  Related Topics:

& HASATTR()
HASATTR()

  FUNCTION: 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.

  Related Topics:

& HASATTRP()
HASATTRP()

  FUNCTION: 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.

  Related Topics:

& HASFLAG()
HASFLAG()

  FUNCTION: hasflag(<object>[/<attribute>],<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.

  When an <attribute> is given, the following <flag> values can be used.

    const, no_command, dark, god, hidden, html, no_inherit, locked, no_parse,
    regexp, visual, and wizard.

  Example:
    > say hasflag(me, wizard)
    You say "0"
    > say hasflag(me, connect)
    You say "1"

  Related Topics:

& HASPOWER()
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"

  Related Topics: powers()

& HASQUOTA()
HASQUOTA()

  FUNCTION: hasquota(<object>, <quota>[, <type>])

  Returns true if object <object> has enough quota to build anything
  requiring <quota> quota. If <type> is given, the function returns true if
  there is enough quota to build a <type> object requiring <quota> quota.

  Currently, MUX doesn't support typed quotas, but if it did, a type-specific
  query may return true while a generic query would return false.

  Example:
    > say hasquota(me, 100)
    You say "0"
    > say hasquota(me, 1)
    You say "1"

  Related Topics: @quota

& HASRXLEVEL()
HASRXLEVEL()

  FUNCTION: hasrxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Rx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hasrxlevel(me,real)
    You say '1'.

  Related Topics: hastxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTXLEVEL()
HASTXLEVEL()

  FUNCTION: hastxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Tx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hastxlevel(me,real)
    You say '1'.

  Related Topics: hasrxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTYPE()
HASTYPE()

  FUNCTION: 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.

  Related Topics: type().

& HAVEN
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.

  Related Topics: @lock/page.

& HEAD
HEAD

  FLAG: HEAD(?)  ()

  This is another marker flag, for faction heads and the like. As
  with STAFF, no powers come with it, it is purely a marker.

  Related Topics:

& HEIGHT()
HEIGHT()

  FUNCTION: height(<player|port>)

  Returns the height of the client window as reported by Telnet's Negotiate
  About Window Size (NAWS) option. For clients which do not negotiate the
  NAWS option, a value of 24 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the height of the session having the smallest idle
  time is returned.

  You and any object with the See_All @power may obtain the height of your
  sessions.

  Example:
    > think height(me)
    You say "26"

  Related Topics: width().

& HERE
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>'.

& HOME()
HOME()

  FUNCTION: 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"

  Related Topics:

& HOMES
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'.

  Related Topics: @link, DROP-TO, STICKY.

& HOST()
HOST()

  FUNCTION: host(<player|port>)

  Returns the hostname for <player|port> as seen on the SESSION report.

  If <player|port> is numeric, it's taken as a port number.  Otherwise, it's
  treated as a player name.  If the named player is connected more than once,
  the first connection is returned.

  Related Topics: SESSION.

& HSS
HSS

  The HSS flag denotes someone who can see through certain levels of
  invisibility. They must have the HSS_LEVEL attribute set. If they have
  this flag and attribute set they will see anyone with a lower OBF_LEVEL
  then their HSS_LEVEL attribute, they will also see the OBFDESC if it
  is present, showing the invisible character's true appearance. However,
  if HSS_LEVEL is equal to OBF_LEVEL then there is a random chance that
  they will see through the invisibility.

  Related Topics: OBF

& IABS()
IABS()

  FUNCTION: iabs(<integer>)

  Returns the absolute value of its argument.

  Examples:
    > say iabs(4)
    You say "4"
    > say iabs(-4)
    You say "4"
    > say iabs(0)
    You say "0"

  Related Topics: abs(), isign(), sign().

& IADD()
IADD()

  FUNCTION: iadd(<number1>[,<numberN>]...)

  Returns the result of adding its integer arguments together. You may
  add up to 100 numbers in one iadd() call. Similar to add() except
  that the addition is done with integer math.

  Example:
    > say iadd(2,4)
    You say "6"
    > say iadd(5,3,7,-4)
    You say "11"

  Related Topics: add(), dec(), idiv(), imul(), inc(), isub(), mod(),
            mul(), sub().

& IDIV()
IDIV()

  FUNCTION: idiv(<number1>,<number2>)

  Returns the integer quotient from dividing <number1> by <number2>.

  However, integer division for the case where either <integer1> or
  <integer2> is negative is defined in a specific way -- by choosing
  the smallest integer that is greater than or equal to the algebraic
  quotient. If <integer1> and <integer2> are the same sign, then
  idiv() and floordiv() are equivalent.

  For example, division of -9 by 5 would give -1 by this definition
  instead of -2. idiv() would return -1. floordiv() would return -2.

    idiv(x,y)*y + remainder(x,y) ==> x

  Examples:
    > say idiv(15,3)
    You say "5"
    > say idiv(16,3)
    You say "5"
    > say idiv(17,3)
    You say "5"
    > say idiv(18,3)
    You say "6"
    > say idiv(-17,3)
    You say "-5"

  Related Topics: iadd(), imul(), isub(), fdiv(), floordiv(), fmod(), mod(),
                  remainder().

& IDLE()
IDLE()

  FUNCTION: idle(<player|port>)

  Returns the number of seconds that <player|port> has been idle.  If
  <player|port> is not connected then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named 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:1R ORpecific 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.

  Related Topics: SUBSTITUTIONS.

& GET
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.

{ 'help get2' for more }

& GET()
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)

  Related Topics: get_eval(), eval(), u(), v(), xget().

& GET2
GET (continued)

  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'.

  Related Topics: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ,
      ENTER_OK, FAILURE, SUCCESS.

& GET_EVAL()
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"

  Related Topics: get(), eval(), u(), v(), xget().

& GIVE
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.

  Related Topics: @apay, @cost, @opay, @pay, ENTER_OK.

& GOALS
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.

& GOING
GOING

  FLAG: GOING(G)  ()

  Used internally for the @destroy command, it is set on objects that are set
  to be destroyed.  In the event that a player decides before the next @dbck
  to spare the object from destruction, they can accomplish this by reseting
  the object's GOING flag.

  Related Topics: @destroy, @dbck (in wizhelp).

& GOTO
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'.

  Related Topics: enter, home, leave

& GRAB()
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 in <pattern>.  <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"

  Related Topics: graball(), LISTS, member(), match(), regrab().

& GRABALL()
GRABALL()

  FUNCTION: graball(<list>, <pattern>[, <idelim>[, <odelim>]])

  This function matches <pattern> against each word in <list>, returning
  the all words that match.  If no words match, then an empty string is
  returned.  The match is not case-sensitive, and wildcard characters
  are permitted in <pattern>.  <idelim> may be used to specify the <list>
  delimiter other than a space.  <odelim> is the output delimiter.

  Examples:
    > say graball(This is a test of a test,test)
    You say "test test"
    > say graball(This is testing a test,tes*)
    You say "testing test"

  Related Topics: grab(), LISTS, regrab(), regraball().

& GREP()
GREP()

  FUNCTION: 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.

  Related Topics:

& GREPI()
GREPI()

  FUNCTION: grepi(<object>,<attrs>,<pattern>)

  This function works exactly like grep, but is case-insensitive.

  Related Topics: grep()

& GT()
GT()

  FUNCTION: gt(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), eq(), neq().

& GTE()
GTE()

  FUNCTION: gte(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gt(), eq(), neq().

& HALTED
HALTED

  FLAG: HALTED(h)  ()

  While this flag is set, the object cannot perform any MUX
  actions, listen, be triggered, etc.

  Related Topics:

& HASATTR()
HASATTR()

  FUNCTION: 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.

  Related Topics:

& HASATTRP()
HASATTRP()

  FUNCTION: 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.

  Related Topics:

& HASFLAG()
HASFLAG()

  FUNCTION: hasflag(<object>[/<attribute>],<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.

  When an <attribute> is given, the following <flag> values can be used.

    const, no_command, dark, god, hidden, html, no_inherit, locked, no_parse,
    regexp, visual, and wizard.

  Example:
    > say hasflag(me, wizard)
    You say "0"
    > say hasflag(me, connect)
    You say "1"

  Related Topics:

& HASPOWER()
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"

  Related Topics: powers()

& HASQUOTA()
HASQUOTA()

  FUNCTION: hasquota(<object>, <quota>[, <type>])

  Returns true if object <object> has enough quota to build anything
  requiring <quota> quota. If <type> is given, the function returns true if
  there is enough quota to build a <type> object requiring <quota> quota.

  Currently, MUX doesn't support typed quotas, but if it did, a type-specific
  query may return true while a generic query would return false.

  Example:
    > say hasquota(me, 100)
    You say "0"
    > say hasquota(me, 1)
    You say "1"

  Related Topics: @quota

& HASRXLEVEL()
HASRXLEVEL()

  FUNCTION: hasrxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Rx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hasrxlevel(me,real)
    You say '1'.

  Related Topics: hastxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTXLEVEL()
HASTXLEVEL()

  FUNCTION: hastxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Tx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hastxlevel(me,real)
    You say '1'.

  Related Topics: hasrxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTYPE()
HASTYPE()

  FUNCTION: 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.

  Related Topics: type().

& HAVEN
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.

  Related Topics: @lock/page.

& HEAD
HEAD

  FLAG: HEAD(?)  ()

  This is another marker flag, for faction heads and the like. As
  with STAFF, no powers come with it, it is purely a marker.

  Related Topics:

& HEIGHT()
HEIGHT()

  FUNCTION: height(<player|port>)

  Returns the height of the client window as reported by Telnet's Negotiate
  About Window Size (NAWS) option. For clients which do not negotiate the
  NAWS option, a value of 24 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the height of the session having the smallest idle
  time is returned.

  You and any object with the See_All @power may obtain the height of your
  sessions.

  Example:
    > think height(me)
    You say "26"

  Related Topics: width().

& HERE
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>'.

& HOME()
HOME()

  FUNCTION: 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"

  Related Topics:

& HOMES
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'.

  Related Topics: @link, DROP-TO, STICKY.

& HOST()
HOST()

  FUNCTION: host(<player|port>)

  Returns the hostname for <player|port> as seen on the SESSION report.

  If <player|port> is numeric, it's taken as a port number.  Otherwise, it's
  treated as a player name.  If the named player is connected more than once,
  the first connection is returned.

  Related Topics: SESSION.

& HSS
HSS

  The HSS flag denotes someone who can see through certain levels of
  invisibility. They must have the HSS_LEVEL attribute set. If they have
  this flag and attribute set they will see anyone with a lower OBF_LEVEL
  then their HSS_LEVEL attribute, they will also see the OBFDESC if it
  is present, showing the invisible character's true appearance. However,
  if HSS_LEVEL is equal to OBF_LEVEL then there is a random chance that
  they will see through the invisibility.

  Related Topics: OBF

& IABS()
IABS()

  FUNCTION: iabs(<integer>)

  Returns the absolute value of its argument.

  Examples:
    > say iabs(4)
    You say "4"
    > say iabs(-4)
    You say "4"
    > say iabs(0)
    You say "0"

  Related Topics: abs(), isign(), sign().

& IADD()
IADD()

  FUNCTION: iadd(<number1>[,<numberN>]...)

  Returns the result of adding its integer arguments together. You may
  add up to 100 numbers in one iadd() call. Similar to add() except
  that the addition is done with integer math.

  Example:
    > say iadd(2,4)
    You say "6"
    > say iadd(5,3,7,-4)
    You say "11"

  Related Topics: add(), dec(), idiv(), imul(), inc(), isub(), mod(),
            mul(), sub().

& IDIV()
IDIV()

  FUNCTION: idiv(<number1>,<number2>)

  Returns the integer quotient from dividing <number1> by <number2>.

  However, integer division for the case where either <integer1> or
  <integer2> is negative is defined in a specific way -- by choosing
  the smallest integer that is greater than or equal to the algebraic
  quotient. If <integer1> and <integer2> are the same sign, then
  idiv() and floordiv() are equivalent.

  For example, division of -9 by 5 would give -1 by this definition
  instead of -2. idiv() would return -1. floordiv() would return -2.

    idiv(x,y)*y + remainder(x,y) ==> x

  Examples:
    > say idiv(15,3)
    You say "5"
    > say idiv(16,3)
    You say "5"
    > say idiv(17,3)
    You say "5"
    > say idiv(18,3)
    You say "6"
    > say idiv(-17,3)
    You say "-5"

  Related Topics: iadd(), imul(), isub(), fdiv(), floordiv(), fmod(), mod(),
                  remainder().

& IDLE()
IDLE()

  FUNCTION: idle(<player|port>)

  Returns the number of seconds that <player|port> has been idle.  If
  <player|port> is not connected then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named 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:1R ORpecific 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.

  Related Topics: SUBSTITUTIONS.

& GET
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.

{ 'help get2' for more }

& GET()
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)

  Related Topics: get_eval(), eval(), u(), v(), xget().

& GET2
GET (continued)

  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'.

  Related Topics: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ,
      ENTER_OK, FAILURE, SUCCESS.

& GET_EVAL()
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"

  Related Topics: get(), eval(), u(), v(), xget().

& GIVE
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.

  Related Topics: @apay, @cost, @opay, @pay, ENTER_OK.

& GOALS
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.

& GOING
GOING

  FLAG: GOING(G)  ()

  Used internally for the @destroy command, it is set on objects that are set
  to be destroyed.  In the event that a player decides before the next @dbck
  to spare the object from destruction, they can accomplish this by reseting
  the object's GOING flag.

  Related Topics: @destroy, @dbck (in wizhelp).

& GOTO
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'.

  Related Topics: enter, home, leave

& GRAB()
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 in <pattern>.  <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"

  Related Topics: graball(), LISTS, member(), match(), regrab().

& GRABALL()
GRABALL()

  FUNCTION: graball(<list>, <pattern>[, <idelim>[, <odelim>]])

  This function matches <pattern> against each word in <list>, returning
  the all words that match.  If no words match, then an empty string is
  returned.  The match is not case-sensitive, and wildcard characters
  are permitted in <pattern>.  <idelim> may be used to specify the <list>
  delimiter other than a space.  <odelim> is the output delimiter.

  Examples:
    > say graball(This is a test of a test,test)
    You say "test test"
    > say graball(This is testing a test,tes*)
    You say "testing test"

  Related Topics: grab(), LISTS, regrab(), regraball().

& GREP()
GREP()

  FUNCTION: 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.

  Related Topics:

& GREPI()
GREPI()

  FUNCTION: grepi(<object>,<attrs>,<pattern>)

  This function works exactly like grep, but is case-insensitive.

  Related Topics: grep()

& GT()
GT()

  FUNCTION: gt(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), eq(), neq().

& GTE()
GTE()

  FUNCTION: gte(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gt(), eq(), neq().

& HALTED
HALTED

  FLAG: HALTED(h)  ()

  While this flag is set, the object cannot perform any MUX
  actions, listen, be triggered, etc.

  Related Topics:

& HASATTR()
HASATTR()

  FUNCTION: 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.

  Related Topics:

& HASATTRP()
HASATTRP()

  FUNCTION: 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.

  Related Topics:

& HASFLAG()
HASFLAG()

  FUNCTION: hasflag(<object>[/<attribute>],<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.

  When an <attribute> is given, the following <flag> values can be used.

    const, no_command, dark, god, hidden, html, no_inherit, locked, no_parse,
    regexp, visual, and wizard.

  Example:
    > say hasflag(me, wizard)
    You say "0"
    > say hasflag(me, connect)
    You say "1"

  Related Topics:

& HASPOWER()
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"

  Related Topics: powers()

& HASQUOTA()
HASQUOTA()

  FUNCTION: hasquota(<object>, <quota>[, <type>])

  Returns true if object <object> has enough quota to build anything
  requiring <quota> quota. If <type> is given, the function returns true if
  there is enough quota to build a <type> object requiring <quota> quota.

  Currently, MUX doesn't support typed quotas, but if it did, a type-specific
  query may return true while a generic query would return false.

  Example:
    > say hasquota(me, 100)
    You say "0"
    > say hasquota(me, 1)
    You say "1"

  Related Topics: @quota

& HASRXLEVEL()
HASRXLEVEL()

  FUNCTION: hasrxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Rx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hasrxlevel(me,real)
    You say '1'.

  Related Topics: hastxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTXLEVEL()
HASTXLEVEL()

  FUNCTION: hastxlevel(<target>,<level>)

  Returns 1 if <target> has the specified Tx Level. You must control <target>.
  If the level does not exist, or you do not control the target, it returns
  a '#-1'.

  NOTE: This function is not available unless reality levels was enabled at
  compile-time.

  Example: 
    > say hastxlevel(me,real)
    You say '1'.

  Related Topics: hasrxlevel(), rxlevel(), txlevel(), listrlevels()

& HASTYPE()
HASTYPE()

  FUNCTION: 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.

  Related Topics: type().

& HAVEN
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.

  Related Topics: @lock/page.

& HEAD
HEAD

  FLAG: HEAD(?)  ()

  This is another marker flag, for faction heads and the like. As
  with STAFF, no powers come with it, it is purely a marker.

  Related Topics:

& HEIGHT()
HEIGHT()

  FUNCTION: height(<player|port>)

  Returns the height of the client window as reported by Telnet's Negotiate
  About Window Size (NAWS) option. For clients which do not negotiate the
  NAWS option, a value of 24 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named player is
  connected more than once, the height of the session having the smallest idle
  time is returned.

  You and any object with the See_All @power may obtain the height of your
  sessions.

  Example:
    > think height(me)
    You say "26"

  Related Topics: width().

& HERE
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>'.

& HOME()
HOME()

  FUNCTION: 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"

  Related Topics:

& HOMES
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'.

  Related Topics: @link, DROP-TO, STICKY.

& HOST()
HOST()

  FUNCTION: host(<player|port>)

  Returns the hostname for <player|port> as seen on the SESSION report.

  If <player|port> is numeric, it's taken as a port number.  Otherwise, it's
  treated as a player name.  If the named player is connected more than once,
  the first connection is returned.

  Related Topics: SESSION.

& HSS
HSS

  The HSS flag denotes someone who can see through certain levels of
  invisibility. They must have the HSS_LEVEL attribute set. If they have
  this flag and attribute set they will see anyone with a lower OBF_LEVEL
  then their HSS_LEVEL attribute, they will also see the OBFDESC if it
  is present, showing the invisible character's true appearance. However,
  if HSS_LEVEL is equal to OBF_LEVEL then there is a random chance that
  they will see through the invisibility.

  Related Topics: OBF

& IABS()
IABS()

  FUNCTION: iabs(<integer>)

  Returns the absolute value of its argument.

  Examples:
    > say iabs(4)
    You say "4"
    > say iabs(-4)
    You say "4"
    > say iabs(0)
    You say "0"

  Related Topics: abs(), isign(), sign().

& IADD()
IADD()

  FUNCTION: iadd(<number1>[,<numberN>]...)

  Returns the result of adding its integer arguments together. You may
  add up to 100 numbers in one iadd() call. Similar to add() except
  that the addition is done with integer math.

  Example:
    > say iadd(2,4)
    You say "6"
    > say iadd(5,3,7,-4)
    You say "11"

  Related Topics: add(), dec(), idiv(), imul(), inc(), isub(), mod(),
            mul(), sub().

& IDIV()
IDIV()

  FUNCTION: idiv(<number1>,<number2>)

  Returns the integer quotient from dividing <number1> by <number2>.

  However, integer division for the case where either <integer1> or
  <integer2> is negative is defined in a specific way -- by choosing
  the smallest integer that is greater than or equal to the algebraic
  quotient. If <integer1> and <integer2> are the same sign, then
  idiv() and floordiv() are equivalent.

  For example, division of -9 by 5 would give -1 by this definition
  instead of -2. idiv() would return -1. floordiv() would return -2.

    idiv(x,y)*y + remainder(x,y) ==> x

  Examples:
    > say idiv(15,3)
    You say "5"
    > say idiv(16,3)
    You say "5"
    > say idiv(17,3)
    You say "5"
    > say idiv(18,3)
    You say "6"
    > say idiv(-17,3)
    You say "-5"

  Related Topics: iadd(), imul(), isub(), fdiv(), floordiv(), fmod(), mod(),
                  remainder().

& IDLE()
IDLE()

  FUNCTION: idle(<player|port>)

  Returns the number of seconds that <player|port> has been idle.  If
  <player|port> is not connected then -1 is returned.

  If <player|port> is numeric, it's taken as a port number (as shown in
  SESSION).  Otherwise, it's treated as a player name.  If the named 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:1R ORpecific 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.

  Related Topics: SUBSTITUTIONS.

& GET
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.

{ 'help get2' for more }

& GET()
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)

  Related Topics: get_eval(), eval(), u(), v(), xget().

& GET2
GET (continued)

  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'.

  Related Topics: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ,
      ENTER_OK, FAILURE, SUCCESS.

& GET_EVAL()
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"

  Related Topics: get(), eval(), u(), v(), xget().

& GIVE
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.

  Related Topics: @apay, @cost, @opay, @pay, ENTER_OK.

& GOALS
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.

& GOING
GOING

  FLAG: GOING(G)  ()

  Used internally for the @destroy command, it is set on objects that are set
  to be destroyed.  In the event that a player decides before the next @dbck
  to spare the object from destruction, they can accomplish this by reseting
  the object's GOING flag.

  Related Topics: @destroy, @dbck (in wizhelp).

& GOTO
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'.

  Related Topics: enter, home, leave

& GRAB()
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 in <pattern>.  <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"

  Related Topics: graball(), LISTS, member(), match(), regrab().

& GRABALL()
GRABALL()

  FUNCTION: graball(<list>, <pattern>[, <idelim>[, <odelim>]])

  This function matches <pattern> against each word in <list>, returning
  the all words that match.  If no words match, then an empty string is
  returned.  The match is not case-sensitive, and wildcard characters
  are permitted in <pattern>.  <idelim> may be used to specify the <list>
  delimiter other than a space.  <odelim> is the output delimiter.

  Examples:
    > say graball(This is a test of a test,test)
    You say "test test"
    > say graball(This is testing a test,tes*)
    You say "testing test"

  Related Topics: grab(), LISTS, regrab(), regraball().

& GREP()
GREP()

  FUNCTION: 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.

  Related Topics:

& GREPI()
GREPI()

  FUNCTION: grepi(<object>,<attrs>,<pattern>)

  This function works exactly like grep, but is case-insensitive.

  Related Topics: grep()

& GT()
GT()

  FUNCTION: gt(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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"

  Related Topics: BOOLEAN VALUES, lt(), lte(), gte(), eq(), neq().

& GTE()
GTE()

  FUNCTION: gte(<integer1>,<integer2>)

  Takes two integers, and returns a BOOLEAN (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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    