& help
============================================================================
        M i c r o M U S E   O n l i n e   H e l p   F a c i l i t y
----------------------------------------------------------------------------

To get a list of topics:               To get a list of commands:
     help topics                            help commands

To get a list of @commands:            To get a list of flags:
     help @commands                         help flags

To get a list of functions:            To get a list of official commands:
     help functions                         help offcommands

To get syntax of help commands:        To register a character:
     help syntax                            help register

Please notify a Director of any errors in the help text.
----------------------------------------------------------------------------
& cvs
This is for cvs: $Id: helptext,v 1.1.1.1 1992/10/11 15:05:01 nils Exp $.

& syntax

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

Example:  Type
	help look
for help about the look command.

& commands
Help available for MicroMUSE Commands:

drop           enter          examine        get            give
goto           home           inventory      leave          look
money          move           news           page           pose
QUIT           read           say            score          take
throw          whisper        WHO            gripe


+away          +idle          +haven        +laston        +version
+channel       +com           +mail         +uptime        +cmdav
+stats

For a list of building commands, type 'help @commands'.
For a list of functions, type 'help functions'.

& @commands
Help available for MicroMUSE @commands:

@create   @destroy    @lock    @name      @zlink      @teleport   @who_flags
@dig      @undestroy  @elock   @getalias  @unzlink    @cpattr     @who_names
@open     @protect    @ulock   @alias     @chown      @defattr    @columns
@link     @unprotect  @unlock  @clone     @addparent  @undefattr  @akill
@unlink   @poof       @bamf    @aclone    @delparent  @kill       @okill

@move     @succ     @fail     @enter     @efail     @leave     @drop   @ufail
@amove    @asucc    @afail    @aenter    @aefail    @aleave    @adrop  @aufail
@omove    @osucc    @ofail    @oenter    @oefail    @oleave    @odrop  @oufail

@desc     @pay      @listen   @set       @charges   @trigger   @aconnect
@adesc    @apay     @ahear    @nset      @runout    @force     @oconnect
@odesc    @opay     @amhear   @v*        @startup   @switch    @adisconnect
@idesc    @cost     @aahear   @does      @halt      @wait      @odisconnect

@emit     @zemit    @hide     @announce  @quota     @foreach   @decompile
@pemit    @nemit    @unhide   @whereis   @robot     @sweep     @entrances
@remit    @npemit   @relink   @search    @edit      @apage     @password
@oemit    @apemit   @tz       @find      @stats     @npage     @searchobj
                                                    @awhisper  @selfboot

& offcommands

The following commands can only be used by an official of MicroMUSE:

join            summon          slay

@boot           @broadcast      @class       @newpassword
@pcreate        @poor           @ps          @shutdown
@dbtop          @nuke           @wipeout     @allquota
@empower        @giveto         @huhto       @powers
@chownall       @dump           @dbck        @pbreak
@ulink          @doomsday

MicroMuse Officials have access to restricted channels on the +com system:
Channel names beginning with:     Are reserved for officials of rank:

	   _                          Official or higher
	   .                          Admin or higher
	   *                          Directors only

& topics
Help available on the following Topics:

Attributes
Being killed             Bogus commands           Costs
Currency                 Control                  Drop-to
Enactor                  Exits                    Failure  
Gender                   Getting started          Goals
Here                     Homes                    Inheritance
It                       Linking                  Me
Officials                Privacy
Pronouns                 Puppets                  Locks
Strings                  Sacrificing              Stack
Substitutions            Success                  Tinytalk
Timezones		 Types of objects         V-Register
Verbs			 Zones                    @
$ events		 ! events

DIRECTORS                ADMINISTRATORS

& functions
Help available for MicroMUSE functions:

add()  fadd()  land()  band()  sin()  arcsin()  log()   abs()  sgn()     gt()
sub()  fsub()  lor()   bot()   cos()  arccos()  exp()   base() truth()   lt()
mul()  fmul()  lxor()  bxor()  tan()  arctan()  ln()    mod()  if() pi() tms()
div()  fdiv()  lnot()  bnot()  pow()  fsqrt()   sqrt()  simp() ifelse()  tml()

first()    remove()   strcat()  extract()   dist2d()  subj()   ljust()   v()
rest()     pos()      string()  match()     dist3d()  objn()   rjust()   s()
next()     scomp()    strlen()  wmatch()    string()  poss()   cjust()   spc()
delete()   comp()     wcount()  plural()    lnum()    flip()   rtime()   art()

time()     type()     name()    parents()   zone()    con()      quota()
xtime()    class()    lwho()    children()  inzone()  exit()     quota_left()
stime()    owner()    idle()    lattr()     loc()     lcon()     entrances()
objmem()   flags()    onfor()   lattrdef()  room()    lexit()    credits()
playmem()  nearby()   host()    flags()     link()    objlist()  controls()
                                            change()  haspow()   hasflag()

*** Note: Do not type the ()'s. Instead use the word 'function'.
*** Example: to get help on rand(), type 'help rand function'.

& Register
MicroMUSE player registration information.

If you are a guest and wish to register a new character on MicroMUSE,
please send E-Mail to:

             micromuse-registration@chezmoto.ai.mit.edu

Please provide your real name, your character name and password, and
please type out your e-mail address. Please specify if you are a NEW
player and are requesting your first character. If you already have
other characters in MicroMUSE, please specify them also.

Players who do not have an e-mail account may send US mail to:

        MicroMUSE
	c/o Nils McCarthy
	1831 Tatum St.
	Falcon Heights, MN  55113

Please include your address and phone number also.

Once your registration has been processed, you will see Status: Citizen when
you examine yourself. We thank you for your cooperation in making MicroMUSE
more efficient for your enjoyment.

& drop 
drop <object>. Drops <object>. A dropped thing is relocated to the current
room, unless its STICKY flag is set (See STICKY), or the room  has a drop-to
(See Drop-to).  The 'throw' command is the same as 'drop'.      
& examine
examine <object>. Displays all available information about <object>. <object>
may be an object or 'here'. You must control the object to examine it. If you
do not own the object, you will just see the name of the object's owner,
unless the object is set VISIBLE or there are visible attributes on it.
May be abbreviated 'ex <object>'.

examine <object>/<attr>. Displays the value of <attr> on <object>.

& get
get <object>. Picks up <object>. <object> must be a thing.
'take' is the same as 'get'. 
& give
give <player>=<Credits/object>. Gives player the specified number of Credits
or <object>. You can't give someone Credits if their new total would be
greater than 10000 Credits. You may also give players objects, but the other
player must have the ENTER_OK flag set to receive something you give. 
& goto
go[to] <direction>; go[to] home. Goes in the specified direction. 'go home'
is a special command that returns you to your home room. The word
'go' may be omitted. 'move' is the same as 'go'. 
& gripe
gripe <message>.  Leaves <message> in the Official Gripe Log.
& inventory
inventory. Lists what you are carrying. Can be abbreviated to 'i'. 
& join
join <player>   An official command that teleports you directly to the
                location of <player>.
