MOOsaico: Multilingual Virtual Community

Help Database (#61)

 alias		    facetas		miscellaneous	    rooms
 name		    @facetas		@more		    say
"		    features		movement	    security
:		    @features		movimento	    @send
::		    @forward		@netforward	    @sethome
?		    full-index		news		    shout
@abandonar	    @gag		@next		    @skip
@add-feature	    gagging		@notedit	    sms
@addalias	    @gaglist		notes		    speak
ajuda		    gen-index		noticias	    spoofing
@answer 	    @gender		olha		    @subscribe
@bug		    get 		@opacidade	    @subscribed
burn		    give		@opacity	    @sugesta~o
character	    go			page		    @suggest
@check		    gopher		page-conf	    suma'rio
comandos	    @gripe		@pagelength	    summary
@comenta'rio	    hand		@paranoid	    @sweep
commands	    help		@password	    take
@comment	    home		@peek		    talk
common_quota	    @idea		player-names	    throw
communication	    @ideia		players 	    @typo
comunicac,a~o	    index		@prev		    @ungag
container-messages  information 	privacy 	    @unrmmail
containers	    insert		programming	    @unsubscribe
correio 	    introduc,a~o	pronouns	    @uptime
creation	    introduction	put		    user-names
decrypt 	    inventa'rio 	queima		    users
delete		    inventory		@quit		    utilizadores
descric,o~es	    @lastlog		@quota		    vai
descriptions	    @le^		read		    @versa~o
diz		    letters		@read		    @version
drop		    @linelength 	@registerme	    whereis
@edit		    @listgag		remove		    whisper
@edit-options	    look		@remove-feature     @who
@editoptions	    mail		@rename 	    wizard-list
editores	    @mail		@renumber	    @wizards
editors 	    mail-forwarding	@reply		    @wizards-list
@eject		    @mail-options	@request-character  @wrap
@eject! 	    @mailoptions	@resident	    write
emote		    manipulac,a~o	@residente	    yell
encrypt 	    manipulation	@rmalias	    zombie-messages
erase		    me			@rmmail
examina 	    message-sequences	@rn
examine 	    miscela^nea 	room-messages


Every object (including users, rooms, exits) has a name and a set of aliases.
The object name is commonly used to display an object in various contexts. The
object aliases are used to refer to an object when users type commands.
Help is available on the following commands:

@rename -- change the names or aliases of an object or yourself.
@addalias, @rmalias -- add and remove aliases.
@nome  -- define de portuguese name of the object, changing the proper


Usage:	@add-feature  <object>
       @remove-feature <object>

Add or remove a feature from your list.  A feature is an object which provides
additional commands you can use.  For more information, see `help features'.
- Show quoted text -


Syntax: @addalias <alias>[,...,<alias>] to <object>
       @addalias <alias>[,...,<alias>] to <object>:<verb>

The first form is used to add aliases to an object's list of aliases.  You can
separate multiple aliases with commas.	The aliases will be checked against
the object's current aliases and all aliases not already in the object's list
of aliases will be added.

Muchkin wants to add new aliases to Rover the Wonder Dog:
 @addalias Dog,Wonder Dog to Rover
Since Rover the Wonder Dog already has the alias "Dog" but does not have the
alias "Wonder Dog", Munchkin sees:
 Rover the Wonder Dog(#4237) already has the alias Dog.
 Alias Wonder Dog added to Rover the Wonder Dog(#4237).

If the object is a player, spaces will also be assumed to be separations
between aliases and each alias will be checked against the Player Name
Database to make sure no one else is using it. Any already used aliases will
be identified.

Munchkin wants to add his nicknames to his own list of aliases:
 @addalias Foobar Davey to me
@Addalias recognizes that Munchkin is trying to add an alias to a valid player
and checks the aliases against the Player Name Database.  Unfortunately,
DaveTheMan is already using the alias "Davey" so Munchkin sees:
 DaveTheMan(#5432) is already using the alias Davey
 Alias Foobar added to Munchkin(#1523).

The second form of the @addalias command is for use by programmers, to add
aliases to a verb they own.  All commas and spaces are assumed to be
separations between aliases.


Syntax:  @answer [<message-number>] [sender] [all] [include] [noinclude]
		[on <folder>]
Synonym: @reply

Prepares for you to compose a MOO email message to the players who either
received or composed the indicated message from your collection.  The usual
editor is invoked (see `help editors' for details).  The subject line for the
new message will be initialized from that of the indicated message.  If you
leave off the message number, the reply will be to your current message, if
that exists.  In fact you may give a general message-sequence (see `help
message-sequences') argument here, provided that it indicates only a single
message (e.g., `@answer last:1')

If there is a Reply-to: field in the message you are @answer'ing, its contents
will be used to initialize the To: line of your reply.	Otherwise, a To: line
is determined depending on whether you specified `sender' or `all' in the
command line (or your .mail_options).

`include' includes the text of the original message in your reply, `noinclude'
does not.

`sender', `all', `include', and `noinclude' can each be abbreviated (e.g.,
`@answer i').

Defaults are `sender' and `noinclude', but you can change this by setting your
.mail-options (see `help mail-options').


Syntax:  burn <letter>

Destroy the named letter irretrievably.  Only users who can read the letter
can do this.


Syntax:   @check <options>

where <options> is one or more of:
-- the number of lines to be displayed
-- a user's name, someone to be "trusted" during the assignment of
responsibility for the message.
-- a user's named prefixed by !, someone not to be "trusted".

	 @check-full <options>
where <options is either
-- the number of lines to be displayed
-- a search string: only lines containing that string will be displayed.

Used when you are suspicious about the origin of some of the messages your
character has just heard.

Output from @check is in columns that contain, in order, the monitor's best
guess as to:
   what object the message came from,
   what verb on that object that was responsible,
   whose permissions that verb was running with, and
   the beginning of the actual message.

Output from @check-full is in columns that contains a description of all the
verbs that were responsible for the noise heard, not just the best guess as to
who was responsible.

@check operates by examining the list of verbs that were involved in
delivering the message, and assigning responsibility to the first owner it
sees who is not "trusted".  By default, it trusts you and all the wizards.  It
uses the records maintained by @paranoid, so you must have used that command
before you received the message.


Each user has a limit as to how much database disk space they may consume with
their objects, properties, and verbs.  Objects are periodically measured (and
can have their measurement forced---see help @measure).  If a user is over
quota after a measurement, he will not be able to @create any objects, use
@copy, @verb, or @property to grow any objects.  Existing properties and verbs
may be edited/changed at will, even while over quota.

The @quota command prints out your current quota and measured usage.

@quota prints a time of measurement in its display.  This is the time of the
oldest measurement out of all your objects.  For example, if you @measure
three of your objects right now, those individual times get updated, but if
you still have a couple of objects with older measurements, that older time
will be the time printed by @quota.  This is confusing to many people.

The quota mechanism is intended to solve a long-standing problem in many MUDs:
database bloat.  The problem is that a large number of people build a large
number of dull objects and areas that are subsequently never used or visited.
The database becomes quite large and difficult to manage without getting
substantially more interesting.  With the quota system, we can make it
possible for users to experiment and learn while simultaneously keeping random
building to acceptable levels.


There are several commands available to allow you to communicate with your
fellow MOOers.	Help is available on the following communication-related

say	  -- talking to the other connected users in the room
whisper   -- talking privately to someone in the same room
page	  -- yelling to someone anywhere in the MOO
emote	  -- non-verbal communication with others in the same room
gagging   -- screening out noise generated by certain other users
news	  -- reading the wizards' most recent set of general announcements
@gripe	  -- sending complaints to the wizards
@typo @bug @idea @suggest
	 -- sending complaints/ideas to the owner of the current room
@whereis   -- locating other users
@users @u -- finding out who is currently logged in
mail	  -- the MOO email system
security  -- the facilities for detecting forged messages and eavesdropping.


Several kinds of messages can be set on a container object; they are printed
to various audiences at certain times whenever an attempt is made to use the
container.  The ones whose names begin with 'o' are always shown prefixed with
the name of the user making the attempt and a single space character.  The
standard pronoun substitutions (with respect to the user) are made on each
message before it is printed; see 'help pronouns' for details.

The default message is given in brackets after each name below:

 Printed in place of the contents list when the container is empty.

@open  [{list}]
 Printed to the user who successfully opens the container.

@oopen	[{list}]
 Printed to others in the same room if the user successfully opens the

@open_fail  [{list}]
 Printed to the user who cannot open the container.

@oopen_fail  []
 Printed to others in the room when a user fails to open a container.

@close	[{list}]
 Printed to the user who closes a container.

@oclose  [{list}]
 Printed to others in the room when a user closes a container.

@put  [{list}]
 Printed to a user when an object is successfully placed in a container.

@oput  [{list}]
 Printed to others in the room when a user successfully places an object in a

@put_fail  [{list}]
 Printed when a user fails to put an object in a container.

@oput_fail  []
 Printed to others in the room when a user fails to place an object in a

@remove  [{list}]
 Printed when a user succeeds in removing an object from a container.

@oremove  [{list}]
 Printed to others in the room when a user succeeds in removing an object from
a container.

@remove_fail  [{list}]
 Printed when a user fails to remove an object from a container.

@oremove_fail  []
 Printed to others in the room when a user fails to remove an object from a


Containers are objects that allow you to store other objects inside them.  The
following help topics cover verbs that can be used with containers:

put -- putting an object into a container
remove -- taking an object out of a container

Containers may be open or closed, using the verbs 'open container' and 'close
container'.  Containers have a separate lock to determine if a user may open
them.  See the following help topics:

@lock_for_open -- setting the lock for opening a container
@unlock_for_open -- clearing the lock

You can make a container by creating a child of the standard container,
$container (see 'help @create').

Containers have a large number of messages which get printed when users act
upon them.  See 'help container-messages' for more information.

Containers have opacity.  See 'help @opacity' for more information.


The primary means for users to extend the MOO is for them to create new
objects with interesting behavior.  There are convenient commands for creating
and recycling objects and for keeping track of the objects you've created.
Help is available on these commands in the following topics:

@dig -- conveniently building new rooms and exits
@create -- making other kinds of objects
@recycle -- destroying objects you no longer want
@quota -- determining how many space is left to you to build
@count -- determining how many objects you already own
@audit -- listing all of your objects
@classes -- listing all of the public classes available for your use
@realm -- listing the parenting tree for objects owned by one or more users
@move -- moving your objects from place to place


Syntax:  decrypt <note>

Removes any restriction on who may read the named note or letter.  Only the
owner of a note may do this.


Syntax:  delete <line-number> from <note>

Removes a single line of text from a note.  The first line of text is numbered
1, the second is 2, and so on.	Only the owner of a note may do this.


Most objects have one or more descriptive pieces of text associated with them;
these texts are printed under various circumstances depending on the kind of
text.  For example, every object has a 'description' and a 'descricao' text
that is printed whenever a user looks at the object ( the first if he/she is
on english mode or the other if in portuguese mode - see `help @language' ).
The following help topics discuss the commands for manipulating these
descriptive texts on your objects:

@rename -- setting the name and aliases of your objects
@describe -- setting what others see when they look at your objects in
	    english mode
@descreve -- as @describe but sets the portuguese description
messages -- listing and setting the other descriptive texts on an object


Syntax:  drop <object>
	throw <object>

Remove an object you are carrying from your inventory and put it in your
current room.  Occasionally you may find that the owner of the room won't
allow you to do this.


Syntax:  @edit <object>.<property>
	@edit <object>:<verb-name> [<dobj> [<prep> [<iobj>]]]
	@edit <object>

Enters a MOO editor, as appropriate.

Chooses the MOO Note editor for the named property, or the MOO verb editor for
the named verb.  If no property or verb name is given, assumes property .text
for a note object, or .description for any other object.

See 'help editors' for more detail.


Syntax:  @edit-option
	@edit-option <option>

Synonym:  @editoption

The edit options customize the behavior of the various editors (mail editor,
verb editor, etc...) to your particular taste.	The first form of this command
displays all of your edit options.  The second form displays just that one
option, one of the flags listed below.

The remaining forms of this command are for setting your edit options:

	@edit-option +<flag>
	@edit-option -<flag>
	@edit-option !<flag>	       (equivalent to -<flag>)

These respectively set and reset the specified flag

-quiet_insert	 insert (") and append (:) echo back the line numbers
+quiet_insert	 insert (") and append (:) produce no output
-eval_subs	 (VERB EDITOR) ignore .eval_subs when compiling verbs
+eval_subs	 (VERB EDITOR) apply .eval_subs to verbs being compiled
-local		 Use in-MOO text editors.
+local		 Ship text to client for local editing.


One can always enter an editor by teleporting to it, or you can use one of the
commands provided

   @edit     <object>:<verb>	invokes the Verb Editor (edits verb code)
   @notedit  <note_object>	invokes the Note Editor (edits note text)
   @notedit  <object>.<prop>	invokes the Note Editor (edits text property)
   @send     <list of recipients>	 invokes the Mailer (edits a mail msg)
   @answer   [<msg_number>] [<flags>...] invokes the Mailer (edits a reply)

This will transport you to one of several special rooms that have editing
commands available.  These editors are admittedly not as good as EMACS, but
for those with no other editing capability on their host systems, they are
better than nothing.

There is a generic editor that provides basic editing commands that are
applicable to all editors.  Documentation for these commands can be obtained
by typing `help <topic>' within the editor:

   abort	      emote/:		 pause		    send      (M)
   also-to (M)	      fill		 prev		    showlists (M)
   compile (V)	      insert		 print	   (M)	    subject   (M)
   copy 	      join		 quit		    subst
   delete	      list		 ranges 	    to	  (M)
   done 	      move		 save	   (N)	    what
   edit    (V,N)      next		 say/"		    who   (M)

In addition, individual editors provide their own additional commands for
loading text from places, saving text to places, and various other specialized
functions which are denoted in the above list with (M),(N),(V) according as
they apply to the mail editor, the note editor, or the verb editor,

Note that a given editor only allows you one session at a time (ie. one verb,
one note, or one mail message).  If you leave an editor without either
aborting or compiling/saving/sending the item you're working on, that editor
remembers what you are doing next time you enter it, whether you enter it by
teleporting or by using the appropriate command.  Note that editors are
periodically flushed so anything left there for sufficiently long will
eventually go away.

A user may have his own .edit_options property which is a list containing one
or more (string) flags from the following list

     suppresses those annoying "Line n added." or "Appended..." messages
     that one gets in response to 'say' or 'emote'.  This is useful if you're
     entering a long list of lines, perhaps via some macro on your client,
     and you don't want to see an equally long list of "Line n added..."
     messages.	What you do want, however is some indication that this all
     got through, which is why the "." command is an abbreviation for insert.

     Enables the verb editor to process your eval_subs property when
     compiling your verb.  See `help eval' for more information about
     the eval_subs property.

There will be more options, some day.


Syntax: @eject[!] <object> [from <place>]

This command is used to remove unwanted objects from places you own.  Players
thus removed are unceremoniously dumped in their homes (unless that's this
room, in which case they are dumped in the default user starting place).
Other kinds of objects are checked for a .home property and sent there if
possible, otherwise they get thrown into #-1.  Unlike @move, @eject does *not*
check to see if the object wants to be moved, and with the destination being
what it is, there is no question of the destination refusing the move, either.
Generally, you should only resort to @eject if @move doesn't work.

`@eject <object>' removes <object> from the current room, whereas `@eject
<object> from <place>' removes the object from the specified location (in most
cases, <place> will need to be specified as an object number).	In either
case, this command only works if you own the room/entity from which the object
is being ejected.

`@eject ... from me' suffices to get rid of some unwanted object in your

The verbs @eject! and @eject!! are provided for those rare situations in which
@eject does not work.  @eject! does not check for .home properties, sending
the offending object to #-1 immediately, but with a notification.  @eject!! is
just like @eject! but provides no notification to the object.

See 'help room-messages' for a list of messages one can set regarding the
@eject command.


Syntax:  emote <anything> ...
	:<anything> ...
	::<anything> ...

Announces <anything> to everyone in the same room, prepending your name.  This
is commonly used to express various non-verbal forms of communication.	In
fact, it is so commonly used that there's a special abbreviation for it: any
command-line beginning with ':' is treated as an 'emote' command.

The alternate form, '::' (less commonly 'emote :'), does not insert the space
between the player name and the text.

Munchkin types this:
 :wishes he were much taller...
Everyone in the same room sees this:
 Munchkin wishes he were much taller...

Munchkin types this:
 ::'s eyes are green.
Everyone in the same room sees this:
 Munchkin's eyes are green.


Syntax:  encrypt <note> with <key-expression>

Restricts the set of users who can read the named note or letter to those for
whom the given key expression is true.	See 'help keys' for information on the
syntax and semantics of key expressions.  Only the owner of a note may do


Syntax:  erase <note>

Deletes all of the text written on a note or letter.  Only the owner of a note
may do this.


Syntax:  examine <object>
	exam <object>

This shows a better observation of the <object> than the casual `look'. You
will get an in depth description, with its contents and `obvious' verbs
defined on it.


Features are objects that provide you with commands not covered by the
ordinary user objects.	The advantage of using features is that you can mix
and match the things you like; whereas if you like a command that's defined on
a user class, you have to also get all the commands it defines, and all the
commands its ancestors define.

You can list your features with the @features command, and add or remove
features from your list with the @add-feature and @remove-feature commands.


Usage:	@features [<name>] [for <user>]

List all of <user>'s features matching <name>, or all of <user>'s features if
<name> is not supplied.  <user> defaults to you.  See `help features' for more


Syntax:  @forward <msg> [on *<collection>] to <recipient> [<recipient>...]

Takes the indicated message in your (or some other) message collection,
creates a new message whose body is the original message (both headers and
body) and sends it on to the given recipients.


Syntax:  @gag <user or object> [<user or object>...]

Add the given users to your 'gag list'.  You will no longer see any messages
that result from actions initiated by these users.  In particular, you will
not hear them if they try to speak, emote, or whisper to you.  See 'help
gagging' for an explanation of gagging in general.

Munchkin types:
 @gag Grover
and no longer hears anything that Grover says.	What a relief!

If you specify an object, then any text originating from that object will not
be printed.  Example:  Noisy Robot prints "Hi there" every 15 seconds.	 In
order to avoid seeing that, Munchkin types:
 @gag Noisy
and no longer hears that robot!  (Munchkin must be in the same room as Noisy
Robot for this to work, or know its object number.)


Occasionally, you may run into a situation in which you'd rather not hear from
certain other players.	It might be that they're being annoying, or just that
whatever they're doing makes a lot of noise.  Gagging a player will stop you
from hearing the results of any task initiated by that player.	You can also
gag a specific object, if you want to hear what the owner of that object says,
but not the output from their noisy robot.  The commands to use gagging are
listed below; detailed help is available on each of them:

@gag -- add one or more players to your gag list
@ungag -- remove a player from your gag list
@listgag -- list the players you currently have gagged


Syntax: @gender [<object>]
       @gender [<object>] is <gender>

If no <gender> is given, tells you the current gender (sex) of a given
<object>.  If a <gender> is given, sets the gender of <object> to that
<gender>.  The gender of an object determines which pronouns are chosen to
refer to that object in various messages.

By default, <object> is the player using the command.

The <gender> may be the name of a standard gender (e.g., 'male', 'female',
'neuter',...) or the object number of a gender defined by a player.

It should be noted that some of the "genders" on the standard gender list need
verb conjugation in order to work properly and much of the MOO isn't set up
for this (...yet).  For example, you should expect to see `they is' a fair
amount if you @gender yourself `plural'.


Syntax:  give <object> to <user>
	hand <object> to <user>

Move an object from your contents to that of another user.  This doesn't
change the ownership of the object.  Some users may refuse to accept gifts and
some objects may refuse to be given.


Syntax: go <direction> ...

Invokes the named exits in the named order, moving through many rooms in a
single command.

Munchkin types:
 go e s s s sw e
and moves quite rapidly from the Central Hall all the way to the Ye Olde Guild
of Magic, all in one command.


Gopher is an internet service for information retrieval. There are many gopher
servers across the internet, providing a wide variety of information of all
sorts: network news, weather, and White House press releases, campus class
information, and scientific papers.

The programmer interface to Gopher is contained in the object $gopher (`help


Syntax:  @gripe <anything> ...

Puts you into the MOO mail system to register a complaint (or, conceivably, a
compliment) with the wizards.  The rest of the command line (the <anything>
... part) is used as the subject line for the message.	More information on
using the MOO mail system is given once you're in it.

You may hear back from the wizards eventually; see 'help @mail' for how to
read their reply.

Munchkin types:
 @gripe The little bird
 "How come I can't ever see the little bird in the cuckoo clock?
 "	  -- A frustrated user
and, somewhat later, the wizards reply with a note about being sure to look
while the clock is chiming.


Syntax:  help
	help <topic>
	help index

Print out entries from the online documentation system.  The commands `?' and
`information' (usually abbreviated `info') are synonyms for `help'.

The first form prints out a summary table of contents for the entire help

The second form prints out the documentation available on the given topic.
Many help system entries contain references to other entries accessible in
this way.  The topic name may be abbreviated; if there is no topic exactly
matching the name you give, the help system checks for topics for which the
name is a prefix, perhaps with the addition or omission of an initial `@', or
perhaps with some confusion beween dashes (-) and underscores (_), e.g.,
     `bui' instead of `building',
     `who' instead of `@who',
    `@wri' instead of `write',
 `add_ent' instead of `@add-entrance',
 `unlock-'  instead of `@unlock_for_open'

If the abbreviation you give is ambiguous, you will be presented with a list
of the matching complete topic names.

The `help index' commands prints out a list of indices for the various help
databases.  Each index gives a list of topics available on that database.  It
is sometimes easier to find the topics you're interested in this way, rather
than tracing through the chain of cross references.


Syntax: home

Instantly teleports you to your designated home room.
Initially, this room is Grandfather Clock (#11).
You can change your designated home; see 'help @sethome' for details.


MOOsaico is a kind of virtual reality, in which users move about from place to
place manipulating their environment in what we hope are amusing,
entertaining, or enlightening ways.

MOOsaico is more of a pastime than a game in the usual sense; there is no
`score' kept, there are no specific goals to attain in general, and there's no
competition involved.  MOOsaico participants explore the virtual world, talk
to the other participants, try out the weird gadgets that others have built,
and create new places and things for others to encounter and enjoy.

Most commands have the form of simple English sentences:
   <verb>  <direct object>
   <verb>  <direct object>  <preposition>  <indirect object>
Don't use English articles (e.g. 'a', 'an', or 'the') in your commands; the
MOO won't understand them.  You can refer to yourself as 'me' and the room
you're in as 'here'.

The first five kinds of commands you'll want to know are listed below.	Type
'help <topic-name>' for details on any of them:

look -- getting a description of the current room or any other object
say -- speaking to the other users in the same room as you
@who -- showing which users are currently connected to the MOO
movement -- how to move around in the MOO, from room to room
@quit -- disconnecting from the MOO


Syntax:  inventory

Prints a list showing every object you're carrying.


Syntax:  @lastlog
	@lastlog <user>

The first form prints out a list of all users, roughly sorted by how long it's
been since that user last connected to the MOO.  For each user, the precise
time of their last connection is printed.

The second form only shows the last-connection time for the named user.


A letter is a special kind of note (see 'help notes') with the added feature
that it can be recycled by anyone who can read it.  This is often useful for
notes from one user to another.  You create the letter as a child of the
generic letter, $letter (see 'help @create' and 'help write'), encrypt it so
that only you and the other user can read it (see 'help encrypt') and then
either give it to the user in question or leave it where they will find it.
Once they've read it, they can use the 'burn' command to recycle the letter;
see 'help burn' for details.


Syntax:  @wrap <on|off>

	@linelength <number>

If the lines you see get cut off at the edge of your screen (you don't have
word-wrap), you can get MOOsaico to split lines for you.  The @linelength
command tells the MOO how many columns you have on your screen--you probably
want @linelength 79--and "@wrap on" tells the MOO you want it to do word-
wrap. Use always @wrap off if you use a MOO client.

It's better if you can fix this problem without MOOsaico's help, though,
because the MOO's solution will be slower than a local solution.

If you don't want the MOO to split lines for you, there might still be some
use for the @linelength command.  Certain commands, like @who and @check,
print truncated lines so they can print in neat columns.  The default for
these is generally about 79 columns, which looks fine if you have an
eighty-column screen.  If your screen is a different width, though, you
can set @linelength and some of these commands will react accordingly.


Syntax:  @listgag [all]
	@gaglist [all]

Shows you a list of the users and objects currently on your 'gag list'.  You
don't see any messages that result from actions initiated by the users or
objects on this list.  In particular, you will not hear them if they try to
speak, emote, or whisper to you.  See 'help gagging' for an explanation of
gagging in general.  With the optional "all" parameter it will also scan the
database for users who are gagging you.  This may induce lag, so caution is
advised with this option.


Syntax: look
       look <object>
       look <object> in <container>

Show a description of something.

The first form, with no arguments, shows you the name and and a brief
description of the room you're in, along with a list of the other objects that
are there.

The second form lets you look at a specific object.  Most objects have
descriptions that may be read this way.  You can look at your own description
using 'look me'.  You can set the description for an object or room, including
yourself, with the 'describe' command (see 'help describe').

The third form shows you the description of an object that is inside some
other object, including objects being carried by another user.

Please take note that `look' is a casual way of seeing around. Use `examine'
for a more apropriate observation of the environment (see `help examine').


The MOO email system allows you to send and receive messages to and from other
users.	It provides commands to view and manage your own collection of saved
messages and, in addition, to browse through other collections that may be
available (e.g.,archives of public mailing lists).  Help is available on the
following commands:

@mail	  -- seeing a table of contents for a collection of email messages
@read	  -- reading individual messages
@next	  -- reading the 'next'     message
@prev	  -- reading the 'previous' message

@send	  -- composing and sending a message to other users
@answer   -- replying to one of the messages in a collection
@forward  -- resending one of the messages in a collection somewhere else
@netforward -- followup moo messages to your registered email address
@registerme -- check/change your registered email address

@rmmail   -- discarding some subset of a collection
@unrmmail -- undoing the most recent @rmm on a collection
@renumber -- renumbering the messages in a collection

@mail-option -- describes and sets various customization flags

help mail-forwarding
 -- describes mail forwarding
help message-sequences
 -- describes message-sequences arguments to @mail, @read, @rmm, and @answer.

For viewing collections other from your own, the following commands are

@rn	     -- list those collections that have new messages on them
@subscribe   -- indicate that you want @rn to report on a given collection
		 and add yourself to its .mail_notify list
@skip	     -- ignore any remaining new messages in a given collection
@unsubscribe -- ignore a given collection entirely from now on
		 and remove yourself from its .mail_notify list
@unsubscribed-- show the mailing lists that you aren't subscribed to.
@subscribed  -- like @rn, but shows all lists that you are subscribed to
	       even if they have no new activity


Syntax:  @mail
	@mail new	     (to see recent messages)
	@mail 1-$	     (to see *all* messages)

Shows a table of contents for your MOO email message collection.  You are
notified when you connect to the MOO if there are any such messages.  A little
arrow indicates the mail system's notion of your 'current message'.
The first form lists all of your messages or the last 15 if you have more than
that many; the second form lists only those messages after your `current
message'.  The third form shows your entire collection.

If you have a large number of mail messages, you can give arguments so that
@mail only lists the messages you're interested in.  You can also list
messages residing on mail recipients which are public or for which you have
read access.
The general format is

	@mail <message-sequence> [on *<recipient>]

<recipient> must name some child of $mail_recipient (e.g., a mailing list);
<message-sequence> can be a sequence of message numbers; you can also scan the
recipient for articles that fit a given description, as specified in `help

Note that if you view mail on some other recipient and have "sticky" in your
.mail_options (see `help mail-options'), all further mail commands (e.g.,
@read, @next, @rmm,...) will apply to that recipient.  In this case use `@mail
on me' to go back to looking at your own mail.
- Show quoted text -


There are 3 personal properties that you can use to customize how your mail is
composed and forwarded

 -- list of objects that will receive any mail that gets sent to you.
   Objects on this list should either be players or descendants of
   If this list is nonempty, you will not receive any mail yourself unless
   you are on it.  E.g., if Rog is #4292 and ur-Rog is #6349

 #6349.mail_forward={}		  -- usual case; ur-Rog gets his own mail.
 #6349.mail_forward={#4292}	  -- Rog gets ur-Rog's mail instead.
 #6349.mail_forward={#6349,#4292} -- ur-Rog gets mail and Rog gets a copy.
 #6349.mail_forward={#-1}	  -- ur-Rog's mail disappears without a trace.

 -- list of objects to be notified whenever mail is sent to you.
   This list may include anything that has a :notify_mail() verb.
   Notification will take place regardless of whether or how your mail
   is forwarded.

Thus, in the previous example

 #4292.mail_notify={#6349} --- means that ur-Rog will be told
			       whenever Rog is sent new mail.

 -- this controls lots of miscellaneous things.  Use the @mail-option command
   to view and set these options (see `help @mail-option')

See `help mail-resolve' for more detail on how mail forwarding and mail
notification work.  See `help MR-subscribing' for information on how to change
.mail_forward and .mail_notify on $mail_recipient children, where they are !c


Syntax:  @mail-option
	@mail-option <option>

Synonym:  @mailoption

The first form displays all of your mail options
The second displays just that one option, which may be either `@mail',
`replyto', or one of the flags listed below.  The mail options control various
annoying details of your mail reading and mail editing commands.

The remaining forms of this command are for setting your mail options:

	@mail-option +<flag>
	@mail-option -<flag>
	@mail-option !<flag>	       (equivalent to -<flag>)

These respectively set and reset the specified flag

 -include      @reply's start out with a blank message body
 +include      @reply's start with original message included
 -all	       @reply's go to sender only
 +all	       @reply's go to sender and all original recipients
 -nosubject    @send forces you to provide a Subject: line
 +nosubject    allow entering the mail editor without giving a subject line
 -enter        start each mail editing session in the usual command mode.
 +enter        start each mail editing session with an implicit `enter'
 -expert       novice mail user (various annoying messages will be printed)
 +expert       expert mail user (suppress printing of annoying messages)
 -sticky       each mail command applies by default to one's own collection
 +sticky       each mail command applies by default to the same message
		collection that the previous successful command did
 -netmail      mail to you accumulates in your MOO mailbox
 +netmail      mail to you is actually forwarded to your registered email
	       address, if you have one.

For "sticky", `mail command' is one of @mail, @read, @prev, @next, @answer.
All flags default to the `-' settings.

Next, we have

	@mail-option  manymsgs [is] <number>
	@mail-option  manymsgs=<number>
	@mail-option -manymsgs

The first two forms specify that if you give a @mail or @read command asking
for <number> or more messages, you will first be given a yes-or-no prompt to
continue, the idea being that you many not actually have wanted to see that
many messages.	The third form turns off this behavior.

	@mail-option  @mail [is] <message-sequence>

The "@mail" option determines what message-sequence the @mail command uses by
default.  Initially, this is "last:15", but other reasonable choices include
"new" and "1-last"

	@mail-option  replyto [is] <recipient> [<recipient>...]
	@mail-option -replyto

The first form specifies that a Reply-To: field is to be placed in all
messages constructed by @send or @answer.  Note this can still be changed
before sending via the mail room's reply-to command.
The second form resets this option so that no Reply-to: is initially inserted.


Objects usually have verbs defined on them that allow users to manipulate and
use them in various ways. Standard ones are:

   get	-- pick an object up and place it in your inventory
  drop	-- remove an object from your inventory and place it in the room
   put	-- take an object from your inventory and place it in a container
  give	-- hand an object to some other user
  look	-- see what an object looks like
examine  -- take a closer look on an object

You can see what objects you're carrying with the 'inventory' command; see
'help inventory' for details.

Some specialized objects will have other commands. The programmer of the
object will usually provide some way for you to find out what the commands
are.  One way that works for most objects is the 'examine' command; see 'help
examine' for details.

The following specialized objects have help entries you should consult:

notes -- objects that allow text to be written on them and read later
letters -- notes that a recipient can burn after reading
containers -- objects that may contain other objects
- Show quoted text -


The MOO helps those who help themselves.  Try starting with `help summary'.


Certain mail commands, including @mail, @read, and @rmmail, allow a
<message-sequence> argument that indicates to which messages in one's
collection the command is to apply.  Any combination of the following may
appear as a <message-sequence> argument to any of the various mail commands
(@mail, @read, @answer, @rmm).

 17	   message number 17 if there is one (and likewise for other integers)
 17..23    all messages numbered between 17 and 23 (inclusive), if any.
 cur	   the current message
 prev	   the message before
 next	   the message after
 last	   the final message if any (`$' is a synonym for `last')

You may use as many of these at once as sanity permits, e.g.,

 @mail cur 1..5 last

which will display the header for your current message, your messages in the
range 1..5, and your last message.  Though some of these ranges may overlap,
the header for any given message is only shown once in any event.

In addition, there are other message-sequence arguments that act as filters
on whatever precedes them

 before:<date>		     messages strictly before the given date
 after:<date>		     messages strictly after the given date
 since:<date>		     messages on or after the given date
 until:<date>		     messages on or before the given date
 from:<player>[|<player...]  messages from the given player(s)
 to:<recip>[|<recip>...]     messages to the given recipient(s)
 subject:<string>	     messages with <string> in the subject
 body:<string>		     messages with <string> in the body (SLOW!!!)
 first:<number> 	     the first <number> messages
 last:<number>		     the last <number> messages

<date>	is either a weekday, an dd-Month, dd-Month-yy or dd-Month-yyyy date
<recip> is either <player> or *<$mail_recipient kid>


 @read from:G7|Gemba		  read all messages from G7 or Gemba
 @rmm to:yduJ|*Core		  remove messages that are to yduJ or to *Core
 @mail since:1-Jan before:1-Feb   show messages dated in January
 @mail since:Tues		  show messages dated on or after Tuesday
 @rmm subject:manners		  remove msgs with `manners' in the subject:
 @mail subject:"stupid idiots"	  (search string contains a space => need "'s)
 @rmm to:yduJ to:*Core		  remove messages that are to yduJ and *Core
 @mail from:Haakon last:5	  show the last 5 messages from Haakon
 @mail last:10 body:fribble	  show those of the last 10 messages having
				  `fribble' in the body (one should always try
				  to narrow body searches in this way).


Here are a few commands of occasional utility that didn't fit into any of the
neat categories for the rest of the help system:

@version -- printing the MOO server version number
@lastlog -- finding out when some user last connected to the MOO


Syntax:  @more
	@more rest
	@more flush

If you have @pagelength set (see `help @pagelength') and some combination of
events or commands produces sufficiently many lines of output, you will see a
message of the form

*** More ***  37 lines left.  Do @more [rest|flush] for more.

indicating (in this case) 37 more lines of text waiting to be read.
At this point, you should give one of the @more commands above.

@more without arguments prints sufficiently many lines to fill your screen,
assuming you've set @pagelength correctly, unless there are not that many
lines left to print.

@more rest will print all of the remaining lines, regardless of your
@pagelength setting.

@more flush discards all remaining lines


The descriptions of most rooms outline the directions in which exits exist.
Typical directions include the eight compass points ('north', 'south', 'east',
'west', 'northeast', 'southeast', 'northwest', and 'southwest'), 'up', 'down',
and 'out'.

To go in a particular direction, simply type the name of that direction (e.g,
'north', 'up').  The name of the direction can usually be abbreviated to one
or two characters (e.g., 'n', 'sw').  You can also type 'go <direction>' to
move; this is particularly useful if you know you're going to type several
movement commands in a row (see 'help go').

In addition to such vanilla movement, some areas may contain objects allowing
teleportation and almost all areas permit the use of the 'home' command to
teleport you to your designated home (see 'help home' for more details).

As a last resort you can always type '@ways' to get the obvious exits.


Syntax:  @netforward <message-number>
	@netforward <message-sequence> on *collection

Forwards the contents of the indiciated messages from your MOO email
collection to your registered email address.  You get the message numbers for
use here by typing the '@mail' command, which prints a table of contents for
your entire MOO email collection.  If no arguments are given to @netforward,
then the 'current message' in your collection is sent.	In any case, the
'current message' after @netforward finishes is not affected.

The most general form of the @netforward command is

	@netforward <message-sequence> [on *<collection>]

where <message-sequence> is as described in `help message-sequences'.
As with the @mail command you may @netforward messages on any publically
readable collection (child of $mail_recipient).

If you do not have a valid registered email address, you will not be able to
use this command and must first @registerme or get a wizard to register your
address. `help @registerme' for details.


Syntax:  news [ next | all | new ]

Read the latest edition of the Jornal do MOO, which carries articles
concerning recent changes to the MOO server or to the main public classes, or
whatever the wizards feel like writing about.

 news next  -  shows next story
 news all   -  shows all stories
 news new   -  shows new stories

To do something more complicated, use *News as a mailing list.


Syntax:  @next [on <collection>]

Print the `next' message in a given email collection (defaults to your own).
The mail system's notion of your 'current message' for that collection is
incremented.  Thus, e.g., one can read all of one's new messages one-by-one
simply by typing '@next' repeatedly.


Syntax:  @notedit <note-object>
	@notedit <object>.<property>

Enters the MOO Note Editor to edit the text on the named object
For the first form, <note-object> must be a descendant of $note.
For the second form, <object>.<property> can be any string-valued or
text-valued (i.e., list of strings) property on any object.

See 'help editors' for more detail.


Notes are objects that can have text written on them to be read later.	They
are useful for leaving messages to people, or for documenting your creations.

The following help topics cover verbs that can be used with notes:

read -- reading the text on the note
write -- adding text to a note
erase -- removing all the text from a note
delete -- deleting one line of text from a note

@notedit -- general editing on the text of a note

encrypt -- restricting who can read a note
decrypt -- undoing a previous encryption

You can make a note by creating a child of the standard note, $note (see 'help
@create').  Note that, like most objects, only the owner of a note can recycle
it.  If you'd like to make it possible for a reader of your note to destroy it
(this is a common desire for notes to other individual users), then you might
want to look at 'help letters'.


Syntax:  @opacity <container> is <integer>

The opacity can take on one of three values:
  0:  The container is transparent and you can always see into it.
  1:  The container is opaque, and you cannot see into it when closed
  2:  The container is a black hole, and you can never see into it whether
closed or open.

The default @opacity is 1.


Syntax:  sms  <user> [[with] <text>]
	page <user> [[with] <text>]

Sends a message to a connected user, telling them your location and,
optionally, <text>.

Munchkin types:
       page Frebble with "Where are you?"
Frebble sees:
       You sense that Munchkin is looking for you in the Kitchen.
       He pages, "Where are you?"
Munchkin sees:
       Your message has been received.

Advanced Features: `help page-conf'


Advanced Features:
Page refers to the following messages on the users involved (see 'help

@page_origin [You sense that %n is looking for you in %l.]
 Determines how the recipient is told of your location.

@page_echo   [Your message has been sent to %n.]
 Determines the response received by anyone who pages you.

@page_absent [%N is not currently logged in.]
 Determines the response received by anyone who tries to page you when you
aren't connected.

All of these undergo the usual pronoun substitutions (see 'help pronouns')
except that in both cases the direct object (%d) refers to the recipent of the
page and the indirect object (%i) refers to the sender.  You should only
change these messages if you want to add to the Virtual Reality feel of the
MOO for your character.

Do `help @refuse' to see how to refuse someone's attempts to page you.


Syntax:  @pagelength <number>

If the lines you see scroll off the top of your screen too quickly for you to
read and your client program is such that any lines scrolling off the top are
gone forever, you can use the @pagelength command to invoke page buffering to
limit the number of lines sent at a time.  E.g., if your terminal has a 24
screen, you can do @pagelength 24 and output will stop every 24 lines if you
don't type any other commands.

You will need to use the @more command to continue reading output once it
has been stopped.  Make sure you read `help @more' before setting @pagelength.

@pagelength 0 means no page buffering will be done by the MOO.

By default the MOO will assume you have an infinitely wide terminal screen, so
you may wish to set @linelength as well, and ensure wrapping is on with @wrap
on.  (See help @linelength and help @wrap.)  As with word wrapping, you are
best off running a client that can do its own page buffering; the MOO server's
page buffering is inherently slower and many MUD's do not have page buffering
at all.


Syntax:  @paranoid
	@paranoid off
	@paranoid immediate
	@paranoid <number>

In immediate mode, the monitor prepends everything you hear with the name of
the character it considers responsible for the message. Otherwise, it keeps
records of the last <number> (defaults to 20) lines you have heard. These
records can be accessed by the @check command (`help @check').


Syntax:  @password <old-password> <new-password>

Changes your user's password (as typed in the 'connect' command when you log
in to the MOO) to <new-password>.  For security reasons, you are required to
type your current (soon to be old) password as the first argument.

Your password is stored in an encrypted form in the MOO database; in
principle, not even the wizards can tell what it is, though they can change
it, of course.	It is recommended that your password not be your name or a
common word; MOO passwords have been stolen or cracked in the past and
characters have been made unhappy by such theft.  Your password is your
security; choose a safe one.

Only the first 8 characters of a password are significant.


A user name must be a single word, must not contain any spaces, backslashes,
or quotes, nor can it begin with the characters #, *, (, or ).	Finally it
cannot be one that is in use by any other user nor any of the words on the
following list:

 with		 onto		 under		 is		 feiticeiro
 using		 upon		 underneath	 as		 operator
 at		 out		 beneath	 off		 root
 to		 from		 behind 	 of		 administrator
 in		 inside 	 beside 	 me		 administrador
 into		 over		 for		 you		 info
 on		 through	 about		 admin

Note that these rules apply as well to your single-word aliases, since those
can equally well be used to refer to you in commands that match on user names
(@who, whereis, ...).  There are no restrictions on your multi-word aliases,
however the commands that expect user names will not recognize them.


There are a number of commands for modifying various characteristics of the
object representing you in the MOO, your 'character'.  Help on them is
available in the following topics:

@describe -- setting what others see when they look at you in english mode
@descreve -- setting what others see when they look at you in portuguese mode
@gender -- changing your character's gender
@password -- changing your character's password
@sethome -- changing your designated home room
@rename -- changing your name and/or aliases
@linelength -- adding word-wrap to the lines you see
@language -- changing your interface mode language


Syntax:  @prev [on <collection>]

Print the 'previous' message in a given email collection (defaults to your
own).  The mail system's notion of your 'current message' for that collection
is decremented.  Thus, e.g., one can review all of one's previous messages
one-by-one simply by typing '@prev' repeatedly.


Some things you should be aware of:

Wizards can look at absolutely *anything* in the MOO database.
The arch-wizard and the sysadmin for the MOO-server host have complete access
not only to the MOO database itself but to many other possibly-relevant
The above mentioned parties (wizards et al), while they will endeavor to be
discreet about anything incidental that turns up, nevertheless reserve the
right look at anything they want, if only for the sake of being able to
resolve technical problems.

 -*-*- LOGGING: -*-*-
Some client programs (the "client" is the program you use to connect to the
MOO, e.g., telnet, tinytalk, tinyfugue, emacs with mud.el...) are capable of
logging everything that happens to the corresponding user.  In fact, with some
clients this happens by default.  If a given user's client has logging enabled
and said user is either in the room with you or is monitoring an object that
is in the room with you, then *everything* you say and emote gets recorded.
Also, if you are in a room owned by someone else, all bets are off.  There is
*no way* that the MOO server can know about what client a given user is using;
thus, anyone who can hear you is a potential logger.

In and of itself this would not be a problem --- indeed, logs are often useful
for reference purposes.  However, there is no guarantee that the log will not
end up someplace where you'd rather it didn't, e.g., posted on the Usenet newsgroup.  While it considered bad form (i.e., rude) to
circulate or post a log without having the permission of at least the major
participants in the activities logged, there is not a whole lot we can do on
the technical side to prevent it from happening.

Be aware of the problem.  The @sweep command (see `help @sweep') attempts to
determine what users can be listening at any given moment.  If anything, it
errs on the side of paranoia.  Even so, it doesn't cover *all* possible
avenues of eavesdropping, and there's no hope for it covering the situations
like the one where someone manages to convince one of the participants in your
discussion who kept a log that it really doesn't need to be kept private after

If you've got something really sensitive to discuss, you are best off doing it
by encrypted email or in person.
- Show quoted text -


MOO contains a rich programming language for the creation of interesting
rooms, exits, and other objects.

Not every player is allowed to program in MOO, including (at the moment,
anyway) you.  If you would like to be, find a wizard and convince them that
you've got good ideas that the MOO needs.  Good luck!


Some kinds of messages are not printed directly to users; they are allowed to
contain special characters marking places to include the appropriate pronoun
for some user.	For example, a builder might have a doorway that's very short,
so that people have to crawl to get through it.  When they do so, the builder
wants a little message like this to be printed:

       Balthazar crawls through the little doorway, bruising his knee.

The problem is the use of 'his' in the message; what if the user in question
is female?  The correct setting of the 'oleave' message on that doorway is as

       "crawls through the little doorway, bruising %p knee."

The '%p' in the message will be replaced by either 'his', 'her', or 'its',
depending upon the gender of the user.

As it happens, you can also refer to elements of the command line (e.g.,
direct and indirect objects) the object issuing the message, and the location
where this is all happening.  In addition one can refer to arbitrary string
properties on these objects, or get the object numbers themselves.

The complete set of substitutions is as follows:

       %% => `%'  (just in case you actually want to talk about percentages).
       %n => the user
       %t => this object (i.e., the object issuing the message,... usually)
       %d => the direct object from the command line
       %i => the indirect object from the command line
       %l => the location of the user
       %s => subject pronoun:	       either `he',  `she', or `it'
       %o => object pronoun:	       either `him', `her', or `it'
       %p => posessive pronoun (adj):  either `his', `her', or `its'
       %q => posessive pronoun (noun): either `his', `hers', or `its'
       %r => reflexive pronoun:  either `himself', `herself', or `itself'
   General properties:
       %(foo) =>
       %[tfoo], %[dfoo], %[ifoo], %[lfoo]
	      =>,,, and
   Object numbers:
       %#  => user's object number
       %[#t], %[#d], %[#i], %[#l]
	   => object numbers for this, direct obj, indirect obj, and location.

In addition there is a set of capitalized substitutions for use at the
beginning of sentences.  These are, respectively,

  %N, %T, %D, %I, %L for object names,
  %S, %O, %P, %Q, %R for pronouns, and
  %(Foo), %[dFoo] (== %[Dfoo] == %[DFoo]),... for general properties

Note: there is a special exception for user .name's which are assumed to
already be capitalized as desired.

There may be situations where the standard algorithm, i.e., upcasing the first
letter, yields something incorrect, in which case a "capitalization" for a
particular string property can be specified explicitly.  If your object has a
".foo" property that is like this, you need merely add a ".fooc" (in general
.(propertyname+"c")) specifying the correct capitalization.  This will also
work for user .name's if you want to specify a capitalization that is
different from your usual .name

Rog makes a hand-grenade with a customizable explode message.
Suppose someone sets grenade.explode_msg to:

 "%N(%#) drops %t on %p foot.  %T explodes.
  %L is engulfed in flames."

If the current location happens to be #3443 ("yduJ's Hairdressing Salon"),
the resulting substitution may produce, eg.,

 "Rog(#4292) drops grenade on his foot.  Grenade explodes.
  YduJ's Hairdressing Salon is engulfed in flames."

which contains an incorrect capitalization.
yduJ may remedy this by setting #3443.namec="yduJ's Hairdressing Salon".

Note for programmers:
 In programs, use $string_utils:pronoun_sub().
 %n actually calls player:title() while %(name) refers to


Syntax:  put <object> into <container>
	insert <object> in <container>

Moves the named object into the named container.  Sometimes the owners of the
object and/or the container will not allow you to do this.


Syntax:  @quit

Disconnect from the MOO.  This breaks your network connection and leaves your
user sleeping.	Disconnecting in most parts of the MOO automatically returns
your user to its designated home (see 'help home').


Syntax:  read <note>

Prints the text written on the named object, usually a note or letter.	Some
notes are encrypted so that only certain users may read them.


Syntax:  @read <message-number>
	@peek ...

Prints the contents of the indiciated messages from your MOO email collection.
You get the message numbers for use here by typing the '@mail' command, which
prints a table of contents for your entire MOO email collection.  If no
arguments are given to @read, then the 'current message' in your collection is
printed.  In any case, the 'current message' after @read finishes is the last
one printed.

The most general form of the @read command is

	@read <message-sequence> [on *<collection>]

where <message-sequence> is as described in `help message-sequences'.
As with the @mail command you may @read messages on any publically readable
collection (child of $mail_recipient).

The @peek command is a variant of @read that works no differently except that
it refrains from setting your `current message'.  This is useful, for example,
if you want to see some particular message on a collection without losing
track of where you are in it.


 @registerme as <email-address>

This verb changes your registered email_address property. It will modify the
registration, and then, to validate the email address, it will assign a new
password and mail the password to the given email_address.
If, for some reason, this is a problem for you, contact a wizard or registrar
to get your email address changed.

Prints your registered email address.


Syntax: @rename <object>	to [name-and-alias],<alias>,...,<alias>
       @rename <object>        to [name]:<alias>,...,<alias>
       @rename <object>:<verb> to <new-verb-name>

The first two forms are used to change the name and aliases of an object.  The
name is what will be used in most printed descriptions of the object.  The
aliases are the names by which users can refer to the object in commands.
Typically you want to include the name in the aliases, as the MOO parser only
checks .aliases when matching, so the first syntax is generally preferred.

If you leave out the "name" part of the list, @rename will leave the object's
name as it is, and only change the aliases.

Note that for renaming users, more stringent rules apply.  See `help
user-names'.  Certain other kinds of objects (e.g., mail recipients) also
enforce their own rules w.r.t what they can be named.

Munchkin names his dog:
 @rename #4237 to "Rover the Wonder Dog":Rover,dog
Now we'll see 'Rover the Wonder Dog' if we're in the same room as him and we
can refer to him as either 'Rover' or just 'dog' in our commands, like 'pet
dog'.  Note, however, that it will be impossible to use "Rover the Wonder Dog"
to rever to the dog: if you don't include the name in the aliases, confusion
can result.  It might have been better to start off with
 @rename #4237 to "Rover the Wonder Dog",Rover,dog

Since he didn't, Munchkin now changes his dog's aliases:
 @rename #4237 to ,Rover,dog,Rover the Wonder Dog
The name remains the same--we still see 'Rover the Wonder Dog'--but now any of
'Rover', 'dog', or 'Rover the Wonder Dog' can be used to refer to him.	This
can help reduce confusion.

The third form of the @rename command is for use by programmers, to change the
name of a verb they own.  If the <new-verb-name> contains spaces, the verb
will have multiple names, one for each space-separated word.


Syntax:  @renumber [<collection>]

Renumbers the messages in your collection to go from 1 to however many you
have at the moment.  The optional argument allows you to renumber the messages
stored in some other collection (@renumber, like @rmmail, requires write

Note that if you have zombie messages from a previous @rmmail command (see
`help zombie-messages'), these will be expunged.


Usage:	@request <user-name> for <email-address>

This command available to Guest characters only.

The @request command requests a new character, registered for your email
address. Please use your primary address for this, as your password will be
sent to the address provided.


Syntax: @resident user
       @resident !user

Adds or removes a user from the residents list of a room.  The residents list
controls who is allowed to use @sethome in that room.  This defaults to just
the owner of the room; by manipulating the residents list you may allow
additional users to use that room as their home.

@resident user adds that user to the list.
@resident !user removes that user from the list.
@resident with no arguments simply displays the current list (which may be
"none", indicating no additional people besides the owner may use that room as
their home).

See also help @sethome.

Hints for programmers: The verb $room:accept_for_abode is called by @sethome.
By overriding this verb you can give different criteria to @sethome.  It
should return 1 for allowed and 0 for denied.


Syntax: @rmalias <alias>[,...,<alias>] from <object>
       @rmalias <alias>[,...,<alias>] from <object>:<verb>

The first form is used to remove aliases from an object.  If the object is a
valid user, space and commas will be assumed to be separations between
unwanted aliases.  Otherwise, only commas will be assumed to be separations.
Note that @rmalias will not affect the object's name, only its aliases.

The second form is for use by programmers, to remove aliases from a verb they
own.  All spaces and commas are assumed to be separations between unwanted


Syntax:  @rmmail [<message-sequence>] [from *<recipient>]

Deletes the indicated messages from your MOO email collection.
By default, your current message is deleted.
See `help message-sequence' for the full list of possible arguments.
You get the message numbers for use here by typing the '@mail' command.

There is no confirmation for this action, so be careful.  While it is true
that @unrmmail will be able to bring back the messages deleted by the last
@rmm, any messages deleted before then are really gone, i.e., irrecoverable.
See `help @unrmmail' for more information.

This command may be used on other mail recipients (children of
$mail_recipient), but only ones to which you have write access (you either
have to own it or be on good terms with whoever does...).


Syntax:  @rn

For each collection of mail messages that you read other from your own, a
last-read-time is kept.  This command tells you which collections (out of all
those you have ever read) have recently had messages added to them, i.e., more
recently than when you last did a @read, @prev, @next, or @skip on that

Etymologists' note:  If you thought @rn had anything to do with the popular
UNIX newsreading program `rn', it's just your imagination.


A few different messages can be set on a room object (see 'help messages' for
instructions on doing so); they are printed to various audiences when a player
or other object is ejected from the room.  (See 'help @eject'.)  The standard
pronoun substitutions are made on each message before it is printed; see 'help
pronouns' for details.

The default message is given in brackets after each name below:

@ejection  [You expel %d from %i.]
 Printed to the player doing the ejecting.

@victim_ejection  [You have been expelled from %i by %n.]
 Printed to the object being ejected.

@oejection  [%D is unceremoniously expelled from %i by %n.]
 Printed to others in the room from which the object is being ejected.


Rooms may be made by builders, using the @dig verb. By default, all rooms are
instances of _the_ room, $room, or #3, which you can examine to see how it
works. If you require a room to have a more specific behaviour, you can make a
subclass of room.


Syntax:  say <anything> ...
	"<anything> ...

Says <anything> out loud, so that everyone in the same room hears it.  This is
so commonly used that there's a special abbreviation for it: any command-line
beginning with a double-quote ('"') is treated as a 'say' command.

Munchkin types this:
 "This is a great MOO!
Munchkin sees this:
 You say, "This is a great MOO!"
Others in the same room see this:
 Munchkin says, "This is a great MOO!"
if they're in english mode, or,
 Munchkin diz, "This is a great MOO!"
if they're in portuguese mode.	There's a support for other languages too.


There are several commands available to determine the origins of messages and
to check that your communications with other users are secure. Help is
available on the following topics:

@paranoid -- keeping a record of messages your character hears.
@check	  -- looking at that record to determine responsibility for messages.
@sweep	  -- checking who is listening in on your conversation.


Syntax:  @send <recipient> [<recipient> ...]  [subj[ect]="<subject>"]

Prepares for you to compose a MOO email message to the recipients named on the
command line.  A recipient can be specified by giving a player name or
object-id, or a '*' followed by the name or object-id of some non-player mail
recipient (e.g., a mailing list or a mail folder) -- a list of such non-player
recipients is available from within the mailroom with the 'showlists' command.

The usual editor is invoked.
You will be prompted for a subject line if you did not specify one in the
@send command (see `help mail_options' for how to avoid this).
Use `say' (") to insert lines in the body of your message.
See `help editors' for details.

Giving this command without arguments resumes editing the previous unsent
draft message if one exists.


Syntax: @sethome

Sets your designated home (see `help home') to be the room you're in now.  If
the current room wouldn't allow you to teleport in, then the `@sethome'
command nicely refuses to set your home there.	This avoids later, perhaps
unpleasant, surprises.	Additionally, your home must be a room that will allow
you to stay there.  Rooms which you own will do this, as will rooms to which
you have been added as a resident.  See the @resident command for help on
adding someone as a resident to a room you own.


Syntax:  @skip [<collection>...]
	@unsubscribe [<collection>...]

For each collection of mail messages that you read other from your own, a
current message and a last-read-time is kept.  Normally, if you neglect to
actually @read any messages on a collection other from your own, @rn (or
:check_mail_lists) will continue to remind you that they are there.

The @skip command indicates that you're not interested in reading the rest of
the messages that currently exist in that given collection.

The @unsubscribe command flushes the current-message/last-read-time
information completely, indicating that you are not only uninterested in the
rest of the messages on that collection, but also likewise uninterested in
anything else that may appear on that collection later on.  @unsubscribe also
removes you from the collection's .mail_notify list.


Syntax:  @subscribe *<collection> [with notification]

The first form of this command does two things:

(1) it sets up a current message and a last-read-time for the given mail
   collection so that when next you log in, you will be informed about new
   mail that has appeared there.  Note that this happens automatically
   whenever you @read messages on a given collection, so if this much is
   all you care about, you don't need to use this command; just do, e.g.,
	    @read last on *<collection>

(2) if you added the "with notification clause, adds you to the .mail_notify
   list for that collection, so that you will be notified *immediately*
   whenever new mail is sent there.

You can only @subscribe to collections that are readable by you.
The second form of the command gives a list of collections available to you.

Note that this is entirely different from the Mail Room `subscribe' command
which actually adds you to the .mail_forward list for a given collection/
mailing-list, so that mail sent to the list actually shows up in your own
mail collection.
We're probably going to phase out the Mail Room `subscribe' command...


Syntax: @subscribed

Like @rn, but shows you ALL mailing lists to which you are subscribed, even
those which have no new messages.


Help is available on the following general topics:

theme  -- the idea behind all of this
introduction  -- what's going on here and some basic commands
index  -- index into the help system

users  -- setting characteristics of yourself
movement  -- moving yourself between rooms
communication  -- communicating with other users
manipulation  -- moving or using other objects
miscellaneous  -- commands that don't fit anywhere else

@helpers  -- the connected Official Helper Persons
@wizards-list/@wizards	-- the list of the wizards of MOOsaico
@pagelength  -- what to do if lines scroll off your screen too fast
@linelength  -- what to do if lines are truncated

building  -- extending the MOO
programming  -- writing code in the MOO programming language
editors  -- editing text and code in the MOO


Syntax: @sweep

Used when you wish to have a private conversation, and are concerned someone
may be listening in. @sweep tries to list the avenues by which information may
be leaving the room. In a manner analogous to @check, it assumes that you
don't want to hear about your own verbs, or those belonging to wizards, who
presumably wouldn't stoop to bugging.


Syntax:  take <object>
	get <object>
	take <object> from <container>
	get <object> from <container>
	remove <object> from <container>

The first two forms pick up the named object and place it in your inventory.
Sometimes the owner of the object won't allow it to be picked up for some

The remaining forms move the named object from inside the named container (see
'help containers') into your inventory.  As before, sometimes the owner of an
object will not allow you to do this.


Syntax:  @typo	  [<text>]
	@bug	 [<text>]
	@suggest [<text>]
	@idea	 [<text>]
	@comment [<text>]

If <text> is given, a one-line message is sent to the owner of the room,
presumably about something that you've noticed.  If <text> is not given, we
assume you have more to say than can fit comfortably on a single line; the
usual mail editor is invoked.  The convention is that @typo is for
typographical errors on the room or objects found therein, @bug is for
anomalous or nonintuitive behaviour of some sort, @idea/@suggest for any
particular brainstorms or criticisms you might happen to have, and @comment
for anything else.

If you're sending a bug report to someone because you got an error traceback
when you used some object of theirs, please give them enough information to
work on the problem.  In particular, please tell them *exactly* what you typed
and *all* of the error messages that were printed to you, including the entire
traceback, up to the line `(End of traceback.)'.  Without this information, it
is nearly impossible for the programmer to discover, let alone fix, the

The usual mail editor is only invoked for this command when in rooms that
allow free entry, i.e., rooms that are likely to allow you back after you are
done editing your message.  Otherwise these commands will require <text> and
only let you do one-line messages.
Most adventuring scenario rooms fall into this latter category.


Syntax:  @ungag <user or object>
	@ungag everyone

Remove the given user or object (or, in the second form, everyone) from your
'gag list'.  You will once again see any messages that result from actions
initiated by the ungagged user(s) or objects.  In particular, you will once
again be able to hear them if they speak, emote, or whisper to you.  See 'help
gagging' for an explanation of gagging in general.

Munchkin types:
 @ungag Grover
and is once again able to hear Grover's witty remarks.	Sigh...


Syntax:  @unrmmail [list|expunge] [on *<collection>]

When you do @rmmail on a particular message collection, the messages removed
don't go away immediately, but are rather saved elsewhere.  These "zombie"
messages can be brought back or examined using the @UNrmmail command.

Without `list' or `expunge', @unrmm restores the zombie messages, thus undoing
the effect of the most recent @rmmail command.	Only the most recent @rmmail
can be undone in this way; messages deleted by any previous @rmmail commands
on this same collection are lost and gone forever.

The `list' option merely lists the headers of the zombie messages without
actually restoring them.

The `expunge' option banishes the zombie messages forever.

Note that the message numbers used by zombie messages are held in reserve
against the possibility that you might @unrmm them some day; with such
messages around, new messages received will be given higher numbers than you
might have expected.  @renumber does an implicit @unrmm expunge.

`@unrmmail' and `@unrmmail expunge' on collections other than your own are
only allowed when you have write access.  Likewise, `@unrmmail list' on other
collections is only possible when they are readable by you.


Syntax:  @uptime

  The @uptime command displays the amount of time since the last restart of
the server.
  Note to programmers:	The last restart time of the server is stored in


There are a number of commands for modifying various characteristics of the
object representing you in the MOO.  Help on them is available in the
following topics:

@describe -- setting what others see when they look at you
@gender -- changing your user's gender
@password -- changing your user's password
@sethome -- changing your designated home room
@rename -- setting your new name and/or new aliases
@name-swap -- changing your name from one of your aliases
@linelength -- adding word-wrap to the lines you see
@language -- setting your current language mode
@languages -- setting what languages you speak


Syntax:  @version

Prints out the version number for the currently-executing MOO server.


Syntax:  whereis [<user> [<user>...]]
       @whereis [<user> [<user>...]]

Returns the current location of each of the specified users, or of all users
if not arguments given.


Sintaxe:  whisper "<text>" to <user>

sends the message "<yourname> whispers, "<text>" to you " to <user>, if they
are in the room.


Syntax: @who
       @who <user> [<user> ... ]

The first form lists all of the currently-connected users, along with the
amount of time they've been connected, the amount of time they've been idle,
and their present location in the MOO.

The second form, in which a list of user names is given, shows information for
just those users.  For any listed users that are not connected, we show the
last login time instead of the connect/idle times.

@who refers to the @who_location message (see 'help messages') on each user's
location in order to determine what should be printed in the location column.
Pronoun substitutions are done on this string in the usual manner (see 'help
pronouns').  The default value is "%T" (i.e., the room name).


ArchWizard:  Wizard
Wizards:     Oblivion	      (a.k.a. Rodericus)
	    Poirot	     (a.k.a. Kent)
	    Gandalf	     (a.k.a. Biafra)

Please try to get help first from the HELP channel.  One of the
persons listening to that channel will answer your call.
To do that type `page help ...' where ... will be the description
of what you're needing.

Remember also that as you are trying to get some help, it's
possible that some one else has just done the same thing and the
persons on the HELP channel or the wizards are managing to
correct a problem and may not answer to you soon.


@wizards [ connected | all ]

Shows a list of wizards.  Without an argument or with an argument of
"connected", shows only those wizards who are connected.  With an argument of
"all", shows all wizards.



Shows the list of all the wizards and their characters.


Syntax:  write "<any text>" on <note>

Adds a line of text to the named note or letter.  Only the owner of a note may
do this.


Syntax:  yell  <anything> ...
	shout <anything> ...

Everyone in the same room and in the nearby ones will hear your shout.
Naturatly some doors or passageways may block the sound.

Copyright © 1994-2023 MOOsaico, Multilingual Virtual Community
All Rights Reserved. Todos os direitos reservados.
29 years of MOO (1994-2023)