root/1.8.3/trunk/game/txt/hlp/penncmd.hlp

& COMMANDS
Help is available for the following MUSH commands:
 
  ahelp          anews          brief          DOING          drop
  examine        enter          events         follow         get            
  give           go             index          kill           leave          
  LOGOUT         look           move           news           page           
  pose           QUIT           read           rules          say
  score          slay           take           teach          think          
  unfollow       use            whisper        WHO            with
  "              :              ;              +              ]
 
  In addition to these, there are several types of '@' commands. @-commands 
  are usually commands which have permanent effects on the MUSH (such as
  creating a new object). Here are the help topics on @-commands:
 
  @-ATTRIBUTES   @-BUILDING     @-GENERAL      @-WIZARD
 
  Commands that can only be used by connected players are listed in
  HELP SOCKET COMMANDS.
& @-ATTRIBUTES
These '@' commands set standard message/action sets on objects. Each comes
in 3 versions: @<whatever>, @o<whatever>, and @a<whatever>. Only the
@<whatever> version is listed below, but help is available for each:
 
  @death         @describe      @drop          @efail         @enter
  @failure       @follow        @give          @idescribe     @leave
  @lfail         @move          @payment       @receive       @success
  @tport         @ufail         @unfollow      @use           @zenter        
  @zleave

These '@' command set other standard attributes on objects that don't
follow the pattern above:

  @aahear        @aclone        @aconnect      @adisconnect   @amhear
  @away          @charges       @cost          @conformat     @descformat
  @ealias        @exitformat    @filter        @forwardlist   @haven         
  @idescformat   @idle          @infilter      @inprefix      @lalias        
  @listen        @nameformat    @oxenter       @oxleave       @oxmove        
  @oxtport       @prefix        @runout        @sex           @startup       

See also: ATTRIBUTES, NON-STANDARD ATTRIBUTES
& @-BUILDING
These '@' commands are building-related (they create or modify objects):
 
  @atrlock       @atrchown      @chown         @chzone        @clone         
  @cpattr        @create        @destroy       @dig           @elock         
  @eunlock       @firstexit     @link          @lock          @mvattr        
  @name          @nuke          @open          @parent        @recycle       
  @set           @undestroy     @ulock         @unlink        @unlock        
  @uunlock       @wipe
  
& @-GENERAL
These '@' commands are general utility and programming commands:

  @@             @alias         @break         @channel       @chat
  @cemit         @command       @config        @decompile     @doing
  @dolist        @drain         @edit          @emit          @entrances
  @find          @force         @function      @gedit         @grep
  @halt          @lemit         @listmotd      @mail          @map
  @notify        @nsemit        @nslemit       @nsoemit       @nspemit
  @nsprompt      @nsremit       @nszemit       @oemit         @password      
  @pemit         @prompt        @ps            @remit         @restart       
  @scan          @search        @select        @stats         @sweep         
  @switch        @teleport      @trigger       @verb          @version       
  @wait          @whereis       @zemit

& @-WIZARD
These '@' commands are only usable by wizards or privileged players:
 
  @allhalt       @allquota      @boot          @chownall      @chzoneall
  @comment       @dbck          @disable       @dump          @enable
  @flag          @hide          @hook          @kick          @log           
  @motd          @newpassword   @pcreate       @poll          @poor          
  @power         @purge         @quota         @readcache     @rejectmotd    
  @shutdown      @sitelock      @sql           @squota        @uptime        
  @wall          @wizmotd       @wizwall       cd             ch             
  cv
 
& ]
  The "]" command-prefix instructs the MUSH that the rest of the command
  input that follows should not be evaluated. Here's an example:

  > say [add(1,1)]
  You say, "2"

  > say \[add(1,1)\]
  You say, "[add(1,1)]"

  > ]say [add(1,1)]
  You say, "[add(1,1)]"

  > ]"[add(1,1)]
  You say, "[add(1,1)]"
  
  This can be used to pass unevaluated MUSHcode to softcoded commands
  without having to escape every special character, or to help objects
  set attributes to contain unevaluated code.

& @@
 
  The "@@" command is a special kind of command; it signals the start
  of a comment. The comment lasts until a semi-colon is found, just
  like other MUSH programming statements terminate with a semi-colon.
  It cannot be put into the middle of a statement, like
  @va me = $testing:@emit Test. @@ Just a test @@; @vb me=Testing.
  That will result in the object emitting "Test. @@ Just a test. @@"
  The correct usage is to make the comment a statement by itself:
  @va me = $testing:@emit Test.; @@ Just a test @@; @vb me=Testing.
 
  It is not necessary to use a closing '@@', but doing so makes the
  comment stand out much more clearly. A space between the first
  '@@' and the word following it is necessary.
& @aahear
  @aahear <object> = <action list>

  An aahear on an object is activated whenever the object's listen pattern 
  is matched by anything done/said by either anything else in the room OR 
  the object itself. In contrast, an ahear on an object cannot be activated 
  by anything the object itself does.

See also: @listen, @ahear, @amhear, LISTENING
& @aclone
  @aclone <object> = <action list>

  Sets the actions to be taken whenever <object> is @cloned. This command 
  can be useful for notifying the owner of a vending machine or parent 
  object when someone uses the machine.

  Please note that there is no @oclone, and that @clone is always a
  command, not an attribute.

