TinyMUD --> UnterMUD Dictionary
-------------------------------
This is an introductory document for UnterMUD. It isn't intended to
teach you all about UnterMUD, or to be an introduction if you haven't
ever played with a MUD before. This is for people who have played on
TinyMUD and similar systems, and who want to start playing on UnterMUD
without having to learn everything from scratch. If you really want
to learn all about UnterMUD, you need something else, but this should
at least get you started.
Section 1. TinyMUD concepts and their UnterMUD equivalents.
------------------------------------------------------------
Everything in TinyMUD is an object. TinyMUD has four types of
objects: players, rooms, exits, and things. Each of these objects has
a small set of attributes, though they aren't usually called that--a
description, a success message, and the like. Just as important is
the object's number, which uniquely identifies it.
UnterMUD also stores everything as objects. Unlike TinyMUD, there
isn't really a fixed set of object types, but the most important types
correspond to the four TinyMUD objects. Just as in TinyMUD, there are
players, rooms, exits, and things; these work almost exactly like they
do in TinyMUD. Every object has a unique identifier, an "object ID";
however, an object ID in UnterMUD can be any string, not just a
number. The most common object IDs you will see are numbers by
themselves (usually used for rooms and exits), and a number with a
world name (usually used for players and things). For instance, a
player character might be #1774 on a TinyMUD, but 178@UnterStairCase
on an UnterMUD.
There are only a few attributes of TinyMUD objects (description,
success message, failure message, etc.). An UnterMUD object can have
many attributes, though there are a few special attributes which are
used like the TinyMUD ones. You can put almost anything you want into
an UnterMUD attribute.
There are two important concepts in UnterMUD which don't have direct
equivalents in TinyMUD. The first is the ability to define macros (on
a per-object or system-wide basis); the second is the ability to use
several UnterMUDs as one (cyberportals are similar to this, but not
quite as powerful). For documentation on these, see the files "Macros"
and "Intro".
A major difference between TinyMUD and UnterMUD is the handling of
flags. TinyMUD has a plethora of flags--LINK_OK, DARK, STICKY, etc.
UnterMUD currently has an equivalents for LINK_OK, DARK, ROOM, PLAYER,
and WIZARD. These are 'linkok', 'isdark', 'isroom', 'isplayer', and
'wizard' flag. See Section 4 for more information on flags.
Section 2. Dictionary of commands.
-----------------------------------
This section lists TinyMUD commands (mostly from 1.5.4, though
including a few 1.5.5 and MUCK commands) and their UnterMUD
equivalents (when they exist). Wizard-only commands are listed
separately, in section 3. These are in alphabetical order, though the
'@' commands are listed after all normal commands.
In TinyMUD, commands which refer to objects (like 'take' or 'drop')
understand names which are longer than one word long. This means that
'drop red chest' will make you drop the red chest. In UnterMUD, you
would have to use the command 'drop "red chest"' to do the same thing;
if you typed 'drop red chest' it would try to do a 'drop red' and then
a 'drop chest'. (Of course, UnterMUD allows object names to be
abbreviated, rather like TinyMUD does, so that 'drop chest' will work
even for an object named 'red chest' or the behaviour of the command
can be changed with a macro.)
Here's a table of notation used in the dictionary:
[XXX] means that XXX can optionally be used with the command.
<XXX> describes the name of something. Sometimes a '1' and '2'
are used to distinguish them (e.g. <exit1> and <exit2>).
<boolean> means a boolean expression (see the entry for @lock).
<exit> means the name of an exit, for instance 'north.'
<flag> means the name of a flag, for instance 'link_ok.'
<number> means some number, for instance '34.'
<object> means the name (or sometimes ID) of an object of any type.
<player> means the name of a player, for instance 'Fred.'
<room> means the name of a room, for instance 'Blue Room.'
<room-id> means the ID of a room, for instance '1473.'
<string> means anything you type, for instance 'boxes of fish.'
<thing> means the name of a thing, for instance 'chest.'
... means that whatever came before the '...' can be repeated.
For instance, '<thing> ...' means that you can type in
the names of more than one thing (separated by spaces).
--- means that there is no UnterMUD equivalent.
TinyMUD command UnterMUD command
--------------- ----------------
: :
" "
drop <object> drop <object> ...
examine [ <object> ] examine [ <object> ... ]
_dump [ <object> ... ]
get <thing> get <thing>
You cannot pick up exits in UnterMUD.
give <player> = <pennies> ---
UnterMUD does not have pennies.
go <exit> go <exit>
gripe <string> ---
home teleport me home
A simple 'home' macro can be defined.
inventory inventory
kill ---
If you own the room, you may send
players in it home by using the
'teleport <player> home' command.
look [ <object> ] look [ <object> ... ]
move <exit> go <exit>
news NEWS [ <number> ]
outputprefix <string> ---
Replaced by _mark.
outputsuffix <string> ---
Replaced by _mark.
page <player> = <string> page <player> = <string>
QUIT QUIT
read [ <object> ] look [ <object> ... ]
rob ---
UnterMUD does not have pennies.
say <string> say <string>
This is not exactly the same as
TinyMUD's say--quotes are handled
differently, for one thing.
score ---
UnterMUD does not have pennies.
take <object> take <object> ...
You cannot pick up exits in UnterMUD.
throw <object> drop <object> ...
whisper <player> = <string> whisper <player> = <string>
WHO [ <string> ] WHO [ <string> ... ]
You can specify more than one prefix
to be matched using several words,
unlike TinyMUD.
@chown <object> = <player> set <object> owners [ + | - ] <player>
Note that an object can have multiple
owners in UnterMUD. Objects can also
be owned by non-players.
@create <thing> create object [ <thing> = <string> ]
build object [ <thing> = <string> ]
You must put the object's name in
quotes if it is longer than one word.
It is possible to create un-named
objects by omitting the name.
You can also give a description when
you create the object.
@describe <object> = <string> set <object> desc = <string>
unset <object> desc
@dig <room> build room [ <room> <exit1> <exit2> ]
If <exit1> is supplied, an exit to
the room is automatically created.
If <exit2> is also supplied, an exit
back is automatically created as well.
It is possible to create an un-named
room by omitting the name.
@fail <object> = <string> set <object> fail = <string>
unset <object> fail
@find <string> ---
@link <object> = <object> build link <exit> = <room-id>
build dropto <dest-room>
set <object> home = <string>
Players can only be homed to rooms.
Objects can have players as their
homes as well as rooms.
@lock <object> = <boolean> set <object> lock = <boolean>
But be warned that locks are used
somewhat differently in UnterMUD.
In the boolean expression, "T" and
"F" mean "true" and "false"
respectively.
@name <object> = <string> set <object> name = <string>
Players' names can only be changed by
a wizard.
@ofail <object> = <string> set <object> ofail = <string>
@open <exit> [ = <room-id> ] build exit [ <exit> <room-id> ]
BEWARE of using semicolons
in exit names; you *must* put
quotes around the name.
You can't create an unlinked exit.
(You build the exit, then remove
yourself from the owner list, so
anyone can add themselves as an
owner, and then relink the exit.)
@osuccess <object> = <string> set <object> osucc = <string>
@password <oldstring> = <newstring> password <oldstring> <newstring>
@recycle destroy object <object>
destroy room <object>
destroy player <object>
destroy exit <object>
Note that OID's are not recycled!
@set <object> = <flag> set <object> <flag>=
unset <object> <flag>
But see the section on flags, below.
Most flags can only be set/unset by a
wizard.
@success <object> = <string> set <object> succ = <string>
@teleport <object> = <room-id> teleport <object> <destination>
You may only teleport things you
own, are linkok, or are in a room
you own. If you own them, you may
teleport them to a room you own,
a linkok room, or 'me' if the object
is a thing. You may always teleport
things 'home'. This does include
teleporting players.
Note that non-player objects obey
these rules too.
@unlink <exit> unset exit dst
build link <exit> <here>
Only a wizard can unset the destination.
There is no way to unlink an exit;
see @open.
@unlock <object> unset <object> lock
Section 3. Wizard commands.
----------------------------
These commands have fewer equivalents than the user commands,
because an UnterMUD is quite different internally from a TinyMUD.
Don't rely on this to be a wizard on an UnterMUD; it's here only for a
quick reference.
@boot <player> _force <player> QUIT
A macro to do this is available.
@count <player> ---
@dump _cacheconfig sync
But this is not an exact equivalent,
since it does not create a new copy
of the database.
@find <string> ---
'which' will do something like this in
the current room
@force <player> = <string> _force <player> = <string>
@newpassword <player> = <string> _password <player> = <string>
@owned <player> ---
@pcreate <player> = <string> build player <player> = <string>
@shutdown _mudconfig shutdown
@toad <player> = <player> ---
No exact equivalent, though
'unset <player> pass' will
destroy the player's password and
prevent them from connecting.
Simply do this, then force them
to QUIT.
A macro to do this is available.
@untoad <player> ---
No exact equivalent, though
'_password <player> pass' will
readd a password field and allow
them to log in.
@wall <string> _wall <string>
Section 4. Flags in UnterMUD.
------------------------------
As mentioned above, there are only a few flags in UnterMUD. They are
'isdark', 'local', 'isroom', 'isplayer', and 'wizard.' Each of these is
type "flag". 'linkok' is not a flag in Unter, it's a boolean. The flags
'isroom' and 'isplayer' are set automatically when a room or a player is
built. They can only be unset (or set) by a wizard. They just serve to help
identify what the object is.
Note that there are no flags for "isexit" or "isobject". It is possible
to distinguish these from rooms and players because there are two different
types of object IDs in UnterMUD, unqualified object ids and fully qualified
object ids which include the mud's name along with the object number. For
example, 123@UnterStairCase is a fully qualified name. Since only objects
with a fully qualified object id are allowed to move to another UnterMUD,
players and things have this sort of object id, and rooms and exits do not.
A thing, therefore, looks just like a player, except it does not have the
player flag (and it stays in the contents list of a room, not in the player
list). Exits are identified similarly.
The 'wizard' flag is settable only by a wizard, or by using the _wizard
command. In order to use the _wizard command to set your wizard flag, you
must be in the list of wizards on the system object, and know the wizard
password.
The 'isdark' flag works almost the same as in TinyMUD. When a room is
set dark, a 'look' will show none of the room contents, even if you own
something in the room. Players set dark are similar in behaviour to rooms,
essentially hiding their contents. Only a wizard can set a player dark. An
object set dark is not listed in the contents when you look at the room or
player containing it. If you are the owner of a room or player, you may see
all the contents of it by doing an 'examine', a player can also always see
their own contents using "inventory".
The 'local' flag is only meaningful for players and objects. When set,
the player or object (or player holding the object) is not allowed to move
through a cyberportal to another Unter. This is especially useful for
players without nice clients (like raw telnet), and for people who want to
make sure their objects don't get lost on another mud.
Unlike in TinyMUD 'linkok' is actually a boolean, much like lock. This
means that you can set your room linkok only for a certain player, or only
for people holding a certain item, and so forth. In a boolean, the letters
"T" and "F" mean 'true' or 'false', respectively. This allows you to set a
room linkok to everyone with just "set here linkok=T" and get TinyMUD style
behaviour. Just think of 'linkok' as a fancy lock.