& kill
The kill command has been disabled in MicroMUSE.  See also 'slay'.
& look
look <object>. Displays the description of <object>, or the room you're in.
The 'read' command is the same as  'look'.  The 'look' command may be
abbreviated 'l'. You may also look at an object some one or something is
carrying by typing "look <object>'s <object>". The apostrophe and s ('s) must
be appended to the name of the object carrying the object you wish to see.
& move
Same as GO.
& news
Shows you the current news for MicroMUSE. It is highly recommended that you
check the news regularly for new information. 
& page
page <player> [=<message>]. This tells a player that you are looking for
them.  They will get a message telling them your name and and location if
you omit the message. This costs 1 Credit.  If you include the '=<message>',
it will tell the player your name and your message, but not your location. 
If a player is set to HAVEN (See FLAGS), you cannot page them, and they
will not be notified that you tried. You may also page-pose, using : before
the message. Example: 'p jin=:grins'.

See also: @npage

& QUIT    
QUIT. Log out and leave the game. Must be in all capitals.  
& read 
Same as 'look'.
& say
say <message>. Says <message> out loud. You can also use '"<message>'.
Another command is ':<message>'. This is used for actions. Example: If
your name was Igor, and you typed ':falls down.', everyone would see
"Igor falls down." See also 'whisper'and 'pose'. 
& score
score. Displays how many Credits you are carrying.  See 'money'.
& slay
slay <player/object> This is an Official command that 'kills' players (see
the help on topic 'being killed'.  It is used in such areas as Outer Space
and in oceans.
&summon
summon <player>  An official command that teleports <player> to the
                 location where the official is.
& take
See 'get'.  
& throw
See 'drop'.
& whisper
whisper <player>=<message>. Whispers the message to the named person,
if they are in the same room as you. No one else can see the message.
'whisper' can be abbreviated by just 'w'.  
& @who_flags
@who_flags <object>=<flags>

The WHO command output can be adjusted by using one or more of these flags;
uppercase for full output, lowercase for a short, truncated output:

	N,n -- Name (Generally WHO won't be of much use without this flag)
	A,a -- Alias
	F,f -- Flags ('h' if hidden, 'H' if haven, 'N' if set NO_WALLS
        O,o -- On-time (how long a player has been connected)
	I,i -- Idle-time (how long a player has been inactive)
        C,c -- Class (e.g. Citizen, Director). Short forms may be cryptic.
	H,h -- Hostname (long form is bracketed)

The default output corresponds to the flags NfoiC.

See also: WHO, @who_names, @columns

& WHO
WHO [<flags>] [=<namelist>]

WHO   Displays a list of players currently connected to MicroMUSE.  Hidden
players (see @hide) are not listed, but the number of hidden players is shown.
When there is sufficient space on the line, WHO will use multi-column output.

If a list of flags is entered, you can adjust your WHO output by selecting
whether or not you want to see their Names, Aliases, Flags, On-time, Idle-
time, Class, or Hostnames (Directors Only). See '@who_flags'.

If an = sign and list of names is typed, information will be displayed only
for those players, and only if they are connected (and not hidden).

You may set your own default flags or default list of names by setting your
@who_flags and @who_names registers.  E.g. @who_flags me=NafoiC, will add the
alias field to the output you see from WHO.  You can still override your
defaults at any time by including flags or names when typing the WHO command.

See also: @who_flags, @who_names, @columns

& @who_names
@who_names <list of names>

Sets a default list of names that are the ONLY names you wish to look up
when you type WHO.

See also: WHO, @who_flags, @columns

& @columns
@columns <number of columns>

Sets a default number of columns that you want the WHO list to print in.
This is the number of columns of screen text that WHO will use to determine
when to break the list into multiple columns of names.  The default value
for this attribute is 80.

See also: WHO, @who_flags, @who_names

& @adescribe
@adesc <object> = <actions>. Sets the actions to be taken when <object> is
looked at. Actions are lists of commands seperated by semicolons and these
commands are executed by the object (see puppet). Things can execute almost
any command but rooms and exits are restricted to forcing objects/puppets
to do things. Gender substitutions are applied to the commands before they
are executed, allowing the use of %s and %o and %p. <object> can be specified
as <name> or #<number>, or as 'me' or 'here'. May be abbreviated @adesc. See
also @describe, @idescribe and @odescribe.
& @afail
@afail <object> = <actions>. Sets the actions to be taken on failure to use
<object>. Actions are lists of commands seperated by semicolons and these
commands are executed by the object (see puppet). Things can execute almost
any command but rooms and exits are restricted to forcing objects/puppets to
do things. Gender substitutions are applied to the commands before they are
executed, allowing the use of %s and %o and %p. <object> can be specified as
<name> or #<number>, or as 'me' or 'here'. See also @fail and @ofail.
& @ahear
@ahear <object> = <actions>. Sets the actions to be taken after a string
set in the @listen (See @listen) is matched. Actions are lists of commands
seperated by semicolons and these commands are executed by the object (see
puppet). Objects can execute almost any command. Gender substitutions are
applied to the commands before they are executed, allowing the use of %s and
%o and %p.
& @akill
@akill <object> = <actions>. Sets the actions to be taken after killing
<player>. Actions are lists of commands seperated by semicolons and these
commands are executed by the object (see puppet). Objects can execute almost
any command. Gender substitutions are applied to the commands before they
are executed, allowing the use of %s and %o and %p. See also @kill and @kill.
& @alias
@alias <player>=<alias>. <player> is usually yourself. It sets a player's
alias.  This alias can be used in referencing the player. For instance,
page <alias> = <message>.
& @apay
@apay <object> = <actions>. Sets the actions to be taken after a player
gives object Credits (see @cost). Actions are lists of commands seperated
by semicolons, and these commands are executed by the object (see puppet).
Objects can execute almost any command. Gender substitutions are applied
to the commands before they are executed. This allows use %s and %o and %p.
See also @pay and @opay.
& @asuccess
@asuccess <object> = <actions>. Sets the actions to be taken on successful
usage of <object>. Actions are lists of commands seperated by semicolons and
these commands are executed by the object (see puppet). Objects can execute
almost any command. Gender substitutions are applied to the commands before
they are executed, allowing the use of %s and %o and %p.  It can be
abbreviated @asucc. <object> can be specified as <name> or #<number>, or
as 'me' or 'here'. See also @success and @osuccess.
& @bamf
@bamf <musename> <machine_name> <internet_address> <port>
The command allows users of TinyFugue, and other clients that support
Cyberports, to portal to other Muses via their "bamf" functionality.
The portal is text sent by MicroMuse's @bamf of the form:
 #### Please reconnect to <name>@<IP addr> (<normal addr>) port <port> ####
For example:
	@bamf Rhostshyl stealth.cit.cornell.edu 128.253.180.15 4201
results in:
	#### Please reconnect to Rhostshyl@128.253.180.15 4201
	(stealth.cit.cornell.edu) port 4201 ####
If "bamf" is enabled in your client, this will cause the client to open a
socket to the new world. If "bamf" is off or the client does not support
Cyberports, the lines in this format have no effect.
& @broadcast
@broadcast <message>  This is an Official command that allows a Director to 
broadcast a message throughout the entire Muse. It is similar to @announce,
but @broadcast cannot be blocked out as can @announce. Therefore, it should
only be used for emergencies, or urgent announcements.
& @boot
@boot <player>. Disconnects the player from the game. Only Directors can use
this command.
& @charges
@charges <object> = <integer>. Allows you to limit the # of times an action
can be used. If there is a charges attribute it is decremented each time a
register on the object is triggered.  Once it reaches zero actions are
disabled.  See also @runout.
& @chown
@chown <object>=<player>. Changes the ownership of <object> to <player>.
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 it can be @chowned (See FLAGS).
Any chowned object is automatically set Haven and !Inherit for security.

Players can't be @chowned; they always own themselves. 
& @class
@class <player> = <class>. Reclassifies <player> to <class>, which must be
one of: Director, Admin, Constructor, Official, Junior Official, Citizen, or
Visitor. Only Directors may use the @class command.
& @clone
@clone <object>. Creates an exact duplicate of object and puts it in the
current room.
& @cost
@cost <object> = <amount> Number of Credits that need to be given to an
object to trigger @pay,@opay and @apay. Example: 
@cost exit-machine=10
@apay exit-machine=@open %N-exit 
@pay exit-machine=Your exit has been created.  
& @create
@create <name> [=<cost>]. Creates a thing with the specified name. Creation
costs either <cost> Credits or 10 Credits, whichever is greater. The value
of a thing is proportional to its cost. To be exact, value=(cost/5)-1.
& @describe
@describe <object> [=<description>]. <object> can be a thing, player, exit,
or room, specified as <name> or #<number> or 'me' or 'here'. This sets the 
description a player sees when they use the command 'look <object>'. Without
a description argument, it clears the message. It can be abbreviated @desc.
& @destroy
@destroy <object>. This allows the recycling of objects and returns the
player's investment in the object when used. The Destroy_OK flag set on
an objects allows any one in possession of that object to @destroy it.
@destroy has a delayed effect, taking place approximately 10-15 minutes
after the command is issued. During that time you may use @undestroy to
stop the destruction process.  Objects that are protected may not be
destroyed.  See also @protect, @unprotect.
& @dig
@dig <name> [= Exits [, Return-Exits]]. Creates a new room with the specified
name and displays its number. This costs 10 Credits. If the [= Exits] option
is used, the exit will be opened and linked for you. You will have to link
back out from the room manually unless you use the [, Return-Exits] option.
Example: @dig Kitchen = Kitchen;k;north;n, Out;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.  Only
the first Exit name is displayed. 
& @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. See also @odrop and @adrop.
& @emit
@emit <message>. Emits the message to everyone on the room. The message
may be anything with one exception. The message cannot start with the
name of any player. Sorry, no spoofing. :)
& @fail
@fail <object> [=<message>]. <object> can be a thing, player, exit, or room, 
specified as <name> or #<number> or 'me' or 'here'. Sets the fail message
for <object>. The message is displayed when a player fails to use <object>.
Without a message argument, it clears the message.
See also @afail and @ofail. 
& @find
@find [name]. Displays the name and number of every room, thing, or player
that you control whose name matches <name>.  Find costs 10 credits.
& @force
@force <player/object>=<command>. Forces the game to act as though
<player/object> had entered <command>.  In general, objects you own
can @force you if you set them 'inherit'.  Only Administrators may 
@force other players.
& @hide
This command hides your name from the WHO list. It costs 10 Credits.
Directors will still be able to see all players logged on, but hidden
players will have an 'H' after their names. Players are automatically
restored to normal each time they connect. See also @unhide.
& @kill
@kill <player> [=<message>]. <player> can be specified as <name> or #<number>
or 'me' or 'here'. Sets the kill message for <player>. The message is
displayed when <player> is killed.  See also @akill and @okill.
& @okill
@okill <object> [=<message>]. Message shown to other players when you
get killed.  See also @kill and @akill.
& @idescribe
@idescribe <object> = <description>. For objects which are ENTER_OK,
the inside description can be set to be different from the regular
(outside) description.
& @link
@link <object>=<number>; @link <object>=here; @link <exit>|<room>=home. Links
<object> to room specified by <number>. For things and players, sets the home
room (See Homes). For rooms, sets the drop-to room (See Drop-to). For exits,
sets the target room; the exit must be unlinked, and you must own/control the
target room unless its LINK_OK flag is set. Linking an exit costs 1 Credit. If
the exit was owned by someone else, the former owner is reimbursed 1 Credit. 
& @listen
@listen <object> = <string>. A wildcard pattern for an object to listen for.
If/when <string> is heard, the object's ahear, amhear, and/or aahear is
triggered. (see @ahear, @amhear, @aahear) Note: if @listen is matched the
object's contents will also hear the message. 

Note that the listen pattern must be exactly what the object hears in order
for the @ahear, etc., to be triggered. For instance, if your object is
listening for 'foo' (@listen obj=foo) and you say "foo", the @ahear will not
be triggered, because the object hears 'Yourname says "foo"' rather than just
'foo'.  You need to set '@listen obj=* says "foo"' for the object to trigger
anytime anybody says 'foo'.  Or if you want the object to react anytime the
word foo is used in any context including a pose or emit, you might want to
specify @listen obj=*foo*.

See also '! events' for another way of making objects listen.

& @lock
@lock <object> = <lock>.  Sets the lock for an object.  Only players or
things satisfying the lock will be able to SUCCEED with the object (to
pick up an object, go through an exit, and trigger @succ, @osucc, @asucc
registers.  Anything else will fail, triggering the @fail, @ofail, @afail.
See help for 'locks' for complete help on locks.  See also @elock, @ulock.

& Locks
A lock is an attribute that determines who may take, use, enter, or otherwise
control an object.  Currently in MicroMuse 3 locks are defined: the regular
lock (@lock), the enter-lock (@elock), and the use-lock (@ulock). Help is
available on each of those.  In this discussion we will refer to the @lock,
but the same options are available for all the other locks.

All of the following lock types are available:
	Ordinary locks (that work as in previous versions of MUSE)
	Is locks
	Carry locks
	Indirect locks
	Object Attribute Locks
	Register Locks
Help is available on each of the above topics.

Any lock of any type may be combined with any other in a boolean expression,
using '&' (and), '|' (or), '!' (not), and parentheses ('(' and ')') to group.
The lock is satisfied if the boolean expression evaluates to true.

& register locks
A register lock is a mechanism for locking a specific $ or ! event, unlike
the @ulock which locks all of the $ and ! events on an object.  The syntax
for seting individual register locks is:
	@<attr> <object>=$<verb-pattern>:/<lock>/<action-list>

Example:
	@va object=$blee:/#1/"foo

If Jin types 'blee' in the presence of the object, the object will say 'foo',
but the pattern 'blee' will not match this register for anyone else.  That is,
anyone else typing 'blee' will receive the standard 'Huh?' error message.

& ordinary locks
An ordinary lock is checked against the player (or object) trying to pick
up the locked object (or trying to walk through an exit).  It is also
checked against any object the enactor is carrying, and against the zone
the enactor (and hence the object) is currently in.  It can be specified
as a <name> or a #<dbref>, or as 'me' or 'here'.  To lock to a specific
player, prefix their name with '*' (ex. '*Jin').

Examples: @lock purse = #123		Can be picked up by player #123,
					or by anyone carrying object #123,
					or by anyone currently in zone #123.

	  @lock purse = *Jin		Can be picked up by Jin, or by anyone
					carrying Jin.

Objects can also be locked to the value of an attribute on the enactor
(attributes on ordinary locks are not also checked on objects carried by
the enactor).

Examples:  @lock thing=sex:m*		Object may be taken by anyone whose
					sex starts with an 'm'.

	   @lock thing=last:>612345678  will lock thing to anyone whose 'last'
					attribute is greater than 612345678.

The value for the attribute may also be specified as a function, which is
evaluated each time an attempt is made to take the object.

Example:   @lock thing=sex:[add(3,4)]	will allow people whose sex is '7'
					to take the object.
& is locks
An Is-lock is checked against the enacting object only, and not against any 
objects the enactor is carrying, nor against the zone the enactor is in.

Syntax: @lock <thing>==<object>  (Notice the double = sign).

Example: @lock thing==*Jin    Only Jin may take 'thing'. People carrying
			      Jin cannot.
& carry locks
A carry-lock is checked only against objects carried by the enactor, and not
against the enactor itself, nor against the zone the enactor is in.

Syntax: @lock <thing>=+<object>

Example: @lock thing=+*Jin	Only someone carrying Jin can take 'thing'.
				Jin himself cannot.
& indirect locks
An indirect lock checks the lock on some other object.  Since locks are not
inherited (see inheritance), using indirect locks is one way to simulate
such inheritance.

Syntax:	@lock <thing>=@<object>

Example: @lock foo=@#123	Anyone who can pick up #123 can also pick up
				foo.  Foo must control #123 or it will not be
				able to read the lock and the lock will fail.
& object attribute locks
An object attribute lock checks the value of an attribute on any specific
object all (rather than on the enactor).

Syntax: @lock <thing>=@(<object>=<attr>:<value>)
		The parentheses are important.

Example:  @lock foo=@(*Jin=race:human)
		Anyone at all can pick up the object, just so long as Jin's
		race is 'human'.  Foo must be able to read the 'race'
		attribute on Jin, or the lock will fail.
& @name
@name <object>=<new name> [<password>]. Changes the name of <object>.
<object> can be a thing, player, exit, or room, specified as <name> or
#<number> or 'me' or 'here'. For a player, it requires the player's password.  
& @newpassword
@newpassword <player> =<password>. Only Admins may use this command. Changes
<player>'s password, informing <player> that you changed it. Must be typed in 
full. If you forget your password, log on as guest (password = guest) and
talk to an Administrator.
& @nuke
@nuke <player>. Only Directors may use this command. Recycles a player's
character, after which it no longer exists. Must be typed in full.
Cannot be used if the player owns any objects; see @wipeout and @chownall.
& @odescribe
@odescribe <object> [=<message>]. The odescribe message, prefixed by the
player's name, is shown to others when the player looks at <object>. Without
a message argument, it clears the message. <object> can be specified as <name>
or #<number>, or as 'me' or 'here'. May be abbreviated @odesc.
See also @describe, @adescribe and @idescribe.
& @odrop
@odrop <object> [=<message>]. The @odrop message, prefixed by the player's
name, is shown to others when the player drops <object>. Without a message
argument, it clears the message. <object> can be specified as <name> or 
#<number>, or as 'me' or 'here'.  When set on an exit, the message is sent
to all players in the room being entered. See also @drop and @adrop.
& @ofail
@ofail <object> [=<message>]. The @ofail message, prefixed by the player's
name, is shown to others when the player fails to use <object>. Without a
message argument, it clears the message. <object> can be specified as <name>
or #<number>, or as 'me' or 'here'. See also @afail and @fail.
& @opay
@opay <object> [=<message>]. The opay message, prefixed by the enactor's
name, is shown to other players in the room . Without a message argument, it
clears the message. <player> can be specified as <name> or  #<number>, or as
'me' or 'here'. See also @apay and @pay.
& @open
@open <direction>[;<other direction>]* [=<number>]. 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
Credit. If you specify <number>, linking costs 1 more Credit. See also @link
and @dig.
& @osuccess
@osuccess <object> [=<message>]. The @osuccess message, prefixed by the
player's name, is shown to others when the player successfully uses <object>.
Without a message argument, it clears the @osuccess message. It can be
abbreviated @osucc. <object> can be specified as <name> or #<number>, or as 
'me' or 'here'. See also @success and @asuccess. 
& @password
@password <old password>=<new password>. This changes your password.
It can be abbreviated @pass.
& @pay
@pay <object> [=<message>]. The pay messages is triggered and shown to the
player who paid the object. Without a message argument, it clears the
message.  <player> can be specified as <name> or #<number>, or as 'me'
or 'here'. See also @apay and @opay.
& pose
pose <action pose>. Displays your name followed by the statement you
posed.  May be abbreviated by the ':' symbol. Example: If you are player
Bob, and you type in ':laughs out loud.' everybody in the room will see:
Bob laughs out loud. There is also the ';' pose, used like the ':', only
it will append a 's to your name. Example: ';funny bone hurts.' everyone
will see: Bob's funny bone hurts.
& @pemit
@pemit <player> = <message>. Emits the message to <player>. The message
may be anything with one exception. The message cannot start with the name
of a player, or of an object present int the room. Sorry, no spoofing. :)

Note: to emit messages to everybody in a room (or in an object), or to
every room in a zone, use @remit or @zemit.  The use of @pemit to send
a message to everyone in a room is obsolete, although it will work for now.

& @ps
@ps      The @ps command lists queued commands which have not yet been
executed.  See also @wait, @trigger, and @force, all three of which push
commands onto the queue.

& @robot
@robot <name>=<password>. Costs 1000 Credits to create a robot; the robot
comes with the robot attribute set and is slightly different than normal
players.  A robot is owned by its creator and not by itself. Robots can be
@forced and set to be puppets by their creator (useful for debugging).
The principal use for @robots is to run robot code, available by anonymous
ftp from various sites.  You must be an accomplished C programmer to port,
compile, and run robot code.  Among the robots you may see online at
times are Caspian and Eliza.  You may also use a Robot as a test character
for yourself, but it is usually easier to request and use a second real
character, as Robots do not behave identically.  A third use of Robot
characters is for joint projects, since a Robot owns the same things as
its creator.

& @runout 
@runout <object> = <actions>. This is an action to be taken when charges
reach 0 (See '@charges'). Actions are lists of commands seperated by
semicolons, and these commands are executed by the object (see puppet).
Things can execute almost any command but rooms and exits are restricted
to forcing puppets to do things. Gender substitutions are applied to the
commands before they are executed, allowing the use of %s and %o and %p.
& @search
@search [<player>] [<class>=<restriction>]. This command searches the database
and lists objects which meet user specified search criteria. If a <player>
argument is supplied, only objects owned by that player will be listed. If a
<class> argument is supplied only objects of a certain class will be listed.
Possible <class>es include (TYPE, NAME, EXIT, OBJECT, ROOM, PLAYER, and FLAG).
If <class>=TYPE, possible <restriction>s include (OBJECT, ROOM, EXIT, PLAYER).
If <class>=NAME, only objects whose name begin with the string <restriction>
will be listed. If <class>=EXIT, OBJECT, ROOM, or PLAYER, only objects of that
type and whose name begin with the string <restriction> will be listed.
Finally if <class>=FLAG, only objects with the list of flags specified by
<restriction> will be listed. For the the class TYPE=PLAYER, and for
PLAYER=<player-name>, anyone  may obtain information on any player.  In all
other cases, only Officials may obtain information about other players.
Costs 10 Credits.

Examples:
   @search flags=RHD     <-- search for rooms set Haven and Dark.
   @search type=rooms    <-- list all rooms owned by me.
& @set
@set can be used both to set flags and to set attribute values.

To set a flag:
	@set <object>=<flag>
To unset the flag:
	@set <object>=!<flag>;

To set an attribute value:
	@set <object>=<attribute>:<value>

A shorthand may also be used:
	@<attribute> <object>=<value>

To copy attributes from one object to another, you can use:
	@<newattribute> <newobject>=_<oldobject>/<oldattribute>

See help on FLAGS, Attributes
& @sex
@sex <player> = <gender>  Used for pronoun substitution, normally male or
female. Visible to all.  The first letter, 'm' or 'f', determines the sex.
Example:
@sex me = Male
& @shutdown
@shutdown. Only Directors may use this command. Shuts down the game. Must be 
typed in full.
& @startup
@startup = <action list>. In event that the muse crashes and gets rebooted,
@startup will be triggered. Thus, you can retrigger objects that need to be
running continuously.
& @stats
@stats. Display the number of objects in the game broken down by object types.
Administrators can supply a player name to count only objects owned by that
player.
& @success
@success <object> [=<message>]. Sets the success message for <object>.
The message is displayed when a player successfully uses <object>.  Without
a message argument, it clears the message. It can be abbreviated @succ.
<object> can be specified as <name> or #<number>, or as 'me' or 'here'.
See also @osuccess and @asuccess. 
& @teleport
@teleport [<object>=] <room>. Teleports <object> to <room>. <object> must be
a thing. (Wizards can also teleport players.) You must be able to link to the
destination, and either control the object or its current location. You can
only teleport objects into rooms or objects you own, or that are set Jump_OK.
If the target room has a drop-to, <object> will go to the drop-to room
instead.  Administrators can teleport things into players' inventories.
& @tzone
@tz <player>=<# of hours>:<y|n>. Sets an object's time zone. <# of hours>
is a numerical value representing the number of hours the <player>'s time is
ahead of or behind Greenwich Mean Time (GMT) (also referred to as Universal
Coordinated Time (UTC), or London Time. <y|n> refers to whether or not U.S.
style Daylight Savings Time is used in your area. For example, a player in
the Eastern Time Zone, where U.S. style Daylight Savings Time was used,
would type "@tz me=-5:y" since Eastern Standard time is 5 hours behind
GMT.  A player in the Pacific Time Zone would type "@tz me=-8:y", and a
player in Copenhagen would type "@tz me=1:n" since Denmark is one hour
ahead of GMT.

If a @tz is set on a Player, then any of that players' objects that do
not have a @tz set on them will use their owner's @tz.  However, a
player may set the @tz register on any object individually.  If neither
the object nor the object's owner has a @tz set, the muse will default
to the local time at MIT, which is U.S. Eastern Time (equivalent to -5:Y).

See also Timezones.
& @unhide
Restores your name in the WHO list. Does not cost any Credits. Players
are automatically reset to @unhide each time they connect.
& @unlink
@unlink <exit>; @unlink here. Removes the link on the specified exit,
or removes the drop-to on the room. Be careful, anyone can relink an
unlinked exit, becoming its new owner (but you will be reimbursed your 1
Credit). See @link.
& @unlock
@unlock <object>. Removes the lock on <object>. See @lock.
& @announce
@announce <message>. Broadcasts <message> to every player connected. May be
abbreviated to @ann. Costs 250 Credits per announcement. Players may block
out all announcements by setting themselves NO_WALLS (See FLAGS).
& @wall
@wall    See @announce.
& @wait
@wait n = <command>.  <command> is placed on the queue and will be executed
no earlier than n seconds from the time it is queued.  <command> may be a
list of commands in curly braces: {command1; command2; command3}
See also @ps.
& @whereis
@whereis <player>. Tells you the location of the player. If you wish to
remain unlocatable, set your DARK flag. (See FLAGS). The person being
located will get a message to inform them that you have successfully or
unsuccessfully located them.  Ex: @whereis Jin
& 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 cannot be killed by other players on MicroMuse; only by running afoul
of the laws of nature (for instance, by venturing into space without a suit).
& 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=me&!me" (impossible to be both at
once, therefore 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.  Another way to create
commands is with v-registers on an object.  See V-Registers, and ask people
online for assistance.
& Control
Control.     In general, you can examine, modify, or otherwise user or
abuse an object if you control it.  You control everything you own. Unless
you are an Official, you do not control anything else.  Officials and
Administrators have various degrees of control over objects and players
they do not own.

There is one exception to this rule: anybody controls an unlinked exit, and
can link to it. The exit is automatically @chown'ed to the player who links
it. Unlinked exits can thus be stolen; all builders should be aware of this.

& Costs
Only the following commands cost any credits:
        page: 1C 
        +com: 1C

        @dig: 10C deposit on the room; 1C deposit per exit.
        @link: 1C (if you  didn't already own it, +1 to the previous owner). 
        @open: 1C (2C if linked at  the same time)
        @create: 10C (or  more, up to 505C), sacrifice value=(cost/5)-1.
           These amounts are deposits, refunded when the object is @destroyed.

        @find: 10C
        @search: 10C
        @announce: 250C.  Use +com public for general discussion.

Note: queued commands (@wait, @trigger, @force) cost 1/16th credit on average.
There is also a 10-credit deposit for any commands waiting on the queue. The
deposit will be returned when the command is executed.

& Drop-to
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.
& Exits
Exits.    Exits may be linked from rooms or objects into other rooms or
objects.  Thus you may take an exit and find yourself inside an object; if
there are no obvious exits where you are, try 'leave' before giving up.
& Failure
Failure.  You fail to use 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's
unlinked or locked). You fail to use a room when you fail to look around
(because it's locked). See Strings, @fail and @ofail.
& Flags
FLAGS     @set <object> = <Flags> to set, @set <object> = !<Flag> to reset.
Everything in the universe of MicroMUSE (Rooms, Exits, Objects, Players,
etc...) are represented in the same way at the program level.  A room merely
has the room flags set and a player has the player flags set.  In addition,
flags also give objects abilities or qualities. For specific information on
a particular flag, request help on a flag title.  Example: help ENTER_OK

Flag  Title           Flag  Title           Flag  Title
------------------------------------------------------------------
  R - ROOM flag         p - PUPPET flag       G - GOING flag
  H - HAVEN flag        s - SLAVE flag        m - MORTAL flag
  T - TRANSPARENT flag  c - CONNECTED flag    S - STICKY flag
  J - JUMP_OK flag      K - KEY flag          D - DARK flag
  e - ENTER_OK flag     d - DESTROY_OK flag   L - LINK_OK flag
  E - EXIT flag         N - NO_WALLS flag     C - CHOWN_OK flag
  P - PLAYER flag       I - INHERIT flag      h - HIDE flag
  t - TERSE flag        v - VISIBLE flag      q - QUIET flag
  o - OPAQUE flag       b - BEARING flag      l - LIGHT flag
  f - FLOATING flag     Z - ZEROG flag        z - ZONED flag
------------------------------------------------------------------
& ABODE
See JUMP_OK
& JUMP_OK
JUMP_OK     If a room is set JUMP_OK (formerly ABODE), players can
freely teleport to that room.  (See also LINK_OK).
& CHOWN_OK
CHOWN_OK   This flag, when set, allows you to transfer ownership to
another player. To set it, you must be carrying the object. You also
have to be in the room if you want to set this flag on rooms or exits.
After this flag is set, the new player may gain ownership of the object
by using the @chown command (See @chown).
& LIGHT
LIGHT     When set on an object, it enables the object to be seen in a
room set DARK.
& CLONE
CLONE     When set on an exit linked to an object causes the object to be
duplicated instead of teleported.   (Obsolete. Doesn't work anymore)
& CONNECTED
CONNECTED  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 not here! You cannot reset
this flag, and it is used internally by the code for things like
tabulating players for the WHO list, etc.
& DARK
DARK      If a room is DARK, then anyone who looks there sees only the
room description, no objects. If a thing is DARK, then 'look' does not list 
that object in the room's contents. Players who do not wish to have their
location found with the @whereis commands may set themselves DARK. Puppets 
cannot be DARK, but an object set puppet and DARK enters 'debug' mode, and
relays to its owner everything it does as well as everything it hears.

& DESTROY_OK
DESTROY_OK   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.
& ENTER_OK
ENTER_OK   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>'.
& Gender
Gender.   @sex me=unassigned|male|female|neuter. Default unassigned. If a
player's gender is set, %-substitutions will use the appropriate pronoun for
that player. Only  meaningful for players. See Substitutions.  
& GOING
GOING     Used internally for the @destroy command, it is set on objects
that are set to be destroyed. If you change your mind about destroying an
object, use @undestroy to unset it.  
& HAVEN
HAVEN     This flag when used on a player will enable you to ignore all
messages from all other Citizens. When people page you, they will receive
your +haven message.  An object set HAVEN will be halted, and commands on
its registers will not be triggered.
& HIDE
HIDE     A flag used to mark players who do not want their names to show
up on the WHO list. Set by @hide, and reset by @unhide. Administrators may
set a player's HIDE flag by using @set <player> = (!)HIDE
& INHERIT
INHERIT   If the INHERIT flag is set on an object, it inherits any special
powers of the player who owns the object.  Otherwise, the object has no
special powers.  An object set INHERIT retains the powers of the player who
owns it even when the player is temporarily set MORTAL.
& KEY
KEY       When set on an object prevents puppets from picking it up.  This
flag also causes objects to return to their home when the person holding them
teleports away (except that the owner of the object can teleport with it).
& LINK_OK
LINK_OK   If a room or object is LINK_OK, anyone can link exits to it
(but still not from it).  Anyone can also set that room or object as their
home room. (See Homes).
& MORTAL
MORTAL     When set on a player, it inhibits the use of any special
powers associated with that player's Status.  A wizard can set him/herself
mortal for testing purposes, and then unset the flag again.
& NO_WALLS 
NO_WALLS   When set on a player, it prevents the player from hearing any
announcements from Officials or from the Announcement Office. This does not
block out broadcasts, which are only used by Officials for emergencies.
& OPAQUE
OPAQUE   When set on a player, it prevents other players from seeing
what you are carrying in your inventory.  Players can still see objects
you are carrying that they own.
& PLAYER
PLAYER   The PLAYER flag identifies you as a player. This flag cannot be
reset by any player, not even a Director (not, yet, anyway *grin*). It is
used mainly by the Muse code to identify your commands, check for
validity of commands or locks etc.
& QUIET
QUIET    When you set this flag on yourself, it will block out all the
'Set' and 'triggered' messages that you get when your objects are set ot
triggered. This is useful if you have a lot of machines running continuously.
It will also keep you from hearing 'shake and crumble' and 'deposit back'
messages when you destroy your objects.
& PUPPET flag
PUPPET    @set <object> = puppet. Causes an object to grow eyes and ears,
and relay all it sees and hears to its owner.  
& ROOM
ROOM     This flag is automatically set on rooms when you @dig a new
room. It cannot be changed. 
& VISIBLE 
VISIBLE   When set on your object, it allows other players to examine it and
see all the object's attributes as if they owned the object. They cannot make
any changes to the object.
& SLAVE
SLAVE     When set on a player, it disables him from doing anything
except to pose. He cannot talk, page, build, get or drop objects. Only
MicroMUSE Officials have been empowered to set this flag.
& STICKY
STICKY    If a thing is STICKY, it goes home when dropped (See Homes). If a
room is STICKY, its drop-to is delayed until the last person leaves (See
DROP-TOs). Only meaningful for things and rooms.  
& TEMPLE
TEMPLE    If a room is TEMPLE, you can sacrifice things for Credits by
dropping them there. It has no meaning for players, things, or exits.
Only Directors can set this flag.  
& TRANSPARENT
TRANSPARENT	If an exit is TRANSPARENT, then when you look at it you
will see first its description; then you will look through it and see the
description and contents of the room on the other side.
& TERSE
TERSE     If a player has the TERSE flag set, room descriptions will not
be displayed when they enter a new room. Contents and Exits will still
be displayed. This is good when you wish to move about quickly, or do
not bother to read room descriptions. Beware: You might miss some
important information in some room descriptions.  If an object is set terse,
it will not 'shake and crumble' when it is destroyed.
& X_OK
X_OK   If an object is X_OK, it can be sacrificed. Warning: if
an object is sacrificed, it is destroyed. See sacrificing.
& Officials
OFFICIALS  Players who are OFFICIALS have additional powers which enable
them to manage the MUSE. See also ADMINISTRATORS and DIRECTORS, and @class.
& Goals
Goals.  There is no ultimate goal to this game, any more than there is in
life. This is a virtual society, and, just as in any other small society,
there is a wide range of opportunities.  There are objects and places
to examine, puzzles to solve, scenery to visit, and people to meet. You may
build private or public additions to the world.  There are no winners or
losers, only fellow players. Enjoy.  
& Here
Here.     The word 'here' refers to the room you are in. For example, to
rename the room  you're in (if you control it), you could enter
"@name here=<new name>". 
& Homes
Homes.    Every thing or player has a home. This is where things go when
sacrificed, players when they go home, or things with the STICKY flag set go
when dropped (See STICKY). Homes are set with the @link command. You may set
your home to any room that has the LINK_OK flag set.  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 their inventory)
by "@link <exit-name>=home".  Drop-tos can also be set to 'home'.
See also DROP-TO and @link.
& It
It.        The last object matched is remembered in the 'IT' attribute.
The next command may refer to IT or may use get(<object>/It) to retrieve
the value of 'IT' from another object
& Linking
Linking.  You can link to a room if you control it, or if it is set LINK_OK.
Being able to link means you can set the homes of objects or yourself to that
room (if it is LINK_OK). See LINK_OK, Homes, and @link.  
& Me
Me.   The word 'me' refers to yourself. Some things to do when starting out:
1) give yourself a description with "@describe me=<description>", then look
at yourself with "look me". 2) set your gender, if you wish it known, with
"@set me=male" or "@set me=female" (or "@set me=neuter" to be an 'it').  
& Currency
Currency.    MicroMUSE works on a Credit and Debit system, meaning there is
no tangible forms of currency. Building and some actions cost money.

How to get money: You receive a daily allowance of 250 credits on days
 you connect.  You may also borrow money from the bank, or request loans
 or gifts from other players, or you may sell objects you create. Directors
 and Administrators may also be approached regarding subsidies for useful
 building projects.

See Costs and Sacrificing.
& Pronouns
You may use special pronoun-substitution characters inside messages you
create on @osucc, @ofail (etc.) registers, as well as on commands you
program on @v*-registers. The following character combinations will provide
substitution when the object triggering the message or command has its sex
set to male or female:

	%s - 'he' or 'she'   (subjective pronoun)
	%S - 'He' or 'She'
	%o - 'him' or 'her'  (objective pronoun)
	%O - 'Him' or 'Her'
	%p - 'his' or 'her'  (possessive pronoun)
	%P - 'His' or 'Her'

If the object has no sex set, the object's name will be used instead. In the
case of the possessive pronoun, the object's name will be used and a trailing
apostrophe + s will be added.

	%n or %N will substitute the player's or object's exact name.
	%# will substitute the player's or objects' dbref number.

The other pronouns (you, I ,we, etc.) are not currently available.  If you
have a use for them, speak with a Director.  See also Substitutions.

& Puppets
Puppets.  An object is made into a puppet by doing @set [object]=puppet,
once an object is a puppet it will relay all that it sees and hears to its
master.  All objects created by a puppet are owned by its master, when
puppets spend or earn Credits they are also taken from and given to its
master. In order to prevent puppets from screwing up puzzles, objects may
have the key flag set, this will prevent puppets from picking the object up.
A puppet may be commanded by its master by:  @force [object]=command
or shorthand version:
[name/# of puppet] command
Example:       
@force fred="hi there. or     
fred "hi there. or       
#4342 "hi there.  
& Sacrificing
Sacrificing an object gives you the value of an object. You can't sacrifice
something you own. If you have >= 10000 Credits, all sacrifices are worth
only 1 Credit. The sacrifice value of a thing is set at creation by
"@create frob=cost", by the formula value=(cost/5)-1. Only a Director can
change the value of an object, once created.  There is currently no temple
on MicroMuse, so there is nowhere to sacrifice objects.
& Strings
Strings.  Objects can have many strings stored on them, in various
registers.  The seven most important are: 1) A Name. 2) A Description.
3) A Success message (seen by the player). 4) A Fail message (seen by the
player). 5) An OSuccess message (seen by others). 6) An OFail message (seen
by others).   7) An Odesc message (seen by others).
& Substitutions
Substitutions.  Apart from Pronoun substitutions (see 'Pronouns'), the
following %-substitutions are available:

%N or %n	the enactor's name.
%# 		the enactor's dbref.
%va - %vz	the value of register va (etc.), like [get(me/va)]
%/attr/		the value of arbitrary register <attr>, like [get(me/attr)]
%/thing/attr/	the value of register <attr> on object <thing>, where <thing>
	        is a db number.

& Success
Success.  You successfully use an object when you take it. You use an exit
successfully  when you go through it. You successfully use a room when you
look around. See  STRINGS, @SUCCESS and @OSUCCESS. 
& Types of objects
Types of objects.   There are 4 types of objects: things, players, exits, and
rooms. The first  letter following an object's ID number indicates the type:
P(layer), E(xit),  R(oom), otherwise, thing. Things are inanimate objects that
can be carried.  Players are animate objects that can move and carry. Exits
are the means by which objects move. Rooms are locations that contain objects
and linked exits. Things can be programmed using V-Registers so that they
perform useful and interesting behaviors.
& V-Registers
V Registers are the main technology for programming Muse objects.  Each object
has 26 V Registers, named VA, VB, ..., VZ.  Each V Register can hold a number,
a character string, or an executable command.  See the help entry for @v* for
more details on programming the V Registers.
& DIRECTORS
The Engineers/Directors of this MUSE are:

   Jin, Michael, Ender, Erk, Moulton, Koosh, Priam_Agrivar, and Aslan.