See also: @clone, @create, ACTION LISTS
& @aconnect
  @aconnect <object> = <action list>

  Sets the actions to be taken by a player right after connecting to
  the game.

  Example: @aconnect me = :stretches luxuriously, as if waking from a nap.

  Note that long and spammy @aconnect messages, whether in your room or
  on a channel, are frequently found annoying by other players.

  The player's location, and zone object/objects in the zone parent
  room of the location, as well as objects in the master room, are
  also checked for an @aconnect. If one is found, it will be executed
  when a player connects in that location or zone (or, in the case of
  the master room, anywhere). This is only done if the room_connects
  config option is enabled.

  One descriptor variable is passed to @aconnect:
  %1 = number of player connections (1 if this is an initial connect)

See also: @adisconnect, ACTION LISTS
& @adeath
  @adeath <object> = <action list>

  Sets the actions to be taken after <object> is killed. 
 
See also: @odeath, @death, kill, BEING KILLED, ACTION LISTS
& @adescribe
  @adescribe <object> = <action list>
  
  Sets the actions to be taken when  <object> is looked at. 
  A common use of this command is:

    @adesc me=think %N just looked at you.

  which will inform you whenever someone looks at you. %N will be 
  replaced by the name of the person who looked. While it is possible to
  set a message to be broadcasted to everyone in the area when someone
  looks at you, this is strongly discouraged, as many people find it 
  annoying.

See also: @describe, @aidescribe, look, SUBSTITUTION, ACTION LISTS
& @adestroy
  @adestroy <object> = <action list>

  Sets the actions to be taken by the object when it is destroyed
  (via @rec or @nuke). This can only be set by a Wizard.
  If @adestroy doesn't work, try &adestroy. :)
& @adisconnect
  @adisconnect <object> = <action list>

  Sets the actions to be taken by a player right after disconnecting
  from the game.

  Example: @adisconnect me = home

  The player's location, and zone object/objects in the zone parent
  room of the location, as well as objects in the master room, are
  checked for an @adisconnect. If one is found, it will be executed
  when a player disconnects in that location or zone (or, in the case of
  the master room, anywhere). This is only done if the room_connects
  config option is enabled.

  Several descriptor variables are passed to @adisconnect:
  %1 = number of remaining connections (0 if a full disconnect)
  %2 = bytes received by the disconnecting descriptor
  %3 = bytes sent by the disconnecting descriptor
  %4 = commands issued by the disconnecting descriptor

See also: @aconnect, ACTION LISTS, recv(), sent(), cmds()
& @adrop
  @adrop <object> = <action list>

  Sets the actions to be taken when <object> is dropped. 
  If <object> is an exit, sets an action to be done after a player
  has passed through the exit.

See also: @odrop, @drop, drop, ACTION LISTS
& @aefail
  @aefail <object> = <action list>

  Sets the actions to be taken by the object when someone fails to enter
  it.

See also: enter, FAILURE, ACTION LISTS
& @aenter
  @aenter <object> = <action list>

  Sets the actions taken by the object whenever someone enters it.

See also: @enter, @oenter, enter, ACTION LISTS
& @aufail
& @oufail
& @ufail
  @ufail <object> = <message>
  @oufail <object> = <message>
  @aufail <object> = <action>

  Sets message shown to a player who fails to use an object via
  the 'use' command (@ufail), message shown to others in the room
  (@oufail), and action for the object to take (@aufail).

  Note that these attributes are @ufail, NOT @ufailure, for
  TinyMUSH compatibility.

& @afailure
  @afailure <object> = <action list>

  Sets the actions to be taken on failure to pass the @lock on an
  object. For players and things, this means failure to pick them up
  with get/take. For exits, this means failure to go through an exit.
  
  May be abbreviated @afail. 

See also: @fail, @ofail, get, EXITS, @lock, ACTION LISTS
& @afollow
  @afollow <object> = <action list>

  Sets the actions to be taken after someone or something begins 
  following the object. 

See also: follow, unfollow, followers(), @follow, @ofollow, ACTION LISTS
& @aunfollow
  @aunfollow <object> = <action list>

  Sets the actions to be taken after someone or something stops 
  following the object. 

See also: follow, unfollow, followers(), @unfollow, @ounfollow, ACTION LISTS
& @ahear
  @ahear <object> = <actions>

  Sets the actions to be taken after the object's @listen is matched. 
  Note that @ahear ignores any messages that the object itself creates, 
  so it can only be triggered by other things. If you want the object to
  be able to trigger itself, try using @amhear or @aahear.
  
See also: @aahear, @amhear, @listen, ACTION LISTS, LISTENING
& @aleave
  @aleave <object> = <action list>

  Sets the actions to be taken whenever someone leaves the object.

See also: leave, @leave, @oleave, ACTION LISTS
& @alfail
  @alfail <object> = <action list>

  Sets the actions to be taken whenever someone tries to leave the 
  object and fails (because the object is set NO_LEAVE or because
  the person fails the @lock/leave on the object). 

