[ nwe help ]
Search Help   »  General   »  MOO  »   JHC  »   Builder Help

Builder Help



  @building-options  @buildingoptions       @create 
  @dig               furniture              @measure 
  pronoun-example    pronoun-substitution   @recreate 
  substitution       two-letter             two-letter-qr 
  two-letter-spec    @who



@building-options, @buildingoptions

Usage:  @building-options
        @building-option <option>

These options (see `help option'[1]) allow you to customize your
building environment.

The first form displays all of your building options.  The second
shows or sets a given option.  Current building options are:

  room=<object>	Type of object the @dig command should create.
 !room		Default ($room).

  exit=<object> Type of exit the @dig command should create.
 !exit		Default ($exit).

The @dig command (see `help @dig'[2]) creates rooms and/or exits when
you're building.  These two options let you determine what parent
classes are used for the objects created.

 +furnishing	@created objects are locked in the room you're in
 -furnishing	@created objects are carried by you, unlocked

By default, when @create makes an object, the object is placed in your
inventory.  While this is handy for programming, it's often not what
you want when you're furnishing rooms.  If you have this option set,
the objects created will be placed in the room you're in, and locked
down.

 +create-set-co @create sets your current object to the one created.
 -create-set-co @create doesn't change your current object.

When this option is set, a @create command will set your current
object (see `help current-object'[3]) to the newly created object.
This is useful primarily for porting (an object creation script can
start with a @create, then refer to _ in the rest of the script), but
can also be handy for general creation.

 +bi-create     @create/@recycle call create()/recycle() directly.
 -bi-create     @create/@recycle re-use object numbers.

This option determines whether @create and other commands will use the
server's create() and recycle() primitives or the database's $recycle.


@create

Syntax:  @create <parent-object> named "<names>"

The main command for creating objects other than rooms and exits (for
them, see `help @dig'[1]; it's much more convenient).

The first argument specifies the 'parent' of the new object: loosely
speaking, the 'kind' of object you're creating.  You can use a `class
name' such as $note, $letter, $thing, or $container; you can also
specify a parent object by object number or just by name, if it's
nearby.

The <names> are given in the same format as in the @rename
command:

        <name-and-alias>,<alias>,...,<alias> [preferred]
        <name>:<alias>,...,<alias>           [not preferred]

See `help @rename'[2] for a discussion of the difference between a
name and an alias.


@dig

Syntax:  @dig <exit-spec> to <new-room-names>
         @dig <exit-spec> to <old-room-object-number>

This is the basic building tool.  It creates an exit leading from your
current location to another room, and optionally another exit leading
back.  The destination room may already exist, or it may be created by
the @dig command.

An <exit-spec> has one of the following two forms:
        <names>
        <names>|<names>

where the first form is used when you only want to create one exit,
from your current room to the destination room, and the second form
when you also want an exit back.

The <names> piece is just a list of names for the exit, as
described in `help @rename':

        <name-and-alias>,<alias>,...,<alias> [preferred]
        <name>:<alias>,...,<alias>           [not preferred]

These are the names of the commands people can type to use the exit.
It is usually a good idea to include explicitly the standard
abbreviations for direction names (e.g., 'n' for 'north', 'se' for
'southeast', etc.).  DO NOT put spaces in the names of exits; they are
useless in MOO.

If you give an object number for the indirect object of the command
(<old-room-object-number>), then that object will be used as the
destination room.  Otherwise, that part of the command is another set
of names and aliases, which will be used to create a new room.

NOTE: You must own the room at one end or the other of the exits you
create.  If you own both, everything is fine.  If you own only one
end, then after creating the exits you should write down their object
numbers.  You must then get the owner of the other room to use
@add-exit and @add-entrance to link your new exits to their room.

You can determine what objects will be used as the parents of new
exits and rooms that @dig creates by setting your building options:
    @options building room=<parent class>
and
    @options building exit=<parent class> will set your
defaults.  You can also specify "-room" or "-exit" to use the global
defaults ($room and $exit).

Examples:

    @dig north,n to "The North Pole"

creates a new room and also an exit linking the player's current
location to the new room; players would say either 'north' or 'n' to
get from here to the new room.  No way to get back from that room is
created.

    @dig west,w|east,e,out to "The Department of Auto-Musicology"

creates a new room and two exits, one taking players from here to the
new room (via the commands 'west' or 'w') and one taking them from the
new room to here (via 'east', 'e', or 'out').

    @dig up,u to #7164

creates an exit leading from the player's current room to #7164, which
must be an existing room.


furniture

Generic Furniture.

Users can sit on, shove someone else from, and get up from furniture.

Properties for builders to know about:

seats: the number of people that can easily sit on this.
squeeze: the number of extra people that might be able to fit.
          if negative, people can't squeeze on when it's full.

Integration:

If the furniture is empty, its @integrate_empty message is used.  This
defaults to something like "A couch is here."

If anyone is sitting on the furniture, and it has a non-null
@integrate_room message, that is used.  The default is null.

If anyone is sitting on the furniture, and it has a null
@integrate_room message, then @integrate_empty and @integrate_sitters
messages are concatenated.  The latter message defaults to something
like " You, Jay, and the System Object are sitting on it."

In all messages, %N stands for the list of sitters.

Other messages for builders to know about:

@sitting ("sitting"):  verb for what people are doing on it.
@on ("on"):  preposition for what people are, uh, figure it out.
@empty (""):  message for description, if no one is sitting on it.
              (if anyone is, the string is hard-coded.)

@sit ("Foo sits on the couch"):  obvious.  may have extra text tacked on.
@squeeze ("Bar is squeezed off the couch."):  not enough room!
@nosqueeze ("There's no room on the couch."):  really not enough room.
@stand ("Foo stands up from the couch."):  obvious again.

@fall ("Foo falls off the couch."):  when furniture gets moved.

@shove ("Foo shoves Bar off the couch!"):  obvious.
@also_shove ("Bar takes Baz with her."):  innocent bystanders.



@measure

Syntax:
  @measure object <object name>
  @measure summary [player]
  @measure new [player]
  @measure breakdown <object name>

When the MOO is under byte-quota, objects in the MOO are measured
approximately once a week, and the usage tally as reported by @quota
is updated.  You may wish to measure an object specially, however,
without waiting for the automatic measurement to take place, or if the
MOO is under object-quota.  @measure has some subcommands to handle
this.

@measure object will measure an individual object right now, update
the usage of that object in your usage as reported by @quota, and
update the date of that object's measurement.

@measure summary will go through your or another player's objects and
produce the summary information that is printed by @quota.  Normally
this will be just the same as @quota prints out, but occasionally the
addition/subtraction done to keep @quota in sync will get out of date,
and @measure summary will be needed.

@measure new will go through all your or another player's objects,
measuring exactly those which have never been measured before (that
is, are too newly @created to have any measurement data).  This is
necessary as any player is only permitted to own 10 unmeasured
objects, or object creation will not be permitted.

@measure breakdown will give you full information on where an object's
size is coming from.  It will offer to moomail you the result.
Caution: don't forget to delete this message, as it is large and takes
up a lot of space!


Pronoun-example

This text is intended to tell you something about how to use pronoun
substitution in programming.  If you don't know anything about pronoun
substitution, you should probably read `help pronouns' before you
start.

Note that, at least for now, the text assumes two-letter pronoun
substitution (see `help two-letter'[1] for a full specification).

STEP ONE
--------

Okay.  For our example, let's say you've been creating a duck.  It's a
pretty independent duck, and you don't want people to be able to pick
it up, so you write a simple verb:

   >@verb duck:take this
   >@program duck:take
   >player:tell("You try to pick the duck up, but it swiftly dodges away.");
   >.

Here's a sample interaction with that code:

   >take duck
   You try to pick the duck up, but it swiftly dodges away.

About what you'd expect.

STEP TWO
--------

So now you have a duck that won't let itself be picked up.  But if you
change the duck's name, or if you make a generic ornery bird, then
"the duck" won't be correct.

One way to deal with this would be to have the `take' verb call
this:dname().  This verb will return "the duck" (or "the mallard" or
"Bob the Wonder Pigeon").  This is an improvement, but it still lacks
flexibility for the generic case.  You can provide this flexibility by
using a pronoun-sub message.

   >@newmessage @dodge on duck
   @dodge on duck is now "".

This command just creates a message called `@dodge' on the duck.
Actually, it creates a property named `dodge_msg'.  This is all a
message is: A property with a special name (`something_msg') and a
special format (more complicated).

   >@dodge duck is "You try to pick up %td, but %ts swiftly %t:(dodges) away."

This command sets the contents of the .dodge_msg property on the duck.
Notice that a lot of words related to the duck have been replaced with
strange expressions that begin with `%t'.  This is NOT A COINCIDENCE.

The `%t' means that some piece of information about `this' should be
used.  (`This' is usually the object on which the message is located.)
The particular piece of information is then specified:

   %td         -- the object's name, with definite article if needed
                  ("the duck", "Bob the Wonder Pigeon", "the goslings")
   %ts         -- the subjective pronoun
                  ("it",       "he",                    "they")
   %t:(dodges) -- a verb, conjugated for the object
                  ("dodges",   "dodges",                "dodge")

The last of these may be a little bit tricky.  `%t' means `substitute
information about "this"'.  Following that, `:' means `use a
conjugated verb'.  Then `(dodges)' specifies what verb to use.

Now, reprogram the verb to actually use this new message:

   >@program duck:take
   >player:tell($string_utils:pronoun_sub(this.dodge_msg));
   >.

$string_utils:pronoun_sub is a verb that takes a message in the
standard format, looks at information in the state of the world
(knowing `player' and the object that called it) or passed in
explicitly, and returns a string with the appropriate substitutions
made.  So a sample interaction might go:

   >take duck
   You try to pick the duck up, but it swiftly dodges away.

.. exactly the same!  But if you change the duck's name, make it
plural, or change its gender, the message will change automatically.

STEP THREE
----------

Now, suppose you're not satisfied with having your duck reject
players' advances; you want everyone around to know what the player is
doing, too.  (This is a perfectly reasonable goal, by the way; that
way if the player says `That pesky duck!', everyone will know why.)


So, you make a new message:

   >@newmessage @ododge on duck
   @ododge on duck is now "".
   >@ododge duck is "%nD %n:(tries) to pick up %td, but %ts swiftly %t:(dodges) away."

In this message, `%n' works just the way `%t' does, but it refers to
`player' (the one who typed the command), not to `this'.

   >@program duck:take
   >player:tell($string_utils:pronoun_sub(this.dodge_msg));
   >player:room_announce($string_utils:pronoun_sub(this.ododge_msg));
   >.

The :room_announce verb tells its arguments to everyone in the room
with `player', except for `player'.  So:

Munchkin types:
   >take duck
Munchkin sees:
   You try to pick the duck up, but it swiftly dodges away.
Everyone else in the room sees:
   Munchkin tries to pick the duck up, but it swiftly dodges away.

Two messages and two lines take care of all of this.

STEP FOUR
---------

Actually, when the message is essentially the same for all parties
involved (as in this example), you can simplify it still more.

   >@dodge duck is "%nD %n:(tries) to pick up %td, but %ts swiftly %t:(dodges) away."

Notice that this sets the `@dodge' to just the same thing `@ododge'
was.

   >@program duck:take
   >$you:say_action(this.dodge_msg);
   >.

$you:say_action is a very handy verb that takes a message in the
standard format, and substitutes appropriately for everyone involved
(or nearby).  So, with this one message (you could `@rmprop
duck.ododge_msg') and one line of code, you get this:

Munchkin types:
   >take duck
Munchkin sees:
   You try to pick the duck up, but it swiftly dodges away.
The duck sees:
   Munchkin tries to pick you up, but you swiftly dodge away.
Everyone else sees:
   Munchkin tries to pick the duck up, but it swiftly dodges away.

Munchkin gets treated as `you' in his own message; so does the duck.
Everyone else sees it in third person.

STEP ZERO
---------

This is a basic use of pronoun substitution, but if you understand it
well it will cover many cases.  To find out more, you might want to
read `help two-letter'[2] for more description of the capabilities of
pronoun substitution; search through existing code that does things
that interest you; and don't hesitate to ask other people for help.


pronoun-substitution

This text describes the basic pronoun substitution model.  An
introduction to the pronoun substitution concept can be found in `help
pronouns'[1], and a detailed example can be find in `help
pronoun-example'[2].  Detailed information on the format of a
two-letter substitution is in `help two-letter'[3].
XXX
The Evaluation Context
-----------------------
Pronoun substition is done on a string by calling:
  $string_utils:pronoun_sub(string);

This will return a new string that is based on the format of string
and the context in which pronoun_sub:() was called.

For example, if an object named `sun' calls this code:
  $string_utils:pronoun_sub("%td sets in the west.");
the returned string will be:
  "The sun sets in the west."

The information that :pronoun_sub() can use to try to decipher the
string includes, (along with they way they can be referred to in the
format string):

  - The player who caused the code to execute. (%p)
  - The object where the code is stored, usually referred to as `this'. (%t)
  - The location of the player. (%l)
  - The direct object of the command line that was typed by the player. (%d)
  - The indirect object of the command line that was typed by the player. (%i)

These values, which :pronoun_sub() figures out by itself, can be set
explicitly by passing them in as arguments:

   $string_utils:pronoun_sub(string, player, this, location, dobj, iobj)
  
All of these (except the string) are optional, but order is important,
so if you want to change the location, you also need to specifically
mention the string, player, and this.

Each of these arguments can be:
  - an object (as you'd expect)
  - a list of objects
  - a list like you'd pass to $string_utils:english_list, i.e:
       :pronoun_sub("The %n", {{#0, #1, #2}, "nothing", " or "})


Multiple Similar Contexts
-------------------------

It often turns out that you want to say nearly the same thing to
several different targets.  For example, if Munchkin picks up a duck,
three messages will probably be printed:

  To Munchkin: You pick the duck up.
  To the duck: Munchkin picks you up.
  To everyone else in the room: Munchkin pick the duck up.

If you want to use :pronoun_sub() to create these messages, you'll
either have to call it three times with three different format
messages, or you'll have to call it three times with one format while
tweaking the arguments to :pronon_sub().

This happens so often that a special command has been created to do
this for you.  The verb $you:say_action(string) takes the string and
then substitutes in appropriately for everything involved or nearby.
In the above situation, you would simply call:

  $you:say_action("%nD %n:(picks) up %td.")

This will print the message according to how each person should see
it, exactly like the three messages above.

A detailed example using $you:say_action() can be found in `help
pronoun-example'[4].


@recreate

Usage: @recreate <object> as <parent> named <name spec>

This is a combination of @create and @chparent.  It takes an existing
object, completely strips it of any verbs, properties, and values for
inherited properties.  This object is then reshaped into a child of
the parent specified, as though @create had been called, but retaining
the same object number as the original.

The <parent> and <name spec> arguments are as in @create.
See `help @create'[1] and `help @chparent'[2].


Substitution

This text describes the basic pronoun substitution model.  An
introduction to the pronoun substitution concept can be found in `help
pronouns'[1], and a detailed example can be find in `help
pronoun-example'[2].  Detailed information on the format of a
two-letter substitution is in `help two-letter'[3].

The Evaluation Context
-----------------------
Pronoun substition is done on a string by calling:
  $string_utils:pronoun_sub(string);

This will return a new string that is based on the format of string
and the context in which pronoun_sub:() was called.

For example, if an object named `sun' calls this code:
  $string_utils:pronoun_sub("%td sets in the west.");
the returned string will be:
  "The sun sets in the west."

The information that :pronoun_sub() can use to try to decipher the
string includes, (along with they way they can be referred to in the
format string):

  - The player who caused the code to execute. (%p)
  - The object where the code is stored, usually referred to as `this'. (%t)
  - The location of the player. (%l)
  - The direct object of the command line that was typed by the player. (%d)
  - The indirect object of the command line that was typed by the player. (%i)

These values, which :pronoun_sub() figures out by itself, can be set
explicitly by passing them in as arguments:

   $string_utils:pronoun_sub(string, player, this, location, dobj, iobj)

All of these (except the string) are optional, but order is important,
so if you want to change the location, you also need to specifically
mention the string, player, and this.

Each of these arguments can be:

  - an object (as you'd expect)
  - a list of objects
  - a list like you'd pass to $string_utils:english_list, i.e:
       :pronoun_sub("The %n", {{#0, #1, #2}, "nothing", " or "})


Multiple Similar Contexts
-------------------------

It often turns out that you want to say nearly the same thing to
several different targets.  For example, if Munchkin picks up a duck,
three messages will probably be printed:

  To Munchkin: You pick the duck up.
  To the duck: Munchkin picks you up.
  To everyone else in the room: Munchkin pick the duck up.

If you want to use :pronoun_sub() to create these messages, you'll
either have to call it three times with three different format
messages, or you'll have to call it three times with one format while
tweaking the arguments to :pronon_sub().

This happens so often that a special command has been created to do
this for you.  The verb $you:say_action(string) takes the string and
then substitutes in appropriately for everything involved or nearby.
In the above situation, you would simply call:

  $you:say_action("%nD %n:(picks) up %td.")

This will print the message according to how each person should see
it, exactly like the three messages above.

A detailed example using $you:say_action() can be found in `help
pronoun-example'[4].


two-letter

This help text describes the format of pronoun-substitution messages.
Other help texts on pronoun_substitution include:

pronouns[1]
      An overview.
pronoun-substitution[2]
      How to call pronoun_sub and how it works.
pronoun-example[3]
      A detailed example.
two-letter-qr[4]
      A quick reference guide to the format string.
pronoun-style[5]
      Dunno yet.

Pronoun-substitution messages are entered as strings, but are usually
converted to an arcane list format before they're used.  This document
is about the format of the string entry; the list format may be
discussed elsewhere.

The information passed to :pronoun_sub() can have subsitution
specifiers in it that are replaced by values that depend on the
context.  The string that results after all the substitutions are made
is returned.

In the format string that :pronoun_sub() parses, a `%' indicates that
a substition should take place.  The characters after it specify the
type of substition.  Take a look at this string:

  "%Td %t:(looks) at %dd oddly."

It has three substitutions to be made in it: `%Td', `%t:(looks)', and
`%dd'.

In most cases, a substition consists of three elements:

  o  The % sign, indicating that a substitution should be made.
  o  A symbol indicating the object that should be considered.
  o  A symbol indicating what about that object to substitute.


The Object Specifier
====================

The object specifier is the letter that follows the % sign.  Consider
the string:

    "%Td %t:(looks) at %dd oddly."

In `%Td' and in `%t:', the object specifer is `t'.  In `%dd', the
object specifer is `d'.

The possible letters and the objects that they correspond to include:

  t - represents the thing where the verb callig :pronoun_sub() is stored
  n - represents the player that started the command
  d - represents the direct object of the initial command
  i - represents the indirect object of the initial command
  l - represents the location of the player

As an example, If Munchkin typed this command:

  put duck in pond

and the duck had this as a @put_in_water message:

  "%Nd %n:(puts) %td in %id."

Then:

  %Nd would get the `D' information on Munchkin.

  %n:(puts) would conjugate `puts' according to Munchkin's gender.

  %td would get the `d' information from the duck.

  %id would get the `d' information from the pond.


The Information Specifier
=========================

The character following the object specifier is the information
specifier.  It specifies what sort of information to get about the
object.  It can be any of these characters:

  n - the object's name        ("Susan",   "duck",    "king and queen")
  d - definite-article         ("Susan",   "the duck","the king and queen")
  i - indefinite-article       ("Susan",   "a duck",  "a king and queen")
  o - the objective pronoun    ("her",     "him",     "them")
  p - possessive adjective     ("her",     "his",     "their")
  q - possessive pronoun       ("hers",    "his",     "theirs")
  r - reflexive pronoun        ("herself", "himself", "themselves")
  s - subjective pronoun       ("she",     "he,       "they")

Sometimes, several characters follow the object specifier:

  'i  - indefinite possessive  ("a duck's")
  'd  - definite possessive    ("the duck's")
  'n  - possessive name        ("duck's")

In using any of these, you can capitalize the object specifier to have
the phrase capitalize--for example, `%Nd' might become "The duck".  If
you capitalize both the object specifier and the information specifier
(`%ND'), you'll get all caps--"THE DUCK".

Information Specifiers for Verb Conjugation
===========================================

You often want to insert a verb into a sentence, but the conjugation
depends on the context that it's used in.  Give this as the
information specifer in order to have pronoun_sub conjugate a verb:

  :(foos) - conjugate the verb `to foo'

For example:
  "%ns %n:(runs)"

will result in "he runs", "she runs", or "they run", depending on the
gender of the player who called the verb.

If you capitalize the verb, the result will be c the gender of the
player who called the verb.

If you capitalize the verb, the result will be capitalized:

  "%ns %n:(Runs)"
  => "he Runs"


Information Specifiers for Pluralizing Nouns
============================================

If you want to make a noun singular or plural depending on context,
you can give the noun as an information specifier, and it will be
pluralized if the object you specified is plural.  This is the format
of the information specification:

  '(noun)

For example, this string:
  "%nD %n:(shakes) %d'd %d'(hand)."

may result in either:
  "Munchkin shakes Susan's hand."
or
  "Munchkin shakes the king and queen's hands."

Again, capitalizing the noun will result in a capitalized
substitution.


Information Specifiers for Object Data
======================================

You can also obtain information about the actual object by using these
information specifiers.

  #      - the object's number 
  .(foo) - the object's "foo" property

For example:
  %t.(mood)
would return the string in the object's `mood' property.

If the proprety doesn't exist, the string `Property not found' will be
returned.

If you capitalize the property name, the resulting string will be
capitalized.


Object Locations
=============================

Sometimes you want information about an object's location.  This can
be retrieved by appending an `l' to the object specifier.  For
example:

  %tln - Get the `thing' this code is on, find out where it's located,
  and then get the name of that location.

This can be done to every kind of object specifier: %tl, %nl, %il,
%dl, and %ll.

Other Substitutions
===================

In addition to the format of %(object specifier)(information
specifier), you can also use these substituions:

  %% - A percent sign.   That is:  %

  %$a - the argstr to the verb that called :pronoun_sub().
  %$d - the dobjstr to the verb that called :pronoun_sub().
  %$i - the iobjstr to the verb that called :pronoun_sub().
  %$p - the preptsr to the verb that called :pronoun_sub().

  %;(statements) - Evaluates the statements, which should return a
                   string, and inserts the result.

  %{information} - This does something, but you have to be James to
                   know what.


Errata
======

If the information following the % isn't a valid substitution string,
the % will remain a %.  This is a clue that the format string needs
some work.


two-letter-qr, two-letter-spec

This help text is a quick reference for pronoun_sub format strings.
For explanation, see `help two-letter'[1].

General format:   %<object specifier><information specifier>

Object Specifiers
  %t - this           %d - the dobj     %l - the player location
  %n - the player     %i - the iobj
  Append `l' to refer to that object's location, or `L' for the outermost.

Information Specifiers (capitalizable)

  n - the object's name         ("Susan",   "duck",    "king and queen")
  d - definite-article          ("Susan",   "the duck","the king and queen")
  i - indefinite-article        ("Susan",   "a duck",  "a king and queen")
  o  - the objective pronoun    ("her",     "him",     "them")
  p  - possessive adjective     ("her",     "his",     "their")
  q  - possessive pronoun       ("hers",    "his",     "theirs")
  r  - reflexive pronoun        ("herself", "himself", "themselves")
  s  - subjective pronoun       ("she",     "he,       "they")
  'i - indefinite possessive    ("a duck's")
  'd - definite possessive      ("the duck's")
  'n - possessive title         ("duck's")
  #  - the object's number 

Verbs, Nouns, Properties (capitalizable)
  :(foos) - conjugate the verb `to foo'
  '(foo)  - pluralize the noun `foo' if necessary
  .(foo)  - the object's `foo' property

Other Substitutions
  %${a,d,i,p} - the {arg,dojb,iobj,prep}str 
  %;(statements) - Evaluates statements


@who

Syntax: @who
        @who <player> [<player> ... ]
        @who [<players>] by <order>

        @who in <room>
        @who with <player>

The first form lists all of the currently-connected players, along
with an indication of how long they've been idle, their present
location in the MOO, and their doing/idle string (see `help doing' and
`help idle').

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

The third form lets you specify a sort order.  (See `help
@who-options'[1].)  You can also specify the players you want to see,
or specify nothing to see everybody who's on.

The fourth and fifth forms show you @who information for everybody in
a given room, or everybody in the same room as a given player,
respectively.

@who's format and sorting order can be modified using @who-options
(see `help @who-options').

Note for builders: @who refers to the @who_location message (see `help
messages'[2]) on each player'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'[3]).  The
default value is "%Tn" (i.e., the room name).


 


help@nwe.ufl.edu
http://web.nwe.ufl.edu/writing/help/moo/jhc/builder_help.html
Last modified: Tue May 15 14:54:24 2001