MOOsaico: Multilingual Virtual Community

Builder Help Topics (#122)
==========================

@add-entrance	    @contents		@kids		    @remove-entrance
@add-exit	    @count		@locations	    @remove-exit
@add-owned	    @create		@lock		    @set
@audit		    creation		@lock_for_open	    @setprop
@build-options	    @dig		locking 	    @sort-owned
builder-index	    @dump		messages	    thing-messages
building	    @entrances		@messages	    topology
@check-chparent     @examine		@move		    @unlock
@check-property     exit-messages	@parents	    @unlock_for_open
@chparent	    @exits		@realm		    @verify-owned
@classes	    key-representation	@recreate	    
connectivity	    keys		@recycle	    


@ADD-ENTRANCE
=============

Sintaxe:  @add-entrance <nu'mero-objecto-saida>

Adiciona a saida com o nu'mero de objecto dado como uma entrada reconhecida no
quarto corrente ( isto e', uma cujo uso na~o e' considerado teletransporte ). 
Normalmente o @dig faz isso por si, excepto se voce^ na~o for o/a dono/a do
quarto em questa~o.  Nesse caso, diz-lhe o nu'mero de objecto da nova saida e
tem de ser voce^ a encontrar o/a dono/a de quarto e dizer-lhe para usar
@add-entrance para efectuar a ligac,a~o.

@ADD-EXIT
=========

Sintaxe:  @add-exit <nu'mero-objecto-saida>

Adiciona a saida com o nu'mero de objecto dado como uma saida convencional do
quarto corrente (isto e', uma saida que pode ser invocada apenas digitando o
seu nome, como por exemplo `oeste'). ).  Normalmente o @dig faz isso por si,
excepto se voce^ na~o for o/a dono/a do quarto em questa~o.  Nesse caso,
diz-lhe o nu'mero de objecto da nova saida e tem de ser voce^ a encontrar o/a
dono/a de quarto e dizer-lhe para usar @add-exi
t para efectuar a ligac,a~o.


@ADD-OWNED
==========

Syntax:  @add-owned <object>

Adds an object to your .owned_objects property in case it managed not to get
updated properly upon creation of that object.	Checks to ensure that the
objects is really owned by you and otherwise belongs in your .owned_objects
property.  See help @audit for more information.

@AUDIT
======

Sintaxe:  @audit [<pessoa>] [for <string>] [from <nu'mero>] [to <nu'mero>]

`@audit'	imprime uma auditoria de todos os objectos que possui.
`@audit pessoa' imprime o mesmo relato'rio sobre outro utilizador.

A string do `for' restringe a procura a objectos cujo nome comece por ela.
E' tambe'm possivel restringir a extensa~o dos nu'meros dos objectos em ordem a
incluir apenas os que esta~o acima de um certo nu'mero (`from') ou abaixo de um
certo nu'mero (`to').

Todas as formas do @audit imprimem um relato'rio:

   #14 Gemba			      [The Pool]
  #144 Popgun			      [Gemba]
 #1479 Cockatoo 		     *[The Living Room]
 #1673 Bottom of Swimming Pool	     
 #2147 Cavern			     <-*west
 #2148 tunnel			      Bottom of Swimming ->Cavern