See also: leave, @lfail, @olfail, ACTION LISTS
& @alias
  @alias <player>=<name>;<alias>[;<alias2>[;<alias3>[...]]]
 
  @alias is a special attribute that lists a player's names; players
  can be paged by their aliases, matched with *<alias>, and all other game 
  functions which look up player names will also accept an alias. 
  The attribute is visible to all players.

  A list of aliases, separated by semicolons, may be provided.
  Players should include their usual @name in the alias list, because
  the @name command allows setting name to any alias in the list.
  The number of aliases allowed in the list may be limited by
  the game's administrators through the 'max_aliases' @config parameter.

  If the page_aliases config directive is on, the first alias in the
  list is returned along with the player's name.
  
  Each alias cannot be longer than the limit allowed for player names, 
  cannot contain spaces, and must be unique -- no other player may
  have the same alias or name as any other player's alias or name.

  @alias has no effect on non-players.

See also: @name, alias(), fullalias()
& @allhalt
  @allhalt

  This command halts all objects in the game in an effort to free up 
  the queue. Wizard-only command.
  
  This command is equivalent to "@halt/all".

See also: QUEUE, @ps
& @allquota
  @allquota[/quiet] [<limit>]

  This is a God level command that is only available if the quota
  system is being used.  It displays the current max and owned objects
  of every player (unless the /quiet switch is used) and resets their 
  quota left to the new limit minus the current number owned if a limit 
  is given.
& @amhear
  @amhear <object> = <action list>

  Sets the actions to be taken whenever the @listen on the object is
  matched by something that the object itself does. It will not react
  if anyone else in the area does anything that matches the @listen
  pattern. If you want other objects to be able to set off the action
  list, try using @ahear or @aahear.

See also: @listen, @ahear, @aahear, LISTENING, ACTION LISTS
& @amove
  @amove <object> = <action list>

  This is the action to be taken whenever an object moves.

See also: @move, @omove, @oxmove, ACTION LISTS, go
& @apayment
  @apayment <object> = <action list>

  Sets the actions to be taken after a player gives an object some
  amount of pennies. The amount paid is passed in as %0.

See also: give, @pay, @opay, @cost, MONEY, ACTION LISTS
& @atport
  @atport <object>=<action list>

  Sets the list of actions that <object> will perform when it is
  teleported. These actions are done after <object> has arrived
  in its new location.

  %0 is the object causing the teleport, and %1 is the old location
  of the teleported object.

See also: @tel, ACTION LISTS, @tport, @otport, @oxtport
& @atrchown
  @atrchown <object>/<attribute> = <new_owner>.
  Like @chown except it changes the control of an attribute from one person
  to another. You may only @atrchown attributes that you can normally set,
  and unless you're a wizard, you can only @atrchown attributes to yourself.

See also: @atrlock, ATTRIBUTES, NON-STANDARD ATTRIBUTES
& @atrlock
  @atrlock <object>/<attribute> = [on|off].

  If 'on' is specified, it 'locks' the specified attribute on the object.
  If the attribute is owned by someone other than you, you will gain
  ownership of it.  If an attribute is unlocked, then anyone who controls
  the object may change it.  If it is locked, only wizards and the attribute's
  owner (Assuming the owner controls the object) can change it. Wizards may
  lock/unlock anyones attributes.  If you specify 'off' it will unlock a
  locked attribute. Specifying neither will return the current value of the
  lock. You can only lock or unlock attributes you can normally set.

See also: @atrchown, ATTRIBUTES, NON-STANDARD ATTRIBUTES
& @asuccess
  @asuccess <object> = <action list>

  Sets the actions to be taken when the @lock of an object is passed.
  For things/players, this means picking them up. For exits, this means
  going through them. 

See also: @success, @osuccess, get, @lock, EXITS, ACTION LISTS
& @attribute
  @attribute <attrib>
  @attribute/access[/retroactive] <attrib> = <flag list or "none">
  @attribute/delete <attrib>
  @attribute/rename <attrib> = <new name>

  @attribute is a wizard-only command which modify's the MUSH's
  table of standard attributes (use @list/attribs to list them).
  A standard attribute is one that can be set with @<attrib> instead
  of &<attrib>, and which, when set, has a predefined set of
  initial permissions.

  *** Unlike TinyMUSH, changes to the PennMUSH attribute table
  *** are not saved across shutdowns. Use these commands from
  *** God's @startup to insure they are run at each startup.

  Used without switches, @attribute shows info about a standard attrib.

  @attribute/access adds a new standard attribute into the table,
  associating it with the given space-separated list of full flag names.
  See 'help attribute flags' for possible flags. A flag list of "none" removes
  all flag associations.
  If the /retroactive switch is added, the flags are assigned to every copy
  of the attribute that already exists in the database.

  @attribute/delete removes a standard attribute from the table.
  @attribute/rename renames a standard attribute. 
& @ause
  @ause <object> = <action list>

  Sets the actions to be taken when an object is successfully "used".
  
See also: use, @use, ACTION LISTS, @charges, @runout
& @away
  @away <player> = <message>

  This message is sent to a player who tries to page you when you are
  not connected, if it evaluates to something non-null.

  Example: @away me=I'm not here, please send me @mail instead.