They have the special powers to tweak virtual reality in ways mortals can
only dream of.
& ADMINISTRATORS
Our Guides are all Public Relations personnel, and are always willing to
help you.  Check the WHO list to see which guides are connected.  Our
guides include:
	Ezmeralda, Tom_Yakazu, Aries, Static, Gandalf, Zeus, Dodger

The Officials, and Administrators are the co-planners of the future of
this MUSE.  They also help with Public Relations.  They include:
	Laura, George_Cohan, Spark, M'rlin, Calliope, Kaneda, Sword,
	Virgil, and Calvin.

& wizards
The term 'wizard' is a holdover from the past, and refers to those people
known here as Directors, Administrators, Constructors, and Officials.

& Enactor
The enactor is the thing that is doing something.  If one of your Objects
does something (through a @force or @trigger) it is the enactor.  If one of
your links or rooms does something (through a @ASucc, @AFail or @AEnter) then
YOU are the enactor and the action happens as if you typed it in directly. 
To determine the enactor create an object to listen for the action with
@ahear = :[v(N)].
& Stack
V(0) through V(9) are the ten items on the stack.  Stack values can be set by
either parameters after an @trigger or asterisk substition in pattern matching.
Example: @listen item=* foo *; @ahear item=: [v(1)] bar [v(0)].
& @switch
@switch argument={pattern1},{yes-commands},{no-commands}
@switch argument={pattern1},{yes-cmds},{pattern2},{yes-cmds}...,{default-cmds}

The @switch is the general for/while/until/if part of MUSE.

Example: @switch rand(2)={0},{say it's 0!},{say it's not.}

& @trigger 
@trigger can pass control and data (on the stack) between or within items.
Example: @va item=@trigger me/vb=[v(0)]; @vb item = :[v(0)];
@trigger item/va=foo.
& Verbs
For most verbs there are three forms: Verb (what the Enactor sees), OVerb
(what others in the area see) and AVerb (the action to be taken when the
event happens). Example: @Drop, @ODrop and @ADrop
& @sweep
@sweep gives you alist of all objects/players 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 and puppets since they will hear everything you say
and do.

& Getting started
Some commands to start with:

   QUIT - quit and leave MicroMUSE
   WHO  - print list of users currently on MicroMUSE
   help - access online help
   news - access online news about MicroMUSE events and topics

   say <something> - make your character 'say' <something>
	Example: say Hi Everyone!
   page <player>=<message> - send a <message> to a <player> on the muse
	Example: page Jin=Hello, Can you help me?
   look  - look at the room you're in, or at a person or object in it.
	Examples: look
		  look Tourbot
   go <exit> - go through one of the obvious exits in the room.
	Example: go out

& Timezones
Timezones         This feature coverts Muse Standard Time to your preferred
                  Time Zone.  All times are now stored internally as a single
                  integer representing the exact number of seconds since a
                  fixed long-ago date.  When you run a command that involves
                  time, such as +laston, +uptime, or the time() and xtime()
                  functions, the Muse checks your @tz setting to determine
                  what time to print out to you.  See @tz for more details.
                  The Default timezone for this muse is U.S. Eastern Time.

& TinyTalk
                 TinyTalk, V1.1.7 by Anton Rang

  TinyTalk is an interface to the TinyMUD/MUSE system.  It replaces telnet,
and adds many new features.  Its features include:

  * TinyTalk can wrap words at the end of a line.
  * TinyTalk can automatically log into your characters.
  * TinyTalk can record a TinyMUD session to a file.
  * TinyTalk keeps your typing and TinyMUD output from being
    intermingled.
  * TinyTalk allows input lines to be up to 512 characters long.
    This allows long descriptions to be entered.
  * TinyTalk supports simple macros.
  * TinyTalk supports "portals", special exits which connect between
    the various TinyMUD systems.  There are also commands which allow
    manually switching systems.
  * TinyTalk can hilite pages and whispers, on terminals which support
    boldface or inverse characters.