A primeira coluna e' o nu'mero do objecto, a segunda o seu nome.  A terceira
coluna mostra a localizac,a~o do objecto: Gemba esta' em The Pool, e transporta
Popgun (#144).
Para saidas, a terceira coluna mostra origem -> dest (precedida de um * se
possuida por outra pessoa).
Para quartos, a terceira coluna mostra qualquer entrada que pertenc,a a outra
pessoa, listado como <-*.

@audit usa uma propriedade .owned_objects da personagem, para rapidez.	Esta
propriedade e' actualizada quando se cria ou se destroi objectos e quando ha'
uma mudanc,a de posse.	Na verdade, o verbo @auditdb (mesmos args que o @audit)
percorre toda a base de dados pelos objectos.

Ver tambe'm @verify-owned, @sort-owned, e @add-owned.

Ver tambe'm @prospectus, que fornece informac,a~o adicional.

@BUILD-OPTIONS
==============

Syntax:  @build-option
	 @build-option <option>

Synonyms:  @buildoption, @builder-option @builderoption

The first form displays all of your builder options.
The second displays just that one option, which may be one of the flags listed
below.	The builder options control various annoying details of your building
commands (e.g., @create, ...)

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

	 @build-option create_flags [is] <flags>
	 @build-option create_flags=<flags>
	 @build-option -create_flags
		      (equivalent to create_flags="")

where flags is some substring of "rwf".  This option determines the
read/write/fertility permissions of an object freshly created with @create (see
`help @create' and `help @chmod').  E.g., to make every object you create
henceforth readable by default, do

	 @build-option create_flags=r

For controlling the behavior of @dig, we have

	 @build-option	dig_room=<room>
	 @build-option	dig_room [is] <room>
	 @build-option -dig_room
		      (equivalent to dig_room=$room)
	 @build-option	dig_exit=<exit>
	 @build-option	dig_exit [is] <exit>
	 @build-option -dig_exit
		      (equivalent to dig_exit=$exit)

The following respectively set and reset the specified flag option

	 @build-option +<option>
	 @build-option -<option>
	 @build-option !<option>	   (equivalent to -<option>)

Currently the only builder flag option available is
 -bi_create	@create/@recycle re-use object numbers.
 +bi_create	@create/@recycle call create()/recycle() directly 

we prefer that you not use +bi_create, since this drives up the object numbers.

BUILDING
========

Ha' um nu'mero de comandos disponiveis `as personagens para construirem novas
partes do MOO.	Esta' disponivel ajuda sobre eles nos seguintes to'picos:

criac,a~o  -- fazer, desfazer e listar os seus quartos,saidas e outros objectos
topologia  -- criar e listar as ligac,o~es entre quartos e saidas
descric,o~es  -- definir os nomes e textos de descric,a~o dos objectos novos
locking  -- controlar o uso e o acesso aos seus objectos

@CHECK-CHPARENT/@CHECK-PROPERTY
===============================

Syntax:  @check-property <object>.<propname>
	 @check-chparent <object> to <newparent>
	 
You cannot add a new property to an object if an ancestor or a descendant
already defines a property with the same name.	@check-property will give you
the list of all descendants of <object> that that define .<propname>.  

Likewise you cannot chparent an object to a new parent if the new parent has a
property that is also defined on the object or some descendant.  Use
@check-chparent to find out all instances of conflicting properties that would
interfere with @chparent in this manner.

Note that @check-property requires either that you own the object or that it be
writeable, the same conditions that need to hold if you are to create new
properties on the object.  Similarly, @check-chparent requires that you own the
object and that the new parent is either fertile or likewise owned by you.

For objects with large numbers of descendants, these commands can be
time-consuming.

@CHPARENT
=========

Syntax:  @chparent <object> to <new parent>

Changes the parent of the named object to be the named parent.	The object
acquires all the verb and property definitions of its parent.  Newly acquired
properties are initilialized with `clear' values so that they inherit whatever
values are currently assigned to the parent's corresponding properties (see
`help @clearproperty').

If the user does not own <new parent>, it must have been set `fertile'. 
<object> must be owned by the user.  Neither <object> nor any descendant can
define any property which already exist on <new parent>.  Use @check-chparent
(see `help @check-chparent') to list such property conflicts.

It is also sometimes the case that you will own some object and want to
@chparent some child of that object that you do not own.  Use @disinherit (see
`help @disinherit') in such situations.

@CLASSES
========

Syntax:  @classes
	 @classes <class-name> ...

The wizards have identified several useful classes of objects in the database. 
The @classes command is used to see which classes exist and what their member
objects are.

The first form simply lists all of the defined classes along with short
descriptions of the membership of each.

The second form prints an indented listing of that subset of the object
parent/child hierarchy containing the objects in the class(es) you specify.

CONNECTIVITY
============

Para construir uma sala sem ligac,a~o:

    @dig <nome>
 ou @dig <nome1>,<nome2>,...

Para ligar um local ao si'tio onde se encontra, a sintaxe e' diferente.

    @dig <nome-da-direcc,a~o> to <nome>
 ou @dig <nome-da-direcc,a~o1>,<nome-da-direcc,a~o2>,... to <nome>

Isto criara' uma nova sala chamada <nome> e uma sai'da da sala corrente para
essa nova sala.  Mas normalmente na~o e' bem isto que quer pois tambe'm quer
retornar.  Para isso fac,a:

    @dig <nome-da-direcc,a~o>|<nome-da-direcc,a~o-de-retorno> to <nome>

Isto criara' tre^s objectos: a sala/local (chamada <nome>), uma sai'da de onde
se encontra para a nova sala (chamada <nome-da-direcc,a~o>), e uma sai'da da
nova sala de volta ao local onde se encontra (chamada
<nome-da-direcc,a~o-de-retorno>).

O @dig na~o o move para o novo local criado.  Se quiser construir outra sala a
partir dela', tem de se mover primeira para la' (usando a sua nova sai'da).

Quase sempre, deve dar va'rios nomes `as direcc,o~es.  Por exemplo,

    @dig sul,s|norte,n to "A Minha Nova Sala"

Dessa maneira, pode-se usar tanto `sul' como `s' para se chegar la', e tanto
`norte' ou `n' para voltar.

Para se ligar a uma sala ja' existente em vez de criar uma nova, use o nu'mero
de objecto da sala em vez do nome.  Por exemplo, para se ligar a um local com o
nu'mero de objecto #123456, pode fazer:

    @dig sul,s|norte,n to #123456

Na~o pode criar ligac,o~es para e de locais que na~o lhe pertenc,am sem a ajuda
dos seus donos (O @dig lembra-se de avisar sobre isso).  Para uma sai'da
funcionar, tanto o dono da origem da sai'da como o dono do destino devem estar
de acordo.  Um dono pode adicionar uma entrada ou sai'da da sua sala para a
dele indo para essa sala e utilizar o @add-entrance e @add-exit.  Assim, se
fizer uma sai'da #987654 que va' para #123456 mas que na~o possa ficar ligada
por na~o a possuir, o dono dela pode ir para essa (#123456) e fazer:

    @add-entrance #987654

Ou se tentar contruir uma sai'da com o @dig (#987654) desde a sala de outra
pessoa para uma sua e na~o pode ficar ligada, o dono da sala de onde tentou
fazer a ligac,a~o pode ir para a sala dele e fazer:

    @add-exit #987654

Para mais informac,a~o, fac,a `ajuda topologia'.

@CONTENTS
=========

Sintaxe:  @contents <objecto>

Uma maneira ra'pida de saber o conteu'do de um objecto.  Imprime os nomes e
nu'meros de objecto de todos os objectos contidos em <objecto>.  Isto pode ser
u'til quando precisa de referenciar uma coisa por nu'mero de objecto porque
qualquer coisa na~o esta' bem com os seus aliases.

Exemplo:
  @contents here
  The Entrance Hall(#19) conte'm:
  Strasbourg Clock(#71)   mirror at about head height(#7444)

@COUNT
======

Syntax:  @count

Prints out the number of objects you own.  Do not be surprised if this is one
larger than you think it should be: remember that your user object is owned by
you as well, even though you didn't create it in the usual way.

@CREATE
=======

Sintaxe:  @create <nome-classe> named "<nomes>"
	  @create <objecto-pai> named "<nomes>"

O comando principal para criar objectos sem serem quartos ou saidas (para esse,
veja `ajuda @dig'; e' muito mais conveniente).

O primeiro argumento especifica o `pai' do objecto: isto e', o `tipo' de
objecto que esta' a criar.  <nome-classe> e' uma das quatro classes
normalizadas de objectos: $note, $letter, $thing, or $container.  Com o passar
do tempo, mais `classes normalizadas' podem ser adicionadas.  Se o progenitor
que esta' a pensar para o seu novo objecto na~o e' um destes, pode usar o nome
do progenitor (se estiver consigo no quarto) ou enta~o o seu nu'mero de objecto
(e.g., #4562).

Os "nomes" sa~o dados no mesmo formato que o do comando @rename:
	<nome-e-alias>,<alias>,...,<alias> [preferivel]
	<nome>:<alias>,...,<alias> [na~o preferivel]

Veja `ajuda @rename' para um debate sobre a diferenc,a entre um nome e um
alias.

CREATION
========

O principal meio para os utilizadores extenderem o MOO e' criarem novos
objectos com comportamentos interessantes.  Estes sa~o comandos convenientes
para se criar e reciclar objectos bem como manter um conhecimento dos objectos
que se criou.  Existe ajuda disponivel sobre estes comandos nos seguintes
to'picos:

    @dig  -- constroi convenientemente novos quartos e sai'das
 @create  -- cria outro tipo de objectos
@recycle  -- destroi objectos que ja' na~o quer
  @quota  -- determina quanto espac,o de criac,a~o tem disponivel
  @count  -- determina quantos objectos e' que possui
  @audit  -- lista todos os seus objectos
@classes  -- lista todas as classes pu'blicas disponiveis que pode usar
  @realm  -- lista a a'rvore de descendencias de objectos seus ou de outra
pessoa
   @move  -- move os seus objectos de um si'tio para outro

@DIG
====

Sintaxe:  @dig "<nome-quarto-novo>"
	  @dig <espec-sai'da> to "<nome-quarto-nome>"
	  @dig <espec-sai'da> to <nu'mero-objecto-quarto-antigo>

Esta e' a ferramenta ba'sica de construc,a~o.  A primeira forma do comando cria
um novo quarto com o nome dado.  O novo quarto na~o esta' ligado a lado nenhum;
flutua no limbo.  O comando @dig diz-lhe o nu'mero de objecto dele, para assim,
usar o comando @move para chegar la' facilmente.

A segunda forma do comando na~o so' cria o quarto, mas tambe'm uma ou duas
sai'das ligando o seu local corrente ao ( e possivelmente do ) novo quarto. 
Uma <espec-sai'da> tem uma das duas seguintes formas:
       <nomes>
       <nomes>|<nomes>
onde a primeira forma e' usada quando so' quer criar uma sai'da, do seu quarto
corrente para o novo quarto, e a segunda forma quando tambe'm quer uma sai'da
de volta, do seu novo quarto para o corrente.  Em ambos os casos, a parte
<nomes> e' apenas uma lista de nomes para a sai'da, separados por vi'rgulas;
estes sa~o os nomes dos comandos que os utilizadores podem digitar para usar a
sai'da.  E' vulgarmente boa ideia incluir explicitamente as abreviaturas usuais
para nomes de direc,o~es (e.g., `n' para `norte', `se' para `sudeste', etc.). 
NA~O ponha espac,os nos nomes das sai'das; sa~o inu'teis no MOO.

A terceira forma do comando e' quase como a segunda forma excepto que nenhum
quarto e' criado; em vez disso especifica por nu'mero de objecto o outro quarto
para/de onde a nova saida vai estabelecer ligac,a~o.

NOTA: Te^m de possuir o quarto de uma ponta ou da outra para as sai'das serem
criadas.  Se possui as duas, esta' tudo [hunky-dorey].	Se so' possui um dos
lados, enta~o depois da criac,a~o das sai'das deveria escrever para si os seus
nu'meros de objecto.  Deve enta~o tratar para que o dono do outro quarto use
@add-exit e @add-entrance para ligar as suas novas sai'das ao quarto dele.

Exemplos:
    @dig "The Conservatory"
cria um novo quarto chamado "The Conservatory" e imprime o seu nu'mero de
objecto.
    @dig north,n to "The North Pole"
cria um novo quarto assim como uma sai'da a ligar o local corrente onde o
utilizador se encontra com o novo quarto; as personagens podera~o dizer `north'
ou `n' para irem daqui para o novo quarto.  Na~o e' criado nenhum caminho de
retorno desse quarto.
    @dig west,w|east,e,out to "The Department of Auto-Musicology"
cria um novo quarto e duas sai'das, uma que leva as pessoas daqui para o novo
quarto (via os comandos `west' ou `w') e uma que as tra's do novo quarto para
aqui (via `east',`e', ou `out').
    @dig up,u to #7164
cria uma sai'da que vai desde o quarto corrente do utilizador ate' #7164, que
tem de ser um quarto existente.

@DUMP
=====

Sintaxe:  @dump <objecto> [with [id=#<id>] [noprops] [noverbs] [create]

Isto revela todas as propriedade e verbos de um objecto, suspendendo-se a
intervalos apropriados.
   id=#<id> -- especifica um id de nu'mero para ser usado em lugar do actual id
do objecto (para transportar para outro MOO)
    noprops -- na~o mostra as propriedades
    noverbs -- na~o mostra os verbos
     create -- indica que deve ser gerado um comando @create e todos os verbos
sejam introduzidos por @verb em vez de @args; por defeito supo~em-se  que o
objecto ja' existe e que voce^ so' esta' a fazer isto para lhe dar uma olhada.

@ENTRANCES
==========

Sintaxe:  @entrances

Imprime uma lista de todas as entradas reconhecidas no quarto corrente (mas so'
se possuir o quarto).  Uma entrada reconhecida e' aquela cujo uso na~o e'
considerado teletransporte.

@EXAMINE
========

Sintaxe:  @examina <objecto>
	  @exam <objecto>

Imprime va'rios tipos de informac,a~o u'til sobre o objecto dado, incluindo o
seguinte:
	+ o seu nome completo, aliases, e nu'mero de objecto
	+ o nome do(a) dono(a) e nu'mero de objecto
	+ a sua descric,a~o
	+ a sua expressa~o chave (se estiver fechado e for o(a) dono(a))
	+ o seu conteu'do e os respectivos nu'meros dos objectos
	+ os verbos ` o'bvios ' definidos nele

[Nota aos programadores: os verbos ` o'bvios ' sa~o aqueles que sa~o legiveis e
podem ser invocados como comandos.  Para manter um verbo fora desta lista, ou
coloca'-lo ilegivel (veja `ajuda @chmod') ou, se ele na~o deve ser usado como
um comando, de^-lhe `this none this' como `args' (veja `ajuda @args').]

EXIT-MESSAGES
=============


Va'rios tipos de mensagens podem ser definidos num objecto sai'da (veja `ajuda
mensagens' para instrucc,o~es como o fazer); sa~o imprimidas para va'rias
audiencias em certas alturas quando e' feita uma tentativa de se passar por uma
sai'da.  Aquelas que comec,am por `o' te^m sempre o nome da personagem que faz
a tentativa mais um espac,o a precederem-na.  A substituic,a~o de pronomes
usual (em respeito ao utilizador) e' efectuada em cada mensagem antes de ser
impressa; veja `ajuda pronouns' para detalhes.

A mensagem por defeito e' dada entre pare^nteses rectos depois de cada nome
abaixo:

@leave	[0]
  Imprimida `a pessoa mesmo antes de usar a sai'da com sucesso.

@oleave [has left.]
  Imprimida aos outros no quarto de origem quando uma pessoa usa uma sai'da com
sucesso.

@arrive [0]
  Imprimida `a pessoa logo depois de ter usado a sai'da com sucesso.

@oarrive [has arrived.]
  Imprimida aos outros no quarto de destino quando uma pessoa usa uma sai'da
com sucesso.

@nogo  [You can't go that way.]
  Imprimida `a pessoa que na~o consegue usar a sai'da.

@onogo [0]
  Imprimida ao outros quando uma pessoa na~o consegue usar a sai'da.

@EXITS
======

Sintaxe:  @exits

Imprime uma lista de todas as sai'das convencionais do quarto corrente (mas so'
se possuir o quarto).  Uma sai'da convencional e' daquelas qu podem ser usadas
digitando simplesmente o seu nome, como `oeste'.

KEY-REPRESENTATION
==================

The representation of key expressions is very simple and makes it easy to
construct new keys on the fly.

Objects are represented by their object numbers and all other kinds of key
expressions are represented by lists.  These lists have as their first element
a string drawn from the following set:
	"&&"	 "||"	  "!"	  "?"
For the first two of these, the list should be three elements long; the second
and third elements are the representations of the key expressions on the left-
and right-hand sides of the appropriate operator.  In the third case, "!", the
list should be two elements long; the second element is again a representation
of the operand.  Finally, in the "?" case, the list is also two elements long
but the second element must be an object number.

As an example, the key expression
	#45  &&  ?#46  &&  (#47  ||  !#48)
would be represented as follows:
	{"&&", {"&&", #45, {"?", #46}}, {"||", #47, {"!", #48}}}

KEYS
====

LambdaMOO supports a simple but powerful notation for specifying locks on
objects, encryption on notes, and other applications.  The idea is to describe
a constraint that must be satisfied concerning what some object must be or
contain in order to use some other object.

The constraint is given in the form of a logical expression, made up of object
numbers connected with the operators 'and', 'or', and 'not' (written '&&',
'||', and '!', for compatibility with the MOO programming language).  When
writing such expressions, though, one usually does not use object numbers
directly, but rather gives their names, as with most MOO commands.

These logical expressions (called 'key expressions') are always evaluated in
the context of some particular 'candidate' object, to see if that object meets
the constraint.  To do so, we consider the candidate object, along with every
object it contains (and the ones those objects contain, and so on), to be
'true' and all other objects to be 'false'.

As an example, suppose the user Munchkin wanted to lock the exit leading to his
home so that only he and the holder of his magic wand could use it.  Further,
suppose that Munchkin was object #999 and the wand was #1001.  Munchkin would
use the '@lock' command to lock the exit with the following key expression:
	me || magic wand
and the system would understand this to mean
	#999 || #1001
That is, users could only use the exit if they were (or were carrying) either
#999 or #1001.

To encrypt a note so that it could only be read by Munchkin or someone carrying
his book, his bell, and his candle, Munchkin would use the 'encrypt' command
with the key expression
	me || (bell && book && candle)

Finally, to keep users from taking a large gold coffin through a particularly
narrow exit, Munchkin would use this key expression:
	! coffin
That is, the expression would be false for any object that was or was carrying
the coffin.

There is one other kind of clause that can appear in a key expression:
	? <object>
This is evaluated by testing whether the given object is unlocked for the
candidate object; if so, this clause is true, and otherwise, it is false.  This
allows you to have several locks all sharing some single other one; when the
other one is changed, all of the locks change their behavior simultaneously.

[Note to programmers: The internal representation of key expressions, as stored
in .key on every object, for example, is very simple and easy to construct on
the fly.  For details, see 'help key-representation'.]

@KIDS
=====

Syntax:  @kids <object>
	 @kids-f*ertil <object>

A quick way to find out the children of an object.  Prints out the names and
object numbers of the found children.  Note: this is not a list of all
descendents, just direct children. Use the -fertil extention to get a report of
fertil direct kids.

Example:
  @kids #3107
  Generic Body of Chlorinated Water(#3107) has 3 kids.
  The Pool(#1428)   The Hot Tub(#388)	Deep Blue Underground Pool(#17340)

@LOCATIONS
==========

Sintaxe:  @locations <objecto>

Imprime-lhe os nomes e nu'meros de objecto de todos os objectos contidos.

Exemplo:
  @locations ur-Rog
  ur-Rog(#6349)   ur-Rog's Display Case(#6355)	 Editorial Boardroom(#5747)

@LOCK
=====

Sintaxe:  @lock <objecto> with <expressa~o-chave>

Po~e uma fechadura no <objecto> para restringir o seu uso.  Veja `ajuda
locking' para informac,o~es gerais sobre fechaduras e `ajuda keys' para a
sintaxe e sema^ntica das expresso~es chaves.

N.B.  Na caso de quartos, e' preferivel por quarto.free_entry a 0 prevenindo
assim o teletransporte e enta~o usar o @lock com as va'rias entradas.  O
problema de usar o @lock sobre o quarto e' que pode tornar impossivel largar
objectos no quarto.

@LOCK_FOR_OPEN
==============

Sintaxe:  @lock_for_open <recipiente> with <expressa~o-chave>

Define a fechadura no <recipiente> que restringe quem o pode abrir.  Veja
`ajuda locking' para informac,a~o geral sobre fechaduras e `ajuda keys' para a
sintaxe e sema^ntica das expresso~es chave.

Para informac,a~o sobre os recipientes veja `ajuda container'.

LOCKING
=======

E' frequentemente u'til restringir o use de certos objectos.  Por exemplo,
pode-se querer que as personagens na~o usem uma certa sai'da a na~o ser que
transportem uma campainha, um livro, e uma vela.  Alternativamente, pode-se
permitir que todos usem a sai'da excepto se estiverem a transportar aquele
enorme caixa~o de ouro que esta' no canto.  O MOO suporta uma mecanismo geral
de fechaduras desenhado para facilitar a implementac,a~o de essas restric,o~es,
normalmente sem nenhuma programac,a~o.

Todos os objectos suportam a noc,a~o de estarem travados (fechados) com
respeito a uns certos objectos.  Por exemplo, a sai'da acima pode ser travada
para qualquer objecto que estava a transportar o objecto caixa~o mas destravada
para todos os outros objectos.	Em geral, se um objecto `A' esta' travado para
um outro objecto, `B', enta~o `B' e' normalmente impedido de usar `A'.	Claro
que o significado de `usar' neste contexto depende do tipo de objecto.

As va'rias classes de objectos usuais usam as fechaduras da maneira seguinte:
  + Quartos e recipientes rejeitam qualquer objecto neles se
    estiverem travados para ele.
  + As sai'das recusam transportar qualquer objecto para que estejam travadas.
  + As coisas (incluindo notas e cartas) na~o podem ser deslocadas para
    si'tios para os quais estejam travadas.

Ha' dois lados a travar:
  + Como e' que e' especificado se um objecto esta' travado em
    relac,a~o a outros ?
  + Qual e' o efeito de um objecto estar travado ?
Note que estas duas questo~es sa~o inteiramente independentes: pode-se inventar
um nova maneira de especificar fechaduras, mas o efeito numa sai'da que esta'
travada na~o se alteraria.

[Nota aos programadores: o `interface' entre estes dois lados e' o verbo
x:is_unlocked_for(y), que e' chamado por x para determinar se esta' travado
para o objecto y.  A maneira como `is_unlocked_for' e' implementado e'
inteiramente independente das maneiras com que x usa os resultados.  Note que
pode trabalhar em ambos os lados deste `interface' com os seus pro'prios
objectos, definindo novas implementac,o~es de `is_unlocked_for' que
correspondam `as suas circunsta^ncias particulares ou ter os seus objectos a
interpretar o estar travado de novas maneiras.]

Existe uma maneira por defeito de especificar fechaduras nos objectos; os
to'picos de ajuda seguintes cobrem os comandos relevantes:

@lock  -- define uma fechadura num objecto
@unlock  -- limpa a fechadura de um objecto
keys  -- descreve a linguagem utilizada para descrever as chaves das fechaduras

MESSAGES
========

Most objects have messages that are printed when a user succeeds or fails in
manipulating the object in some way.  Of course, the kinds of messages printed
are specific to the kinds of manipulations and those, in turn, are specific to
the kind of object.  Regardless of the kind of object, though, there is a
uniform means for listing the kinds of messages that can be set and then for
setting them.

The '@messages' command prints out all of the messages you can set on any
object you own.  Type 'help @messages' for details.

To set a particular message on one of your objects use a command with this
form:
	@<message-name> <object> is "<message>"
where '<message-name>' is the name of the message being set, <object> is the
name or number of the object on which you want to set that message, and
<message> is the actual text.

For example, consider the 'leave' message on an exit; it is printed to a user
when they successfully use the exit to leave a room.  To set the 'leave'
message on the exit 'north' from the current room, use the command
	@leave north is "You wander in a northerly way out of the room."

[Note to programmers: This class of commands automatically applies to any
property whose name ends in '_msg'.  Thus, in the example above, the command is
setting the 'leave_msg' property of the named exit.  You can get such a command
to work on new kinds of objects simply by giving the appropriate properties
names that end in '_msg'.  Additionally, in many cases the _msg property is
accompanied by a _msg verb, which defaultly returns the named property, but
which is available to be customized in more complex ways than allowed by simple
string substitution.  You should check for the particular property you're
considering whether the verb form exists (typically with @list).]

The following help topics describe the uses of the various messages available
on standard kinds of objects:

container-messages -- the messages on objects that can contain other objects
exit-messages -- the messages on exit objects
thing-messages -- the messages on objects that can be taken and dropped

@MESSAGES
=========

Sintaxe:  @mensagens <objecto>

Lista todas as mensagens que podem ser definidas no objecto dado e os seus
valores correntes.  Para mais detalhes veja `ajuda mensagens'.

@MOVE
=====

Sintaxe:  @move <coisa> to <local>

Move o objecto especificado para o local especificado.	Na~o ha' garantia que
funcione; em particular, o objecto tem de concordar ser deslocado e o destino
concordar em deixa'-lo entrar.	Normalmente e' este o caso.  O caso especial
onde <coisa> e' `me' e' util para se teletransportar a si mesmo(a) por ai'.

Se o @move na~o funcionar e voce^ for o(a) dono(a) do quarto onde o objecto se
encontra, tente antes usar o @eject.

@PARENTS
========

Sintaxe:  @parents <objecto>

Uma maneira ra'pida de descobrir a ascendencia de um objecto.  Imprime-lhe os
nomes e nu'meros de objecto de todos os ascendentes.

Exemplo:
  @parents Wizard
  Wizard(#2)   generic wizard(#58)   generic programmer(#59)   generic 
  player(#6)   Root Class(#1)

@REALM
======

Sintaxe:  @realm [donos] [from raiz] [descendentes em falta]

Visualiza uma parte da a'rvore de descendencia de objectos do MOO, i.e., todos
os descendentes de um objecto dado pertenc,a de um utilizador particular.

donos:	      uma lista de personagens em cujos objectos esta' interessado(a).
	      Se um deles for * ou !, o @realm visualizara' objectos que
	      pertenc,am a personagens que na~o mencionou (voce^ por defeito).
raiz:	      o objecto que e' um antecessor de todos os objectos em que esta'
	      interessado(a) ($root_class por defeito).
descendentes: uma lista de objectos (descendentes de raiz) em que na~o esta'
	      interessado(a).  Nem eles, nem os seus descendentes sera~o
	      visualizados.

@realm tambe'm visualiza os objectos que sa~o antecessores da raiz, e se na~o
for redundante, os donos de todos os objectos.	O @realm tem o ha'bito de
ultrapassar os ticks se tentar visualizar grandes partes do MOO.

@RECREATE
=========

Uso:  @recreate <objecto> as <progenitor> named <espec nome>

Isto e' uma combinac,a~o de @create e @chparent.  Pega num objecto existente,
tira-lhe todos os verbos, propriedades e valores de propriedades herdadas. 
Este objecto e' enta~o depois moldado num descendente do progenitor
especificado, como se o @create tivesse sido invocado, mas mantendo o mesmo
nu'mero de objecto que o original.

Os argumentos <progenitor> e <espec nome> sa~o como no @create.

@RECYCLE
========

Sintaxe:  @recycle <nome-ou-nu'mero-objecto>

Destroi irremediavelmente o objecto dado.  Naturalmente que so' pode fazer isto
a objectos que possua.

@REMOVE-ENTRANCE
================

Sintaxe:  @remove-entrance <entrada>

Remove a entrada especificada da lista de entradas correntes do quarto.  A
entrada pode ser o nome ou nu'mero de objecto de uma entrada para este quarto.

@REMOVE-EXIT
============

Sintaxe:  @remove-exit <sai'da>

Remove a sai'da especificada da lista de sai'das corrente do quarto.  A sai'da
pode ser o nome ou nu'mero de objecto de uma sai'da deste quarto.

@SETPROP/@SET
=============

Sintaxe:  @set <objecto>.<nome-prop> to <valor>

Altera o valor da propriedade especificada do objecto para o valor dado.
Tem de ter permisso~es para modificar a propriedade, ou por ser o dono dela ou
por se poder escrever nela.

@SORT-OWNED
===========

Syntax:  @sort-owned

Sorts your .owned_objects property so @audit shows up sorted.  See help @audit
for more information.

THING-MESSAGES
==============

Several kinds of messages can be set on 'things', objects that have $thing as
an ancestor (see 'help messages' for instructions on doing so).  They are
printed to various audiences under various circumstances when an attempt is
made to 'take' or 'drop' a thing.  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:

@take_failed  [You can't pick that up.]
  Printed to a user who fails to take the object.

@otake_failed []
  Printed to others in the same room if a user fails to take the object.

@take_succeeded  [You take %t.]
  Printed to a user who succeeds in taking the object.

@otake_succeeded  [picks up %t.]
  Printed to others in the same room if a user succeeds in taking the object.

@drop_failed  [You can't seem to drop %t here.]
  Printed to a user who fails to drop the object.

@odrop_failed [tries to drop %t but fails!]
  Printed to others in the same room if a user fails to drop the object.

@drop_succeeded  [You drop %t.]
  Printed to a user who succeeds in dropping the object.

@odrop_succeeded  [drops %t.]
  Printed to others in the room if a user succeeds in dropping the object.

TOPOLOGY
========

The topology of the MOO universe is determined by the rooms that exist and the
exits that connect them.  Several commands are available for creating and
discovering the topology of the MOO.  Help on them is available under the
following topics:

@dig -- creating new rooms and exits
@add-exit -- adding other users' exits from your rooms
@add-entrance -- adding other user's entrances to your rooms
@exits -- listing all of the conventional exits from your rooms
@entrances -- listing all of the conventional entrances to your rooms
@resident -- listing or changing the residents of your rooms

@UNLOCK
=======

Sintaxe:  @unlock <objecto>

Limpa qualquer fechadura que possa existir no objecto dado.  Veja `ajuda
locking' para informac,a~o geral sobre fechaduras.

@UNLOCK_FOR_OPEN
================

Sintaxe:  @unlock_for_open <recipiente>

Limpa qualquer fechadura restringindo a abertura do <recipiente>.  Veja `ajuda
locking' para informac,a~o geral sobre fechaduras.

Veja `ajuda containers' para informac,a~o sobre recipientes.

@VERIFY-OWNED
=============

Sintaxe:  @verify-owned

Verifica que todos os objectos na sua propriedade .owned_objects sa~o na
realidade seus, e faz as reparac,o~es que forem precisas.  Veja `ajuda @audit'
para mais informac,o~es.

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