& @boot
  @boot[/silent] <player>
  @boot/port[/silent] <descriptor number>
  @boot/me

  Disconnects the player from the game, with a standard message unless
  the /silent switch is given. 

  The /port switch takes a descriptor number instead (the "Port" number
  in WHO for wizards).

  The /me switch boots any single descriptor for the same player which
  has been idle for at least 1 minute. Players can use this command
  to terminate hung connections.

  Only admin and those with the "boot" power can @boot other players. 

& @BREAK
& @ASSERT
  @break  <boolean>[=<command list>]
  @assert <boolean>[=<command list>]

  @break stops the execution of further commands in the current action
  list if <boolean> 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. If <command> is given, it is executed instead of
  the rest of the commands in the current queue.

  @assert does the inverse: it stops execution if <boolean> evaluates to false.

  Examples:
  > @va obj=$testme *:@pemit %#=You try a test;
                      @break [lt(%0,10)] = @pemit %#=But you're too low!;
              @pemit %#=And you succeed!
  > testme 0
  You try a test
  But you're too low!
  > testme 10
  You try a test
  And you succeed!

  > @force me={@switch 1=1, think Third; think First; @break 1; think Second}
  First
  Third
  (The @switch is run, which queues 'think Third', think First is
   run, displaying 'First', command execution is broken (so we never
   think Second), and then the queued 'think Third' is run, displaying
   Third. If you figured that out, you have a very good understanding
   of the PennMUSH queue. :)

See also: ACTION LISTS, QUEUE, BOOLEAN VALUES
& @charges
  @charges <object> = <integer>

  Allows you to limit the number of times an object can be "used". 
  The "charges" attribute will be decreased by one each time the
  object's @ause is triggered, and once it reaches zero, the object 
  cannot be used anymore.

See also: use, @runout, @ause
& @chown
  @chown[/preserve] <object>=<player>

  Changes the ownership of <object> to <player>. You can chown things,
  rooms, or exits. To chown a thing, you have to be carrying it. 
  If you do not own an object, you can only chown it if it is CHOWN_OK.
  If you're not a Wizard, you can only @chown objects to yourself or
  to a Zone Master whose zone-lock you pass.

  Normally, @chown'ing an object clears privileged flags and powers,
  and sets the object halt.  Wizards may use @chown/preserve to chown
  an object, preserving these privileges and not setting the object
  halt. Doing this to an active object with queued commands is not
  recommended, and may have strange and insecure effects.

  Examples:
    (for a room)    @chown here=me
    (for an object) @chown box=Soundwave
  
  Players can't be @chowned; they always own themselves.

See also: CHOWN_OK, Zone Masters
& @chownall
  @chownall[/preserve] <player> [= <target_player>]

  Transfers ownership of all the objects that the player owns to 
  <target_player>. If the target player is not included, then all 
  the objects are chowned to the person executing the command. 
  This is a wizard-only command. The /preserve switch keeps privileged
  flags and powers instead of clearing them, and doesn't halt them.

See also: @chown
& @chzone
  @chzone <object>=<zone master> 
  @chzone <object>=none

  The first form of this command changes the ZONE of <object> to
  <zone master>. This puts the object on that zone and may (if the
  zone_control_zmp_only option is off) allow anyone who passes the
  zone-lock of the zone master to make changes to the object. Any
  kind of object can be @chzoned, and any kind of object can be used
  as the zone master.

  The second form of this command resets the zone of <object> to *NOTHING*.
  Anyone can reset the zone of an object s/he owns.

  If a player is @chzoned, anything s/he makes afterwards will start out
  with that Zone, but none of the objects that s/he presently owns will
  have their Zone changed. Players can @chzone themselves to a master if
  they own it. Otherwise, only wizards can @chzone players.

(continued in help @chzone2)
& @chzone2

  To see the Zone of an object, you can use either 'brief' or 'examine'
  to examine it. The Zone is listed on the same line as the Owner of
  the object.

  Players can @chzone objects they own if they own the zone master or
  if they pass its @lock/chzone.  Wizards can @chzone objects to any
  zone master as long as the object has a zone-lock.

  Whenever an object besides a player is @chzoned to a zone master, the
  WIZARD, ROYALTY, and TRUST flags will be reset, as will all @power's
  (for security purposes). For similar reasons, it is strongly recommended
  that you do not @chzone admin- or wizard-owned objects to any zone
  that less privileged players have access to.

See also: ZONES, @chzoneall
& @chzoneall
  @chzoneall <player>=<zone master>

  Changes the zone of all objects owned by <player> to <zone master>. 
  If <zone object> is "none", the zone is reset to NOTHING. Only wizards 
  may use this command.
  