Tinytalk may be ftped from:

jaguar.cs.wisc.edu (128.105.1.202) in ~/ftp/pub/tinytalk
michael.ai.mit.edu (18.43.0.177) in ~/tinymuse
groan.berkeley.edu (?) in /pub/mud_clients
Power users may prefer the more elaborate client, TinyFugue.
& version
See +version.
& +version
+version	This command gives you the current version number for
the code being run on MicroMUSE. It also tells you when the last code
update was done.
& mail
See +mail.
& +mail
+mail...The online mail system.

MicroMUSE has an online mail system. The commands are as follows:

+mail                           Check your mailbox for messages.
+mail <player> = <Message>      Send a message to another player.
+mail <n>                       Read message <n>.
+mail clear                     Clear all messages from your mailbox.
& idle
See +idle.
& +idle
Message sent to players who page you when you are connected.
+idle <Message>                 Set your idle message.
+idle ?                         View your idle message.
+idle                           Remove your idle message.
& away
See +away.
& +away
Message sent to players who page you when you are not connected.
+away <Message>                 Set your away message.
+away ?                         View your away message.
+away                           Remove your away message.
& +haven
Message set to players who page you when you are set haven.
+haven <Message>                Set your haven message.
+haven ?                        View your haven message.
+haven                          Remove your haven message.
& laston
See +laston.
& +laston
+laston <player>                Find out the last time <player> was connected.
& +channel
+channel  Select or lists channels for the online communicator system.
The new +com communicator system supports an arbitrary number of named
channels.  Players who are working as a group can make up a channel name
for their group and add it to the list of channels which their +com is
listening to.

Usage:
  +channel +<channel-name>    Adds the named channel to those being scanned.
  +channel -<channel-name>    Deletes the named channel from the list.
  +channel                    Lists the current channels on your +com.
 
For a general chatting channel, turn to channel 'public'.
You can listen to as many simultanous channels as you wish.
See help on +com.
& +com
The +com system works like Citizen's Band radio.  

Usage:
  +com <channel-name> = <message>   Transmit <message> on the named channel.
  +com <channel-name> = who         Find out who is listening on the channel.

Shortcut:
   To broadcast over your default channel, which is defined as the last
   channel you added with the +channel command, use the '=' symbol.
   For most people who have not added additional channels, 'public' is
   the default channel.  If you later add an additional channel and you
   wish to keep 'public' as your default, you may remove it and add it back.

Example:

=hello		Transmits 'hello' over the default channel
=who		Find out who is listening on the default channel

See help on +channel for selecting the channels on your personal +com.
To leave a message with someone who is not online, use the +mail command.
Sending a +com message costs 1C.
& +uptime
+uptime         This command gives you MicroMUSE's current runtime statistics.
& @huhto
@huhto <player> [=<E-Mail-Address>].  This command may only be issued by
a Director.  It initiates or terminates the automatic logging of failed
commands attempted by players in rooms owned by <player>.  The log is
periodically mailed to the specified E-Mail-Address.  The use of HuhLogs
enables a Builder to improve the choice of exit-names and trigger verbs
in the Builder's realm to better respond to commands most frequently
attempted by visitors.
& @empower
@empower <object/player>=<powername>:{Yes,No,YesEQ,YesLT}.  Only Directors
may invoke this command, which alters the authorized powers of <object> or
<player>.  Yes and No unconditionally enable/disable the named power. YesEQ
and YesLT enable the named power to be used on objects or players of equal
or lesser status than <object/player>, respectively. Powers adjusted in this
way may not be elevated above the maximum allowed powers for each class of
player or object. See also @powers and @class.
& @giveto
@giveto <player> = <amount>.  Quietly gives <amount> of credits to <player>
without generating the usual messages associated with the regular 'give'
command.  See also 'give'.
& @powers
@powers <player/thing>.  Lists the authorized powers of <player> or <thing>.
See all @empower.
& @chownall
@chownall <player> = <newowner>.  Only a Director can issue this command.
All the possessions of <player> are @chowned to <newowner>.

& @aahear
@aahear <object> = <actions>.  @aahear works the same as @ahear (q.v.),
but the <actions> will be trigger if the @listn (q.v.) is matched by a
pose or utterance enacted by either the object itself or by another player
or object.  See also @amhear.
& @aclone
@aclone <object> = <actions>.  Sets the actions to be taken when <object>
is cloned (see @clone).  The actions are performed by the newly cloned
copy, not by the original.
& @adrop
@adrop <object> = <actions>.  Sets the actions to be taken by <object> when
it is dropped.
& @aenter
@aenter <room/object/player> = <actions>.  Sets the actions to be taken by
<room>, <object> or <player> when it is entered (see enter) by another
player or object.
& @aleave
@aleave <room/object> = <actions>.  Sets the actions to be taken by <room>
or <object> when a player or other object leaves.
& @amhear
@amhear <object> = <actions>.  @amhear works the same as @ahear (q.v.),
but the actions will be trigger only if the @listen (q.v.) is matched by
a pose or utterance enacted by the object itself.  See also @aahear.
& @edit
@edit <object>/<attr> = {oldstring},{newstring}.  <Object> can be a thing,
player, exit, or room; <attr> can be any attribute on <object> that holds
a string value (e.g. desc, succ, adrop, listen, ahear, va, vb, etc.).  The
first occurrence of oldstring is replaced by newstring.  If the strings
contain only alphabetic characters, the curly braces may be omitted.
& @enter
@enter <object> [=<message].  Sets the message which a player sees upon
entering <object>.  See 'enter'.
& @leave
@leave <object> [=<message>].  Sets the message which a player sees upon
leaving an object.  See also leave, @oleave and @aleave.
& @oenter
@oenter <object> [=<message>].  The @oenter message, prefixed by the
player's name, is shown to others when a player enters <object>.  See
also enter, @enter, and @aenter.
& @oleave
@oleave <object> [=<message>].  The @oleave message, prefixed by the player's
name, is shown to others when the player leaves <object>.  See also leave,
@leave, and @aleave.

& inventory
inventory. Lists what you are carrying. Can be abbreviated by just 'i'. 
& enter
enter <object>.  Go inside of an Enter_OK object.  See also 'leave'.
& leave
leave.  Leave the object you are currently inside of.
& money
money.    This command will give you your current credits as well as the
total value of all of your assest. Thus, your total worth.
& home
home.     This command will send you back to your place of origin as
contained in your 'HOME' attribute.  See 'goto'.
& @poor
@poor.    This resests all players credits to 0.  Be careful.
& @quota
@quota <me>.  This will give you your current and remaining quota.
@quota *<player>=<value>.  Will reset <players> quota to <value>. This is
a director command only.
& @dbtop
@dbtop <item>. This will give you to top list for <item> in the database.
Do '@dbtop' to see what <items> are available to list. This is a db search.
& @allquota
@allquota.   This lists the total quota for the enitire Muse.
& @dump
@dump.  This command will dump the database for storage. It is vital to the
continued survial to the Muse. An object is usually set up to do this
automaticly every few minutes.
& @wipeout
@wipeout <player>.   This command will destroy all posetions of <player>.
Use with caution.
& @pbreak
@pbreak.   This will give a list of the player broken-down into classes.
It is currently an Administrator command only.
& @dbck
@dbck.  This lists disconnected rooms and clears the free list.
& @does
@does <object>=<actions>.  The @does atrribute works like a v-register,
however, it will remove a charge on the object (if any) when triggered.
& @v*
@v<a-z> <object>=<actions>.  This command sets any v-register on an object
as specified. There are 26 registers VA-VZ.   Anything may be stored on a
v-register.  If a @v-register contains a semicolon-separated list of
actions, e.g. @va object = action1;action2;action3, then these actions will
be executed in order when @va is triggered (see @trigger).

V-Registers are built in, but users may define additional attributes with
arbitrary names.  See @defattr.

V-Registers may also be used to create new commands and to listen for strings.
See help under '$ events' and '! events' for details.

See 'V-Registers', 'V function' and @trigger, and see the courses in the
University (Section 1, Arc 0) or the MUSE manual for more information on
programming objects.

& @halt
@halt <object>.  This will stop a process or a runaway machine. To stop
one particular object, use '@force object=@halt'.
& @zlink
@zlink <room>=<object>.  This command will link the <room> into the zone
represented by the <object>. See Zones.
& @unzlink
@unzlink <room>.  This command resets the zone of the specified <room> to
the Universal Zone, removing any previously defined zone. See Zones, @zlink. 
&HuhLog
To obtain a list of the unrecognized commands players type in your rooms,
contact your local administrator or director.  These logs can be used to
fix misleading or incomplete descriptions in your rooms.

&rand function
rand(num)   	a number between 0 and num-1

& xtime function

Given an ASCII time string, returns a timezone-independent x-value.
This function is the inverse of the time() function.

xtime() --     xtime() returns the timezone independent X-value
               for the current time.  This X-value may later be converted to
               any timezone using the time() function.  For a discussion of
               X-values, see the help entry above for the time() function.


xtime(s) --    xtime(s) converts an ascii string `s' (without the
               quotes) into an X-value.  Xtime() has been written to analyze
               and interpret a variety of string representations of the time.
               If it won't recognize a particular specification, please advise
               us at MicroMUSE and we will try to increase its flexibility.

               It is important to realize that an ascii string representation
               of the time must be in `some' timezone.  This timezone must be
               known during the time of conversion in order to calculate the
               timezone independent X-value.  The following rules will be used
               to determine the best guess at the timezone for the string `s'.

               A) If the string `s' contains a timezone specification such
	        as `gmt', `edt', `est', `cdt', `cst', `mdt', `mst',
	        `pdt', or `pst', that timezone will be assumed during
	         conversion.
	       B) If A) fails, and the calling object has a TZ value set,
	          that value will specify the timezone.
	       C) If A) and B) fail, and the owner of the calling object has
	          a TZ value set, it will specify the timezone.
	       D) if A), B) and C) all fail, then the muse default timezone
	          will be used.  For MicroMUSE this is the eastern timezone.

xtime(s,tz) -- Same as above, but with the timezone set explicitly as 'tz'.

See also time(), @tz, Timezones.

&time function
time()		Returns the current system time and date, in an alphanumeric
                format; the exact value returned depends on your @tz
                setting.  The default is U.S. Eastern Time.  time() first
                checks the @tz value on the object calling time(), and if
                none is present it next checks the @tz value of the
                object's owner.

time(tz)        Returns the current system time and date, using 'tz' as the
                timezone value. 'tz' should represent a number of hours before
                or after GMT and can include an optional ':Y' or ':N' suffix
		which indicates if U.S. style daylights savings time is to
		be taken into consideration.  'tz' can also be the special
                value 'D' which means that the object's default timezone is
                to be used. time(D) returns the same value as time().

time(tz,x)      Returns the time and date represented by the long integer 'x'
                in timezone 'tz', where 'tz' is as above and 'x' is the
                timezone-independent internal representation of the time,
                expressed as the exact number of seconds since some fixed date
                long ago.  time(D,x) returns the time represented by 'x'
                while using the object's default timezone.

		See also xtime(), @tz, Timezones.

