This is TinyMUCK version 1.1, a user-extendible, multi-user adventure game.
Basic commands: 
 move/go <direction>
 get/take <thing>; drop/throw <thing>
 look; look <thing>; look <direction>
 say <message>; whisper <player> = <message>
 rob <player>; give <player> = <number of pennies>; kill <player>
 inventory
 help
 news
 @describe me = <description>
 @password <oldpassword>=<newpassword>
 page <player> --- tell player that you are looking for them (cost 1 penny)
 gripe <message> --- complain to the management.
 home --- go home

Other commands are available for extending the universe.  Many of
these commands cost pennies, which you can obtain in a number of ways.
Full names of exits can be used in place of a go or move command.  The
names "me" and "here" are special; me means the current player, and
here means the current player's location.

Remember, no matter how bad it gets, you can always go home.
---------------- TinyMUCK mods ----------------
This document describes the differences between TinyMUCK and TinyMUD
v1.5.2.  It is *not* an introduction to TinyMUD, nor a tutorial on
TinyMUCK.  It is a reference guide to the changes which have been
made.

The main additions in TinyMUCK are object-local and player-local
commands, multi-destination links and player @chown.

Object-Local and Player-local Commands
======================================

In order to allow players to do interesting things with objects,
TinyMUCK adds the ability to attach 'actions' to them.  Actions
are much like 'exits' on a room, and in fact use the same type in the
database (TYPE_EXIT).  In order to use these actions, an object
must either be in the room, or in the player's possession.

Player-local commands can only be used by the player who owns them.

The two new commands, @action and @attach, are used as follows:

@action <action-name>=<source-object>
@attach <existing-action-name>=<source-object>

@action creates a new action named <action-name>, and attaches it
to <source-object>.  <source-object> can also be 'here' or 'me'.

@attach re-attaches an existing action to a new source object.

To get an action to do something, you link it like a regular exit.

Notes:	Exits and actions are interchangeable, so @action foo=here
	is equivalent to @open foo.
	You can no longer 'get' and 'drop' actions.  Use @attach foo=me
	and @attach foo=here, respectively.

TinyMUCK Links
==============

The @link command in TinyMUCK works a little differently than in TinyMUD.
The format is:

@link <action-name>=<dest1> <dest2> <dest3> ...

Where <action-name> can also be an exit name, and <destn> are the
numbers of the objects to link to.

If you @link an action to an object, using that action will summon the
indicated object.  If someone else is holding the object, it will
immediately disappear from their inventory.

In the case of an action attached to an object, an object-summon will
also send the source object home.  To prevent this, set the action
STICKY.  Room destinations on things and players teleport the player
to that room.

If TinyMUCK is compiled with #define TELEPORT_TO_PLAYERS, <destn> can
also be another player, provided that they are LINK_OK.  Using this
action will cause you to teleport to that player's location.
To provide some degree of privacy, that player must also be JUMP_OK
for the action to work.  The default for new players is !JUMP_OK.
Summary:  player must be LINK_OK at link-time, and JUMP_OK at use-time.

You can also link an action to a room you control (like a regular
exit), or another action.  The latter I have termed a _meta-link_.
Note that meta-links override the locks on all actions below the
initial one.  A recursive check is performed to make sure that
an action destination does not cause a loop.  Room or player
destinations in actions which are linked to will be ignored
in a meta-link.

Meta-links can be used, for example, to restore the objects
in an adventure to their starting places, or to move objects
around in rooms other than the one that the player is in.

The JUMP_OK Flag
================

In order to restrict the use of teleport-to-player and teleport-
to-room destinations on movable things (like players and objects),
TinyMUCK has the JUMP_OK flag.  If you create an action on an
object or yourself, it will always work in rooms that you own.

You can only use these actions in other rooms if the other
rooms are JUMP_OK.

When new rooms are created, their JUMP_OK flag is set to whatever
the player's JUMP_OK flag is.  This allows the puzzle builder
(for example) to create a set of rooms which are !JUMP_OK,
or a social-area-builder to create a set of JUMP_OK rooms.

JUMP_OK also serves the purpose (as mentioned above) of stopping
players from teleporting to you.

Player @chown
=============
In TinyMUD, the @chown command allows Wizards to change ownership
of objects.  In TinyMUCK, the @chown can be used by players to
transfer ownership of other players objects to themselves.  The object
to be transferred must be a THING, it have the CHOWN_OK flag set,
and it must be in the player's inventory.

The format of the player @chown command is:

@chown <thing>

This allows two things:

1)  Players can give each other gifts.
2)  Players can trash old objects, and put them in public-accessible
    places for re-use (until real recycling is implemented).

For example, a player might create a note, lock it to the appropriate
player, do @set note=CHOWN_OK, and then leave it in their mailbox.
The receiving player could then @chown note, transferring ownership
to themselves, and use it to reply, or leave it CHOWN_OK and drop
it to a junkpile someplace.

The #ifdef PLAYER_CHOWN must be used when compiling to allow this feature
to be implemented.

Type "news" for site-specific modifications.
Please read news every time you log on.

If you are an absolute novice, send e-mail to
lachesis@nyquist.bellcore.com to get a full set of documentation.