See also: @chzone, ZONES
& @clone
  @clone <thing, room, or exit>[=<new name>]
  @clone/preserve <thing, room, or exit>[=<new name>]

  For things, creates an exact duplicate of it and puts it in the
  current room. For exits, it creates an exact duplicate of that
  exit, except the clone's source is the current room rather than
  whatever the original exit's source was. For rooms, creates an
  exact duplicate of the room, without contents or exits. The name
  of the duplicate object can be provided; it defaults to the same
  as the name of the original object.

  The thing to be cloned must be controlled by the @cloning player.
  The clone will be owned by the @cloning player.

  If creation times are enabled, a clone will have a different creation
  time than the object it was cloned from, but will have the same
  modification time, to make tracking revisions of code easier.

  A wizard may use @clone/preserve, which has the effect of preserving
  all the bits, powers, and warnings of the original object.

  To clone a room and all its exits, use code like:
    @tel [setq(0,%l)][clone(here)]; @dol lexits(%q0)=@clone ##

See also: @create
& @command
  @command <command>
  @command/<switch> <command>
  @command/alias <command>=<new command name>

  @command provides information about and controls the availability 
  of other commands.

  With no switches, @command shows all sorts of interesting information
  about how a command is parsed.

  Switches include:
  /disable   : Disable the <command>
  /off       : Synonym for /disable
  /enable    : Enable the <command>
  /on        : Synonym for /enable
  /alias     : Creates an alias for a command.
  /quiet     : Don't make noisy output when doing one of the above
  /add       : Creates a useless command. @hook/override it.
  /delete    : Deletes a command added by @command/add, or aliases.

  See HELP RESTRICT for more.
(continued in help @command2)  
& @command2
  @command/add and @command/delete are powerful tools in that they let
  you write $-commands which may or may not parse their arguments, and
  have the precedence of a built-in command, being checked before
  $-commands on objects. Only God may use these switches.

  Additional switches are used in @command that only apply when used
  with @command/add. These switches are:

  /noparse   : The command does not evaluate arguments passed to it.
  /eqsplit   : The parser parses leftside and rightside around =
  /lsargs    : Comma-separated arguments on the left side are parsed.
  /rsargs    : In conjunction with eqsplit, the right-side arguments,
               comma-separated, are parsed individually and passed
               to the $-command in @hook/override.

  Any command added without the /noparse switch is provided with a
  /noeval switch itself, so if you @command/add foo, then foo's arguments
  are parsed by default, but you can call foo/noeval. Note: the $-command
  needs to make allowances for the /noeval switch in it's matching.

  Commands added with @command/add, like other standard commands,
  are never case-sensitive (regardless of CASE flag on the attribute).

(examples in help @command3)
& @command3
  Examples:

  > @create Dining Machine
  > &eat dining=$eat *:@remit %L=%N takes a bite of %0.
  > @command/add/noeval eat
  > @hook/override eat=dining machine,eat
  > eat meat loaf
  Walker takes a bite of meat loaf.
  > eat randword(apple tomato pear)
  Walker takes a bite of randword(apple tomato pear)

  > &drink dining=$^drink(/noeval)? (.*)$:@remit %L=%N drinks %1.
  > @set dining/drink=regexp
  > @command/add drink
  > @hook/override drink=dining machine,drink
  > drink reverse(tea)
  Walker drinks aet.
  > drink/noeval reverse(tea)
  Walker drinks reverse(tea).

& @comment
  @comment <object> = <comment>

  This is a wizard-only command which sets a COMMENT attribute on
  <object>. The comment can only be seen by other wizards and royalty.
& @config
  @config/functions
  @config/commands
  @config/attribs
  @config/flags
  @config/list[/lowercase] [<option|option-type>]
  @config/set option=value
  
  This command lists the MUSH configuration parameters, indicating what
  special things are enabled, and the cost of certain commands.
  Switches include:

  /functions  --   Lists all functions.
  /commands   --   Lists all commands.
  /flags      --   Lists all flags.
  /attribs    --   Lists all standard attributes.
  /list       --   Lists the value of a particular <option> or <option-type>
                   if given one; lists the option-types if not.
  /set        --   Wizard only, changes parameters from the mush. See
                   help @config parameters for available ones.
& @conformat
  @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)'.
  A |-delimited list of all the unparsed object names is passed 
  in %1 (so iter(%1,itext(0),|,%r) produces the standard list)
 
  One could change the format to 'Contents: Object1 Object2 Object3'
  through '@conformat here = Contents: [iter(%0,name(##))]',
  for example. More complex things are, obviously, possible.
 