&get function
get(obj,attr)
get(obj/attr)	These two formats are equivalent and each returns the
		value of the 'attr' attribute on object 'obj'.

	Examples:

		@sex me = neuter
		get(me/sex) then returns the string 'neuter'.

		get(#123,va) returns the value of 'va' on object #123.

&mid function
mid(str,startchar,howmany)
    	    	returns 'howmany' characters from str starting at the
		startchar'th character.  (i.e. mid(hithere,2,3) returns the)
		characters are numbered starting at 0.
&add function
add(a,b)    	a+b
&mul function
mul(a,b)	a*b
&div function
div(a,b)	a div b  (Integer division with no remainder)
&mod function
mod(a,b)	a mod b  (The remainder after integer division)
&first function
first(str)	the first word of str
&rest function
rest(str)	everything *BUT* the first word of str
&comp function
comp(n,m)	returns 0 if n = m, -1 if n < m, 1 if n > m.  The
		comparison is numeric only. Alphabetic strings are
		treated as equal to 0.
&scomp function
scomp(str1,str2)
		returns 0 if str1 = str2, -1 if str1 < str2, 1 if
		str1 > str2.  For the purposes of comparison ascii
		values of characters are used, and str1 is less than
		str2 if it occurs earlier alphabetically.

	Examples:

		scomp(a,b) = -1
		scomp(abc,aba) = 1
		scomp(abc,abcd) = -1
		scomp(A,a) = -1
		scomp(a,A) = 1
	
&strlen function
strlen(str)	number of characters in str
&quota function
quota(player)	returns the quota of player
&quota_left function
quota_left(p)	returns the balance of unused quota for player p.
&credits function
credits(player)	returns the number of credits belonging to player
&V Function
The V function has many forms: v(N) {The enactor}, v(#) {the number of the
enactor}, v(vq) {@VQ of the current object}, v(0) {The top item on the stack},
etc. Example, try: :[v(N)]

v(s)		
		v(i) (i in 0..9) returns %i  (i.e. v(0) == %0) 
		v(va) returns me/va (the object's va field.)
		v(#) returns the object # of whoever caused this action.
		v(n) returns the object name of whoever caused this action.
		v(!) returns the object # of the object calling v().
		v(attr) returns the value of the attr attribute (me/attr).
		Play around with this function.  It's quite powerful.

See also Pronouns, Substitutions.

&s function
s(str)		does pronoun substitution on str.
&num function
num(obj)    	obj. # of obj.
&con function
con(obj)    	first thing in the contents list of obj. 
                See also 'next function'.
&exit function
exit(obj)   	first exit in a room. (i.e. exit(here) -> first exit )
		exit() on a thing returns its home. See also 'next function'.
&next function
next(obj)   	next thing in a list. (i.e. next(exit(here)) -> second exit)
&link function
link(obj)	destination of an exit; home of a player or object; dropto
		of a room.
&loc function
loc(obj)    	location of obj. (Room #)
&owner function
owner(obj)    	number of the owner of obj.
&name function
name(obj)	name of obj. (obj is probably #<obj. num.>)
&match function
match(s1,s2)	returns 1 if s1 matches s2, 0 otherwise.  s1 is a character
		string, and s2 is a string which may contain wildcards.

&pos function
pos(str1,str2)	returns the position in str2 where str1 first appears.
&extract function
extract(str,wordnum,howmany)
    	    	returns the string from str starting at word number wordnum
		and containing 'howmany' words.
		(i.e. extract(four score and seven years,2,3) returns
		score and seven.)  extract(str,1,1) == first(str).
		Words are numbered starting at 1.
&remove function
remove(str,wordnum,howmany)
		return the remainder of string 'str' after removing 'howmany'
		words starting at wordnum.
		(i.e. remove(four score and seven years,2,3) returns
		'four years'.) Words are numbered starting at 1.
&delete function
delete(str,charnum,howmany)
		returns the remainder of string 'str' after deleting 'howmamy'
		characters starting at charnum. Characters are numbered
		starting at 0.  (i.e. delete(abcdef,2,3) returns 'abf'.)
&flags function
flags(obj)  	Returns a string consisting of the current flags on obj.
&class function
class(player)   Returns the class of a player.
&zone function
zone(obj)       If obj is a room, returns the db # of the room's zone. If
                obj is an exit, thing, or player, returns the db # of the
                room the obj is in.  The function checks for objects inside
                other objects and traces all the way back to a room before
                returning a zone #.
&wmatch function
wmatch(str,arg)  Takes a string of words/numbers (str) separated by spaces,
                 and locates the position of the argument (arg). The function
                 returns a value of '0' if the argument is not in the string.
                 For example: "wmatch(blee foo garb fargle,foo)" will return a
                 value of '2'.  The wmatch() function is not case sensitive.
&@efail
A fail message shown to a player who fails to enter an object.
&@oefail
A fail message shown to others in the room if a player fails to enter an
object.
&@aefail
A list of actions performed when someone fails to enter an object.
&Privacy

This help topic attempts to explain to what extent your communications
with other users on the Muse are kept private.  Reading this section
will give you a better understanding of how 'safe' your privacy is.

  1) When you speak normally, using the 'say' command, you are heard by
     every object in the room that is 'listening'.  To determine who and
     what is listening, the user may use the @sweep command.  You may
     see objects 'listening' that listen only for a particular command,
     but unless you own the object you cannot know for certain whether an
     object in the @sweep list is listening to everything you say.

  2) This Muse does not record ordinary speech, pages, or whispers within
     its log files or any other fashion. If nobody in the room is listening, 
     there is no way for anybody outside the room to know what you are doing.
     The only exception to this rule is that, for debugging purposes, we
     may occasionally log the last few commands executed just before a system
     crash, but never more than that.  Even in such cases, commands executed
     more than one minute before the crash will never be logged.

  3) Things said with the 'whisper' and 'page' command, when these are used
     correctly, are heard only by the player to whom they are addressed. No
     other user or object can hear them.

  4) Things broadcast over the +com channels are heard by everyone on the
     channel. Read the online help to learn how to tell who is on the channel.

  5) Any user may use the @whereis command to determine the location
     of another user.  If you do not wish to be located, you may use
     the command '@set me=dark' to prevent other users from locating you.
     When you use the @whereis command, the other user receives a message
     to the effect that you are finding out where they are.

  6) Any user may use the @hide command to remove their name from the WHO
     listing.  There is a charge for this each time you use it.  To restore
     your name on the list, use the @unhide command. You are also unhidden
     automatically each time you reconnect to the Muse.

  7) Users may use the command '@set me=Haven' if they do not wish to
     receive pages, and '@set me=No' if they do not wish to hear public
     announcements.

This topic is long. If you missed any of it and do not have a scrollback
option, try setting '/more on' in tinyfugue and reading it page by page.

& Zones

Every room in MicroMUSE is in a Zone.  The Zone of a room (returned by the
zone() function and also visible when a room you own is examined) is an
object, referred to hereafter as the zone object or ZO.  Any object may
be used as a zone object, although (as will become clear later) it is unwise
for the zone of a room to be an object that is being used for any purpose
other that simply as a ZO.  A room's zone is changed with the @zlink and
@unzlink commands (see the help pages on those commands) and referenced with
the zone function (help is available for that as well).  All rooms whose zone
has not been set are in the Universal Zone (UZ), defined by a UZ object (on
MicroMUSE, the UZ is an object named Micro Zone).

The zone object of a room affects access to the room, commands available in
the room, and messages heard in the room.

Access to a room:  If Zone1 and Zone2 are zone objects, and Room1 is in Zone1
and Room2 is in Zone2, then players may walk from Room1 into Room2 (assuming
the exit is not locked against them) only if Zone2 is not locked against the
player, and also not locked against Zone1.  A player may teleport from
Room1 to Room2 (assuming Room2 is set Abode) only if object Zone2 is enter_ok.
Zone objects do not affect walking or teleporting between rooms in the same
zone.  When access is permitted or denied, the @succ, @osucc, @asucc, @fail,
@ofail, @afail (for walking attempts) or @enter, @oenter, @aenter, @efail,
@oefail, @aefail (for teleportation attempts) on the ZO are triggered.

Since a zone object must be unlocked to permit access, it is wise to keep
zone objects safe inside a locked box or room to which others have no access.

Commands in a room:  V-register commands on a zone object are accessible from
any room in the zone, as if a separate copy of the zone object were present
in each room.  However, any actions performed by the ZO are performed from
its actual location.  Thus, for instance, @emit's will not be heard in the
room in which the command is typed; @remit-to-the-room should be used instead.
Zone Objects can also listen if the listen is set, and the @ahear will be
triggered if the listen pattern is matched.

Messages heard:  Apart from the usual ways of sending messages to a room,
a message may also be sent to every room in a zone by @zemit-ting a message
to the Zone Object.  See @zemit.

& @foreach

Syntax: @foreach <list>=<command>

Executes <command> (which may be a semicolon-separated list of commands)
once for each item in <list> (whose elements are separated by spaces).
If a %0 occurs in the command, @foreach will substitute for %0 each element
of the list, in order, while iterating.

Example: typing
	@foreach m i c r o m u s e="gimmie a %0!
will case you to say "gimmie a m", "gimmie a i", etc.

Since the '%0' is evaluated each time the command passes through the command
queue, you will need several %'s if the %0 is embedded in function calls.
If you're having trouble, ask other folks for help.

& @entrances

@entrances <obj>
will show you a list of all the entrances into a room or object.  You
must control the room or object to use the command.

& entrances function

entrances(<object>) is a function analogous to @entrances, (actually,
@entrances uses entrances(), and was implemented as a command on the
universal zone object). It returns a list of exits leading into <object>,
in a format suitable for use by @foreach (that is, space-separated dbrefs).

& objlist function

objlist(<object>) returns a list of space-separated dbrefs of the list
of objects beginning with <object>.  It is analagous to using the 'next'
function repeatedly on an object and return the list of results.

The two most common ways to use this function are in conjunction with con()
or exit().  Here are some examples:

	@foreach objlist(con(here))=say %0 is here!

this will cause you to tell about all objects that are in the current room

	@foreach objlist(exit(here))=say %0 is a way out!

this will go through all exits leading out of the current room, and cause
you to tell people that they can get out through them.

& @ulink

@ulink <object>

This is a GOD-only command that changes the Universal Zone object to
<object>.  it affects the zones of all rooms currently in the Universal
Zone, or with no Zone set.  See Zones, @zlink, @unzlink

& @undestroy

@undestroy <object>

If an object is scheduled for destruction, this stops the process. It
unsets the GOING flag and removes the @doomsday attribute.  See also
@destroy, @protect, @unprotect.

& @protect

@protect <object>

Sets the @doomsday attribute on the object to -1, keeping the object
from being destroyed with @destroy.  To destroy the object, it must first
be @unprotected.

If you @protect an object that is scheduled for destruction, it will be
spared, but the GOING flag will take a few minutes to go away.

& @unprotect

Removes the @doomsday attribute on the object, allowing it to be destroyed
with @destroy.

& @remit

@remit <object> = <message>

Emits <message> to the contents of <object>.  <object> is generally a room.
This command supersedes @pemit <room> = <message>, which is now obsolete,
although it will continue to work for a while.  See @pemit, @zemit.

& @zemit <object> = <message>

Emits <message> to every object in every room in the zone <object>.  If
<object> is not a zone object, nothing will happen.  This command
supersedes @pemit <zone object> = message, which will emit only to
the zone object and not to the rooms in the zone.  See @pemit, @remit.

& @doomsday

The @doomsday attribute is set by @destroy, @undestroy, @protect, and
@unprotect.  In general, it is a time in xtime() format, specifying
the system time before which an object should not be destroyed.  Objects
with the GOING flag set will be destroyed during the first @dbck after
the time given.  If @doomsday is set to -1, the object is protected.
If an object winds up with a @doomsday value but no GOING flag, it cannot
be destroyed and must be @unprotected first.  Only Administrators may
set the doomsday attribute directly.
& land function
land(a,b)	Logical AND of a,b
& lor function
lor(a,b)	Logical OR of a,b
& lxor function
lxor(a,b)	Logical XOR of a,b
& lnot function
lnot(a)		Logical NOT of a
& band function
band(a,b)	Bitwise AND of a,b (signed decimal integers)
& bor function
bor(a,b)	Bitwise OR of a,b (signed decimal integers)
& bxor function
bxor(a,b)	Bitwise XOR of a,b (signed decimal integers)
& bnot function
bnot(a)		Bitwise NOT of a (signed decimal integers)
& sgn function
sgn(a)		1 if a>0, -1 if a<0, 0 if a=0.
& truth function
truth(a)	Returns 0 on the empty string, the number 0, and dbref #-1.
		Returns 1 otherwise.
& abs function
abs(a)		Absolute value of a.
& base function
base(num,oldbase,newbase)
		Converts 'num' from oldbase to newbase.  Bases must be
		between 2 and 36.  Digits in 'num' must be in range of
		the oldbase.  Digits above 9 are 'a'(=10) through 'z'(=35),
		or 'A' through 'Z'.

	Examples:
		base(14,10,2) = 1110
		base(aa,16,10) = 170

& inzone function
inzone(zone)	Returns the list of rooms @zlinked to 'zone'.
& sqrt function
sqrt(number)	Returns the square root of 'number', rounded down to the
		nearest integer.  If number is negative, returns the square
		root of its absolute value.

& @poof
@poof object
The @poof command teleports the object into itself, and then destroys it (if
possible).  Has the effect of making an object disappear from the scene
immediately, even though it is not in fact destroyed for several more minutes.
& @getalias
@getalias User
Tells you the user's alias, if any.

& fadd function
fadd(n1,n2)	Returns n1+n2 where n1 and n2 are floating point numbers.
& fsub function
fsub(n1,n2)	Returns n1-n2, where n1 and n2 are floating point numbers.
& fmul function
fmul(n1,n2)	Returns n1*n2 where n1 and n2 are floating point numbers.
& fdiv function
fdiv(n1,n2)	Returns n1/n2, where n1 and n2 are floating point numbers.
& sin function
sin(num)	Returns the sine of num.
& cos function
cos(num)	Returns the cosine of num.
& tan function
tan(num)	Returns the tangent of num.
& arcsin function
arcsin(num)	Returns the arcsine of num.
& arccos function
arccos(num)	Returns the arccosine of num.
& arctan function
arctan(num)	Returns the arctangent of num.
& sub function
sub(n1,n2)	Returns n1-n2 where n1 and n2 are integers.
& log function
log(num)	Returns the logarithm base 10 of num.
& ln function
ln(num)		Returns the natural log of num.
& exp function
exp(num)	Returns num raised to the power of 'e' (reverse ln).
& pow function
pow(n1,n2)	Returns n1 raised to the n2'th power, where n1 and n2 are
		floating point numbers.
& BEARING flag
BEARING.    When set on any MUSE object, allows people to @addparent or
@delparent objects they control to or from the object with the BEARING flag
set.  If BEARING is not set, the object can neither bear new children nor
lose old ones.  See @addparent, @delparent.

& parents function
parents(object)		Returns a space-separated list of the parents of
			object, in a format suitable for @foreach.
& children function
children(object)	Returns a space-separated list of the children of
			object, in a format suitable for @foreach.

& objmem function
objmem(object)		Returns the number of bytes used by the object.

& playmem function
playmem(player)		Returns the total number of bytes used by all the
			objects owned by the player.
& @defattr
@defattr <object>/<attr> [=option1 option2 ...]

The @defattr command allows you to create user-defined attributes on objects,
and to specify with options how the attribute will behave.

This command creates a new attribute with name <attr> on <object>, with
options 'option1', 'option2', etc., if any are specified.  The attribute
can be set using @set <object>=<attr>:value, or with the usual shorthand
@<attr> <object>=value.  (See @set).  See the help on Attributes and on
Inheritance for a detailed discussion of this topic. See 'help option list'
for a list of options that an attribute may have.

Example:  @defattr Book/title=osee
          @title Book=Muse Tutorial

[get(book/title)] now returns "Muse Tutorial", and anybody examining
the book will see the 'title' attribute because it was defined 'osee'.

@defattr can also be used to change the options on a previously defined
attribute. Simply use the same syntax as above, but with the new list
of options, and the options will be changed. @undefattr removes an attribute.

See also: Option List, Attributes, @undefattr

& @undefattr
@undefattr <object>/<attr>

The @undefattr command removes an attribute definition from an object,
if it was set with @defattr.  the object has descendents that use the
attribute, they will lose the definition and any stored values, so use
this command with great caution on any object that has children.

See also: @defattr

& @reparent
The reparent command has been replaced by @addparent and @delparent.
Help is available for both of those.

& @addparent

Syntax: @addparent <object>=<parent>

The @addparent command gives an object a new parent.  Objects may have
any number of parents.  In order to make <parent>  a parent of <object>,
<parent> either must be controlled by you, or must have the BEARING flag
set.  In any case, you must control <object>.

An object inherits attribute definitions from its parents. It also inherits
attribute values, if the attribute has the 'inherit' option set.  See
'help Inheritance' for more information on this topic. See also @delparent.

& @delparent

Syntax: @delparent <object>=<parent>

The @delparent command removes a parent from an object.  In order to remove
<parent> from <object>'s list of parents, <parent> either must be controlled
by you, or must have the BEARING flag set.  In any case, you must control
the <object>.  See also Inheritance, @addparent.

& Option List
User-Defined Attribute Option List:

  inherit
  wizard
  dark
  osee
  unsaved
  date
  lock
  function

You may get help for each one. For example, to get help on the inherit
option, type 'help inherit option'.

See also: @defattr

& function option
Attribute option: function
An attribute with the function option set can create a user-defined function
for the object. You may place any text, or simply another function in the
attribute, and will be activated whenever anyone tries the function. The
function must be defined on the object for the object to recall it. It
cannot be defined on another object in the room for it to work. However, if
a function is on a zone and has the inherit option set, all items within
that zone will be able to do that function.

Examples: @defattr blee/test=function inherit
	  @test blee=[mul(60,v(0))]
	  say [test(3)]  -would produce 180

	  @defattr blee/foo=function inherit
	  @foo blee=Everyone with [v(0)]: go to the [v(1)]!
	  say [foo(coats,closet)]  --'Everyone with coats: go to the closet!'

& wizard option
Attribute option: wizard
An attribute with the wizard option set can be @set only by the owner of the
object on which the attribute is defined, or by an Adminstrator. If <parent>
defines an attribute with an inheritable wizard option set, and <child> is a
child of parent, you may give <child> away -- even allowing a player to
@chown it -- and the new owner will not be able to reset the attribute. Some
built-in attributes, such as @race, have the wizard option set.

& inherit option
Attribute option: inherit
An attribute set 'inherit'able will pass its value down from parent to child.
The child may overwrite the value (unless the attribute has the wizard option
set as well) but if the child erases its value, the parent's value will
reappear.  

Most built-in attributes (succ, osucc, va, etc.) have the inherit option set.

& dark option
Attribute option: dark
A dark attribute is not visible in an 'examine' except on the object on
which the attribute is defined (not on its children) and only if you own
the object.  In any case, its value cannot be retrieved by the 'get' command.
This option has limited utility for most non-internal operations.

& osee option
Attribute option: osee
An attribute with the 'osee' option can be seen by anyone who examines
an object on which the attribute has a value, even if the object is not
set visible.  

Built-in osee attributes: last, sex, race.

& lock option
An attribute with the 'lock' option set is treated as a lock for the purposes
of 'examine';  all dbrefs are expanded to show names, and the value must
conform to lock syntax.  There is currently no meaning to a user-defined
lock attribute, except as a place to store values that can be copied into
built-in locks.

Built-in lock attributes: lock, elock, ulock.

& date option
Attribute option: date
A 'date' attribute acts like the 'last' field.  If a number in the style of
xtime() is stored in it, then anyone examining the object will see a date
and time, the exact date and time shown depending on the timezone
of the person examining the object.

Built-in 'date' attributes: last.

& unsaved option
Attribute option: unsaved
An 'unsaved' attribute, used for temporary data storage, will not keep 
its value when the muse is rebooted.  The value will disappear.  Internally,
the 'It' attribute is of this type.

& Attributes
Attributes are registers, attached to MUSE objects, in which you can store
data or commands.  There are built-in attributes, such as 'succ', 'osucc', 
'fail', 'ofail', etc.  These can be set on any muse object.  The @defattr
command can be used to define additional attributes on particular objects.
(See the help on @defattr for more information on creating attributes).
Those attributes can be set only on the object on which they are defined,
or on descendants of that object. (See Inheritance).  User-defined attributes
can be set and unset the same way built-in attributes are set: with the
@set command, or with the @<attribute> shorthand (see the help on @set).

If an attribute is defined on an object obj1, then you can also set that
attribute on children of obj1.  You do not need to (and in general should not)
use @defattr to define the attribute on the children as well.

If two attributes defined on different objects have the same name, they are
different attributes (much like local variables in all standard programming
languages).  If one object is a child of another with a similarly-named
attribute there is an overlap.  In such a case, the variables are considered
lexically scoped and an object can reference only the most local version.
(See Inheritance for more information on this topic).

& Inheritance
Inheritance Topic: Introduction.

Objects in the muse can be assigned a list of 'parents' with the @reparent
command.  The purpose of making one object a child of another is so that the
child object can inherit (1) attribute definitions, and (2) attribute values,
from its parent(s).  For this help section, examples will be crucial. Let
us therefore assume the existence of objects A, B, and C, and say that
object C has both A and B as parents.

Type 'help inheritance definitions' for topic (1).
Type 'help inheritance values' for topic (2).

See also help on @reparent, @defattr, and Attributes.

& Inheritance definitions

(1) Inheritance of attribute definitions:  If object A has on it a user-
defined attribute 'foo', then you can set a value for 'foo' on C with
the usual syntax, @foo C=value.  If both A and B define attributes
named 'foo', these are different attributes, and you can set either or
both of them on C separately.  By default, @foo C=value will reference
the attribute on whichever parent is defined first in C's parent list.
If C also defines an attribute 'foo', this is also a different attribute
from the one defined on A, and @foo C=value will set the local 'foo'
attribute.  In cases such as this, where one attribute shadows another with
the same name, you can refer to one of the other attributes by giving
its full name, which includes the number of the object on which it is
defined.  If A's number is #11 and C's is #22, you can type @set C=foo:val1
to set C's local 'foo' attribute, and @set C=#11.foo:val2 to set a value,
on object C, for the 'foo' attribute defined on A.

See 'help inheritance' for the intro and other topics.

& Inheritance values

(2)  Inheritance of attribute values:  If object A has a value on any
inheritable attribute, whether built-in or user-defined, then object C
will inherit that value.  When you examine 'C' you will notice, for each
inherited attribute, that its name and value is preceded by a + sign.
An object can inherit values from grandparents or other ancestors as well,
and the number of + signs before the attribute name indicates how many
generations up the tree the value is coming from.  Attribute values inherited
in this manner behave exactly as do non-inherited values.  All $ and !
events, @listens, triggered commands, etc., work as expected.

An inherited value can be superseded in a child by simply setting a local
value for the attribute. (If the attribute was originally defined with
the wizard option set, or is a built-in wizard-only attribute, you will
not be able to set it unless you control not only the child but also the
object on which the attribute was defined).  Inherited values can thus be
used to create generic parents that can produce identical children, and said
children can then be modified slightly by overwriting selected registers.

See 'help inheritance' for the intro and other topics.

& @decompile
@decompile

Outputs a series of commands that can be fed back into tinyMUSE 1.4 to
redefine and reset all of an objects' registers and flags. Can be used to
save an object to disk, edit it, and read it back in via the tinyfugue
/quote macro.  When using @decompile for this purpose, be sure also to
set /wrap off so that lines are not broken every 80 characters.

The commands @decompile issues include @set to set flags, @defattr to
define attributes, and @nset to set attribute values.
& $ events

$ events

New verbs can be defined on any register with $ events.  Store
a string on the register with the following format:
	$verb pattern:action1;action2;....

The verb pattern may include wilcards (* to match strings of any length,
and ? to match a single character).  If the verb pattern is matched by
a typed command by any player in the room with the object or carrying the
object, the actions will be executed.  If the verb pattern includes
wildcards, then the strings matching them may be referenced in the action
part of the command by %0 or v(0) for the first, %1 or v(1) for the second,
and so forth.

Events are matched only on objects in the room, if any match (although events
on players can be matched only by the player, not by other objects in the
room).  If no objects in the room match the event, matches are then performed
on objects carried by the enactor or, if no such object can match, matches
are then performed on the zone object and on the universal zone.

For examples, type: help event examples.

& ! events

! events

Analagous to $ events, ! events match what they hear rather than typed
commands.  Store a string on any register with the following format:
	!listen pattern:action1;action2;....

The listen pattern may include wildcards (* to match strings of any length,
and ? to match a single character).  If the listen pattern is heard by the
object, the actions will be executed.  If the listen pattern includes
wildcards, then the strings matching them may be referenced in the action
part of the command by %0 or v(0) for the first, %1 or v(1) for the second,
and so forth.

Events are matched only on objects in the room, if any match.  Since ! events
are analagous to 'ahear', they cannot be matched on the player itself, nor
will they be matched on other player characters in the room.  If no objects
in the room match the event, matches are then performed on objects carried
by the enactor or, if no such object can match, matches are then performed
on the zone object and on the universal zone.

For examples, type: help event examples.

& event examples
Examples of $ and ! events:

 (1) @va obj=$foo:say hi
	If you type 'foo', the object will say 'hi'.


 (2) @va obj=$foo *:say %0
	If you type 'foo abcde', the object will say 'abcde'.  If you type
	just 'foo', nothing will happen, as the pattern you have specified,
	'foo *', requires at least one additional space (and therefore one
	additional word) after the word 'foo'.

 (3) @va obj=!* says "foo":say hi
	If someone says foo and the object hears, it will say 'hi'.  Notice
	that the entire pattern, '* says "foo"', is necessary.  Compare with
	example (4).

 (4) @va obj=!foo:say hi
	Your object will say 'hi' if it hears exactly the line 'foo'.  But
	if you say foo, or pose foo, the object will not hear 'foo' but will
	hear 'Yourname says "foo"' or "Yourname foo".  The object will hear
	'foo' only if you @emit or @pemit just that one word.

& @move
@move <object> [=<message>]. Sets the move message for <object>. The
message is displayed to an object when it moves by any means including
teleportation.  See also @omove, @amove.

& @omove
@omove <object> [=<message>]. Sets the omove message for <object>. The
message is displayed to all other things in the room when <object> moves
by any means including teleportation.  See also @move, @amove.