See also: @exitformat, @nameformat, @descformat
& @invformat
  @invformat <object> [=<format>]

  Replaces the usual "You are carrying:" format when an object uses the
  "inventory" command, by a player-specified format. This is evaluated
  as if it were a description or other similar message on the object.
  The objects carried are passed as a dbref list in %0.
  A |-delimited list of all the unparsed object names is passed 
  in %1 (so iter(%1,itext(0),|,%r) produces the standard list)

  One could change the format to 'You've got: Object1 Object2 Object3'
  through '@invformat me = You've got: [iter(%0,name(##))]',
  for example. More complex things are, obviously, possible.
 
See also: inventory
& @descformat
  @descformat <object> [=<text>]

  Replaces the usual description of the object when it is looked at
  by player-specified text. The evaluated DESCRIBE attribute is
  passed as %0; the unevaluated DESCRIBE can be acquired through
  v(DESCRIBE).

  This is useful for things like room parents that enforce a consistent
  "look" for each room's @desc.

See also: @exitformat, @nameformat, @conformat, @idescformat
& @idescformat
  @idescformat <object> [=<text>]

  Replaces the usual description of the object when it is looked at from
  within by player-specified text. The evaluated IDESCRIBE attribute
  is passed as %0; the unevaluated IDESCRIBE can be acquired through
  v(IDESCRIBE).

  This is useful for things like object parents that enforce a consistent
  "look" for each object's @idesc.

See also: @exitformat, @nameformat, @conformat, @descformat
& @nameaccent
  @nameaccent <object> [=<accent template>]

  When this attribute holds an accent template that has the same
  length as the object's name, it is used to change the object's name
  in some situations (How it shows up in speech, look, and a few other
  commands). This allows for accented names without having to use the 
  accented characters directly in a name, which can make it harder for
  people to type.

  If a container has both a @nameaccent and a @nameformat, the
  @nameformat is used.

See also: accent(), @nameformat
& @nameformat
  @nameformat <object> [=<format>]

  Customizes the usual display of the object's name to people who
  are inside it and 'look'. It is evaluated as if it were a description
  or similar message on the room. The room's dbref is passed as %0,
  and the default-formatted name as %1.

  @nameformat is not used when people outside the object look at it.

  Example: Show the room's zone after its name.
  @nameformat here = %1 [if(isdbref(zone(%0)),<[name(zone(%0))]>)]

See also: @exitformat, @conformat, @descformat
& @cost
  @cost <object> = <amount> 

  This sets the number of pennies that need to be given to an object to
  trigger its @pay/@opay/@apay attributes. It is evaluated, so you
  may use functions as well as simple integers; the amount given by
  the player is passed as %0.

  Example:
    @cost exit-machine=10
    @apay exit-machine=@open %N-exit 
    @pay exit-machine=Your exit has been created.  
 
    give exit-machine=10
    > Your exit has been created.
    (The exit will also have been opened by the machine.)

    @cost charity=%0
    @pay charity=Thanks for your donation of %0.

See also: give, MONEY, @pay, money()
& @cpattr
& @mvattr
  @cpattr[/noflagcopy] <obj>/<attr> = <obj1>[/<attr1>] [,<obj2>/<attr2>,...]
  @mvattr[/noflagcopy] <obj>/<attr> = <obj1>[/<attr1>] [,<obj2>/<attr2>,...]
  
  @cpattr copies an attribute from one object to another, or several 
  others. @mvattr does the same thing, except it also removes the original
  attribute from the original object. Attribute flags ARE copied as well,
  unless you use the /noflagcopy switch, which you probably want if you're
  copying from a non-standard attribute to a standard one.

  For example:
    @cpattr box/test = box/test1, cube/random, tribble/describe

  would check the object "box" for an attribute named TEST and then
  copy it to the attributes TEST1 on "box", RANDOM on the object named
  "cube", and DESCRIBE on the object named "tribble".

  If you leave out the destination attribute, the attribute is copied
  to one of the same name on the new object. For example:
    @cpattr box/test=cube
  would copy the TEST attribute from "box" to TEST on "cube".

See also: ATTRIBUTES, NON-STANDARD ATTRIBUTES
& @create
  @create <name> [=<cost>]

  Creates a thing with the specified name. Creating a thing costs
  a certain amount of MUSH money, which usually defaults to 10 pennies.
  You can specify a higher cost if you wish, but not a lower one.
  This cost is refunded if you @destroy/@recycle the thing.

  Once you have created a thing, you can use it as a PUPPET, to store
  USER-DEFINED COMMANDS, or just as a prop. Some MUSHes choose to limit 
  the number of objects that players can create by setting a QUOTA.
 
See also: give, @quota, MONEY
& @dbck
  @dbck
  This is a wizard only command.  It forces the database to perform a
  series of internal cleanup and consistency checks that normally run 
  approximately every 10 minutes:

  1. For every object, make sure its location, home, next, contents,
     parent, and zone fields are valid objects.
  2. Check for disconnected rooms that aren't set FLOATING
  3. For every exit, player, or thing, make sure there is exactly one
     way to reach it from a room by following the contents fields of
     non-exits, the next fields of non-rooms, and the exits fields of
     rooms.
  4. For every thing or player, make sure that it is in the contents
     list of its location. Make sure every exit is in the exits list
     of its location.
  5. Check that objects being used as zones have a @lock/zone.

  @dbck no longer performs an @purge. The results of @dbck are written
  to the game's error log, and not reported to the Wizard.

& @death
  @death <player> [=<message>]

  This command sets the message displayed to the killer when <player>
  is killed. Typing just '@death <player>' or '@death <player>=' 
  without a message will clear the currently set message.

  Example:
   @death me=You have just slain Cyclonus!

  Note that some MUSHes choose to disable the KILL command, which makes
  this attribute rather pointless.

See also: kill, BEING KILLED, @odeath, @adeath
& @decompile
  @decompile[</switch>] <object>[/<attribute-pattern>]
  @decompile/prefix <object>[/<attribute-pattern>]=<prefix>

  This command produces a list of the commands that you would have to
  enter in order to recreate <object>. Useful for either copying objects
  from one MUSH to another, or for making logs of important objects to
  protect against an accidental @nuke or a crash.

  When the /prefix switch is specified, and a prefix given, all output
  lines will be prefixed with <prefix>. Good for creating client-side
  scripts to edit code with.

  You can either @decompile an entire object, or just certain parts of it.
  To @decompile just a few attributes, for example, you could type:

      @decompile <object>/<attribute name>

  for each attribute. You can also use wildcards in <attribute name> to
  @decompile a list of similarly-named attributes.

(continued in help @decompile2)
& @decompile2
  @decompile takes five switches: /db, /flags, /attribs, /tf, /skipdefault
  Multiple switches may be usefully combined (other than /tf).

  @decompile/db
    This command makes @decompile use the object's DBREF # instead of its
    name, which is useful for editing code off-MUSH.
  @decompile/flags
    Only the code to @create the object and set flags/powers/locks is printed.
  @decompile/attribs
    Only the code to set the object's attributes is printed.
  @decompile/skipdefault
    Don't output commands to set attribute flags if those flags are the
    defaults for that attribute on that MUSH.
  
  If an attribute contains special characters, such as %r or %t, ansi, pueblo,
  or begins or ends with spaces, then the command sent will be an @set command
  that has its special characters escaped, and with such %rs, %ts, and %bs as
  to exactly duplicate the attribute as it is currently set.

(continued in help @decompile3)
& @decompile3

  @decompile/tf <object>[/<attribute>]

  Supplying the /tf switch makes @decompile act exactly as if you typed:
  @decompile/prefix <object>[/<attribute>]=FugueEdit >%b

  You can use a string other than "FugueEdit > " by setting your TFPREFIX
  attribute.  You are strongly urged to do so. Using @decompile/tf with
  the default prefix presents the opportunity for a malicious player
  to load your TinyFugue command line with a harmful command for you to
  execute inadvertantly.

  The /tf switch is handy for grabbing code and placing it right
  into your input window. To do this:

    In TinyFugue:
      /def -ag -mglob -p100 -t"FugueEdit > *" fe = /grab %-2

    In SimpleMU:
      Set your Options -> Grab Password
      @set me=tfprefix:<grabpassword>FugueEdit >%b

See also: CLIENTS, ATTRIBUTES, WILDCARDS, MUSHCODE
& @describe
& @desc
  @describe <object> [=<description>]

  This command sets the description of the object, which will be seen 
  whenever something looks at the object with the command 'look <object>'.
  Every object should have a description, even if just a short one 
  describing its purpose. If the [=<description>] is left out, the desc.
  on the object will be reset to nothing. When you look at something that
  has no desc., you are told, "You see nothing special."

  @describe can be abbreviated as @desc

See also: look, @adescribe
& @destroy
& @recycle
& @nuke
& @undestroy
& @unrecycle
  @destroy[/override] <object>  OR   @recycle[/override] <object>
  @undestroy <object>           OR   @unrecycle <object>
  @nuke <object>

  NOTE: @destroy and @recycle are the same command - some MUSHes
  choose to use @recycle instead of @destroy to avoid the typo of
  '@dest obj' for '@desc obj'. Others use @destroy. @nuke is an alias
  for @dest/override.

  Recycles <object> and returns the player's investment (the cost of
  @create). You should always @destroy objects you no longer need;
  this keeps the database down to a manageable size.  When an object
  is @destroyed, it is set GOING, its queue is cleared and any
  semaphores are drained, and its ADESTROY attribute is immediately
  triggered. 

(continued in help @destroy2)
& @destroy2

  GOING objects are actually removed from the db approximately every
  10-20 minutes. Until then, you may use the @undestroy/@unrecycle
  command to abort the destruction sequence. If you @undestroy an
  object, its STARTUP attribute is triggered. If you @destroy a
  GOING object, it is purged immediately.

  Wizards may @nuke players. If the destroy_possessions config option
  is set (see @config), destroying a player destroys all non-SAFE
  things the player owns, and @chowns SAFE things to God. If not,
  destroying a player @chowns all their objects to God.

See also: SAFE, GOING, DESTROY_OK  
& @dig
  @dig[/teleport] <room name>[=<exit name>;<alias>*,<exit name>;<alias>*]
  
  This command is used to create a new room, possibly with exits linking
  it to the room you are standing in. This command normally costs 10 pennies,
  although some MUSHes may have different amounts or may restrict this 
  command to those with the builder @power.
  
  @dig/teleport will automatically @tel the digger to the new room.

  If you use the long form of this command, an exit to the new room
  from the one you are standing in and an exit back from the new room
  will both be automatically @open'ed and @link'ed. You may have as 
  many or as few exit aliases for an exit as you like, separated in the
  command by semicolons. The exit leading to the new room is separated
  from the exit leading back by a single comma.

(continued in help @dig2)
& @dig2
  Examples: 
  @dig Kitchen
    This command will create a new room named 'Kitchen'. You will be informed
    what the dbref # of this room is.

  @dig Kitchen = Kitchen <N>;n;north;kitchen;k
    This will create the room as above and also open an exit leading
    to it named "Kitchen <N>;n;north;kitchen;k". It will appear in the 
    list of Obvious exits as just "Kitchen <N>", but you will be able to
    go through it by typing any of the following: n, k, north, kitchen
    It will NOT create an exit coming back from the Kitchen room.

  @dig Kitchen = Kitchen <N>;n;north;kitchen;k,Out <S>;s;south;out;o
    This will do just the same as the above, except it will also create
    an exit named "Out <S>;s;south;out;o" coming back from the kitchen
    to whatever room you are currently in.

See also: @open, @link, EXITS, @create, DBREF
& @doing
  @doing <message>
  @doing/header <message>

  This command sets a short message that shows up in the WHO/DOING listing
  next to your name. @doing/header <message> works exactly like @poll and
  can only be used by Wizards or those with the poll power.

See also: @poll, WHO, DOING
& @dolist
  @dolist[/notify][/delimit] [<delim>] <list> = <action>
  
  @dolist executes the <action> for each element in <list>. If <list> is a
  function, it will be evaluated to obtain the necessary list to use. It
  may be any space-separated list of strings, which can be object numbers,
  attributes, or arbitrary words. If the /delimit switch is given, the first
  character of the list is used as the separator, instead of space.
  
  <action> is a command or list of commands enclosed in braces { }
  and is performed once for every item in <list>. The special symbol "##"
  is replaced by the corresponding item from <list>.  The special symbol
  "#@" is replaced by the position of that item in the list.
 
  If the /notify switch is used, a "@notify me" is queued after all the
  list commands. This is useful for object synchronization with semaphores.
   
  Example: @dolist [lcon(here)] = "[name(##)]
    would cause you to say the name of all objects in the room.
& @drain
  @drain[/any][/all] <object>[/<attribute>][=<number>]
  
  This command discards commands waiting on a semaphore without
  executing them.

  If the /any switch is given, then all semaphores associated with
  <object> are @drained.  Otherwise, the only the specified semaphore
  attribute (or SEMAPHORE if no attribute is specified) is @drained.

  If the /all switch is given, then all queue entries associated
  with the selected semaphore(s) are discarded, and the semaphore
  attribute(s) are cleared.  Otherwise, only the indicated <number>
  of queue entries are discarded.  If no <number> is given, then
  the /all switch is assumed.

  You may not specify both the /any switch and a specific attribute.
  Similarly, you may not specify both the /all switch and a number.

  See also the help for: SEMAPHORES, @notify, @wait
& @drop
  @drop <object> [=<message>]. <object> can be a thing, player, exit,
  or room, specified as <name> or #<number> or 'me' or 'here'. Sets 
  the drop message for <object>. The message is displayed when a 
  player drops <object>. Without a message argument, it clears the 
  message. 

  On an exit, this message is sent to a player after they pass through
  the exit.

See also: drop, @odrop, @adrop.
& @dump
  @dump [/paranoid] [check interval]
 
  This is a wizard only command that saves a copy of the current memory
  database out to a save file.  This preempts the normal regular dumping
  that the mud performs on its own.
 
  If the /paranoid switch is used, the game performs additional consistency
  checking which corrects possible data corruption. If a check interval
  is specified, the game writes confirmation of the dump to the checkpoint
  log file every <interval> objects. If no interval is specified, it is
  taken to be the size of the database, divided by 5.
  This switch should ONLY be used if a normal @dump is not being done
  correctly. Paranoid dumps should generally only be done by wizards with 
  access to the account on which the MUSH is running, since others will
  not have access to the checkpoint log file.
& @ealias
  @ealias <object> = <enter alias>

  This allows a player to type the enter alias instead of "enter <object>"
  If you have a chair, you could "@ealias chair = sit down" and then just
  type "sit down" instead of "enter chair" - using the object name is
  not necessary. Note that the enter alias is checked after normal exits.
  Like an exit, it may have a semicolon separated list of words,
  i.e. sit down;sit;sit on chair
& @edit
& @gedit
  @edit[/first][/check] <object>/<pattern> = <search>,<replace> 
  @edit[/check] <object>/<pattern> = $,<string to append>
  @edit[/check] <object>/<pattern> = ^,<string to prepend>

  This is useful when you don't want to have to retype those obnoxiously 
  long descriptions just to make one little change.  Instead, search and 
  replace via @edit.  
  
  <pattern> is a pattern, optionally containing wildcards, for the attribute 
  names you wish to edit. Only attributes already defined on <object> may be 
  edited. <search> and <replace> are two strings. It's also possible to use 
  "$" and "^" to signal appending and prepending text, respectively.
  
  If the text contains commas, percent signs, or similar special characters,
  it usually must be enclosed in curly braces.

  If the /first switch is used, only the first occurrence of <search>
  is replaced.

  If the /check switch is used, the editing is not actually done, but the
  results are shown to you (with changes hilighted) as if a normal @edit
  was performed.
  
  See also ATTRIBUTES, edit()
& @efail
  @efail <object> = <message>
  This is the message shown to the player who fails to enter the object.
& @elock
  @elock <object> = <key>
  Enter-locks an object, restricting who is allowed to enter it. Special
  lock types are supported (see "help @lock" for details). Only objects
  which are ENTER_OK may be entered, regardless of the key.
 
  Rooms don't use ENTER_OK or @elock; they use @lock/teleport