& @amove
@amove <object> [=<message>]. Sets the amove register for <object>. The
register contains a semicolon separated list of actions that are taken
after the object moves by any means including teleportation.
See also @move, @amove.

& @oemit
@oemit <object>=<string>.  This command emits <string> to everything in the
room *except* <object>.  See also @emit, @pemit.

& if function
if(test,act)		This function checks the test, and performs act1
			if the test is true, otherwise it does nothing.
			The test is false if it evaluates to 0, to #-1, or
			to the null string. Otherwise it is true.  See also
			ifelse(), truth().

& ifelse function
ifelse(test,act1,act2)	This function checks the test, and performs act1
			if the test is true, act2 if the test is false.
			The test is false if it evaluates to 0, to #-1, or
			to the null string. Otherwise it is true.  See also
			if(), truth().

& wcount function
wcount(string)		Returns the number of words in the string.

& @ulock
@ulock <object> = <lock>.  Sets the use-lock for an object.  Only players
or things satisfying the lock will be able to trigger $ and ! events on the
object. See help for 'locks' for complete help on locks.

& @elock
@elock <object> = <lock>.  Sets the enter-lock for an object. Only players
or things satisfying the lock will be able to enter the object.
See help for 'locks' for complete help on locks.  See also @lock, @ulock.

&@ufail
A fail message shown to a player who fails to use an object (because of
the @ulock).
&@oufail
A fail message shown to others in the room if a player fails to use an
object (because of the @ulock).
&@aufail
A list of actions performed when someone fails to use an object (because
of the @ulock).
& strcat function
strcat(str1,str2)
		Returns the concatenation of the two strings, str1
		and str2.  Example: strcat(abc,def) returns abcdef.

& @nemit
@nemit <string>
	Works just like @emit except does not parse its argument.  May be
used for emitting strings with spaces in them, or with brackets and
parentheses, without worrying about functions being evaluated or spaces
being removed.

See also @npemit, @nset.

& @npemit
@npemit obj=<string>
	Works just like @pemit except does not parse its argument.  May be
used for pemitting strings with spaces in them, or with brackets and
parentheses, without worrying about functions being evaluated or spaces
being removed.

See also @nemit, @nset.

& @nset
@nset <obj>=<attr>:<commands>
	Works just like @set does for setting attribute values, except does
not parse its argument.  May be used for setting attribute values with
leading or embedded spaces, or with brackets or parentheses, without
worrying about functions being evaluated or spaces being removed.

See also @set, @nemit, @npemit.

& lwho function
lwho()		Returns a list of dbrefs of connected users.  If an object
		uses this function it is charged 50 credits.

& idle function
idle(user)	Returns the idle time, in seconds, of the given user.  If
		the user is not connected, nonexistant, or hidden, the
		function returns #-1.

& onfor function
onfor(user)	Returns the connect time, in seconds, of the given user.
		If the user is not connected, nonexistant, or hidden, the
		function returns #-1.

& host function
host(user)	Returns the hostname of the given user.  If the user is not
		connected, nonexistant, or hidden, or if you are not
		authorized to see the user's hostname, returns #-1.

& type function
type(object)	Returns the type of the object, where type is one of Player,
		Room, Exit, or Thing.

& lattr function
lattr(obj)	Returns a list of the attributes on object 'obj' that have
		a non-null value.  See also lattrdef().

& lattrdef function
lattrdef(obj)	Returns a list of the attributes defined (with @defattr) on
		object 'obj'.  See also @defattr, lattr().

& lnum function
lnum(num)	Returns a list of numbers from 0 to (num-1).  The maximum
		legal value for num is 250.

	Example: lnum(5) returns '0 1 2 3 4'.

& tms function
tms(num)	Takes a number of seconds, and returns the time represented
		by the given number of seconds, in the format of the idle
		column in the WHO list, showing 's' for some number of
		seconds, 'm' for some number of minutes (dropping any
		fraction), 'h' for some number of complete hours, or 'd' for
		some number of complete days.

	Examples: tms(33) returns '33s'.
		  tms(121) returns '2m'.
		  tms(86401) returns '1d'.

& tml function
tml(num)	Takes a number of seconds, and returns the time represented
		by the given number of seconds, in the format of the 'On For'
		column in the WHO list, showing hh:mm for times less than one
		day, and dd hh:mm for periods longer than one day.

	Examples: tml(33) returns '0:33'.
		  tml(121) returns '02:01'.
		  tml(86401) returns '1d 00:01'.

& flip function
flip(string)	Returns the character-reversal of the argument string.

	Example: flip(abcd efg) returns 'gfe dcba'.

& string function
string(char,num)	Returns a string of 'num' occurences of 'char'.
	Example: string(*,6) returns '******'.

& ljust function
ljust(string,num)	Returns the string, left-justified in a field of
			width 'num'.

& rjust function
rjust(string,num)	returns the string, right-justified in a field of
			width 'num'.

& cjust function
cjust(string,num)       Returns the string, center-justified in a field of
			width 'num'.

& spc function
spc(n)			Returns a string consisting of n spaces.

& pi function
pi()                    Returns 'pi', which is approximately 3.1415927

& gt function
gt(num1,num2)           Returns 1 if num1 is greater than num2, 0 otherwise.

& lt function
lt(num1,num2)           Returns 1 if num1 is less than num2, 0 otherwise.

& fsqrt function
fsqrt(num)              Returns the floating-point square root for 'num'.
			If 'num' is negative, returns 0.

& plural function
plural(num,suffix)      Returns the 'suffix' text if 'num' does not equal 1.
			This returns a null string otherwise.

& art function
art(word)               Returns an article of a word; basically 'a' if the
			first letter of the word is a constanant, 'an' if
			it's a vowel.  This function may be improved later.

& subj function
subj(<object>)          Returns the subject form of <object> (he, she, it),
			depending on its sex. Similar to %s, but returns 'it'
			instead of the subject's name if the sex is neither
			male nor female.  See objn(), poss().

& objn function
objn(<object>)          Returns the object form of <object> (him, her, it),
			depending on its sex. Similar to %o, but returns 'it'
			instead of the object's name if the sex is neither
			male nor female.  See subj(), poss().

& poss function
poss(<object>)          Returns the possesive form of <object> (his, her,
			its), depending on its sex. Similar to %p, but
			returns 'its' instead of the apostrophe-S version
			of the object's name, if the sex is neither male
			nor female.  See also subj(), objn().

& lcon function
lcon(<object>)          Returns a space-separated list of items in <object>.

& lexit function
lexit(<object>)         Returns a space-separated list of exits in <object>.

& simp function
simp(<floating-point number>)     Returns the simplifacation of a floating-
				  point number. For example, 027.603100 would
				  return 27.6031. 

& rtime function
rtime([<seconds>])                Returns a short time readout in hours,
				  seconds, minutes, and AM or PM. <seconds>
				  may state the number of seconds starting
				  at a fixed point of time. <seconds> can
				  be added together with 'xtime()' to in-
				  crease or decrease the current 'rtime'
				  by seconds, minutes, or hours. If <seconds>
				  is omitted, the current time will be
				  displayed.

& stime function
stime(<seconds>)                  Returns the string-readout of the time in
				  <seconds> after a fixed point of time.

& nearby function
nearby(obj1,obj2)	Checks to see whether obj1 is 'nearby' obj2.  Two
			objects are near each other if they are in the same
			room, or if one is inside the other.  Returns 1 if
			the objects are nearby, 0 if not, and #-1 if either
			object cannot be identified or if you cannot find the
			location of either object.  You must control both
			objects to get a precise outcome.

& room function
room(<object>)          Traces all the way back to the actual room that
			<object> is in, and returns that room number.
			This works no matter how deep inside boxes an object
			might be.

& dist2d function
dist2d(x1,y1,x2,y2)     Returns the distance between x1,y1 and x2,y2 as if
			on a 2-dimensional graph.

& dist3d function
dist3d(x1,y1,z1,x2,y2,z2)     Returns the distance between x1,y1,z1 and
			      x2,y2,z2 as if on a 3-dimensional graph.

& controls function
controls(p1,p2,power)   Returns 1 if player1 has a specific 'power' over
			player2, else 0. An example of a 'power' is Join.

& @aconnect
@aconnect <object>=<commands>

These commands will get activated when someone connects into MicroMUSE. When
set on a zone, this will get activated whenever anyone connects within the
zone. This will also get executed if set on a room or another object in the
room when a person connects.

Example: @aconnect here=@emit Welcome back to MicroMUSE, %n.

See also: @oconnect, @adisconnect, @odisconnect

& @oconnect
@oconnect <object>=<message>

This message will be shown to everyone else except <object>, when a person
connects to MicroMUSE.

See also: @aconnect, @adisconnect, @odisconnect

& @adisconnect
@adisconnect <object>=<commands>

These commands will get activated when someone disconnects from MicroMUSE.
When set on a zone, this will get activated whenever anyone disconnects
within the zone. This will also get executed if set on a room or another
object in the room when a person disconnects.

See also: @aconnect, @oconnect, @odisconnect

& @odisconnect
@odisconnect <object>=<message>

This message will be shown to everyone else except <object>, when a person
disconnects from MicroMUSE.

See also: @aconnect, @oconnect, @adisconnect

& hasflag function
hasflag(<object>,flag)  This will return 1 if <object> has the specified
                        flag, and 0 if not.

    Example: say [hasflag(*Jin,c)]  -see if Jin is connected

& haspow function
haspow(<object>,power)  This will return 1 if <object> has the desired power,
                        and 0 if not. An example of 'power' is Join.

& @relink
@relink <exit>=<room#>

This command can be used to @relink an exit to a different room#.

See also: @link, @unlink

& @apage
@apage <player>=<commands>

These set of commands will be activated whenever you are online and receive
a page.

See also: @awhisper, @apemit

& @npage
@npage <player>=<message>

Pages a player without parsing the message. For example.. using @npage, you
can type '@npage player=()*{}    []' and it will come out exactly that way.

See also: page

& @awhisper
@awhisper <object>=<commands>

These set of commands will be activated whenever <object> receives a
whisper.

See also: @apage, @apemit

& @apemit
@apemit <object>=<commands>

These set of commands will be activated whenever <object> gets a @pemit.

See also: @apage, @awhisper

& @searchobj
@searchobj <object>=<text>

This command will search an entire object and it's attributes for the
specified <text>. It will then list out each matching attribute. You
may include wildcard characters.

Examples: @searchobj me=I*    -Lists all attributes beginning with 'I'.

          @searchobj me=*foo* -Lists all attributes with the word 'foo' found
                               inside

          @searchobj me=*     -Lists every attribute.

& FLOATING flag

FLOATING   When set on a disconnected room or *one* room of a group
of disconnected rooms it will supress the 'disconnected room' message.
This flag should be used only by experienced builders. Your 'floating'
rooms could easily be forgotten and/or misplaced.

& ZEROG flag

ZEROG   When set on a room the space() process will look for this flag
upon booting and put all the contents into a Zero-Gravity environment.
This is part of the MUSE-Space code and is restricted to the Space power.

& ZONED flag

ZONED   When set on an object that is also a zone (see zones) it will
effectively 'seal off' the zone. You cannot @zlink or @unzlink any 
rooms in the zone, nor can you open any exits out of the zone.
Once the ZONED flag is set you cannot change any of the flags on
the zone object (ex: if the ENTER_OK flag is not set it effectively
blocks all @teleports). If the OPAQUE flag is set on the zone object
it will block all @triggers and @forces into the zone from another zone.
This flag is restricted to the WizFlags power.

& @selfboot
@selfboot

This command will automatically @boot you 3 times, to clear up double logins
into MicroMUSE. This means that you and your doubles will be disconnected
only. You may relogin afterwards.

& @cpattr
@cpattr <newobj>/<newattr>=<oldobj>/<oldattr>

This command will copy an attribute from the old object to the new object. It
does not have to be the same attribute that you wish to copy.

Examples: @cpattr foo/vb=me/va

& +cmdav
+cmdav

This command will show you the average number of commands per second
over the last 5 seconds, 30 seconds, and 5 minutes.  There are
three catagories: player commands, queue commands, and total
commands.  Player commands are commands that come directly through
the network.  Queue commands are things that are triggered, such
as by @trigger, @ahear, etc.  Total commands is just a sum of
these two.

& +stats
+stats

This command will show you the logon stats of how many people have logged
onto MicroMUSE each day within the past two weeks.

& change function
change(str1, str2, n)           This function will change the 'n'th character
                                in str1 to str2. If there is more than one
                                character in str2, they will be inserted.
                                Characters are numbered starting at 1.

      Examples:  [change(abcdefg, x, 3)] = abxdefg

                 [change(abcdhijkl, defg, 4)] = abcdefghijkl

